Bagaimana untuk menggunakan kelayakan akses dan pakej untuk melaksanakan enkapsulasi dalam Java?

1. Enkapsulasi

Encapsulation ialah salah satu daripada tiga ciri utama program berorientasikan objek; : enkapsulasi, pewarisan dan keadaan pemultipleksan.

Encapsulation: menggabungkan data secara organik dan kaedah data pengendalian, menyembunyikan sifat dan butiran pelaksanaan objek, dan hanya mendedahkan antara muka untuk berinteraksi dengan objek (secara ringkasnya, ia adalah shell butiran pelindung).

Gunakan objek sebenar dalam kehidupan untuk memahami pembungkusan, seperti komputer:

Untuk peranti yang kompleks seperti komputer, semua yang disediakan kepada pengguna ialah: hidupkan dan matikan, input melalui papan kekunci, dan monitor , bicu USB, dsb., membolehkan pengguna berinteraksi dengan komputer dan menyelesaikan tugasan harian.

Tetapi sebenarnya: kerja sebenar komputer ialah CPU, kad grafik, memori dan komponen perkakasan lain. Bagi pengguna komputer, mereka tidak perlu risau tentang komponen teras dalaman, seperti bagaimana litar pada papan induk disusun, bagaimana CPU direka, dan lain-lain. Pengguna hanya perlu tahu cara menghidupkan komputer dan cara untuk berinteraksi dengan komputer melalui papan kekunci dan tetikus. Oleh itu

apabila pengeluar komputer meninggalkan kilang, mereka meletakkan cangkerang di bahagian luar untuk menyembunyikan butiran pelaksanaan dalaman, dan hanya menyediakan suis kuasa, bicu tetikus dan papan kekunci ke bahagian luar supaya pengguna boleh berinteraksi dengan komputer .

2. Kelayakan akses (pengubah suai)

Pengenkapsulan dilaksanakan terutamanya di Java melalui kelas dan hak akses:

Kelas boleh menggabungkan data dan kaedah merangkum data, yang lebih selaras dengan pemahaman manusia tentang sesuatu, dan kebenaran akses digunakan untuk mengawal sama ada kelas atau kaedah atau medan dalam kelas boleh digunakan terus di luar kelas . Java menyediakan empat kelayakan akses:

awam: awam, yang boleh difahami sebagai ciri penampilan seseorang, sesiapa sahaja boleh melihatnya

dilindungi: dilindungi, melibatkan pengetahuan dalam warisan, pengenalan terperinci dalam blog warisan

lalai: kebenaran lalai apabila menulis apa-apa, ia bukan rahsia untuk keluarga anda sendiri (dalam pakej yang sama), untuk Bagi orang lain, ia adalah privasi

peribadi: peribadi, hanya anda yang tahu, tiada orang lain yang tahu

Fahami enkapsulasi melalui contoh kod yang diberikan di bawah:

class Person {
    private String name;
    //private修饰的成员变量只能在本类中访问
    private int age;

    String sex;
    //这里不加修饰符即为默认权限，默认是default权限

    public String getName() {
        return name;
    }
    //在其他类中不能直接访问name和age，
    //但可以在本类中提供公开的（public修饰）访问方法和外界进行交互
    //这里就是对成员变量进行了封装
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void show() {
        System.out.println("姓名："+name+" 年龄: "+age);
    }
}

public class Test {

    public static void main(String[] args) {
        Person person = new Person();
        //person.name = "bit";//不能直接进行访问
        person.setName("XIN-XIANG荣");
        person.setAge(21);
        //通过提供Person类中提供的方法间接进行访问
        System.out.println(person.getName()+" => "+person.getAge());
    }
}

Secara amnya, pembolehubah ahli ditetapkan kepada kaedah persendirian dan kaedah ahli ditetapkan kepada awam Melalui contoh ini, anda boleh lebih memahami enkapsulasi Di sini, butiran pelaksanaan di dalam kelas disembunyikan/dikapsulkan, dan hanya luaran Sediakan beberapa kaedah awam untuk diakses oleh pengguna lain.

[Gunakan senario kelayakan akses]:

• Kami berharap kelas harus "terkapsul" yang mungkin, iaitu menyembunyikan dalaman perincian pelaksanaan. Hanya maklumat yang diperlukan didedahkan kepada pemanggil kelas itu, sebagai contoh, jika kaedah boleh menjadi peribadi, kemudian Cuba untuk tidak menggunakan awam.

• Selain itu, terdapat kaedah yang mudah dan kasar: tetapkan semua medan sebagai peribadi dan semua kaedah sebagai awam betul Penyalahgunaan hak akses, tetapi sebaiknya fikirkan tentang "siapa" kaedah medan yang disediakan oleh kelas digunakan semasa menulis kod (sama ada ia digunakan oleh kelas itu sendiri, oleh pemanggil kelas, atau oleh subkelas)

• 3. Pakej
  1. Konsep pakej

Dalam sistem berorientasikan objek, konsep pakej perisian dicadangkan, iaitu ialah:

