Maison >Java >javaDidacticiel >Comment utiliser les qualificatifs d'accès et les packages pour implémenter l'encapsulation en Java ?

Comment utiliser les qualificatifs d'accès et les packages pour implémenter l'encapsulation en Java ?

王林avant: 2023-04-23 12:52:151203parcourir

1. Encapsulation

L'encapsulation est l'une des trois caractéristiques majeures des programmes orientés objet Les trois caractéristiques majeures des programmes orientés objet : l'encapsulation, l'héritage et le polymorphisme ;

Encapsulation : combinez organiquement les données et les méthodes d'exploitation des données, masquez les propriétés et les détails d'implémentation de l'objet et exposez uniquement l'interface pour interagir avec l'objet (en termes simples, il s'agit d'un shell pour protéger les détails).

Utilisez des objets réels de la vie pour comprendre l'emballage, comme les ordinateurs :

Pour un appareil complexe comme un ordinateur, tout ce qui est fourni à l'utilisateur est : la mise sous tension et hors tension, la saisie au clavier, le moniteur, la prise USB, etc. , permettant à l'utilisateur d'interagir avec les ordinateurs pour accomplir les tâches quotidiennes.

Mais en fait : le véritable travail de l'ordinateur est le processeur, la carte graphique, la mémoire et les autres composants matériels. Pour les utilisateurs d'ordinateurs, ils n'ont pas à se soucier des composants internes de base, tels que la disposition des circuits sur la carte mère, la conception du processeur, etc. Les utilisateurs ont seulement besoin de savoir comment allumer l'ordinateur et comment interagir avec l'ordinateur via le clavier et la souris. Par conséquent, lorsque les fabricants d'ordinateurs quittent l'usine, ils mettent une coque à l'extérieur pour cacher les détails d'implémentation internes et ne fournissent que des interrupteurs d'alimentation, des prises pour souris et clavier à l'extérieur afin que les utilisateurs puissent interagir avec l'ordinateur. 2. Qualificateurs d'accès (modificateurs)

L'encapsulation est principalement réalisée via des classes et des droits d'accès en Java :

Les classes peuvent combiner des données et des méthodes d'encapsulation de données

, ce qui est plus conforme à la compréhension humaine des choses, et Autorisations d'accès sont utilisés pour contrôler si une classe, des méthodes ou des champs dans une classe peuvent être utilisés directement en dehors de la classe. Il existe quatre qualificatifs d'accès fournis en Java :

Comment utiliser les qualificatifs daccès et les packages pour implémenter lencapsulation en Java ? public : public, qui peut être compris comme les caractéristiques d'apparence d'une personne, tout le monde peut le voir

protected : protégé, impliquant des connaissances dans l'héritage, l'héritage Introduction détaillée dans le blog

par défaut : l'autorisation par défaut lorsque vous n'écrivez rien n'est pas un secret pour votre propre famille (dans le même package), elle est privée pour les autres

private : privée, vous seul le savez, personne d'autre ne le sait

Comprenez l'encapsulation via le exemple de code donné ci-dessous :

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

Généralement, les variables membres sont définies sur privées et les méthodes membres sont définies sur publiques Grâce à cet exemple, vous pouvez mieux comprendre l'encapsulation, ici Les détails d'implémentation à l'intérieur de la classe sont masqués/encapsulés, et seulement certains. des méthodes publiques sont fournies aux autres utilisateurs.

[Utiliser des scénarios de qualificatifs d'accès] :

1. Le concept de package

Dans le système orienté objet, le concept. d'un progiciel est proposé, c'est-à-dire :

Pour une meilleure gestion de classe, plusieurs classes sont rassemblées dans un groupe, appelé progiciel

. Un peu similaire à un répertoire. Par exemple : afin de mieux gérer les images sur votre ordinateur, un bon moyen consiste à placer les images avec les mêmes attributs dans le même fichier, ou vous pouvez également classer les images dans un certain dossier de manière plus détaillée.

Comment utiliser les qualificatifs daccès et les packages pour implémenter lencapsulation en Java ? Les packages ont également été introduits en Java

Les packages sont l'incarnation du mécanisme d'encapsulation des classes, des interfaces, etc., et sont un bon moyen d'organiser des classes ou des interfaces, etc.

, tels que : des classes dans. un package Ne souhaite pas être utilisé par les classes d'autres packages. Les packages jouent également un rôle important : Les classes portant le même nom sont autorisées à exister dans le même projet, à condition qu'elles se trouvent dans des packages différents. 2. Importer des classes dans le package

2.1 Méthode d'importation 1

Java nous a fourni de nombreuses classes prêtes à l'emploi, par exemple la classe Date : vous pouvez utiliser `java.util.Date pour importer java .util est la classe Date dans ce package.`

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

2.2 Méthode d'importation deux 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.*

Mais cette façon d'écrire est plus gênante. Vous pouvez

utiliser l'instruction import pour importer le package

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 Méthode d'importation. trois

Si vous devez utiliser java.util Pour d'autres classes, vous pouvez utiliser import java.util.* Ici, vous pouvez importer toutes les classes du package java.util, mais veillez à ne pas le faire. importer toutes les classes à la fois. Utiliser Celui qui arrive sera importé. 🎜

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

🎜Mais 🎜 il est plus recommandé de spécifier explicitement le nom de la classe à importer 🎜 🎜Sinon, des conflits 🎜 peuvent facilement survenir.🎜.

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. 自定义包