java自学日记no.5

data：2020/2/15

继承

继承是从已有的类中派生出新的类，新的类吸收已有类的数据属性和行为，并能拓展新的能力

1.java只支持单继承，不支持多继承
2.子类只能继承父类多有非私有成员（成员方法和变量）
3.子类不能继承父类的构造方法（类名都不一样），但是可以通过super区访问父类构造方法
4.子类中的变量名和父类一样，就近原则（但是一般不会这么弄，没有意义）
5.this也可以调用父类的，在子类没有这个成员变量的时候

子类中所有的构造方法都会默认访问父类的空参构造方法，因为子类初始化前一定会先完成父类数据的初始化，其实是省略了一个super();的语句

Q：如果父类只有有参构造，没有无参构造怎么办？
A：在子类的有参构造里加super(" 张三", 23);（转到了父类的有参构造中，值写死了，没意义）
或者this(“张三”, 23)走子类的有参构造，子类再调到父类的有参构造
（注：二者只能取其一）

多重继承，每一个父类的默认构造函数都被执行了！

public class LongTest {
	public static void main(String[] args) {
		EZ ez = new EZ();
	}
}

class YY {
	public YY() {
		System.out.println("this is yy");
	}
}

class BB extends YY {
	public BB() {
		System.out.println("this is BB");
	}
}

class EZ extends BB {
	super();	//这个语句默认被省略了！
	public EZ() {
		System.out.println("this is EZ");
	}
}

输出：
this is yy
this is BB
this is EZ

this关键字

this描述的是本类结构调用的关键字

java中this关键字可以描述3钟结构的调用
1.当前类中的属性：this.属性
2.当前类中的方法（普通方法、构造方法）：this()、this.方法名称()
3.描述当前对象

代码块

代码块是在程序中使用{ }定义起来的一段程序，根据代码块声明位置以及声明关键字的不同分为4种：普通代码块、构造代码块、静态代码块和同步代码块

构造代码块：类中方法外，每创建一次对象就会执行一次，优先于构造函数执行
静态代码块：类中方法外，随着类加载而加载，且只执行一次i，用来给类进行初始化，一般用来加载驱动静态代码块优先于主方法执行

主方法静态代码块 > 主方法 > 下一级类的静态构造方法（无论创建多少对象，只运行一次） > 构造代码块（创建一次对象就会执行一次） > 构造方法

public class LongTest {
	static {
		System.out.println("这是主方法的静态代码块！");
	}
	public static void main(String[] args) {
		{
			System.out.println("这是主方法代码块！");
		}
		Student st1 = new Student();
		Student st2 = new Student("pingan", 23);
	}
}

class Student {
	static {
		System.out.println("这是下一级类的静态代码块");
		}
		{
		System.out.println("这是下一级类的构造代码块！");
		}
	String name;
	int age;

	public Student() {
		{
		System.out.println("这是无参构造函数！");
		}
	}

	public Student(String name, int age) {
		this.age = age;
		this.name = name;
		{
		System.out.println("这是有参构造函数！");
		}
	}

	public void study() {
		System.out.println("这是下一级类的方法");
	}
}

输出：
这是主方法的静态代码块！
这是主方法代码块！
这是下一级类的静态代码块
这是下一级类的构造代码块！
这是无参构造函数！
这是下一级类的构造代码块！
这是有参构造函数！

各种代码块的加载关系：

BB bb = new BB();

1.首先，方法区先把static静态区加载了，然后主函数也加载（毕竟主函数也是static修饰的），然后父类和子类的静态区块相继加载
2.然后堆中new了一个子类的构造函数，先==super()==调用父类的构造函数
3.发现父类的构造函数前面有个静态的编码块，得先把静态编码块加载了
4.然后加载父类的构造函数
5.加载子类的构造函数，发现前面也有个构造代码块，也先加载
6.最后如果有类的方法调用，再加上方法

public class LongTest {
	static {
		System.out.println("这是最大boss的静态代码块，第-1个加载");
		}
	public static void main(String[] args) {
		{
		System.out.println("这是主函数的构造代码块，第0个加载");
		}
		BB bb = new BB();
		bb.study();
	}
}

class YY {
	static {
		System.out.println("这是父类静态代码块，第一个加载");
		}
		{
		System.out.println("这是父类构造代码块，第三个加载");
		}
	public YY() {
		System.out.println("这是父类构造方法，第四个加载");
		}
}
class BB extends YY {
	static {
		System.out.println("这是子类静态代码块，第二个加载");
		}
		{
		System.out.println("这是子类构造代码块，第五个加载");
		}
	public BB() {
		System.out.println("这是子类构造方法，第六个加载");
		}
	public void study() {
		System.out.println("这是类中的方法，最后一个执行");
	}
}

输出：
这是最大boss的静态代码块，第-1个加载
这是主函数的构造代码块，第0个加载
这是父类静态代码块，第一个加载
这是子类静态代码块，第二个加载
这是父类构造代码块，第三个加载
这是父类构造方法，第四个加载
这是子类构造代码块，第五个加载
这是子类构造方法，第六个加载
这是类中的方法，最后一个执行

子类重写父类方法要求

1.访问权限不能更低（最好一致）
2.不能重写父类的private方法
3.父类静态方法，子类也必须写成静态方法