day0720211208

湖南Java

面向对象2 构造函数 构造代码块 this

1.构造方法

1.1概念

构造方法是一种特殊的方法,它是一个与类同名且没有返回值类型的方法
构造方法的主要功能就是完成对象创建或者初始化
当类创建对象(实例化)时,就会自动调用构造方法
构造方法与普通方法一样也可以重载.

1.2形式

与类同名,且没有返回值类型,可以含参也可以不含参

1.3练习：构造方法创建对象/构造方法赋值

创建包：cn.tedu.oop
创建类：TestConstructor.java

package cn.tedu.oop;
/*本类用于测试构造方法*/
public class TestConstructor {
    public static void main(String[] args) {
        //4.创建Perosn类的对象进行测试
        /*1.每次new(实例化)对象时，都会自动触发对应类的构造方法*/
        /*2.每一个类都会默认存在一个没有参数的构造方法
        * 但是，如果你提供了其他的构造函数，默认的无参构造会被覆盖
        * 所以，我们要手动的提供无参构造，这样才能不传参数，也能创建对象*/
        Person p = new Person();
        System.out.println(p.age);
        System.out.println(p.name);
        System.out.println(p.address);
        p.eat();
        //6.创建Person类的第二个对象
        /*4.每次创建对象时，都会执行构造方法
        * 构造方法的作用：用来创建对象的*/
        Person p2 = new Person();
        //8.触发含参构造
        Person p3 = new Person(88);
        System.out.println(p3.name);
        Person p4 = new Person("张三",18,"柳树下");
        System.out.println(p4.name);
        System.out.println(p4.age);
        System.out.println(p4.address);
    }
}
//1.创建Person类，用来描述人这一类事物
class Person{
    //2.属性--成员变量
    String name;//姓名
    int age;//年龄
    String address;//住址
    //8.创建本类的全参构造
    //右键->Generate->Constructor->Shift全选所有属性->OK
    public Person(String name, int age, String address) {
        this.name = name;//局部变量name的值赋值给this指定的成员变量name
        this.age = age;//局部变量age的值赋值给this指定的成员变量age
        this.address = address;//局部变量address的值赋值给this指定的成员变量address
        System.out.println("我是Person类的全参构造");
    }

    /*3.构造方法的格式：没有返回值类型并且与类名同名的方法*/
    //5.创建本类的无参构造
    public Person(){
        System.out.println("我是Person类的无参构造~");
    }
    //7.创建本类的含参构造
    public Person(int n){
        System.out.println("我是Person类的含参构造"+n);
    }

    //3.功能--方法
    public void eat(){
        System.out.println("干饭不积极，思想有问题~");
    }
}

关于构造函数怎么记忆:
1.特点：方法名与类名相同，且没有返回值类型
2.执行时机：创建对象时立即执行
3.默认会创建无参构造，但是，如果自定义了含参构造，默认的无参构造会被覆盖，注意要手动添加哦

2.构造代码块与局部代码块

2.1形式

• {代码...}

2.2构造代码块的特点

1. 位置：在类的内部，在方法的外部
2. 作用：用于抽取构造方法中的共性代码
3. 执行时机：每次调用构造方法前都会调用构造代码块
4. 注意事项：构造代码块优先于构造方法加载

2.3局部代码块

1. 位置：在方法里面的代码块
2. 作用：通常用于控制变量的作用范围，出了花括号就失效
3. 注意事项：变量的作用范围越小越好，成员变量会存在线程安全的问题

2.4练习：测试代码块的加载顺序

创建包：cn.tedu.oop
创建类：TestBlock.java

package cn.tedu.oop;
/*本类用于测试代码块
执行顺序：构造代码块->构造方法->普通方法->局部代码块,分析：
1.当创建对象时，会触发构造函数
2.创建对象时，也会触发构造代码块，并且构造代码块优先于构造方法执行
3.我们创建好对象后才能通过对象调用普通方法
4.如果普通方法里有局部代码块，才会触发对应的局部代码块 */
public class TestBlock {
    public static void main(String[] args) {
        //5.分别触发3个构造函数创建对象
        Pig p1 = new Pig();//触发的是无参构造
        Pig p2 = new Pig("佩奇");//触发的是含参构造
        Pig p3 = new Pig("肉包子",5);//触发的是全参构造
        //6.通过创建好的对象进行测试
        System.out.println(p1.age);//0,默认值
        System.out.println(p2.age);//0,默认值
        System.out.println(p3.age);//5，创建对象时赋值的
        p1.eat();
        p2.eat();
        p3.eat();
    }
}
//1.创建一个小猪类用来测试
class Pig{
    //2.定义属性
    String food;//食物
    int age;//年龄

    //7.创建本类的构造代码块
    {
        /*构造代码块：{}
        * 1.位置：类里方法外
        * 2.执行时机：每次创建对象时都会执行构造代码块，并且构造代码块优先于构造方法执行
        * 3.作用：用于提取所有构造方法的共性功能*/
        System.out.println("我是一个构造代码块");
        System.out.println("黑猪肉！");
    }

