Methoden zum Initialisieren dieser Referenz und Objektkonstruktion in Java

1. Diese Referenz

1.1 Warum sollten wir diese Referenz haben? Schreiben wir zunächst ein Beispiel für eine Datumsklasse: Dann werden in der Hauptmethode drei Objekte erstellt, und die Objekte werden über die Mitgliedsmethoden in der Klasse classCode festgelegt und gedruckt. Die Gesamtlogik des Codes ist sehr einfach und es gibt keine Probleme.

Es sind zwei Dinge zu beachten:

1. Der Name des formalen Parameters ist versehentlich mit dem Namen der Mitgliedsvariablen identisch:

public class classCode {
    public int year;
    public int month;
    public int day;
    public void setDay(int y, int m, int d){
        year = y;
        month = m;
        day = d;
    }
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
    public static void main(String[] args) {
        // 构造三个日期类型的对象 d1 d2 d3
        classCode Date1 = new classCode();
        classCode Date2 = new classCode();
        classCode Date3 = new classCode();

        // 对d1，d2，d3的日期设置
        Date1.setDay(2022, 8, 9);
        Date2.setDay(2023, 8, 9);
        Date3.setDay(2024, 8, 9);

        //打印日期的内容
        Date1.printDate();
        Date2.printDate();
        Date3.printDate();
    }
}

Wer weist wem im Funktionskörper einen Wert zu? Mitgliedsvariable zu Mitgliedsvariable? Parameter zu Parameter? Parameter für Mitgliedsvariablen? Parameter von Mitgliedsvariablen?

2. Alle drei Objekte rufen die Funktionen setDate und printDate auf, aber es gibt keine Beschreibung der Objekte in diesen beiden Funktionen. Woher wissen die Funktionen setDate und printDate, welche Daten gedruckt werden?

Sie können sehen, dass der Wert der Variablen nach der Zuweisung 0 ist, wenn der formale Parametername und der Mitgliedsvariablenname unterschiedlich sind, was darauf hinweist, dass die Zuweisung nicht erfolgreich war.

Was sollen wir tun? Schauen Sie nach unten. 1.2 Was ist diese Referenz? Diese Referenz verweist auf das aktuelle Objekt (das Objekt, das die Mitgliedsmethode aufruft, wenn die Mitgliedsmethode ausgeführt wird). Über diese Referenz wird auf alle Mitgliedsvariablenoperationen in der Mitgliedsmethode zugegriffen.

Es ist nur so, dass alle Vorgänge für den Benutzer transparent sind, das heißt, der Benutzer muss sie nicht übergeben, der Compiler schließt sie automatisch ab.

Verbesserter Code:

public void setDay(int year, int month, int day){ 
    year = year;
    month = month;
    day = day; 
}

Sie können sehen, dass die Aufgabe nach dem Hinzufügen der

this-Referenz erfolgreich ist. dies wird standardmäßig hinzugefügt. Auch wenn dies nicht hinzugefügt wird, wird es standardmäßig hinzugefügt. Wenn Sie es jedoch nicht hinzufügen, führt dies zu Problemen, wenn der Name des formalen Parameters und der Name der Mitgliedsvariablen identisch sind.

Im Code unten können Sie sehen, dass die drei Objekte die Funktionen setDate und

printDate

aufrufen, und es gibt keine Erklärung. Woher wissen Sie also, welche Objektdaten gedruckt werden?

public void setDay(int year, int month, int day){
    this.year = year;
    this.month = month;
    this.day = day;
}

Sie können anhand der folgenden zwei Punkte beurteilen, welches Objekt gedruckt werden soll:

Welches Objekt ist das vorherige Objekt und welche Objektdaten werden gedruckt?Versteckte Parameter. Drei Möglichkeiten,

