Java：继承

1、继承的基本概念

（1）extends关键字

class Animal{
	public String name;
	int age;

	public void eat(){
		System.out.println(this.name + "正在吃饭");
	}
}
//子类/派生类  extends  父类/基类/超类
class Cat extends Animal{
	public void miaomiao(){
	}
}

private只决定访问限制，不影响能不能被继承；所以被private修饰的成员依然会被继承
（2）当子类和父类有同名成员变量时，优先使用子类自己的
成员变量访问遵循优先原则，优先查找子类的成员变量

class Base{
	int a = 99;
}

class Dedrived extends Base{
	int a = 88;
	public method(){
		System.out.println(a);
	}
}

public class Test(){
	public static main(){
		Dedrived d = new Dedrived();
		d.method();
	}
}
//打印结果是88

父类和子类的方法相同时，优先调用子类自己的

class Base{
	int a = 99;
	public method(){
		System.out.println("b");
	}
}

class Dedrived extends Base{
	int a = 88;
	public
	public method(){
		System.out.println("d");
	}
}

public class Test(){
	public static main(){
		Dedrived d = new Dedrived();
		d.method();
	}
}
//打印结果是d

2、super关键字

（1）当父类与子类中的成员变量/方法相同时，如果要调用父类的变量或方法，就用super关键字

class Base{
	int a = 99;
	public method(){
		System.out.println("b");
	}
}

class Dedrived extends Base{
	int a = 88;
	public method(){
		System.out.println(super.a);
		System.out.println("d");
	}
}

public class Test(){
	public static main(){
		Dedrived d = new Dedrived();
		d.method();
	}
}
//打印结果是d

（2）super的作用
· 访问父类成员变量
· 调用父类成员方法
· 调用父类构造方法

class Dog extends Animal{
	public Dog(){
	super();
	}
}

（3）父类初始化
当子类使用构造方法初始化时，必须同时对父类初始化
若是子类未写构造方法，编译器会自动提供一个默认构造方法
· 父类未写构造方法时，直接使用super()对不带参数的构造方法进行初始化

class Animal{
   String name;
   int age;
}
class Dog extends Animal{
   public Dog(){
   super();
   }
}

· 父类提供带参数的构造方法后，要初始化带参数的构造方法

class Animal{
  String name;
  int age;

  public Animal(String name,int age){
  this.name = name;
  this.age = age;
  }
}
class Dog extends Animal{
  public Dog(String name,int age){
  super(name,age);
  }
}

· 若父类带参数和不带参数的构造方法都提供，则随便初始化任意一个都可以
代码执行顺序：先进行父类构造，再进行子类构造
但不能同时写两个super，只能出现一个super

 class Animal{
	String name;
	int age;

	public Animal(){
	}

	public Animal(String name,int age){
	this.name = name;
	this.age = age;
	}
}
class Dog extends Animal{
	public Dog(String name,int age){
	super(name,age);
	//super只能出现一个，并只能出现在第一行
	System.out.println("dog初始化");
	}
}

注意： 1、调用父类的构造方法，并不会实例化一个父类对象，而只是帮助初始化子类从父类继承过来的对象 2、super和this都不能出现在静态方法中 3、super和this不能同时出现 ## 3、初始化代码执行顺序 ```java class Animal{ String name; int age;

static {  
    System.out.println("执行Animal静态代码块");  
}  

{  
    System.out.println("执行Animal实例代码块");  
}  
public Animal(){  
    System.out.println("执行Animal无参构造方法");  
}  

public Animal(String name,int age){  
    this.name = name;  
    this.age = age;  
    System.out.println("执行Animal有参构造方法");  
}  

}

class Dog extends Animal{
static {
System.out.println(“执行Dog静态代码块”);
}

{  
    System.out.println("执行Dog实例代码块");  
}  

public Dog(){  
    super();  
    System.out.println("执行Dog无参构造方法");  
}  

public Dog(String name,int age){  
    super(name,age);  
    System.out.println("执行Dog有参构造方法");  
}  

}

public class Test {
public static void main(String[] args){
System.out.println(“执行main函数”);
Dog d = new Dog();
Dog d1 = new Dog(“王五”,34);
}
}

最终执行顺序为
```java
执行main函数
执行Animal静态代码块
执行Dog静态代码块
执行Animal实例代码块
执行Animal无参构造方法
执行Dog实例代码块
执行Dog无参构造方法
执行Animal实例代码块
执行Animal有参构造方法
执行Dog实例代码块
执行Dog有参构造方法

Process finished with exit code 0

4、final关键字

一般继承的层次数不超过3
当继承到某一个层次后，不建议再继承
（1）final修饰类，表示该类不再被继承

final class Test{
}
//该类不再被继承

（2）当想让一个变量保持不变时，用final修饰
此时这个变量是一个常量，不能被改变

final int a = 10;

（3）final修饰方法，表示该方法不能被重写

5、组合

class Student{
}

class Teacher{
}

class School{
	public Student[] students;
	public Teacher[] teachers;
	
	public School(){
		this.students = new Student[];
		this.teachers = new Teachers[];
	}
}