    //4.1创建本类的无参构造
    public Pig(){
        //System.out.println("黑猪肉~");
        System.out.println("我是Pig类的无参构造");
    }
    //4.2创建本类的含参构造
    public Pig(String s){
        //System.out.println("黑猪肉~");
        System.out.println("我是Pig类的含参构造"+s);
    }
    //4.3创建本类的全参构造
    //右键->Generate->Constructor->Shift全选所有属性->ok
    public Pig(String food, int age) {
        //System.out.println("黑猪肉~");
        System.out.println("我是Pig类的全参构造");
        this.food = food;
        this.age = age;
    }

    //3.创建普通方法
    public void eat(){
        System.out.println("小猪爱吃菜叶子");
        //8.创建本类的局部代码块
        {
            /*局部代码块：{}
            1.位置：方法里
            2.执行时机：调用本局部代码块所处的方法时才会执行
            3.作用：用于控制变量的作用范围，变量的作用范围越小越好
            * */
            System.out.println("我是一个局部代码块");
            int i = 100;
            System.out.println(i);
        }
        //System.out.println(i);//局部代码块中的局部变量i只能在代码块里使用
    }
}

3.this

3.1概念

this代表本类对象的一个引用对象

3.2形式

3.3练习：this练习之变量名相同时使用

使用包：cn.tedu.oop
使用类：TestThis1.java

package cn.tedu.oop;
/*本类用于this测试*/
public class TestThis1 {
    public static void main(String[] args) {
        //4.创建对象并调用方法
        Cat c = new Cat();
        c.eat();
    }
}
//1.创建小猫类
class Cat{
    //5.创建成员变量
    int count = 666;
    int sum = 100;
    //2.创建方法
    public void eat(){
        //3.创建局部变量
        int sum = 10;
        System.out.println(sum);//10,使用的是局部变量，就近原则
        /*当成员变量与局部变量同名时，可以使用this指定本类的成员变量
        * 如果不使用this指定，打印的就是近处的这个局部变量，就近原则*/
        System.out.println(this.sum);//100
        System.out.println(count);//666
    }
}

3.4练习：this练习之构造方法间的调用

创建包：cn.tedu.oop
创建类：TestThis2.java

package cn.tedu.oop;
/*本类用于测试this的用法2*/
public class TestThis2 {
    public static void main(String[] args) {
        //3.1触发无参构造创建本类对象
        Dog d1 = new Dog();
        //3.2触发含参构造创建本类对象
        //Dog d2 = new Dog("旺财");
    }
}
//1.创建小狗类
class Dog{
    //2.1创建本类的无参构造
    public Dog(){
        /*在无参构造中，调用含参构造的功能
        * 注意：调用是单向的，不能来回双向调用，否则会死循环*/
        this("小旺旺");
        System.out.println("无参构造");
    }
    //2.2创建本类的含参构造String s
    public Dog(String s){
        /*在含参构造中，调用无参构造的功能
        * 规定：this关键字必须在构造函数的第1行*/
        //this();
        System.out.println("含参构造"+s);
    }
}

4.拓展

练习4.1：创建Teacher类进行OOP综合练习之封装

创建包：cn.tedu.oop
创建类：TestTeacher.java

package cn.tedu.oop;
/**本类用于进行OOP综合练习*/
public class TestTeacher {
	public static void main(String[] args) {
		Teacher t = new Teacher();//6.调用无参构造创建对象
		//7.由于private将Teacher类中的属性都封装了,外界无法直接使用,所以需要使用set()/get()
		//t.name;//报错:The field Teacher.name is not visible
		System.out.println(t.getName());//如果没有设置值或者是设置没有成功，获取的是默认值null
		t.setName("鲁智深");
		System.out.println(t.getName());
		
		//8.直接调用全参构造来创建对象并且给对象的属性赋值
		Teacher t2 = new Teacher("李逵","壮汉",28,300);
		System.out.println(t2.getName()+t2.getAge()+t2.getGender()+t2.getSalary());
	}
}
//1.创建Teacher类
class Teacher{/**1.属性  2.get()/set() 3.构造方法*/
	//2.1提供属性
	//2.2对属性进行封装--通过private关键字进行封装
	private String name;
	private String gender;
	private int age;
	private double salary;
	
	/**如果什么构造方法都没有添加,默认会存在无参构造
	 * 我们创建了丰富的构造方法,是为了给外界提供创建本类对象的多种方式
	 * 如果自定了含参构造,默认的无参构造会被覆盖,注意手动添加哦
	 * */
	//3.添加无参构造方法
	public Teacher() {
		System.out.println("我是无参构造");
	}
	//4.添加全参构造方法
	public Teacher(String n,String g,int a,double s) {
		//5.在构造方法中为成员变量进行赋值
		name = n;//n是局部变量也就是用户调用此构造传入的参数,把参数赋值给成员变量name
		gender = g;
		age = a;
		salary = s;
		System.out.println("我是全参构造");
	}
	
	//2.3需要给外界提供公共的属性设置与访问方式
	//快捷方法:右键空白处-->Source-->Genreate Getters and Setters-->select All-->Generate生成即可
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
}

4.2创建对象的流程

Person p = new Person();//短短这行代码发生了很多事情
1.把Person.class文件加载进内存
2.在栈内存中，开辟空间，存放引用变量p
3.在堆内存中，开辟空间，存放Person对象
4.对成员变量进行默认的初始化
5.对成员变量进行显示初始化
6.执行构造方法（如果有构造代码块，就先执行构造代码块再执行构造方法）
7.堆内存完成
8.把堆内存的地址值赋值给变量p ，p就是一个引用变量，引用了Person对象的地址值