public static void main(String[] args) {
     // 构造三个日期类型的对象 Date1 Date2 Date3
     Date Date1 = new Date();
     Date Date2 = new Date();
     Date Date3 = new Date();

     // 对Date1，Date2，Date3的日期设置
     Date1.setDay(2022, 8, 9);
     Date2.setDay(2023, 8, 9);
     Date3.setDay(2024, 8, 9);

     //打印日期的内容
     Date1.printDate();
     Date2.printDate();
     Date3.printDate();
}

this zu verwenden:

this. Zugriffsmitgliedsmethode
this(); Zugriffskonstruktor

1. 3 Dies bezieht sich auf Funktionen

• Typ davon:
Entsprechende Klassentypreferenz, dh welches Objekt aufgerufen wird, ist die Referenzklasse dieses Objekts.
Dies kann nur in „Mitgliedsmethoden“ verwendet werden.
In „Member-Methoden“ kann dies nur auf das aktuelle Objekt und nicht auf andere Objekte verweisen.

Dies ist der erste versteckte Parameter der „Member-Methode“, der automatisch vom Compiler übergeben wird. Wenn die Member-Methode ausgeführt wird, ist der Compiler für den Aufruf der Member-Methode verantwortlich.

• Die Referenz des Objekts wird an die Member-Methode übergeben, und diese ist für den Empfang verantwortlich.

Auch wenn sich der Name der Mitgliedsvariablen vom Namen des formalen Parameters unterscheidet, wird empfohlen, dies zu schreiben. Dies entspricht einer Schutzmaßnahme und ist auch eine gute Programmierpraxis.

• 1.4 diese Zitierübung

Schreiben Sie eine akademische Klasse mit Attributen wie Name, Alter usw. und legen Sie dann die Werte dieser Attribute durch eine Methode fest. Zweitens schreiben Sie zwei Methoden und verwenden diese in einer Methode Rufen Sie die andere Methode auf.

• public void setDay(Date this, int y, int m, int d){
      this.year = y;
      this.month = m;
      this.day = d;
  }
  public void printDate(Date this){
      System.out.println(this.year +"-"+ this.month +"-"+ this.day);
  }

• 2. Konstruktion und Initialisierung von Objekten
  2.1 So initialisieren Sie Objekte

Durch die vorherigen Wissenspunkte wissen wir, dass beim Definieren einer lokalen Variablen innerhalb einer Java-Methode diese initialisiert werden muss, andernfalls wird die Kompilierung durchgeführt scheitern.

public class Student {
    public String name;
    public int age;

    public void setStudent(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void printStudent() {
        System.out.println(this.name + "->" + this.age);
    }

    public static void main(String[] args) {
        Student student = new Student();
        student.setStudent("zhangsan", 19);
        student.printStudent();
    }
}

Wenn es sich um ein Objekt handelt, wird kein Fehler gemeldet, auch wenn ihm kein Wert zugewiesen ist, da es sich um eine Referenzvariable handelt.

public static void main(String[] args) {
    int a;
    System.out.println(a);
}// Error:(26, 28) java: 可能尚未初始化变量a.

Ich habe in den obigen Beispielen zwei Probleme gefunden:

Der Aufruf der setDate-Methode zum Festlegen des spezifischen Datums bei jeder Objekterstellung ist problematisch. Wie sollte das Objekt initialisiert werden?

Lokale Variablen müssen initialisiert werden, bevor sie verwendet werden können, nachdem das Feld deklariert wurde.

Hier wird die Bauweise vorgestellt. Dann schau nach unten.

2.2 Konstruktor 2.2.1 Konzept

Der Konstruktor (auch Konstruktor genannt) ist eine spezielle Member-Methode, deren Name mit dem Klassennamen übereinstimmen muss. Sie wird beim Erstellen eines Objekts automatisch aufgerufen und durchgehend verwendet Es wird nur einmal während der Lebensdauer des Objekts aufgerufen.

• public class Student {
      public String name;
      public int age;
      public Student(){//这是一个构造方法
          System.out.println("不带参数的构造方法");
      }
      public Student(String name, int age) {//这是一个构造方法
          System.out.println("带参数的构造方法");
          this.name = name;
          this.age = age;
      }
      public void setStudent(String name, int age) {
          this.name = name;
          this.age = age;
      }
      public void printStudent() {
          System.out.println(this.name + "->" + this.age);
      }
      public static void main(String[] args) {
          Student student = new Student();//这一行是构造方法的调用
      }
  }

  

