Explication détaillée des exemples d'encapsulation des trois principales fonctionnalités de Java

L'une des trois caractéristiques majeures ---Encapsulation

Encapsulation signifie littéralement emballage. Le point professionnel est la dissimulation d'informations, qui fait référence à l'utilisation de types de données abstraits pour encapsuler des données et des opérations basées sur des données. pour en faire une entité indépendante indivisible, les données sont protégées à l'intérieur du type de données abstrait, cachant autant que possible les détails internes et ne conservant que quelques interfaces externes pour les connecter avec l'extérieur. Les autres objets du système ne peuvent communiquer et interagir avec cet objet encapsulé que via des opérations autorisées en dehors des données. C'est-à-dire que l'utilisateur n'a pas besoin de connaître les détails internes de l'objet (bien sûr, il n'y a aucun moyen de le savoir), mais l'utilisateur peut accéder à l'objet via l'interface fournie par l'objet.

Pour l'encapsulation, un objet encapsule ses propres propriétés et méthodes, afin qu'il puisse effectuer ses propres opérations sans s'appuyer sur d'autres objets.

L'utilisation de l'encapsulation présente trois avantages majeurs :

1. Une bonne encapsulation peut réduire le couplage.

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

3. Les membres peuvent être contrôlés avec plus de précision.

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

Examinons d'abord deux classes : Husband.Java, Wife.java

public class Husband {
    
    /*
     * 对属性的封装
     * 一个人的姓名、性别、年龄、妻子都是这个人的私有属性
     */
    private String name ;
    private String sex ;
    private int age ;
    private Wife wife;
    
    /*
     * setter()、getter()是该对象对外开发的接口
     */
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

    public void setWife(Wife wife) {
        this.wife = wife;
    }
}

public class Wife {
    private String name;
    private int age;
    private String sex;
    private Husband husband;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

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

    public void setHusband(Husband husband) {
        this.husband = husband;
    }

    public Husband getHusband() {
        return husband;
    }
    
}

À partir des deux exemples ci-dessus, nous pouvons voir que la référence de la femme dans Mari n'a pas de méthode getter() et que l'âge de la femme n'a pas de méthode getter(). Quant à la raison, je pense que tout le monde la sait. Un homme cache sa femme dans une maison profonde, et aucune femme ne veut que les autres connaissent son âge.

Ainsi, l'encapsulation privatise les propriétés d'un objet et fournit des méthodes pour les propriétés accessibles par le monde extérieur. Si nous ne voulons pas être accessibles par des méthodes extérieures, nous n'avons pas besoin de fournir de méthodes. pour accès extérieur. Mais si une classe ne fournit pas de méthodes d’accès externe, alors cette classe n’a aucun sens. Par exemple, nous considérons une maison comme un objet. Les belles décorations à l'intérieur, comme les canapés, les séries télévisées, les climatiseurs, les tables basses, etc., sont la propriété privée de la maison. Mais si nous n'avons pas ces murs. bloquez-le, les autres le verront d'un coup d'œil. Aucune intimité du tout ! Avec ce mur de protection, nous pouvons avoir notre propre intimité et changer le mobilier à l’intérieur à volonté sans affecter les autres. Mais s’il n’y a ni portes ni fenêtres, que signifie une boîte noire bien emballée ? Par conséquent, d’autres peuvent également voir le paysage intérieur à travers les portes et les fenêtres. Par conséquent, les portes et les fenêtres sont les interfaces de l’objet maison laissées au monde extérieur pour y accéder.

Grâce à cela, nous ne pouvons pas vraiment apprécier les avantages de l’encapsulation. Nous analysons maintenant les avantages de l'encapsulation du point de vue du programme. Si nous n'utilisons pas d'encapsulation, alors l'objet n'a pas setter() et getter(), alors la classe Husband doit être écrite comme ceci :

public class Husband {
    public String name ;
    public String sex ;
    public int age ;
    public Wife wife;
}

On devrait l'utiliser comme ça :

Husband husband = new Husband();
        husband.age = 30;
        husband.name = "张三";
        husband.sex = "男";    //貌似有点儿多余

Mais ça See More jour si nous devons modifier le Husband , par exemple, qu'en est-il du changement age en type String ? Il n'y a rien de mal à ce que vous n'utilisiez cette classe qu'à un seul endroit. Si vous avez des dizaines, voire des centaines d'endroits de ce type, vos modifications provoqueront-elles un crash ? Si l'encapsulation est utilisée, nous n'avons pas besoin d'apporter de modifications. Il suffit de modifier légèrement la méthode setAge() de la classe Husband.

public class Husband {
    
    /*
     * 对属性的封装
     * 一个人的姓名、性别、年龄、妻子都是这个人的私有属性
     */
    private String name ;
    private String sex ;
    private String age ;    /* 改成 String类型的*/
    private Wife wife;
    
    public String getAge() {
        return age;
    }
    
    public void setAge(int age) {
        //转换即可
        this.age = String.valueOf(age);
    }
    
    /** 省略其他属性的setter、getter **/
    
}

      其他的地方依然那样引用(husband.setAge(22))保持不变。

      到了这里我们确实可以看出，封装确实可以使我们容易地修改类的内部实现，而无需修改使用了该类的客户代码。

      我们在看这个好处：可以对成员变量进行更精确的控制。

      还是那个Husband，一般来说我们在引用这个对象的时候是不容易出错的，但是有时你迷糊了，写成了这样：

Husband husband = new Husband();
        husband.age = 300;

      也许你是因为粗心写成了，你发现了还好，如果没有发现那就麻烦大了，逼近谁见过300岁的老妖怪啊！

      但是使用封装我们就可以避免这个问题，我们对age的访问入口做一些控制(setter)如：

public class Husband {
    
    /*
     * 对属性的封装
     * 一个人的姓名、性别、年龄、妻子都是这个人的私有属性
     */
    private String name ;
    private String sex ;
    private int age ;    /* 改成 String类型的*/
    private Wife wife;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age > 120){
            System.out.println("ERROR：error age input....");    //提示錯誤信息
        }else{
            this.age = age;
        }
        
    }
    
    /** 省略其他属性的setter、getter **/
    
}

      上面都是对setter方法的控制，其实通过使用封装我们也能够对对象的出口做出很好的控制。例如性别我们在数据库中一般都是已1、0方式来存储的，但是在前台我们又不能展示1、0，这里我们只需要在getter()方法里面做一些转换即可。

public String getSexName() {
        if("0".equals(sex)){
            sexName = "女";
        }
        else if("1".equals(sex)){
            sexName = "男";
        }
        else{
            sexName = "人妖???";
        }
        return sexName;
    }

      在使用的时候我们只需要使用sexName即可实现正确的性别显示。同理也可以用于针对不同的状态做出不同的操作。

public String getCzHTML(){
        if("1".equals(zt)){
            czHTML = "<a>启用</a>";
        }
        else{
            czHTML = "<a>禁用</a>";
        }
        return czHTML;
    }

      鄙人才疏学浅，只能领悟这么多了，如果文中有错误之处，望指正，鄙人不胜感激！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!