Jom tulis one first Contoh kelas tarikh:
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();
}
}
Kod di atas mentakrifkan kelas tarikh, dan kemudian mencipta tiga objek dalam kaedah utama dan menghantarnya melalui kaedah ahli dalam kelas classCode Untuk menetapkan dan mencetak objek, logik keseluruhan kod adalah sangat mudah dan tiada masalah.
Terdapat dua perkara yang perlu diberi perhatian:
1 Nama parameter formal secara tidak sengaja sama dengan nama pembolehubah ahli:
public void setDay(int year, int month, int day){
year = year;
month = month;
day = day;
}Siapa yang memberikan nilai kepada siapa dalam badan fungsi? Pembolehubah ahli kepada pembolehubah ahli? Parameter ke parameter? Parameter kepada pembolehubah ahli? Parameter pembolehubah ahli?
2. Ketiga-tiga objek memanggil fungsi setDate dan printDate, tetapi tiada penerangan tentang objek dalam kedua-dua fungsi ini Bagaimanakah fungsi setDate dan printDate mengetahui data objek yang sedang dicetak?
Anda boleh melihat bahawa jika nama parameter formal dan nama pembolehubah ahli berbeza, nilai pembolehubah selepas tugasan ialah 0, menunjukkan bahawa tugasan itu tidak berjaya.
Apa yang perlu kita lakukan? Tengok bawah.
Rujukan ini menunjuk kepada objek semasa (objek yang memanggil kaedah ahli apabila kaedah ahli sedang dijalankan). melalui rujukan ini. Pergi lawati . Cuma semua operasi adalah telus kepada pengguna, iaitu, pengguna tidak perlu melepasinya, pengkompil melengkapkannya secara automatik.
Kod yang dipertingkatkan:
public void setDay(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}
Anda boleh melihat bahawa selepas menambah rujukan ini, tugasan adalah berjaya.
Ini ditambahkan secara lalai. Walaupun ini tidak ditambahkan, akan ada penambahan ini secara lalai. Tetapi jika anda tidak menambahnya, ia akan menyebabkan masalah jika nama parameter formal dan nama pembolehubah ahli adalah sama.
Dalam kod di bawah, anda boleh melihat bahawa ketiga-tiga objek sedang memanggil fungsi setDate dan printDate, dan tiada penjelasan, jadi bagaimana anda tahu yang mana satu sedang dicetak?
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();
}Anda boleh menilai objek mana yang hendak dicetak dengan dua perkara berikut:
Objek manakah objek sebelumnya dan data objek mana yang dicetak ?
Parameter tersembunyi.
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);
}Tiga cara untuk menggunakan ini:
pembolehubah ahli
this.Access member method
this();Access constructor method
Jenis ini: sepadan dengan rujukan jenis kelas, iaitu objek yang dipanggil ialah kelas rujukan objek itu.
Ini hanya boleh digunakan dalam "kaedah ahli".
Dalam "kaedah ahli", ini hanya boleh merujuk kepada objek semasa dan tidak boleh merujuk kepada objek lain.
Ini ialah parameter tersembunyi pertama bagi "kaedah ahli".
Rujukan objek diserahkan kepada kaedah ahli, dan ini bertanggungjawab untuk menerimanya.
Walaupun nama pembolehubah ahli berbeza daripada nama parameter formal, adalah disyorkan untuk menulis ini bersamaan dengan langkah perlindungan dan juga merupakan amalan pengaturcaraan yang baik.
Tulis kelas akademik dengan atribut seperti nama, umur, dsb., dan kemudian tetapkan nilai atribut ini melalui kaedah, dan kemudian tulis dua kaedah, dalam satu kaedah Gunakan ini untuk memanggil kaedah lain.
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();
}
}
Melalui mempelajari mata pengetahuan sebelumnya, kita tahu bahawa dalam kaedah Java Apabila pembolehubah tempatan ditakrifkan secara dalaman, ia mesti dimulakan, jika tidak penyusunan akan gagal.
public static void main(String[] args) {
int a;
System.out.println(a);
}// Error:(26, 28) java: 可能尚未初始化变量a.Jika ia adalah objek, tiada ralat akan dilaporkan walaupun ia tidak diberikan nilai, kerana ia adalah pembolehubah rujukan.
public static void main(String[] args) {
// 构造一个日期类型的对象
Date date = new Date();
date.setDay(2022, 8, 9);
//打印日期的内容
date.printDate();
}//代码可以正常通过编译Saya menemui dua masalah melalui contoh di atas:
Memanggil kaedah setDate untuk menetapkan tarikh tertentu setiap kali objek dicipta adalah menyusahkan, maka Bagaimanakah objek harus dimulakan?
Pembolehubah setempat mesti dimulakan sebelum ia boleh digunakan Mengapakah medan masih boleh digunakan tanpa nilai selepas ia diisytiharkan?
Ini memperkenalkan kaedah pembinaan. Kemudian lihat ke bawah.
Pembina (juga dipanggil pembina) ialah kaedah ahli khas Nama mesti sama dengan nama kelas semasa menciptanya dipanggil secara automatik oleh pengkompil apabila objek dicipta, dan hanya dipanggil sekali semasa keseluruhan kitaran hayat objek.
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在实例化对象，而实例化对象一定会调用构造方法。
注意：当我们没有提供构造方法时，编译器会自动提供一个不带参数的构造方法。
名字必须与类名相同。
没有返回值类型，设置为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修饰(后序讲单例模式时会遇到)
为什么使用成员变量不需要初始化呢?
在程序层面只是简单的一条语句，在JVM(以后讲)层面需要做好多事情，下面简单介绍下：
检测对象对应的类是否加载了，如果没有加载则加载
为对象分配内存空间
处理并发安全问题
比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突初始化所分配的空间
即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值
比如：
设置对象头信息(关于对象内存模型后面会介绍)调用构造方法，给对象中各个成员赋值
定义成员变量的时候就已经赋值好了。
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();
}
}
注意：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中。
Atas ialah kandungan terperinci Kaedah permulaan rujukan dan pembinaan objek ini dalam java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
