Java-Basisklassen und -Objekte, Singleton-Muster, Vererbung-javaLernprogramm-php.cn

Java-Klassen und -Objekte

Allgemeine Klassen können nur öffentlich oder standardmäßig sein. Wenn sie öffentlich sind, muss der Klassenname mit dem Dateinamen identisch sein. Im Allgemeinen wird nur eine Klasse in eine Datei geschrieben, daher wird diese Klasse normalerweise mit public hinzugefügt.

Innere Klassen können auch privat und geschützt sein, im Allgemeinen privat, da nur die aktuelle Klasse benötigt wird. Auf diese Weise können nur die äußeren Klassen direkt darauf zugreifen. Es spielt also keine Rolle, ob die darin enthaltenen Daten öffentlich, privat oder standardmäßig sind.

public class Out {private int d = 10;public int add() {      // 外部类不能直接访问内部类的数据，除非new出内部类对象,如下  // Out.In abc = new Out().new In();a = 3; // falseb = 5; // false}  // 内部类private class In {private int a = 100;int b;public int c;public void add() {
            System.out.println(d); // true, 内部类却可以直接访问外部类的数据}
    }public static void main(String[] args) {
        Out bb = new Out();
        Out.In abc = new Out().new In();
        bb.d = 20; // 本类可以直接访问private，一般不这样，而是写个set函数，搭配get函数System.out.println(aa.a); // 100System.out.println(bb.d); // 被修改为20}
}Nach dem Login kopieren

Anonymes Objekt

new Abc().run(); // 调用一次后这个对象就销毁new Abc().run(); // 这是另外一个Abc对象了Nach dem Login kopieren

Über private
private Variablen: Kapseln Sie Daten und zeigen Sie Benutzern nur Methoden an. Beispielsweise kann der private String-Name nicht nach Belieben geändert werden, aber die Methoden setName () und getName () können aufgerufen werden, um eine sicherere Datenkapselung zu realisieren.
Private Methode: Eine Funktion, die nicht vom Benutzer aufgerufen werden muss, kann nach Abschluss einiger interner Implementierungsdetails als privat definiert werden. Beispielsweise ist der Auswahlsortierungsalgorithmus als Methode geschrieben, die den Prozess des Austauschs zweier Daten enthält und in eine Funktion gekapselt ist. Diese Funktion muss nicht vom Benutzer ausgeführt werden (der Benutzer muss nur sort() verwenden), und dieser swap() ist als privat definiert.

Einzelnes Entwurfsmuster

kann die Einzigartigkeit der Objekte einer Klasse im Speicher sicherstellen. Wenn Sie dasselbe Konfigurationsinformationsobjekt für mehrere Programme verwenden müssen, müssen Sie dies tun Stellen Sie sicher, dass das Objekt einzigartig ist, dann ist einzelne Instanz erforderlich.

Wenn in der Werkzeugklasse die Objektmitgliedsdaten nicht verwendet (abgerufen) werden, besteht keine Notwendigkeit, ein Objekt zu erstellen. Um die Objekterstellung zu verhindern, kann der Konstruktor als privat definiert werden.

Wie kann die Einzigartigkeit von Objekten sichergestellt werden?

Erlauben Sie anderen Programmen nicht, Objekte dieser Klasse mit new zu erstellen, und setzen Sie den Konstruktor auf privat
Erstellen Sie eine eindeutige Klasseninstanz in diese Klasse
Stellen Sie eine Methode bereit, damit andere Programme dieses einzigartige Objekt erhalten können

Einzelfall-Entwurfsschritte

Private den Konstruktor dieser Klasse
Fügen Sie ein Objekt dieser Klasse durch new in diese Klasse ein
Definieren Sie eine öffentliche Methode, gibt das in 2 erstellte Objekt zurück. >

A: Da new keine neuen Objekte in anderen Klassen erstellen darf, kann getInstance() nicht aufgerufen werden. Wenn wir es auf eine

statische Methode

 festlegen, kann es über <🎜 abgerufen werden > Es ist kein neues Objekt erforderlich und die Daten in der statischen Methode müssen ebenfalls statisch sein. Daher muss dieses SingleDemo-Objekt auch statisch sein. // 饿汉式--不管用不用得到，先new出一个再说public class SingleDemo {// private不能将这个实例暴露出去，只能通过getInstance()获取，另为何是static？private static SingleDemo s = new SingleDemo();private SingleDemo() {}// 供外界调用来获取这个对象public static SingleDemo getInstance() {return s;
    }  // 只有本类中可以new对象并调用addpublic void add() {
        System.out.println("danli");
    }public static void main(String[] args) {      // 本类可以newSingleDemo a = new SingleDemo();
        a.add();
    }
}public class Test {public static void main(String[] args) {      // fasle, 其他类中若用到这个单例，不能newSingleDemo aa = new SingleDemo();      // true  SingleDemo aa = SingleDemo.getInstance();
    }
}Nach dem Login kopieren

