Maison > Java > javaDidacticiel > 01.Bases de Java - Encapsulation

01.Bases de Java - Encapsulation

黄舟
Libérer: 2017-02-27 10:08:05
original
1312 Les gens l'ont consulté

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 成员名();
Copier après la connexion

É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);
    }
}
Copier après la connexion

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());
    }
}
Copier après la connexion

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());
    }
}
Copier après la connexion

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

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) !


Étiquettes associées:
source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal