继承和多态

1.继承

 1.1 为什么需要继承

Java中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是现实世界错综复杂，事物之间可能会存在一些关联，那在设计程序是就需要考虑。

比如：狗和猫，它们都是一个动物。 

 使用Java语言来进行描述，可以这样设计：

class Dog{
  public string name;
  public int age;
 
  public void eat(){
    System.out.println(name + "正在吃饭");
 }
 
  public void wangwangwang(){
    System.out.println(name + "正在汪汪叫");
 }
}

class Cat{
  public string name;
  public int age;
 
  public void eat(){
    System.out.println(name + "正在吃饭");
 }
 
  public void miaomiaomiao()
 {
    System.out.println(name + "正在喵喵叫");
 }
}

通过观察上述代码会发现，猫和狗的类中存在大量重复：

Dog：name：String；age：int；eat();

Cat：name：String；age：int；eat();

那能否将这些共性抽取呢？面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用。

 1.2 继承概念

继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。

继承最大的意义是：对代码可以进行复用

继承：对共性进行抽取，从而对代码进行复用！

例如：狗和猫都是动物，那么我们就可以将共性的内容进行抽取，然后采用继承的思想来达到共用。

上述图示中，Dog和Cat都继承了Animal类，其中：Animal类称为父类/基类或超类，Dog和Cat可以称为Animal的子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可。
从继承概念中可以看出继承最大的作用就是：实现代码复用，还有就是来实现多态

 1.3 继承的语法

 在Java中如果要表示类之间的继承关系，需要借助extends关键字，具体如下：

父类：
public Animal(){

}
子类：
public Dog(){
    super();
}

对1.2中场景使用继承方式重新设计：

class Animal{
    public String name;
    public int age;
    public void eat(){
        System.out.println(name + " 正在吃饭！！！");
    }
}
class Dog extends Animal{
    public void wangwang(){
        System.out.println(name +"  正在汪汪叫");
    }
}
class Cat extends Animal{
     public voidmiaomiao(){
        System.out.println(name +"  正在喵喵叫");
    }
}
public class Test {
public static void main(String[] args) {
    Dog dog=new Dog();
    // dog类中并没有定义任何成员变量，name和age属性肯定是从父类Animal中继承下来的
    System.out.println(dog.name);
    System.out.println(dog.age);
    // dog访问的eat()是从Animal中继承下来的
    dog.eat();
    dog.wangwangwang();
    }
}

注意：
1. 子类会将父类中的成员变量或者成员方法继承到子类中了
2. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了

 1.4 父类成员访问

 在继承体系中，子类将父类中的方法和字段继承下来了，那在子类中能否直接访问父类中继承下来的成员呢？

1.4.1 子类中访问父类的成员变量

1. 子类和父类不存在同名成员变量
2. 子类和父类成员变量同名

父类优先子类执行，静态的最先执行

静态代码块只会执行1次

class Animal{//证明这个类不能被继承了
    class Dog estends Animal{
        
    }
}

class Animal{
    public final String name = "123";
//如果是成员变量定义为final，语法规定必须同时给定一个初始值！

2.多态

 2.1 多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

向上转型：子类对象到父类

Animal animal = dog;

理论上：等号两边的数据类型必须一致，否则赋值会出错！

Animal animal = new Dog();
animal.name = "jianjian";
animal.eat();
//animal.wangwang();

当发生向上转型之后，此时通过父类的引用只能访问父类自己的成员。不能访问到子类特有的成员。

 public void eat(){
        System.out.println(name + " 正在吃饭！！！");
    }

class Dog extends Animal{
    public void wangwang(){
        System.out.println(name +" " + age + " 正在汪汪叫");
    }
    public void eat() {
        System.out.println("");
    }
}

重写：

1. 方法名称相同

2. 参数列表相同

3. 返回值相同

public static void function(Animal animal) {
    animal.eat();
}
public static void main(String[] args) {
    Animal animal = new Dog();
    animal.name = "han";
    function(animal);
    System.out.println("=====");
    Animal animal1 = new Bird();
    animal1.name = "jian";
    function(animal1);
}

多态：当父类引用，引用的对象不一样的时候，表现出的行为是不一样的！！！

重写需要注意的点：

1. privat修饰的方法不能重写

2. static修饰的方法是不能重写的

3. 子类的访问修饰限定权限要大于等于父类的权限private<默认<protected<public

4. 被final修饰的方法是不能被重写的此时这个方法被称做密封方法

向上转型的优点：让代码实现更简单灵活

向上转型的缺点：不能调用到子类特有的方法

Animal animal = new Dog();
//向下转型
Dog dog = (Dog)animal;
dog.name = "jj";
dog.age = 12; 
dog.wangwang();

向下转型非常不安全

注意：当在父类的构造方法当中去调用父类和子类重写的方法的时候，此时会调用子类的！！