Java基础——面向对象之多态

面向对象之多态
实现方式：抽象类（成员特点、类型转换、引用传递）接口（final和static关键字）
多态：多种状态，同一对象在不同情况下表现出不同的状态或行为（比如一个人扮演不同角色）
实现方式的区别：
抽象类和接口的设计理念：
实现步骤：要有继承（或实现）关系；要有方法重写；父类引用指向子类对象
成员方法会被重写，但成员变量不会
成员方法：编译看左，运行看右

package poly.demo.demo1;

public class Test {
    public static void main(String[] args) {
        /*已知父类Animal，成员变量：姓名，成员方法：eat（）
        * 两个子类Dog和mouse类，两个子类都重写了Animal类中的eat（）方法
        * 测试类中，定义showAnimal()方法，测试Dog和mouse类*/
        Dog an = new Dog();
        an.setName("小黑");
        showAnimal(an);

        Mouse bn = new Mouse();
        bn.setName("Jerry");
        showAnimal(bn);
    }
    /*多态使用：父类可以作为形参的数据类型，接收任意子类对象*/
    public static void showAnimal(Animal animal){
        animal.eat();
    }
}

package poly.demo.demo1;

// 父类
public class Animal {
    //成员变量
    private String name;
    //构造方法
    public Animal(){
    }

    public  Animal(String name){
        this.name = name;
    }

    //成员方法
    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    public void eat(){
        System.out.println("全员干饭");
    }
}

package poly.demo.demo1;
// 	Dog类
public class Dog extends Animal{
    public void eat(){
        System.out.println(getName()+"吃狗粮");
    }
}

package poly.demo.demo1;
// Mouse类
public class Mouse extends Animal{
    public void eat(){
        System.out.println(getName()+"吃大米");
    }
}

运行结果

小黑吃狗粮
Jerry吃大米

成员变量：编译看左，运行看左

package poly.demo.demo2;

public class Test {
    public static void main(String[] args) {
        /*多态关系中，成员变量不涉及重写*/
        Animal a = new Dog();//成员变量，编译看左，运行看左
        System.out.println(a.name);

        Dog b= new Dog();
        System.out.println(b.name);

package poly.demo.demo2;

public class Animal {
    String name = "Animal";
}

package poly.demo.demo2;

public class Dog extends Animal{
    String name = "Dog";
}

运行结果

Animal
Dog

多态：可维护性强、可扩展性；不能子类特有成员
多态的类型转换：向上转换：子类转父类；向下转换：父类转子类
只能在继承层次内进行转换；将父类对象转换成子类之前，要用instanceof进行检查。

package poly.demo.demo3;
/*
* 父类引用不能使用子类的特有成员
* 可以通“类型转换“实现
* 只能在继承层次内进行转换，否则会有ClassCastException异常
* 父类转换成子类之前可以用instanceof进行检查*/
public class Test {
    public static void main(String[] args) {
        Animal an = new Dog(); // 父类转子类
        an.eat();
        Animal dn = new Animal();
        
       /* Cat cn = (Dog) bn;//dog类不能转换为猫类
        cn.eat();*/
        if (dn instanceof Dog){//判断dn是不是Dog类型对象
            Dog bn = (Dog) dn;  //强制转换，将Dog类bn转换成与dn同样的Animal类
            bn.eat();//如果bn是Dog类型对象，则执行此行
        }
    }
}

报错

java: 不兼容的类型: poly.demo.demo3.Dog无法转换为poly.demo.demo3.Cat

package poly.demo.demo3;
// 父类
public class Animal {
    public void eat(){
        System.out.println("吃饭");
    }
}

package poly.demo.demo3;

public class Dog extends Animal{
    public void eat(){
        System.out.println("吃狗粮");
    }
}

package poly.demo.demo3;

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

抽象类用abstract修饰，比普通类多一种抽象方法，其他和普通类一样。
有抽象方法的类一定是抽象类（或接口）。
抽象类的子类：如果是抽象类不需要重写抽象方法；若为普通类必须重写所有的抽象方法
抽象类不能实例化，即不能new，比如下列中的Animal抽象类，就不可以写Animal an = new Animal();

package poly.demo.demo4;

public class Test {
    public static void main(String[] args) {
        Cat a = new Cat();
        a.setName("大橘");
        a.eat();
        Dog b = new Dog();
        b.eat();

        Animal c = new Dog();
        c.eat();
    }
}

package poly.demo.demo4;
// 父类中包含抽象方法，加abstract修饰成为抽象类，具体吃什么由子类去决定，无方法体
public abstract class Animal {
    private String name;
    public abstract void eat();
}

package poly.demo.demo4;

public class Dog extends Animal{

    @Override
    public void eat() {
        System.out.println("小狗吃骨头");
    }
}

package poly.demo.demo4;

public class Cat extends Animal{
    String name;

    public Cat() {
    }

    public Cat(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void eat() {
        System.out.println(getName() +"吃条鱼吧");
    }
}

运行结果

大橘吃条鱼吧
小狗吃骨头
小狗吃骨头

抽象类的成员特点：
成员变量：可以有普通成员变量也可以有成员常量( final 修饰)
成员方法：可以有普通方法，也可以有抽象方法 (抽象类不一定有抽象方法，有抽象方法的类一定是抽象类 (或接口))
构造方法：像普通类一样有构造方法且可以重载。

package poly.demo.demo5;
/*抽象类的成员特点：
* 可以由普通的成员变量，也可以有成员常量；可以有抽象方法，也可以有非抽象方法；
* 有构造方法，并且构造方法还可以重载*/
public class Test {
    public static void main(String[] args) {
        Animal c = new Cat("大橘");//对抽象类进行初始化（父类被初始化）
        c.name = "大橘";//父类中name值被修改
        System.out.println(c.name);

        //c.age = 3;报错，常量值不能被改变，但是可以输出
        System.out.println(c.age);
        c.call();
        c.eat();
        c.sleep();

    }

}

抽象父类

package poly.demo.demo5;

public abstract class Animal {
    // 成员变量、常量
    String name = "旺财";
    final int age = 4;
    // 构造方法
    public Animal(){}
    public Animal(String name){
        this.name = name;
        System.out.println(name + "会有输出吗");
    }
    // 两个抽象类的成员方法
    public abstract void eat();
    public abstract void sleep();
    // 非抽象方法
    public void call(){
        System.out.println("大橘喵喵喵");
    }

普通类继承抽象父类

package poly.demo.demo5;

import java.nio.channels.ScatteringByteChannel;

public class Cat extends Animal{
//    String name = "旺财";  //如果加了这一句，则是使用本类当中的name，成员变量不进行重载，这里不赋值则为null
    // 不加这一句，则会找父类当中的name，有值就用，没有就继续找父类的父类，要是都没有就写null

public Cat(String name){
super(name);

}//有super关键字用于集成父类的构造方法将父类中的第一个大橘输出“大橘会有输出吗”

    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }
    public void eat(){
        System.out.println(getName()+"吃鱼仔");
    }//这个是抽象类eat子类中的普通类，所以重写

    public void sleep(){
        System.out.println(getName()+"睡大觉吧");
    }//这个同eat子类为普通类
}

抽象子类继承抽象父类

package poly.demo.demo5;

public abstract class Dog extends Animal{
//抽象子类可以不重写抽象父类中的抽象方法
}

输出结果

大橘会有输出吗
大橘
4
大橘喵喵喵
大橘吃鱼仔
大橘睡大觉吧