01.Bases de Java - Encapsulation

Concepts de base

Java orienté objet possède trois fonctionnalités majeures : encapsulation, héritage, polymorphisme. L'encapsulation et l'héritage servent essentiellement au polymorphisme.

Encapsulation  : Elle combine les propriétés et les opérations (ou services) d'un objet en un tout indépendant, et masque autant que possible les détails d'implémentation à l'intérieur de l'objet. En termes simples, cela signifie privatiser les variables membres de la classe et fournir des méthodes publiques pour accéder à ces variables membres.

Masquage des données : Si une variable membre est déclarée comme membre privé, elle n'est pas accessible directement via la classe externe, masquant ainsi la variable membre à l'intérieur de la classe. Pour cette raison, l’encapsulation est également appelée masquage de données.

---

JavaBean

JavaBean est une spécification qui stipule une bonne spécification d'encapsulation Tant que la classe est conforme à la spécification, elle s'appelle JavaBean.

Il présente les caractéristiques suivantes :

• Les données membres (membres objets) doivent être modifiées par privé.

• Fournir des méthodes setter/getter publiques pour chaque membre de l'objet

• Le prototype du setter/getter doit être :

public void set 成员名(成员类型 arg);public 成员类型 get 成员名();

---

Étude de cas

1. Non encapsulé et encapsulé

Tout d'abord, regardons l'avenir. Variables membres encapsulées :

class Person{    // 将成员的访问权限设置为 public，这也为意味这谁都访问到它
    public String name;    public int age;
}public class Test{
    public static void main(String[] args) {
        Person person = new Person();        //通过类，我们可以直接操作成员变量
        person.name ="kobe";
        person.age =1000;        //直接获得成员变量的值
        System.out.println(person.name+"-"+person.age);
    }
}

Ensuite, nous encapsulons la classe ci-dessus :

class Person {    //1.将成员变量私有化，这样一来外部就不能直接访问到它们
    private String name;    private int age;    //2.提供公共的方法来操作成员变量
    public String getName() {        return name;
    }    public void setName(String name) {        this.name = name;
    }    public int getAge() {        return age;
    }    public void setAge(int age) {        this.age = age;
    }
}public class Test {
    public static void main(String[] args) {
        Person person = new Person();        // 不能直接访问成员变量，而是通过提供的公共方法来设置/获取成员变量的值
        person.setName("kobe");
        person.setAge(1000);
        System.out.println(person.getName() + "-" + person.getAge());
    }
}

Jusqu'à présent, nous avons vu la différence générale entre les objets encapsulés et non encapsulés :

• Pour les objets non encapsulés, nous accédons/définissons directement leurs variables membres

• Et pour les objets encapsulés, nous devons utiliser les méthodes publiques fournies (telles que getter/setter) pour faire fonctionner les membres. variables

---

2.Encapsuler l'objet de contrôle

Si c'est comme ça, l'encapsulation semble n'avoir aucun effet, ensuite. nous regardons comment contrôler les objets via l'encapsulation :

class Person {    
private String name;    
private int age;    
private int city;    
//对于 name 的控制，直接取消了 setter 方法，这样外部只能访问，而不能设置 name 的值
    public String getName() {        
    // 直接返回值
        return "kobe";
    }    public int getAge() {        
    return age;
    }    
    // 有两个 setter 方法，可以接收 int，String 类型的参数
    public void setAge(int age) {        
    this.age = age;
    }    public void setAge(String age) {        
    // 对参数值进行验证，默认只能输入数字
        if(age.matches("[0-9]")){            
        this.age = Integer.valueOf(age);
        }else{
            System.out.println("Error：年龄只能为数字");
        }
    }    
    // 在日常开发，我们一般会将文字转换成编码在数据库存储，因此在存储调用时就要做转换
    public String getCity() {        
    switch (city) {        
    case 001:            
    return "北京";        
    default:            
    return "上海";
        }
    }    
    public void setCity(String city) {        
    if("北京".equals(city)){            
    this.city = 001;
        }else if("上海".equals(city)){            
        this.city = 002;
        }else{
            System.out.println("Error：没有找到该城市");
        }
    }
}public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        person.setAge("a"); //Error：年龄只能为数字
        person.setAge(1000); //既可以接收 String 类型，也可以接收 int 类型
        person.setCity("广州"); //Error：没有找到该城市
        person.setCity("北京"); //此时已经被转换成 001 存储了    

        //在访问 city 成员变量时，001 又被转换成 北京 显示
        System.out.println(person.getName()+"-"+person.getAge()+"-"+person.getCity());
    }
}

Grâce au code ci-dessus, nous pouvons résumer grossièrement le rôle de l'encapsulation :

• Une bonne encapsulation réduit le couplage.

• La structure à l'intérieur de la classe peut être modifiée librement.

• permet un contrôle plus précis sur les membres.

• Masquer les informations et mettre en œuvre les détails.

---

Référence

• http://www.php.cn/java-article -351262.html

Ce qui précède est le contenu de 01.Java Basics - Encapsulation Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php. cn) !