Tout d'abord, écrivons un exemple de classe de date :
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();
}
}
Le code ci-dessus définit une classe de date, et puis dans la méthode principale, trois objets sont créés, et les objets sont définis et imprimés via les méthodes membres de la classe classCode. La logique globale du code est très simple et il n'y a aucun problème.
Il y a deux choses auxquelles il faut faire attention :
1. Le nom du paramètre formel est accidentellement le même que le nom de la variable membre :
public void setDay(int year, int month, int day){
year = year;
month = month;
day = day;
}Qui attribue des valeurs à qui dans le corps de la fonction ? Variable membre à variable membre ? Paramètre à paramètre ? Paramètres des variables membres ? Paramètres des variables membres ?
2. Les trois objets appellent les fonctions setDate et printDate, mais il n'y a aucune description des objets dans ces deux fonctions Comment les fonctions setDate et printDate savent-elles quelles données d'objet sont imprimées ?
Vous pouvez voir que si le nom du paramètre formel et le nom de la variable membre sont différents, la valeur de la variable après l'affectation est 0, indiquant que l'affectation n'a pas réussi.
Que devons-nous faire ? Regardez en bas.
Cette référence pointe vers l'objet actuel (l'objet qui appelle la méthode membre lorsque la méthode membre est en cours d'exécution). Toutes les opérations de variables membres dans la méthode membre sont accessibles via cette référence. C'est juste que toutes les opérations sont transparentes pour l'utilisateur, c'est-à-dire que l'utilisateur n'a pas besoin de les transmettre, le compilateur les complète automatiquement.
Code amélioré :
public void setDay(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}
Vous pouvez voir qu'après avoir ajouté la référence this, la mission est réussie.
ceci est ajouté par défaut. Même si cela n'est pas ajouté, il y aura un ceci ajouté par défaut. Mais si vous ne l'ajoutez pas, cela posera des problèmes si le nom du paramètre formel et le nom de la variable membre sont identiques.
Dans le code ci-dessous, vous pouvez voir que les trois objets appellent les fonctions setDate et printDate, et il n'y a aucune explication. Alors, comment savoir quel objet est imprimé ?
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();
}Vous pouvez juger quel objet imprimer à travers les deux points suivants :
Quel objet est l'objet précédent et quelles données d'objet sont imprimées
Paramètres cachés. Trois façons d'utiliser
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);
}this :
this Variable membre
méthode membre d'accès
constructeur d'accès
Type de ceci : Référence de type de classe correspondante, c'est-à-dire que l'objet appelé est la classe de référence de cet objet.
Ceci ne peut être utilisé que dans les "méthodes membres".
Dans les "méthodes membres", cela ne peut faire référence qu'à l'objet actuel et ne peut pas faire référence à d'autres objets.
c'est le premier paramètre caché de la "méthode membre", qui sera automatiquement passé par le compilateur Lorsque la méthode membre est exécutée, le compilateur se chargera d'appeler la méthode membre.
La référence de l'objet est transmise à la méthode membre, et celle-ci se charge de la recevoir.
Même si le nom de la variable membre est différent du nom du paramètre formel, il est recommandé de l'écrire. Cela équivaut à une mesure de protection, et c'est également une bonne pratique de programmation.
Écrivez une classe académique avec des attributs tels que le nom, l'âge, etc., puis définissez les valeurs de ces attributs via une méthode. Deuxièmement, écrivez deux méthodes et utilisez-les dans une seule méthode pour. appeler une autre méthode.
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();
}
}
Grâce aux points de connaissances précédents, nous savons que lors de la définition d'une variable locale à l'intérieur d'une méthode Java, elle doit être initialisée, sinon la compilation sera échouer.
public static void main(String[] args) {
int a;
System.out.println(a);
}// Error:(26, 28) java: 可能尚未初始化变量a.S'il s'agit d'un objet, aucune erreur ne sera signalée même si aucune valeur ne lui est attribuée, car il s'agit d'une variable de référence.
public static void main(String[] args) {
// 构造一个日期类型的对象
Date date = new Date();
date.setDay(2022, 8, 9);
//打印日期的内容
date.printDate();
}//代码可以正常通过编译J'ai trouvé deux problèmes à travers les exemples ci-dessus :
Appeler la méthode setDate pour définir la date spécifique à chaque fois que l'objet est créé est gênant. Comment l'objet doit-il être initialisé ?
Les variables locales doivent être initialisées avant de pouvoir être utilisées. Pourquoi peuvent-elles encore être utilisées sans donner de valeur une fois le champ déclaré ?
Ceci présente la méthode de construction. Alors regarde en bas.
Le constructeur (également appelé constructeur) est une méthode membre spéciale dont le nom doit être le même que le nom de la classe. Elle est automatiquement appelée par le compilateur lors de la création d'un objet et est utilisée partout. Il n'est appelé qu'une seule fois au cours de la vie de l'objet.
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();
}
}
注意：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中。
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
