面向对象（二）构造函数,this,static,类的成员,对象初始化顺序

点击查看好文

TestCode

package com.openlab.day10.object;

public class Test {
	
	public static void main(String[] args) {
//		Student stu = new Student("张三", "110");
//		System.out.println(stu.name);
		// 
//		System.out.println(Student.no);
//		Student.say();
//		stu.say();
		
		
//		Student stu2 = new Student();
//		Student stu3 = new Student();
		
		
		MiddleStudent ms = new MiddleStudent();
		
	}
	
}

一.构造方法：

在创建对象的同时，初始化属性的值。

注意：在java中，当我们定义了一个类之后，如果没有定义构造方法，则JVM在运行时会自动生成一个无参的构造，让我们使用.如果我们定义了构造方法，则不会再生成无参构造

最佳实践：在java中，当定义了一个类后，不管有没有写其他的构造函数，无参的构造一定要写一个。

对象属性默认值

代码

package com.openlab.dayp10.hw;
//类定义：访问修饰[public|private|protected|默认] class 类名称 {}
public class user {
	//1.属性
	String username;
	int age;
	
	//2.方法
	
	
//构造函数（alt+insert:上传构造方法)
	public user(String username,int age) {
		//对象赋值:对象名称.属性名称 = 值;
		//使用两个参数的构造函数，初始化属性
		this.username=username;
		this.age=age; 
	}
	
		//将无参的构造函数，实现
	public user() {}
	
	public void say() {
		System.out.println("My name is"+this.username);
	}
	
	//3.主函数
	public static void main(String[] args) {
		//user u2=new user(); 
		
		//创建对象：类型 对象名称 = new 类型名称()【构造方法】
		//在实例化对象的同时，将属性的值，通过构造函数赋予
		user u1=new user("张三",16);
		
		System.out.println(u1.age);
		System.out.println(u1.username);
		
		user u2=new user();//默认提供一个无参的构造方法
		
	}
}

二.关键字this

this指向当前类中的

在java中，this的关键字，this关键字是一个指针
在类中，this默认指向当前类
如果构造对象，当对象构造完成后，会有一个this指向当前对象

代码

package com.openlab.day10.object;

public class ClassRoom {

	public String name;
	public String into;
	
	
	public ClassRoom() {
	}

	public ClassRoom(String name, String into) {
		this.name = name;
		this.into = into;
	}

	public ClassRoom(String name) {
		this.name = name;
		System.out.println(name);
	}
	
	
	
}

三.static关键字的使用

static：静态的

1.可以修饰java的类、属性、方法 static如果修饰类，只能修饰内部类，等我们讲解内部类的时候再说.也可以修饰属性，如果使用static修饰属性，该属性就是静态属性属于类 也可以修饰方法，静态方法，属于类.
static也可以直接单独使用，被static单独使用的语法块，静态块
静态块：静态块，会最先被类加载，而且只加载一次！！！
4、static也可以修饰import import static 包.*
static修饰的东西，提前加载内存中

 
 
 
public class Test {
    public static void main(String[] args) {
        Student.say();
    }
}
//构造学生类
class Student{
    //创建属性
    int id;
    String name;
    String gender;
    //引用其他类
    Cls cls=new Cls();
    //构造函数
    public Student(int id,String name,String gender,Cls cls){
        this.id=id;
        this.name=name;
        this.gender=gender;
        this.cls=cls;
    }
    //创建无参构造函数
    public Student(){
        System.out.println("我是一个学生");
    }
    //static 修饰的方法先加载
    public static void say(){
        System.out.println("我是一个学生");
    }
 
}

 
 
 
 
 
public class Test {
    public static void main(String[] args) {
        Student one= new Student();
        //static修饰后，加载后可以访问为空
        System.out.println(one.id);
 
    }
}
//构造学生类
class Student{
    //创建属性
    static int id; //static 修饰后先加载。
    String name;
    String gender;
    //引用其他类
    Cls cls=new Cls();
    //构造函数
    public Student(int id,String name,String gender,Cls cls){
        this.id=id;
        this.name=name;
        this.gender=gender;
        this.cls=cls;
    }
    //创建无参构造函数
    public Student(){
        System.out.println("我是一个学生");
    }
 
}
//构造教室类
class Cls{
    int cla_id;
    String cls_mame;
    public Cls(int cla_id,String cls_mame){
        this.cla_id=cla_id;
        this.cls_mame=cls_mame;
 
    }
    //创建无参构造函数
    public Cls(){
        System.out.println("我是一个教室");
    }
 
}

四.构造代码块与静态块

代码

package com.openlab.day10.object;

public class Student {

	public String name;
	public static String no = "123456";
	public int age;
	public String email;
	// 对象属性
	public ClassRoom cs ;
	
	
	static {
		// 静态块
		System.out.println("这个是静态块，我会被提前加载");
		System.out.println("这个是静态块，我会只调用一次");
	}
	
	{
		System.out.println("构造代码块！！！");
		System.out.println("在构造函数调用前执行");
	}
	
	public Student() {
		System.out.println("我是一个无参的构造函数");
	}

	public Student(String name, String no, int age, String email) {
		this.name = name;
		this.no = no;
		this.age = age;
		this.email = email;
	}

	public Student(String name, String no) {
		this.name = name;
		this.no = no;
	}
	
	public static void say() {
		System.out.println("我就说一句话，我说完了");
	}
	
}

五.类的成员

在类中：

正常的属性和方法，都是为对象提供的，都是属于对象
类型 对象名称 = new 构造函数();
对象名称.属性
对象名称.方法()
如果类里面的属性或者方法被static，那这些就属于类。

构造代码块：

直接定义在类中{} 相当于构造函数，在构造函数调用前会被触发

代码

package com.openlab.day10.object;

public class MiddleStudent {
	// 普通属性
	public String name;
	public String email;
	public ClassRoom cr1 = new ClassRoom("java");
	// 静态属性
	public static ClassRoom cr2 = new ClassRoom("python");
	
	// 静态代码块
	static {
		System.out.println("静态代码块开始执行了~~~~~~~");
	}

	// 构造代码块
	{
		System.out.println("构造代码块已经执行了");
	}
	
	// 构造函数
	public MiddleStudent() {
		System.out.println("普通的构造函数开始执行了……");
	}
	
	public static void main(String[] args) {
		MiddleStudent ms = new MiddleStudent();
	}
}

五.面试热点：java中类成员在构造（对象创建的时候）的调用顺序

当一个类被初始化时：

面试题（代码）：

package com.openlab.day10.object;

public class Order {

	static int num = 0;
	String name = "qqqqqq";
	static String name2 = "wwwwwwwwwww";
	static Order parentClass = new Order(); // 第二次初始化对象，static部分不会再触发

	Order() {
		System.out.println("这里是构造函数*************");
	}

	{
		System.out.println("name1:" + name);
		System.out.println("这里是块1============");
	}

	static {
		num += 1;
		System.out.println("parentClass.name:" + parentClass.name);
		System.out.println("这里是静态块*************" + num);
	}

	public static void main(String[] args) {
		// 构造函数的执行顺序问题
		new Order();
	}

}