Wie verwende ich Zugriffsqualifizierer und Pakete, um die Kapselung in Java zu implementieren?

1. Kapselung

Kapselung ist eines der drei Hauptmerkmale objektorientierter Programme. Die drei Hauptmerkmale objektorientierter Programme: Kapselung, Vererbung und Polymorphismus.

Kapselung: Kombinieren Sie Daten und Methoden zum Betreiben von Daten organisch, verbergen Sie die Eigenschaften und Implementierungsdetails des Objekts und legen Sie nur die Schnittstelle für die Interaktion mit dem Objekt offen (einfach ausgedrückt handelt es sich um eine Shell zum Abschirmen der Details).

Verwenden Sie reale Objekte im Leben, um Verpackungen wie Computer zu verstehen:

Bei einem komplexen Gerät wie einem Computer stehen dem Benutzer lediglich Folgendes zur Verfügung: Ein- und Ausschalten, Tastatureingabe, Monitor, USB-Buchse usw. Dadurch kann der Benutzer mit Computern interagieren, um tägliche Aufgaben zu erledigen.

Aber tatsächlich: Die eigentliche Arbeit des Computers sind CPU, Grafikkarte, Speicher und andere Hardwarekomponenten. Computerbenutzer müssen sich keine Gedanken über die internen Kernkomponenten machen, z. B. wie die Schaltkreise auf der Hauptplatine angeordnet sind, wie die CPU konstruiert ist usw. Benutzer müssen lediglich wissen, wie und wie sie den Computer einschalten über Tastatur und Maus mit dem Computer interagieren. Deshalbwenn Computerhersteller das Werk verlassen, setzen sie eine Hülle auf die Außenseite, um die internen Implementierungsdetails zu verbergen, und stellen nur Netzschalter, Maus- und Tastaturanschlüsse nach außen, damit Benutzer mit dem Computer interagieren können.

2. Zugriffsqualifizierer (Modifikatoren)

Die Kapselung wird hauptsächlich durch Klassen und Zugriffsrechte in Java erreicht: Klassen können Daten und Methoden zur Kapselung von Daten kombinieren, was eher dem menschlichen Verständnis der Dinge entspricht, und Zugriffsberechtigungen werden verwendet, um zu steuern, ob eine Klasse oder Methoden oder Felder in einer Klasse direkt außerhalb der Klasse verwendet werden können. In Java werden vier Zugriffsqualifikatoren bereitgestellt:

public: öffentlich, was als Erscheinungsmerkmale einer Person verstanden werden kann, jeder kann es sehen

protected: geschützt, Wissen über Vererbung, Vererbung. Detaillierte Einführung im Blog

Standard: Die Standardberechtigung beim Schreiben von Nichts ist kein Geheimnis für Ihre eigene Familie (im selben Paket), sie ist für andere privat

privat: privat, nur Sie wissen es, niemand sonst weiß es

Verstehen Sie die Kapselung durch die Codebeispiel unten:

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());
    }
}

Im Allgemeinen werden Mitgliedsvariablen auf privat und Mitgliedsmethoden auf öffentlich gesetzt. Durch dieses Beispiel können Sie die Kapselung hier besser verstehen. Die Implementierungsdetails innerhalb der Klasse sind verborgen/gekapselt, und zwar nur einige Öffentliche Methoden werden bereitgestellt, damit andere Benutzer darauf zugreifen können.

[Zugriffsqualifizierer-Szenarien verwenden]:

• Wir hoffen, dass die Klasse so „gekapselt“ wie möglich sein sollte, das heißt, die internen Implementierungsdetails verbergen und nur die notwendigen Informationen dem Aufrufer der Klasse zugänglich machen .

• Daher sollten wir unser Bestes geben, um strengere Zugriffsberechtigungen zu verwenden, wenn eine Methode beispielsweise privat verwendet werden kann, versuchen Sie, sie nicht öffentlich zu verwenden.

• Darüber hinaus gibt es eine einfache und Grobe Methode: Setzen Sie alle Felder auf privat und alle Methoden auf öffentlich. Diese Methode stellt jedoch einen Missbrauch der Zugriffsrechte dar. Es ist jedoch am besten, beim Schreiben von Code darüber nachzudenken, „von wem“ die von der Klasse bereitgestellten Feldmethoden verwendet werden ( Es dient der internen Verwendung der Klasse, unabhängig davon, ob es vom Aufrufer der Klasse oder von der Unterklasse verwendet wird. Paket

1. Das Konzept des Pakets Es wird ein Softwarepaket vorgeschlagen, das heißt:

Für eine bessere Klassenverwaltung werden mehrere Klassen zu einer Gruppe zusammengefasst, die als Softwarepaket bezeichnet wird

. Etwas ähnlich einem Verzeichnis. Zum Beispiel: Um Bilder auf Ihrem Computer besser zu verwalten, ist es eine gute Möglichkeit, Bilder mit denselben Attributen in derselben Datei abzulegen, oder Sie können Bilder in einem bestimmten Ordner auch detaillierter klassifizieren.

Pakete wurden auch in Java eingeführt. Pakete sind die Verkörperung des Kapselungsmechanismus von Klassen, Schnittstellen usw. und eine gute Möglichkeit, Klassen oder Schnittstellen usw. zu organisieren.

, wie zum Beispiel: Klassen in Ein Paket möchte nicht von Klassen in anderen Paketen verwendet werden. Auch Pakete spielen eine wichtige Rolle:

Klassen mit demselben Namen dürfen im selben Projekt existieren, solange sie sich in unterschiedlichen Paketen befinden.

2. Klassen im Paket importieren 2.1 Importmethode 1 Java hat viele vorgefertigte Klassen zur Verfügung gestellt, zum Beispiel die Date-Klasse: Sie können java.util.Dateverwenden > zum Importieren von Java .util ist die Date-Klasse in diesem Paket.

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

2.2 Importmethode zwei

Aber diese Schreibweise ist schwieriger. Sie können

die Importanweisung verwenden, um das Paket zu importieren

java.util.Date 导入 java.util 这个包中的 Date类.

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

2.2 导入方法二

但是这种写法比较麻烦一些, 可以使用 import语句导入包

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

2.3 导入方法三

如果需要使用 java.util 中的其他类, 可以使用 import java.util.*

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 都匹配

2.3 Importmethode 3

Wenn Sie java.util verwenden müssen, können Sie für andere Klassen import java.util.* verwenden. Hier können Sie alle Klassen im Paket java.util importieren, achten Sie jedoch darauf, dies nicht zu tun Importieren Sie alle Klassen auf einmal. Verwenden Sie: Wer ankommt, wird importiert.

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());
    }
}

Aber Es ist empfehlenswerter, den zu importierenden Klassennamen explizit anzugeben

Andernfalls kann es leicht zu Konflikten 🎜 kommen.🎜

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编程开发包。

Das obige ist der detaillierte Inhalt vonWie verwende ich Zugriffsqualifizierer und Pakete, um die Kapselung in Java zu implementieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!