JAVA-继承和多态（笔记-重制版）

继承

继承的好处和弊端

好处：

• 提高了代码的复用性（多个类相同的成员放在同一个类中）
• 提高了代码的维护性（需要修改的时候，只需要改变一个地方就行）

弊端：

• 增加了类的耦合性，减弱了类的独立性

注意：

• 当类A和B，A是B的一种，B是A的一种，他们之间存在继承关系，就可以考虑用继承来实现。

继承中变量访问的特点

在子类中访问一个变量：

• 先在子类局部范围内找
• 之后在子类成员范围内找
• 然后在父类成员范围内找
• 如果都没找到，一般都会报错（除去考虑在父类的父类中找）

super关键字的用法(和this关键字)

this和super关键字的使用

• this:代表本类对象的使用
• super：代表父类存储空间的标识（父类对象的使用）

以下是详细用法：

继承中构造方法的访问特点

子类中所有的构造方法默认都会访问父类中无参的构造方法

详细如图所示：

子类对父类的方法重写

注意事项：

• 私有方法不能被重写（父类私有成员是不能继承）
• 子类方法访问权限不能更低（public>默认>私有）一般保持一致就行

继承的注意事项

• java中类只支持单继承，不支持多继承
• java中类支持多层继承

关于static和final

final可以修饰局部变量，成员方法，成员变量，对象，类

• 变量是基本类型的时候：final修饰指的是基本类型的数据值不能发生改变
• 变量是引用类型：final修饰指的是引用类型的地址值不能改变，但地址内的内容是可以改变的，例如用final修饰一个学生类的对象，那么就不能用这个对象在堆中再去new一个新的地址空间。
  

static可以修饰成员方法，成员变量
static修饰的特点：

• 被类的所有对象共享
• 可以通过类名调用，也可以通过对象名调用（推荐使用类名调用）

注意事项：

• 静态成员方法只能访问静态成员和静态的成员变量
• 非静态成员方法能访问静态和非静态的成员方法和成员变量

多态

多态的前提和体现

• 有继承关系；
• 有方法重写；
• 有父类引用指向子类对象；

如代码：

package Ploymorphic;
//父类
public class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}

package Ploymorphic;
//子类
public class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");//方法重写
    }
}

package Ploymorphic;
//多态
public class AnimalDemo {
    public static void main(String[] args){
       //有父类引用指向子类对象
        Animal a=new Cat();
    }
}

多态中成员的访问特点

成员变量和成员方法：

• 父类中没有的成员变量和成员方法，不能进行访问
• 父类和子类中都有的成员变量，可以进行访问，内容是父类变量的值
• 父类中有一个成员方法，但子类中进行重写了，可以访问，内容是子类中方法的内容

如代码：

package Ploymorphic;

public class Animal {

    public int age=20;
    public void eat(){
        System.out.println("动物吃东西");
    }
}

package Ploymorphic;

public class Cat extends Animal{
    public int age=40;
    public int weight=10;
    public void eat(){
        System.out.println("猫吃鱼");
    }
    
    public void playGame(){
        System.out.println("猫捉迷藏");
    }
}

package Ploymorphic;
//多态
public class AnimalDemo {
    public static void main(String[] args){
        Animal a=new Cat();  //看animal
       // System.out.println(a.weight); //在动物类中没有weight，从外界看到的是动物
        System.out.println(a.age); //动物类中的age；

        a.eat();//运行看猫类中有没有，输出的猫类中的内容
        //a.playGame(); 在动物类中没有playGame
    }
}

多态的好处和弊端

多态的好处

• 提高了程序的扩展性
• 具体体现：定义方法的时候，使用父类作为参数，将来在使用的时候，使用具体的子类参与操作。

多态的坏处

• 不能使用子类特有的功能

如代码：

package Ploymorphic1;

public class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}

package Ploymorphic1;

public class Cat extends Animal{
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

package Ploymorphic1;

public class Dog extends Animal{
    @Override
    public void eat(){
        System.out.println("狗吃骨头");
    }
    public void lookDoor(){
        System.out.println("狗看门");
    }
}

package Ploymorphic1;

public class AnimalOperator {
/*
    public void useAnimal(Cat c){
        c.eat();
    }
    public void useAnimal(Dog d){
        d.eat();
    }
    */
    public void useAnimal(Animal a){
        //Animal a=new Cat()
        //Animal a=new Dog() 相当于这样
        a.eat();//调用猫类和狗类中的eat函数
        //a.lookDoor();  不能访问子类所特有的功能
    }
}

package Ploymorphic1;

public class AnimalDemo {
    public static void main(String[] args){
        AnimalOperator ao=new AnimalOperator();
        //创建动物操作类的对象
        Cat c= new Cat();//猫类的对象
        ao.useAnimal(c);

        Dog d=new Dog(); //狗类的对象
        ao.useAnimal(d);
    }
}

多态中的转型

向上转型：

• 从子到父
• 父类引用指向子类对象

向下转型

• 从父到子
• 父类引用转为子类对象

如代码：

public class AnimalDemo {
    public static void main(String[] args){
      Animal a=new Cat();
      a.eat();
      //a.playGame();
      
      //向下转型
      Cat c=(Cat)a;
      c.eat();
      c.playGame();
    }