  Student student = new Student();
  new在实例化对象，而实例化对象一定会调用构造方法。

  注意：当我们没有提供构造方法时，编译器会自动提供一个不带参数的构造方法。

  2.2.2 特性

  • 名字必须与类名相同。

  • 没有返回值类型，设置为void也不行。

  • 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次。

  • 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法。

   public Student(){//不带参数的构造方法
          System.out.println("不带参数的构造方法");
      }
      public Student(String name, int age) {//带两个参数的构造方法
          System.out.println("带参数的构造方法");
          this.name = name;
          this.age = age;
  
      }

  上述两个构造方法：名字相同，参数列表不同，因此构成了方法重载。

  如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。

  public class Work {
      public int one = 1;
      public int three = 3;
      public int two = 2;
  
      public void printWork() {
          System.out.println(one + "-" + two + "-" + three);
      }
  
      public static void main(String[] args) {
          Work work = new Work();
          work.printWork();
      }
  }

  

  上述Work类中，没有定义任何构造方法，编译器会默认生成一个不带参数的构造方法。

  那如何调用带参数的构造方法呢？

  public class Work {
      public int one = 1;
      public int three = 3;
      public int two = 2;
  
      public Work(int one, int two, int three) {
          System.out.println("带参数的构造方法");
          this.one = one;
          this.two = two;
          this.three = three;
      }
  
      public void printWork() {
          System.out.println(one + "-" + two + "-" + three);
      }
  
      public static void main(String[] args) {
          Work work = new Work(3, 6, 9);
          work.printWork();
      }
  }

  

  注意：一旦用户定义，编译器则不再生成。

  构造方法中，可以通过this调用其他构造方法来简化代码。

   public Work() {
          this(10, 20, 30);//调用本类当中其他的构造方法
          System.out.println("不带参数的的构造方法");
      }
  
      public Work(int one, int two, int three) {
          System.out.println("带参数的构造方法");
          this.one = one;
          this.two = two;
          this.three = three;
      }

  注意：

  • this调用必须在构造方法里面，

  • 要在在第一行，

  • 不能写成循环调用。

  绝大多数情况下使用public来修饰，特殊场景下会被private修饰(后序讲单例模式时会遇到)

  2.3 默认初始化

  为什么使用成员变量不需要初始化呢?

  

  在程序层面只是简单的一条语句，在JVM(以后讲)层面需要做好多事情，下面简单介绍下：

  • 检测对象对应的类是否加载了，如果没有加载则加载

  • 为对象分配内存空间

  • 处理并发安全问题

  比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突初始化所分配的空间
  即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值

  比如：

  

  设置对象头信息(关于对象内存模型后面会介绍)调用构造方法，给对象中各个成员赋值

  2.4 就地初始化

  定义成员变量的时候就已经赋值好了。

  public class HardWork {
      public int a = 10;//就地初始化
      public int b = 20;//就地初始化
      public String c = "zhangsan";//就地初始化
  
      public void setWork(int a,  int b, String c) {
          this.a = a;
          this.b = b;
          this.c = c;
      }
  
      public void printWork() {
          System.out.println(a + "-" + b + "-" + c);
      }
      public static void main(String[] args) {
          HardWork work = new HardWork();
          work.printWork();
          System.out.println();
      }
  }

  

  注意：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中。

Das obige ist der detaillierte Inhalt vonMethoden zum Initialisieren dieser Referenz und Objektkonstruktion in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!