java继承知识点合集1

super关键字，this关键字，类的初始化

//继承
class person{
	int age;
	String name;
	public void eat(){
		System.out.println("吃饭");
	} 
}


class person {
	public void eat(){
		System.out.println("吃饭");
	}
		public void sleep(){
		System.out.println("睡觉");
	}
}
class students extends person{

}
class teachers extends person{

}

// 继承的特点：
// 1.java只支持单继承，不支持多继承（一个儿子只有一个爸爸）
//2.支持多层继承
栗2：
class grangFather{
	public void call1(){
		System.out.println("我是爷爷");
	}
}
class Father extends grangFather{
	public void call2(){
		System.out.println("我是爸爸");
	}
}
class son extends Father{}

public static void main(String[] args) {
	son s=new son();
	s.call1();//输出“我是爷爷”
	s.call2();//输出“我是爸爸”
}

//继承的注意事项
//1.子类只能继承父类的非私有的成员变量和方法，父类中的private方法是不能被继承的
//2.子类不可以继承父类的构造方法，可以使用super关键字访问父类的构造方法
//3.不要为了部分功能继承

//什么情况下用继承？继承体现的是一种关系“is a”

//this可以直接访问当前类的成员变量和方法
//super可以访问父类的成员变量和方法
栗子：
class father{
	public int num=10;
}
class son extends father{
	int num=20;
	public void show(){
		System.out.println(num);
		System.out.println(this.num);
		System.out.println(super.num);//super直接调用父类的成员变量

	}
}

public class super关键字 {
		public static void main(String[] args) {
			son s=new son();
			s.show();
		}
}
//this和super可以调用成员变量，构造方法，成员方法
//可以通过super访问父类的构造方法


//*******************************继承中构造方法的关系************************************//
// 子类中所有的构造方法都会默认访问父类中空参数的构造方法
// 子类的每一个构造方法的第一条语句默认都是super();

package 继承;

public class 构造方法的关系 {
	public static void main(String[] args) {
		son2 s=new son2();//子类中所有的构造方法都会默认访问父类中空参数的构造方法
	}
}

class father2{
	public father2() {
		System.out.println("父类的无参构造方法");
	}
}
class son2 extends father2{
	public son2() {
		System.out.println("子类的无参构造方法");
	}
}
输出结果为：
父类的无参构造方法
子类的无参构造方法
// 实例化时子类的构造方法执行前默认调用父类的无参构造方法，如果父类没有无参构造方法就会报错
    //解决方法：
        //1.给父类手动添加一个无参构造方法
        //2.用super(参数)；的方式调用父类的有参构造方法0
        //3.子类通过this调用本类的其他构造方法，前提是被调用的构造方法调用了父类的构造方法
            //总结：子类中一定要有一个构造方法访问了父类的午餐构造方法，否则父类数据没有初始化
            //super();和this();必须要放在第一条语句上，所以super和this不能同时出现在统一方法中
栗子：
class father3{
	public father3(String name) {
		System.out.println("父类的有参构造方法");
	}
	
}
class son3 extends father3{
	public son3() {
		super("super调用父类的有残构造方法");
		System.out.println("子类的无参构造方法");
	}
	public son3(String name2) {
		this();//表示调用本类的无参构造
		System.out.println("子类的有参构造方法");
	}
	public void text() {
		System.out.println("子类的普通无参方法");
	}
}

public class 构造方法的关系 {
	public static void main(String[] args) {
		son3 s=new son3();
		System.out.println("*****************************************");
		son3 ss=new son3("有参");//调用子类的有参构造方法时
	}
}

//一个类的初始化过程：
    //成员变量的初始化
      //默认初始化
      //显示初始化
      //构造方法初始化

//静态代码块，构造代码块和构造方法的执行顺序：
    //1.在同一个类中，优先级为：静态代码块>构造代码块>构造方法
    //2.静态的内容是随着类的加载而加载（静态代码块的内容会优先执行）
    //3.子类初始化之前会进行父类的初始化
栗子1：
//这是父类
class father4{
	static {
		System.out.println("父类的静态代码块");
	}
	{
		System.out.println("父类的构造代码块");
	}
	public father4() {
		System.out.println("父类的无参构造方法");
	}
}
//这是子类
class son4 extends father4{
	static {
		System.out.println("子类的静态代码块");
	}
	{
		System.out.println("子类的构造代码块");
	}	
	public son4() {
		System.out.println("子类的无参构造方法");
	}
}

public class 构造方法的关系 {
	public static void main(String[] args) {
		son4 sss=new son4();
	}
}
结果：
父类的静态代码块
子类的静态代码块
父类的构造代码块
父类的无参构造方法
子类的构造代码块
子类的无参构造方法

栗子2：
//我们加上“爷爷”类
class grandfather{
	static {
		System.out.println("“爷爷”类的静态代码块");
	}
	{
		System.out.println("“爷爷”类的构造代码块");
	}
	public grandfather() {
		System.out.println("“爷爷”类的无参构造方法");
	}
}
class father4 extends grandfather{
	static {
		System.out.println("父类的静态代码块");
	}
	{
		System.out.println("父类的构造代码块");
	}
	public father4() {
		System.out.println("父类的无参构造方法");
	}
}

class son4 extends father4{
	static {
		System.out.println("子类的静态代码块");
	}
	{
		System.out.println("子类的构造代码块");
	}	
	public son4() {
		System.out.println("子类的无参构造方法");
	}
}

public class 构造方法的关系 {
	public static void main(String[] args) {
		son4 sss=new son4();
	}
}
结果：
“爷爷”类的静态代码块
父类的静态代码块
子类的静态代码块
“爷爷”类的构造代码块
“爷爷”类的无参构造方法
父类的构造代码块
父类的无参构造方法
子类的构造代码块
子类的无参构造方法