F: Was ist der Unterschied zwischen dem Hungrig-Man-Modus und dem Lazy-Man-Modus?

A: Im

Lazy-Modus

 wird das Laden verzögert und ist erst nach der Verwendung neu. Die Einzigartigkeit des Objekts kann beim Multithreading nicht garantiert werden und es ist Thread-unsicher. // 另外一种单例设计模式--懒汉模式--用到了才new，延时加载public class SingleDemo {// 先设为空private static SingleDemo s;private SingleDemo() {}// 供外界调用来获取这个对象public static SingleDemo getInstance() {      if (s == null)
        s = new SingleDemo();return s;
    }Nach dem Login kopieren
Der Hungry-Man-Modus

bedeutet, dass das Objekt beim Laden der Klasse neu ist, egal ob es verwendet wird oder nicht, es ist threadsicher.

Vererbung

Java verfügt im Allgemeinen über EinzelvererbungSingle.getInstance() und kann keine direkte Mehrfachvererbung durchführen -> Da mehrere übergeordnete Klassen möglicherweise dieselben Mitglieder haben, führt der Aufruf zu Mehrdeutigkeiten.

Aber Sie können
mehrstufige Vererbung, wie z. B. A --> B -->--> erbt von C, also Und so weiter.

Verwenden Sie

, um zwischen Mitgliedern dieser Klasse und lokalen Variablen zu unterscheiden.

Verwenden Sie

, wenn Mitglieder von Unterklassen und übergeordneten Klassen dies getan haben derselbe Name Unterscheiden Sie zwischen

Abgeleitete Klassen können nicht auf die privaten Mitglieder der Basisklasse zugreifen, sie werden jedoch geerbt, aber Sie können die Funktion

this
Wenn das Mitglied geschützt ist oder über höhere Berechtigungen verfügt, können Sie ohne
super
Die Mitglieder der Elternklasse und der Unterklasse sind unabhängig voneinander. Die Unterklasse ändert ihre eigenen Mitglieder und die Elternklasse bleibt gleich.
set、get
set、getWenn ein untergeordnetes Objekt neu ist, wird zuerst der Konstruktor der übergeordneten Klasse aufgerufen . Führen Sie dann den Konstruktor der Unterklasse aus.
Der Standardkonstruktor ist Parameterlos, und der
-Konstruktor mit Parametern überschreibt den Parameterlosen

Standard super()

 ausgeführt, der der Konstruktor der übergeordneten Klasse ist ohne Parameter. package Chap1;public class Fu {  // 父类的成员是私有的，子类继承过去了也不能直接访问
  private int age;private String name;public Fu(int age, String name) {this.age = age;this.name = name;
    }public int getAge() {return age;
    }public void setAge(int age) {this.age = age;
    }public String getName() {return name;
    }public void setName(String name) {this.name = name;
    }
}class Zi extends Fu {  // 特有的job，父不能访问private String job;Zi(int age, String name, String job) {super(age, name);this.job = job;
    }public String getJob() {return job;
    }  public static void main(String[] args) {
        Zi aa = new Zi(23, "Zi","Study");
        Fu bb = new Fu(55, "Fu");      // 改变子类不会影响父类aa.setAge(24);
        aa.setName("zi");      // zi 24 Study  // Fu 55System.out.println(aa.getName()+" "+aa.getAge() + " " + aa.getJob());
        System.out.println(bb.getName()+" "+bb.getAge());

    }
}Nach dem Login kopieren

- 类是public，构造函数也是public的。他们的修饰符是对应的。
一个对象的实例化过程
Person p = new Person();
1. JVM读取Person.class文件，加载进内存；若有父类，会先加载父类。
2. 在堆内存中开辟空间，分配地址。
3. 在对象空间中，对对象的属性进行默认初始化，如int age = 0; String name = null;
4. 显示初始化，如private int age = 9。若是子类，则会先调用父类的构造器。
5. （子）类的构造函数进行特定的初始化。如下程序中age变成100。
6. 初始化后，将地址传递给引用变量。Person p <-- new Person();
```
package Test;// 先打印9// 再打印100public class Demo {private int age = 9;
    {
        System.out.println(age);
    }Demo(int age) {this.age = age;
    }public static void main(String[] args) {
        Demo aa = new Demo(100);
        System.out.println(aa.age);
    }
}
```
Nach dem Login kopieren
Das obige ist der detaillierte Inhalt vonJava-Basisklassen und -Objekte, Singleton-Muster, Vererbung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!