Untuk Kelas pengurusan yang lebih baik, berbilang kelas dikumpulkan bersama ke dalam kumpulan, dipanggil pakej perisian

. Agak serupa dengan direktori. Contohnya: Untuk mengurus gambar pada komputer anda dengan lebih baik, cara yang baik ialah meletakkan gambar dengan atribut yang sama di bawah fail yang sama, atau anda juga boleh mengelaskan gambar dalam folder tertentu dengan lebih terperinci.

Pakej juga diperkenalkan di Java

Pakej ialah penjelmaan mekanisme enkapsulasi untuk kelas, antara muka, dsb., dan merupakan cara yang baik untuk merangkum kelas atau. antara muka. Kaedah organisasi

, contohnya: kelas dalam satu pakej tidak mahu digunakan oleh kelas dalam pakej lain. Pakej juga memainkan peranan penting: Kelas dengan nama yang sama dibenarkan wujud dalam projek yang sama, selagi mereka berada dalam pakej yang berbeza

.

2. Import kelas dalam pakej 2.1 Import kaedah satu

Java telah menyediakan banyak kelas sedia untuk kami gunakan Sebagai contoh, kelas Tarikh: anda boleh menggunakan

Import kelas Date dalam pakej java.util.

2.2 Import kaedah dua

java.util.DateTetapi cara penulisan ini lebih menyusahkan anda

gunakan pernyataan import untuk mengimport pakej

public class Test1 {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}

2.3 Import kaedah tiga Jika anda perlu menggunakan kelas lain dalam java.util, anda boleh menggunakan

, di mana anda boleh mengimport semua kelas dalam pakej java.util Tetapi berhati-hati untuk tidak mengimport semua kelas sekaligus.

import java.util.Date;
public class Test1 {
    public static void main(String[] args) {
        Date date = new Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}

Tetapi

adalah lebih disyorkan untuk menyatakan secara eksplisit nama kelas yang hendak diimport import java.util.* Jika tidak, konflik

mungkin berlaku dengan mudah.

import java.util.*;
public class Test1 {
    public static void main(String[] args) {
        Date date = new Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}

import java.util.*;
import java.sql.*;
public class Test1 {
    public static void main(String[] args) {
// util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
        Date date = new Date();
        System.out.println(date.getTime());
    }
}

// 编译出错
//Error:(5, 9) java: 对Date的引用不明确
//java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配

在这种情况下需要使用完整的类名

import java.util.*;
import java.sql.*;
public class Test1 {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        System.out.println(date.getTime());
    }
}

2.4 导入静态的方法和字段

import static java.lang.Math.*;
public class Test {
    public static void main(String[] args) {
        double x = 30;
        double y = 40;
// 静态导入的方式写起来更方便一些.
// double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
        double result = sqrt(pow(x, 2) + pow(y, 2));
        System.out.println(result);
    }
}

//对比正常的导入和使用
import java.lang.Math;
public class Test1 {
    public static void main(String[] args) {
        double x = 30;
        double y = 40;
        double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
        System.out.println(result);
    }
}

3. 自定义包

3.1 基本使用规则：

• 在文件的最上方加上一个 package 语句指定该代码在哪个包中.

• 包名需要尽量指定成唯一的名字, 通常会用公司域名的颠倒形式(例如com.bat.demo1 ).

• 包名要和代码路径相匹配. 例如创建 com.bat.demo1 的包, 那么会存在一个对应的路径 com/bat/demo1 来存储代码

• 如果一个类没有 package 语句, 则该类被放到一个默认包中

3.2 IDEA中创键自定义包

在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包

在弹出的对话框中输入包名, 例如 com.bat.demo1 ，敲入回车即可

在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名回车即可.

此时可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了

同时我们也看到了, 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句

4. 不同包中的访问权限控制

Computer类位于com.bat.demo1包中，TestComputer位置com.bat.demo2包中

package com.bat.demo1;

public class Computer {
    private String cpu; // cpu
    private String memory; // 内存
    public String screen; // 屏幕
    String brand; // 品牌

    public Computer(String brand, String cpu, String memory, String screen) {
        this.brand = brand;
        this.cpu = cpu;
        this.memory = memory;
        this.screen = screen;
    }

    public void Boot() {
        System.out.println("开机~~~");
    }

    public void PowerOff() {
        System.out.println("关机~~~");
    }

    public void SurfInternet() {
        System.out.println("上网~~~");
    }
}

注意：如果去掉Computer类之前的public修饰符，Computer类为默认权限，只能在同一包中访问，代码也会编译失败

5. 常见的包

• java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。

• java.lang.reflect:java 反射编程包;

• java.net:进行网络编程开发包。

• java.sql:进行数据库开发的支持包。

• java.util:是java提供的工具程序包；(集合类等) 非常重要

• java.io:I/O编程开发包。

Atas ialah kandungan terperinci Bagaimana untuk menggunakan kelayakan akses dan pakej untuk melaksanakan enkapsulasi dalam Java?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!