Chapitre sur l'amélioration de Java (1) ----- Comprendre l'encapsulation des trois principales caractéristiques de Java

Cela fait presque trois ans que je suis entré en contact avec Java au cours de ma deuxième année. Du HTML et CSS les plus basiques au SSH final, je l'ai parcouru étape par étape. J'étais heureux, déçu et seul. Bien qu'il soit moine à mi-chemin, il a achevé son « étude » grâce à ses propres efforts. Pendant cette période, j'ai participé à des institutions de formation, mais je n'aimais vraiment pas ce genre de méthode de formation, alors j'ai abandonné et j'ai choisi l'auto-apprentissage (pauvre, j'ai payé 6 000 yuans). c'était plus amusant. L'effort et le gain étaient seulement Vous le savez vous-même. Huang Tian a été à la hauteur de son travail acharné, mais je suis stupide. Au cours du premier semestre de sa dernière année, il a finalement terminé Java par lui-même (il a fait un détour et a perdu six mois) et a obtenu un bon travail avec. toi beaucoup!

Trop de potins ! En ce qui concerne le sujet, LZ vient de terminer récemment la lecture du modèle de conception et a beaucoup de sentiments. Et en train de travailler, j'ai profondément le sentiment que les fondations de Java ne sont pas assez solides. Par exemple, je ne suis pas familier avec IO, je ne comprends pas le garbage collection, le polymorphisme, la réflexion et même les trois fonctionnalités les plus élémentaires sont confuses. moi! Je suis donc déterminé à rattraper mes bases Java ! Dès la première leçon---Encapsulation!!!!!!

Une des trois caractéristiques majeures---Encapsulation

L'encapsulation signifie littéralement emballage, et le point professionnel est la dissimulation d'informations, fait référence à l'utilisation de types de données abstraits pour encapsuler des données et des opérations basées sur les données afin de former 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 certaines interfaces externes qui lui permettent de le faire. communiquer avec le monde 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 interne 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.

Tout d'abord, regardons 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 qu'il n'y a pas de getter pour la femme référence dans Husband (), et l’âge de la femme n’a pas de méthode getter(). Quant à la raison, je pense que tout le monde la connaît. Les hommes cachent leur femme dans des maisons profondes, 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 pourront-ils le voir 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 des objets de la 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 devrait être écrite comme ceci :

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

Nous devrions l'utiliser comme ceci :

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

Mais que se passe-t-il si nous devons modifier le mari ce jour-là, par exemple, changer l'âge en type String ? C'est normal que vous n'utilisiez cette classe qu'à un seul endroit. Si vous en avez des dizaines, voire des centaines, la changerez-vous en 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 **/

Autres lieux toujours référence (husband.setAge(22)) inchangée.

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

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

还是那个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 href=&#39;javascript:void(0)&#39; onclick=&#39;qy("+id+")&#39;>启用</a>";  
        }  
        else{  
            czHTML = "<a href=&#39;javascript:void(0)&#39; onclick=&#39;jy("+id+")&#39;>禁用</a>";  
        }  
        return czHTML;  
    }

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

以上就是 java提高篇(一)-----理解java的三大特性之封装的内容，更多相关内容请关注PHP中文网（www.php.cn）！