JAVA中类的继承

一、继承的基本概念

1、定义：继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

2、目的：代码重用，类的重用。
名词:父类(基类,超类)子类(派生类)。
关键字: extends (扩展)。

3、类的继承格式：

class 父类 {
}
 
class 子类 extends 父类 {
}

4、为什么需要继承：
接下来我们通过实例来说明这个需求。
动物类：

public class Animal {
	public String name;
	public void eat(String food){
	System.out. println(name +"正在吃" +food);
}

猫类：

public class cat {
	public String name;
	public void eat(String food){
		System. out.print1n(name +"正在吃" +food);
	public void jump(){
		System. out.println(name +"正在跳");

鸟类：

public class Bird {
	public String name;
	public void eat(String food) {
		System.out.print1n(name +"正在吃"+food);
	}
		public void fly(){
		System. out.print1n(name+"正在飞");
}

从这三段代码可以看出来，代码存在重复了，导致后果就是代码量大，而且维护性不高(维护性主要是后期需要修改的时候，就需要修改很多的代码，容易出错)，所以要从根本上解决这三段代码的问题，就需要继承，把Cat和Bird相同的部分，提取出来,放到Animal中.然后再让Cat和Bird分别继承自Animal即可。

二、继承的特性

1、子类拥有父类非 private 的属性、方法。
2、子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
3、子类可以用自己的方式实现父类的方法。
4、Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
5、提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

三、super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

class Animal {
 public String name;
 public Animal(String name){
 this.name = name;
 }
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  public  Cat(){
  	super(name);
  	}
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

创建子类实例的时候，先构造父类对象(执行父类构造方法的逻辑)，再构造子类对象(再执行子类构造方法的逻辑)，即先使用super。

注意：每个类都有构造方法，如果你不显式的创建构造方法，那么编译器就会给这个类自动生成一个没有参数的构造方法。
当父类里面没有写构造方法的时候，就被自动生成了没参数版本的构造方法。
此时如果直接new子类实例，就会调用到刚才父类这个没参数版本的构造方法。
当父类里有构造方法的时候，并且这个构造方法带有参数的时候，编译器就不再自动生成无参数版本的构造方法了。此时再创建子类实例,就需要显式的调用父类的构造方法，并且进行传参，否则创建不出来父类的实例，就会编译出错。

三、访问权限控制

private：只能在类内部访问（权限要求最高，能被访问的范围越小就认为权限要求越高）
default(啥都不写,默认的)：包级权限，可以被同包的其他类访问。
protected：可以被子类访问，也可以被同包的其他类访问到。
protected在被同包的类访问的基础上，还能被其他包的子类访问。
public:可以在类外部访问（权限要求最低）

注意：能用private 的就尽量用private。

四、final关键字

声明类：

final class 类名 {//类体}

声明方法：

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

特点：
1、final用于修饰类、成员变量和成员方法。
2、final修饰的类，不能被继承（String、StringBuilder、StringBuffer、Math，不可变类），其中所有的方法都不能被重写(这里需要注意的是不能被重写，但是可以被重载，这里很多人会弄混)。
3、final修饰的方法不能被重写，但是子类可以用父类中final修饰的方法。
4、final修饰的成员变量是不可变的，如果成员变量是基本数据类型，初始化之后成员变量的值不能被改变，如果成员变量是引用类型，那么它只能指向初始化时指向的那个对象，不能再指向别的对象，但是对象当中的内容是允许改变的。

五、组合

组合,也是为了代码重用,也是面向对象的一个重要特性。

public class School {
public SchoolMaster schoolMaster = new SchoolMaster();

public student student1 = new Student();
public Student student2 = new Student();
public student student3 = new Student();
public Student student4 = new Student();
public Student student5 = new Student();

public ClassRoom classRoom1 = new ClassRoom();
public ClassRoom classRoom2 = new ClassRoom();
}

组合表示的语义 has - a (拥有xxx，包含 xxx)
继承表示的语义is - a(是xxx)