新手小白学JAVA 面向对象2 构造函数构造代码块 this

川长思鸟来 2021-09-07 16:38 357阅读 0赞

# 1 构造方法 #

## 1.1 概念 ##

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

## 1.2 形式 ##

与类同名,且没有返回值类型,可以含参也可以不含参  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70]

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

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

package cn.tedu.oop;
    /**本类用于测试构造方法*/
    public class TestConstructor { 
    	//4.在公共类中创建入口函数
    	public static void main(String[] args) { 
    		//5.创建Person类的对象进行测试
    		/**1.每次new(实例化)对象时会自动调用构造方法*/
    		Person p = new Person();
    		System.out.println(p.name);
    		System.out.println(p.age);
    		System.out.println(p.address);
    		p.eat();
    		Person p2 = new Person("海绵宝宝");
    		System.out.println(p2.name);
    		System.out.println(p2.age);
    		System.out.println(p2.address);
    		p.eat();
    		Person p3 = new Person("派大星",3,"海底");
    		System.out.println(p3.name);
    		System.out.println(p3.age);
    		System.out.println(p3.address);
    		p.eat();
    	}
    }
    //1.创建Person类,用来描述人这一类型
    class Person{ 
    	//2.属性--创建成员变量
    	String name;//姓名
    	int age;//年龄
    	String address;//地址
    	
    	/**2.默认存在无参构造,当new Person()会自动触发此无参构造*/
    	/**3.构造方法也存在重载的现象:方法的重载:在同一个类中,方法名相同且参数列表不同的现象*/
    	//普通方法的定义:修饰符 返回值类型 方法名 (参数列表){ 方法体 }
    	//构造方法的定义:修饰符 方法名 (参数列表){ 方法体 } --方法名与类名一致
    	
    	//6.1创建无参构造--当new Person()时,会触发
    	public Person() { 
    		System.out.println("我是Person类的无参构造");
    	}
    	/**快速向下复制:Ctrl+Alt+向下键*/
    	/**4.当只提供了含参构造,默认的无参构造会被覆盖,所以在创建重载的构造方法时,一定注意手动添加无参构造*/
    	//6.2创建1个参数的构造
    	public Person(String s) { 
    		System.out.println("我是Person类的1个参数的构造方法"+s);
    	}
    	//6.3创建全参构造--定义了几个属性,就传几个参数,new Person("派大星",3,"海底");会触发
    	public Person(String n,int a,String addr) { 
    		name = n;//n是局部变量,name是成员变量,把用户传的参数值n赋值给成员变量name
    		age = a;//a是局部变量,age是成员变量,把用户传的参数值a赋值给成员变量age
    		address = addr;//addr是局部变量,address是成员变量,把用户传的参数值addr赋值给成员变量address
    		System.out.println("我是Person类的全参构造");
    	}
    	
    	//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.构造代码块的功能: 用于提取构造方法中的共性 * 5.局部代码块的功能:控制变量的作用范围 * */
    public class TestBlock { 
    	public static void main(String[] args) { 
    		//5.在main()中创建对象进行测试
    		Teacher t = new Teacher();/**每次创建对象时/new时,都会执行一次构造代码块*/
    		Teacher t2 = new Teacher();
    		Teacher t3 = new Teacher("大中华");
    		t.study();
    	}
    }
    
    //1.创建一个Teacher类用于测试
    class Teacher{ 
    	String subject;//2.定义成员变量科目,全局生效
    	//6.定义构造代码块
    	{ 
    		/**构造代码块的位置:类里方法外 * 作用:用于提取构造方法中的共性内容 * 执行时机:优先于构造方法执行*/
    		subject = "Java培优";
    		System.out.println("构造代码块");
    	}
    	
    	//3.定义构造方法
    	//3.1创建本类的无参构造
    	public Teacher() { 
    		System.out.println("我是Teacher类的无参构造"+subject);
    	}
    	
    	//3.2创建本类的含参构造
    	public Teacher(String n) { 
    		System.out.println("我是Teacher类的含参构造"+n+subject);
    	}
    	
    	//4.定义普通方法
    	//方法定义:修饰符 返回值类型 方法名(参数列表){方法体...}
    	public void study() { 
    		//7.创建局部代码块
    		/**局部代码块的位置:方法里 * 作用:控制变量的作用范围(作用范围越小越好,因为越小越安全) * 执行时机:调用本方法时*/
    		{ 
    			int i = 10;
    			System.out.println(i);
    		}
    		//System.out.println(i);//报错,因为超出i的作用范围
    		System.out.println("正在备课...");
    	}
    	
    }

# 3 this #

## 3.1概念 ##

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

## 3.2 形式 ##

![在这里插入图片描述][20210510084529213.png]

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

使用包: cn.tedu.oop  
使用类: TestVariableThis1.java

package cn.tedu.oop;
    /**本类用于this测试 * 当一个类中有两个同名的变量,一个成员变量,一个局部变量 * 想使用本类的成员变量时,可以用this指定一下 * this代表的就是"本类",成员变量属于类 * */
    public class TestVariableThis1 { 
    	public static void main(String[] args) { 
    		Cat c = new Cat();
    		c.eat();
    	}
    }
    //1.创建Cat类
    class Cat{ 
    	int sum = 20;
    	int s = 30;
    	
    	public void eat() { 
    		int sum = 10;//局部变量
    		System.out.println(sum);//10,使用的是局部变量sum,就近原则
    		System.out.println(s);
    		
    		//可以通过this关键字来调用成员变量 ,前提:成员变量与局部变量同名时
    		//如果不使用this指定,那么打印10,因为变量的就近原则,使用的是局部变量sum
    		System.out.println(this.sum);//通过this.访问了本类的成员变量sum
    	}
    }

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

创建包: cn.tedu.oop  
创建类: TestConsThis2.java

package cn.tedu.oop;
    /**本类进行this测试2*/
    public class TestConsThis2 { 
    	public static void main(String[] args) { 
    		//创建对象时会自动调用构造方法
    		Dog d = new Dog();
    		Dog d2 = new Dog("小旺旺");
    	}
    }
    /** * this还可以在构造方法间相互调用 * 但请一定注意:是单向的,不是双向来回调用,会死循环 * */
    class Dog{ 
    	//无参构造
    	public Dog() { 
    		/**在无参构造中 调用含参构造的功能*/
    		/**规定:this关键字必须在构造方法中的第一行*/
    		//this("旺财");
    		System.out.println("无参构造");
    	}
    	//含参构造
    	public Dog(String s) { 
    		/**在含参构造中 调用无参构造的功能*/
    		/**规定:this关键字必须在构造方法中的第一行*/
    		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对象的地址值

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70]: /images/20210827/600fcb33627e41d98941c63539a5f868.png
[20210510084529213.png]: /images/20210827/6fca6f84e742415cb406da65c2a614b2.png