Java-Verbesserung Kapitel (1) -----Verstehen der Kapselung der drei Hauptmerkmale von Java

Es ist fast drei Jahre her, seit ich in meinem zweiten Jahr mit Java in Kontakt kam. Vom einfachsten HTML und CSS bis zum endgültigen SSH habe ich es Schritt für Schritt durchgearbeitet. Ich war glücklich, enttäuscht und einsam. Obwohl er ein Halbmönch ist, hat er sein „Studium“ aus eigener Kraft abgeschlossen. Während dieser Zeit nahm ich an Ausbildungseinrichtungen teil, aber diese Art der Ausbildung gefiel mir wirklich nicht, also gab ich auf und entschied mich für das Selbststudium (schlecht, ich zahlte 6.000 Yuan, obwohl das Selbststudium sehr schmerzhaft war). Es hat mehr Spaß gemacht, und der Aufwand und der Gewinn waren nur Sie wissen es selbst. Huang Tian hat seiner harten Arbeit alle Ehre gemacht, aber ich bin dumm. Im ersten Semester seines letzten Jahres hat er Java schließlich im Selbststudium abgeschlossen (wobei er einen Umweg gemacht und ein halbes Jahr verschwendet hat) und einen guten Job bekommen damit. Vielen Dank!

Zu viel Klatsch! Was das Thema angeht: LZ hat kürzlich das Designmuster gelesen und hat viele Gefühle. Und während ich arbeite, habe ich zutiefst das Gefühl, dass die Grundlage von Java nicht solide genug ist. Ich bin beispielsweise nicht mit IO vertraut, ich verstehe Garbage Collection, Polymorphismus und Reflektion nicht und selbst die drei grundlegendsten Funktionen sind verwirrend Mich! Deshalb bin ich fest entschlossen, meine Java-Grundkenntnisse nachzuholen! Beginnend mit der ersten Lektion: Kapselung!!! bezieht sich auf die Verwendung abstrakter Datentypen zur Kapselung von Daten und datenbasierten Vorgängen, um eine untrennbare unabhängige Einheit zu bilden. Die Daten werden innerhalb des abstrakten Datentyps geschützt, wobei interne Details so weit wie möglich ausgeblendet werden und dies nur durch die Beibehaltung einiger externer Schnittstellen möglich ist mit der Außenwelt kommunizieren. Andere Objekte im System können nur über autorisierte Operationen außerhalb der Daten mit diesem gekapselten Objekt kommunizieren und interagieren. Das heißt, der Benutzer muss die internen Details des Objekts nicht kennen (natürlich gibt es keine Möglichkeit, dies zu wissen), aber der Benutzer kann über die vom Objekt bereitgestellte Schnittstelle auf das Objekt zugreifen.

Bei der Kapselung kapselt ein Objekt seine eigenen Eigenschaften und Methoden, sodass es seine eigenen Vorgänge ausführen kann, ohne auf andere Objekte angewiesen zu sein.

Die Verwendung der Kapselung bietet drei Hauptvorteile:

1. Eine gute Kapselung kann die Kopplung verringern.

2. Die interne Struktur der Klasse kann frei geändert werden.

3. Sie können Mitglieder genauer steuern.

4. Informationen ausblenden und Details implementieren.

Schauen wir uns zunächst zwei Klassen an: Husband.java, Wife.java

Anhand der beiden obigen Beispiele können wir erkennen, dass es für die Frau keinen Getter gibt Referenz in Husband (), und das Alter der Frau hat keine getter()-Methode. Was den Grund angeht, denke ich, dass jeder ihn kennt. Ein Mann versteckt seine Frau in einem tiefen Haus, und keine Frau möchte, dass andere ihr Alter erfahren.

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

Die Kapselung privatisiert also die Eigenschaften eines Objekts und stellt einige Methoden für Eigenschaften bereit, auf die die Außenwelt zugreifen kann. Wenn wir nicht möchten, dass externe Methoden darauf zugreifen, müssen wir keine Methoden bereitstellen für den Zugang von außen. Wenn eine Klasse jedoch keine Methoden für den externen Zugriff bereitstellt, ist diese Klasse bedeutungslos. Zum Beispiel betrachten wir ein Haus als Objekt. Die schönen Dekorationen im Inneren, wie Sofas, Fernsehserien, Klimaanlagen, Teetische usw., sind das Privatvermögen des Hauses Blockieren Sie es, andere werden es auf einen Blick sehen. Was ist, wenn nichts mehr übrig ist? Überhaupt keine Privatsphäre! Mit dieser Schutzwand können wir unsere Privatsphäre wahren und die Inneneinrichtung nach Belieben verändern, ohne andere zu beeinträchtigen. Aber wenn es keine Türen oder Fenster gibt, was bedeutet dann eine dicht umwickelte Black Box? Daher können auch andere durch die Türen und Fenster die Landschaft im Inneren sehen. Daher sind Türen und Fenster die Schnittstellen des Objekts Haus, die der Außenwelt zugänglich gemacht werden.

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

Dadurch können wir die Vorteile der Kapselung nicht wirklich einschätzen. Jetzt analysieren wir die Vorteile der Kapselung aus Programmperspektive. Wenn wir keine Kapselung verwenden, dann verfügt das Objekt nicht über setter() und getter(), dann sollte die Husband-Klasse so geschrieben werden:

Wir sollten sie so verwenden:

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

Aber was ist, wenn wir „Ehemann“ an diesem Tag ändern müssen, zum Beispiel das Alter in „String“ ändern? Es ist in Ordnung, dass Sie diese Klasse nur an einer Stelle verwenden. Wenn Sie Dutzende oder sogar Hunderte solcher Stellen haben, führen Ihre Änderungen dann zu einem Absturz? Wenn Kapselung verwendet wird, müssen wir keine Änderungen vornehmen. Wir müssen nur die setAge()-Methode der Husband-Klasse geringfügig ändern. }

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

Andere Orte werden weiterhin unverändert referenziert (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 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）！