Java类和对象（重点：this引用、构造方法）
目录
一、类的定义方式以及实例化
1.面向对象
Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在Java的世界里一切皆为对象。
2.类的定义和使用
1.在java中定义类时需要用到class关键字
3.类的实例化
4.类实例化的使用
二、this引用
例子1：this能区分调用方法的对象。
例子2：this区分局部变量和引用对象。
例子3：建议给对象都加上this.
三、对象的构造及初始化
1.初始化对象
1.通过引用赋值来初始化
2.就地初始化：定义成员变量的同时初始化。（一般不用）
2.构造方法
(1) 不带参数的构造方法
1.这个构造方法是如何被调用的？？？
2.那为什么之前没有写构造方法的时候，也能正常执行show方法呢？？？
(2) 带参数的构造方法
1.构造方法可以有多个 且 构造方法之间构成重载关系
2.一旦自己写了构造函数，编译器不会自动提供了
3.构造函数快捷键生成
4.使用this（）在构造方法内，调用其他构造方法
this（）这个语法只能出现在构造方法当中
只能出现在当前构造方法的第一行！！！
注意：不能自己调用自己！！！
（4）this引用的小总结
一、类的定义方式以及实例化
1.面向对象
Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在Java的世界里一切皆为对象。
举个例子：洗衣服
面向过程：人 - 把洗衣粉倒进盆里 - 打开水龙头 - 放衣服 - 搓衣服 - 清水洗 - 再放洗衣粉 - 搓衣服 - 清水洗 - 扭干衣服
面向对象： 人 - 洗衣粉 - 洗衣机
至于洗衣机是左旋转几圈还是右旋转几圈，不在乎洗的过程。
2.类的定义和使用
类是用来对一个实体 ( 对象 ) 来进行描述的 ，主要描述该实体 ( 对象 ) 具有哪些属性 ( 外观尺寸等 ) ，哪些功能 ( 用来干 啥) ，描述完成后计算机就可以识别了定义了一个类，相当于在计算机中定义了一种新的类型
1.在java中定义类时需要用到class关键字
class WashMachine{
//属性
public String brand; // 品牌
public String type; // 型号
public double weight; // 重量
public String color; // 颜色
//方法
public void washClothes(){ // 洗衣服
System.out.println("洗衣功能");
}
public void dryClothes(){ // 脱水
System.out.println("脱水功能");
}
public void setTime(){ // 定时
System.out.println("定时功能");
}
}3.类的实例化
实例化 ：用 定义的类 创建对象，就是类的实例化
用new关键字实例化对象（同一个类可以实例化多个对象）以下代码：
PetDog petDog1 = new PetDog();
同理PetDog petDog2 = new PetDog();就是在实例化对象
类相当于是一个模型，用这个模型可以造出很多个对象。所以可以实例化多个对象。
class PetDog{
//狗的属性
public String name;//名字
public String color;//颜色
//狗的行为
public void barks(){
System.out.println(name + ":旺旺旺~~~");
}
public void wag(){
System.out.println(name + ":摇尾巴~~~");
}
}
public class Test2 {
public static void main(String[] args) {
//实例化 ：定义了一个类，相当于在计算机中定义了一种新的类型
//用 定义的类 创建对象，就是类的实例化
//用new关键字实例化对象（同一个类可以实例化多个对象）
PetDog petDog1 = new PetDog();
petDog1.color = "红色";
petDog1.name = "feifei";
//访问实例化对象的属性
System.out.println(petDog1.name);
System.out.println(petDog1.color);
//调用实例化对象的行为
petDog1.barks();
petDog1.wag();
System.out.println("============================");
PetDog petDog2 = new PetDog();
petDog2.color = "白色";
petDog2.name = "huahua";
//访问实例化对象的属性
System.out.println(petDog2.name);
System.out.println(petDog2.color);
//调用实例化对象的行为
petDog2.barks();
petDog2.wag();
// System.out.println(petDog1);//对象的地址
// System.out.println(petDog2);
}
}
4.类实例化的使用
给对象赋值
打印实例化对象的属性，以及 .方法 来调用方法
结果：
二、this引用
this引用指向当前对象 ( 成员方法运行时调用该成员方法的对象 ) ，在成员方法中所有成员变量的操作，都是通过该 引用去访问 。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。作用：
1.能区分调用方法的对象。 date调用的，就对date操作；date2调用的，就对date2操作。 2.区分局部变量和引用对象。 避免形参名与对象名相同时，局部变量自己赋值。
例子1：this能区分调用方法的对象。
方法只有1个，现在有两个实例化对象date和date2，那么在调用这个方法的时候，我们怎么确定 这个方法是给date赋值，还是在给date2赋值？ date.setDate(1999,1,1);//调用setDate方法,传参 1999,1,1 date2.setDate(2000,2,2);//调用setDate方法,传参 2000,2,2 虽然在调用的时候，有写date或者date2，但是进入方法以后，谁知道谁是谁呢？ 其实，这个方法有个隐藏的函数，Date.this
public class Date {
//属性
public int year;//public int year = 2023;//一般不写值，写了相当于默认值
public int month;
public int day;
//方法
public void setDate(int y,int m,int d){
year = y;
month = m;
day = d;
}
}
public void print(){
System.out.println("year:"+year+" month:"+month+" day:"+day);
}
public static void main(String[] args) {
Date date = new Date();//实例化一个date
date.setDate(1999,1,1);//调用setDate方法,传参 1999,1,1
// 然后进入该方法，y,m,d根据方法里的内容赋值
Date date2 = new Date();//又实例化一个date2
date2.setDate(2000,2,2);//调用setDate方法,传参 2000,2,2
date.print();
date2.print();
}
}
例子2：this区分局部变量和引用对象。
给当 传入的形参名，与被赋值的对象名不同时，加不加this，没有任何影响，打印出来时正常的。 相同时，例如：此时形参名year和对象名 year相同，此时赋值，受局部变量优先的影响，形参（year）自己给自己赋值， 这样打印的结果就不是正常的
得到的结果：
public class Date {
//属性
public int year;//public int year = 2023;//一般不写值，写了相当于默认值
public int month;
public int day;
//方法
public void setDate(int year,int month,int day){
year = year;
month = month;
day = day;
public void print(){
System.out.println("year:"+year+" month:"+month+" day:"+day);
}
public static void main(String[] args) {
Date date = new Date();//实例化一个date
date.setDate(1999,1,1);//调用setDate方法,传参 1999,1,1
// 然后进入该方法，y,m,d根据方法里的内容赋值
Date date2 = new Date();//又实例化一个date2
date2.setDate(2000,2,2);//调用setDate方法,传参 2000,2,2
date.print();
date2.print();
}
}
例子3：建议给对象都加上this.
又得到了预期的结果
所以建议以后写，都加上this，避免这些容易犯的错误
public class Date {
//属性
public int year;//public int year = 2023;//一般不写值，写了相当于默认值
public int month;
public int day;
//方法
public void setDate(Date this,int year,int month,int day){
this.year = year;
this.month = month;
this.day = day;
}
public void print(){
System.out.println("year:"+year+" month:"+month+" day:"+day);
}
public static void main(String[] args) {
Date date = new Date();//实例化一个date
date.setDate(1999,1,1);//调用setDate方法,传参 1999,1,1
// 然后进入该方法，y,m,d根据方法里的内容赋值
Date date2 = new Date();//又实例化一个date2
date2.setDate(2000,2,2);//调用setDate方法,传参 2000,2,2
date.print();
date2.print();
}
}
三、对象的构造及初始化
1.初始化对象
1.通过引用赋值来初始化
在定义属性的时候一般不赋值，也就是不初始化。
与局部变量不同，局部变量在使用前必须初始化，否则会报错。 而成员变量没有初始化时，有一个默认值。比如int - 0,float - 0.0f,double - 0.0,boolean - false，char - '\u0000' 引用类型例如String - null
2.就地初始化：定义成员变量的同时初始化。（一般不用）
就地初始化：有特殊的业务需求，比如任何一次对象的实例化之后，都期望这个对象叫张三 或者年龄都是9
class Student{
public String name ;//没有初始化，默认为null
public int age ;//没有初始化，默认为0
//public String name = "张三";
//public int age = 9;
public void eat() {
System.out.println(this.name+"吃饭！");
}
public void show(){
//this.eat();//可以在成员方法里，调用另一个成员方法
System.out.println("姓名："+this.name+" 年龄："+this.age);
}
}
public class Test {
public static void main(String[] args) {
/**
* 实例化对象
*/
Student student = new Student();
//同过对象的引用来初始化
student.name = "zhangsan";
student.age = 10;
student.show();
System.out.println("====================");
Student student2 = new Student();
student2.name = "lisi";
student2.age = 15;
student2.show();
}
}
2.构造方法
构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且 在整个对象的生命周期内只调用一次。
构造方法：（非常特殊！！）1.没有返回值
2.方法名必须和类名一样
特性1. 名字必须与类名相同2. 没有返回值类型，设置为 void 也不行3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次 ( 相当于人的出生，每个人只能出生一次 )4. 构造方法可以重载 ( 用户根据自己的需求提供不同参数的构造方法 )这是当前类
这是类里写的构造方法
(1) 不带参数的构造方法
class Student{
public String name ;//没有初始化，默认为null// 就地初始化：定义成员变量的同时初始化。public String name = "张三"
public int age ;//没有初始化，默认为0 //public int age = 9
public void eat() {
System.out.println(this.name+"吃饭！");
}
public void show(){
//this.eat();//可以在成员方法里，调用另一个成员方法
System.out.println("姓名："+this.name+" 年龄："+this.age);
}
//构造方法
public Student(){
this.name = "鼠标";
this.age = 9;
System.out.println("构造方法Student()");
}
}
public class Test {
public static void main(String[] args) {
Student student = new Student();
student.show();
}
}
1.这个构造方法是如何被调用的？？？
运行代码时，发现调用show（）方法之前，先调用了构造方法Student（）
在new Student（）这先调用了构造方法public Student，然后在这个构造方法里赋值了，打印了 ”构造方法Student（）“这个内容。然后调用了student.show，将属性打印出来 姓名：鼠标 年龄：9
2.那为什么之前没有写构造方法的时候，也能正常执行show方法呢？？？
因为，当我们没有写任何一个构造方法的时候，Java会自动提供一个不带参数的构造方法。就是这个样子
public Student(){ }
(2) 带参数的构造方法
1.构造方法可以有多个 且 构造方法之间构成重载关系
class Student{ public String name ;//没有初始化，默认为null// 就地初始化：定义成员变量的同时初始化。public String name = "张三" public int age ;//没有初始化，默认为0 //public int age = 9 public void eat() { System.out.println(this.name+"吃饭！"); } public void show(){ //this.eat();//可以在成员方法里，调用另一个成员方法 System.out.println("姓名："+this.name+" 年龄："+this.age); } /** * 构造方法 */ //不带参数的构造方法 public Student(){ this.name = "鼠标"; this.age = 9; System.out.println("不带参数的构造方法Student()"); } //带参数的构造方法 public Student(String name,int age){ this.name = name; this.age = age; System.out.println("带参数的构造方法Student(String,int)"); } } public class Test { public static void main(String[] args) { Student student = new Student(); student.show(); System.out.println("=================="); Student student2 = new Student("小明",19); student2.show(); } }运行结果
可以发现：
1.构造方法可以有多个
2.构造方法之间构成重载关系
2.一旦自己写了构造函数，编译器不会自动提供了
假如此时把不带参数的构造方法删掉，就会报错了
class Student{
public String name ;//没有初始化，默认为null// 就地初始化：定义成员变量的同时初始化。public String name = "张三"
public int age ;//没有初始化，默认为0 //public int age = 9
public void eat() {
System.out.println(this.name+"吃饭！");
}
public void show(){
//this.eat();//可以在成员方法里，调用另一个成员方法
System.out.println("姓名："+this.name+" 年龄："+this.age);
}
/**
* 构造方法
*/
//带参数的构造方法
public Student(String name,int age){
this.name = name;
this.age = age;
System.out.println("带参数的构造方法Student(String,int)");
}
}
public class Test {
public static void main(String[] args) {
Student student = new Student();
student.show();
System.out.println("==================");
Student student2 = new Student("小明",19);
student2.show();
}
}
不是说，编译器会自动提供不带参数的构造方法吗？？这里为什么又会报错呢？？
原因很简单，当一个构造函数都没有的情况下，才会默认自动提供一个不带参数的
构造方法。目前没有不带参数的构造方法，但是有一个带参数的构造方法，就不会提供了。
以自己编写的这个带参数的构造方法为主，此时，new Student()实例化一个新的对象，里面没有带参数，而自己写的那个是带参数的，所以就报错了。
3.构造函数快捷键生成
如果有太多构造函数需要编写，IDEA有一个快捷键，一键生成。
快捷键 alt+insert ，或者 鼠标右键
4.使用this（）在构造方法内，调用其他构造方法
this（）这个语法只能出现在构造方法当中
只能出现在当前构造方法的第一行！！！
注意：不能自己调用自己！！！
成功调用
只能出现在构造方法的第一行！！！
下面这个就错了！！
（4）this引用的小总结
1.this.成员变量
2.this.成员方法
3.this（）在构造方法里调用其他构造方法
注意！！this代表当前对象的引用，而不是当前对象。
因为实例化对象的重要两步是：
1.为对象分配内存
2.调用合适的构造方法
而在调用构造方法的时候，this还在其中使用，所以是对当前对象的印象！！！