Kapselung bedeutet im wahrsten Sinne des Wortes das Verbergen von Informationen, was sich auf die Verwendung abstrakter Datentypen zur Kapselung von Daten und datenbasierten Vorgängen bezieht Damit es eine unteilbare unabhängige Einheit darstellt, werden die Daten innerhalb des abstrakten Datentyps geschützt, wobei die internen Details so weit wie möglich ausgeblendet werden und nur einige externe Schnittstellen beibehalten werden, um sie mit der Außenwelt zu verbinden. 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 Struktur innerhalb der Klasse kann frei geändert werden.
3. Mitglieder können genauer gesteuert werden.
4. Informationen ausblenden und Details implementieren.
Schauen wir uns zunächst zwei Klassen an: 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;
}
}
Aus den beiden obigen Beispielen können wir ersehen, dass die Ehefrau-Referenz in Husband keine getter()-Methode hat und das Alter der Ehefrau keine getter()-Methode hat. 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.
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. Können andere 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.
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, verfügt das Objekt nicht über setter() und getter(), dann sollte die Husband-Klasse wie folgt geschrieben werden:
public class Husband {
public String name ;
public String sex ;
public int age ;
public Wife wife;
}
Wir sollten es so verwenden:
Husband husband = new Husband(); husband.age = 30; husband.name = "张三"; husband.sex = "男"; //貌似有点儿多余
Aber das Tag, wenn wir beispielsweise den Husband ändern müssen, wie wäre es dann mit der Änderung des Alters in den Typ String? Es ist in Ordnung, diese Klasse nur an einer Stelle zu verwenden. Wenn Sie Dutzende oder sogar Hunderte solcher Orte haben, ändern Sie sie dann in einen Absturz? Wenn Kapselung verwendet wird, müssen wir keine Änderungen vornehmen. Wir müssen nur die Methode setAge() der Klasse Husband geringfügig ändern.
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;
}
鄙人才疏学浅，只能领悟这么多了，如果文中有错误之处，望指正，鄙人不胜感激！
Das obige ist der detaillierte Inhalt vonAusführliche Erläuterung von Kapselungsbeispielen der drei Hauptfunktionen von Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
