java_day9面向对象(多态)

声明：只是本人学习的记录，如果有错误欢迎批评指正，也欢迎有小伙伴交流讨论！：）

一、对象间的转型问题

1. 向上转型
   Fu f=new Zi();//相当于儿子穿上了父亲的衣服，拥有了父亲的特征，儿子的功能
2. 向下转型
   Zi z=(Zi)f;//相当于回家把父亲的衣服脱掉了，恢复了儿子的特征，可以做儿子才会的事请

二、多态的成员访问特点
编译看左边，运行看右边。
继承的时候：子类中有和父亲一样的方法，叫重写。
子类中没有父亲出现过的方法，方法就被继承过来了。

三、抽象类的成员特点（abstract）
成员变量：既可以是变量，也可以是常量。
构造方法（方法名与类名相同）：有。用于子类访问父类数据的初始化。
成员方法：既可以是抽象的，也可以是非抽象的。

抽象类的成员方法特性：抽象方法（强制要求子类做的事）；非抽象方法（子类继承的事情，提高代码复用性）

四、猫狗案例
1.动物类

package TestDemoDay9;
abstract class Animal2{
        private String name;
        private int age;
        public Animal2(){
        }
        public Animal2(String name,int age){
            this.name=name;
            this.age=age;
        }
        public String getName(){
            return name;
        }
        public void setName(String name){
            this.name=name;
        }
        public int getAge(){
            return age;
        }
        public void setAge(int age){
            this.age=age;
        }
        public abstract void eat();
}

2.狗类

package TestDemoDay9;

public class Dog1 extends Animal2{
    public Dog1(){}
    public Dog1(String name,int age){
        super(name,age);
    }
    public void eat(){
        System.out.println("狗吃肉");
    }
}

3.猫类

package TestDemoDay9;

public class Cat2 extends Animal2{
    public Cat2(){}
    public Cat2(String name,int age){
        super(name,age);
    }
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

4.测试类

package TestDemoDay9;

public class AbstractTest {
    public static void main(String[] args){
        //测试狗1
        Dog1 d=new Dog1();
        d.setName("xiaohei");
        d.setAge(28);
        System.out.println(d.getName()+"---"+d.getAge());
        d.eat();
        //测试狗2
        Dog1 d2=new Dog1("xiaohei",3);
        System.out.println(d2.getName()+"---"+d2.getAge());
        d2.eat();
        //多态
        Animal2 a=new Dog1();
        a.setName("xiao ");
        a.setAge(8);
        a.eat();
        System.out.println(a.getName()+"---"+a.getAge());
        //多态2
        Animal2 a2=new Dog1("xiao",8);
        a2.eat();
        System.out.println(a2.getName()+"---"+a2.getAge());
    }
}

五、抽象类的几个小问题
1.一个类没有抽象方法，也可以定义为抽象类。
2.abstract不能和哪些关键字共存
private abstract void show()是不可以的
final abstract void show()是不可以的
static abstract void show()是不可以的，无意义
六、接口的特点 interface
1.interface 接口名{}
2.类实现接口用implements表示
class 类名 implements 接口名 {}
3.接口不能实例化
由此可见：
具体类多态（几乎没有）
抽象类多态（常用）
接口多态（最常用）
4.接口的子类可以是抽象类，但意义不大。也可以是子类，需要重写接口中的所有抽象方法。
抽象类实现接口：

abstract class Dog3 implements AnimalTrain{
}

具体类实现接口：

public class Cat3 implements AnimalTrain{
    public void jump(){
        System.out.println("猫会猜谜");
    }
}

public interface AnimalTrain {
    public abstract void jump();
}

public class InterfaceDemo {
    public static void main(String[] args){
        //AnimalTrain是抽象的，无法实例化
        //AnimalTrain at=new AnimalTrain();  会报错
        AnimalTrain at=new Cat3();
        at.jump();
    }
}

七、接口的成员特点
1.接口中的变量默认是常量，并且是静态的。建议手动给出
2.接口没有构造方法
//所有的类都默认继承一个类 object
八、关系
类与类：继承关系，只能单继承，可以多层继承
类与接口：实现关系，可以单实现，也可以多实现，并且还可以继承一个类的同时实现多接口
九、抽象类和接口的区别
成员区别
关系区别
设计理念区别：
抽象类 中定义的是该继承体系的共性功能
接口 中定义的是该继承体系的扩展功能

class JumpCat extends Cat3 implements Jumping//具有跳高功能的猫继承了猫的特性和跳高的接口