（JAVASE)继承和多态

一、继承

1、作用：共性的抽取，实现代码的复用。

2、extends关键词：

class 子类 extends 父类{}

3、子类中访问父类的成员变量

（1）不同名（可直接访问）

class Animal
{
     public int age;
     public String name;
}

class Dog extends Animal
{
     public void methods()
{
     age=10;//直接访问父类继承下来的age
     name="卡西龙";//直接访问父类继承下来的name
}
}

（2）同名

  成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找 。

  若要访问父类的则使用super关键词。

class Animal
{
     public int age;
     public String name;
}

class Dog extends Animal
{
     public int age;
     
     public void methods()
{
     age=10;//子类与父类中的变量同名，优先访问子类（age与this.age效果一样）
     super.age=20;//访问父类继承下来的age
     name="卡西龙";//直接访问父类继承下来的name
}
}

4、子类中访问父类的成员方法

（1）重载：同名，形参不同，返回值不同-------可直接通过形参分清访问的是子类还是父类

（2）重写：同名，形参相同，返回值相同-------需用super关键词区分子类父类

   a、不能是一个静态方法，且被final修饰的方法也不能重写。

   b、子类重写父类的方法，子类的权限要比父类大。

   c、被private修饰的方法也不能被重写。

   d、构成父子类关系的同名方法也是重写

   e、避免在构造方法中调用重写的方法。

//Animal和Dog构成父子类关系
public Animal eat()
{}
public Dog eat()
{}

（3）super只能在非静态方法中使用

5、子类的构造方法

（1）子类的构造方法中需先调用父类构造方法，对父类进行初始化------使用super（）语法

class Animal//父类
{
     public int age;
     public String name;
}

class Dog extends Animal //子类
{
    public Dog(int age,String name)
{
      super(age,name);//调用父类构造方法
}
}

（2）使用super()必须在第一行。

（3）super()与this()不能共存。

  (4) super只能指代类的父类，不能指代父类的父类。

（5）代码运行时，会先执行父类和子类的静态代码块，再执行父类的实例和构造，最后执行子类的实例和构造。

class Animal
{
     public int age;
     public String name;
static{
       System.out.println("这是父类静态代码块");//1
}

{
       System.out.println("这是父类实例代码块");//3
}


     public Animal(int age,String name)//4
{
     this.age=age;
     this.name=name;
}
}

class Dog extends Animal
{
     
     static{
       System.out.println("这是子类静态代码块");//2
}

{
       System.out.println("这是子类实例代码块");//5
}

     public Dog(int age,String name)//6
{
       super(age,name);
}
    }

5、java不支持多继承，但可通过接口的形式多继承。

6、protected修饰词：同一个包底下都可使用，不同包只有子类可以使用。

7、final关键词

（1）修饰变量时：变量的值不可变；

final int a=10;//a的值不可改变
public final class Dog{}//此类不可被继承

（2）修饰类时：这个类不可被继承，为密封类。

二、组合：将一个类的实例作为另一个类的字段（能用组合尽量用组合）

class Tire{
}
class Engine{
}

class Car{
    private Tire tire;//复用tire中的属性和方法
    private Engine engine;//复用engine中的属实和方法
}

三、多态

1、简单来说就是一种事物，多种形态。

2、实现条件：必须在继承体系下；子类必须要对父类中方法进行重写 ；通过父类的引用调用重写的方法。

3、向上转型：父类引用，引用了子类的对象。

(1）直接赋值

Anmal animal = new Dog("卡西龙",10);

(2)方法的传参

public static void func(Animal animal)
{
}
Dog dog = new Dog("卡西龙",10);
func(dog);

 (3)返回值

publci static Animal func2()
{
   Dog dog =new Dog("卡西龙",10);
     return dog;
}

4、缺点：通过父类的引用无法直接调用子类特有的方法 ，只能调用父类自己的。

5、为什么父类引用调用共有的方法，调用的是子类的方法？---------动态绑定

（1）当运行代码时，通过父类引用，调用父类和子类重写的那个方法，结果实际调用了子类的方法，这种情况叫做动态绑定。（在父类的构造方法中调用重写的方法，也会发生动态绑定。

class Animal
{
   public void eat()
{
    System.out.println("正在吃饭");
}
}

class Dog extends Animal
{
   System.out.println("正在吃狗粮");
}

public static void test()
{
    Animal animal =new Dog();
    animal.eat();//虽然是父类的引用，但实际调用的是子类的eat方法。
}

4、向下转型

（1）基本语句：

Animal animal =new Dog();
Dog dog =(dog)animal;

（2）并不是所有的向下转型都能成功。

5、多态的好处

（1）能够降低代码的 "圈复杂度", 避免使用大量的 if - else

（2）可扩展能力更强

6、多态的缺陷：代码的运行效率降低。