java入门之面向对象4

多态

多态的规则

多态的规则(前提)：

1类与类之间要建立关系 建立继承的关系

2.必须要有方法重写

3.父类的指针(引用) 指向 子类的对象(空间)

需求：创建 动物类 猫类 狗类

都有一个吃的方法 动物类 吃

猫 猫吃鱼

狗 狗吃骨头

public class Demo01 {
    private void mian() {
        // 本类的引用(指针) 指向子类对象(空间)
        // 比如 猫是一只动物(不能是 动物是一只猫)
        Cat c =  new Cat();


        c.eat();
        // 父类的引用(指针) 指向 子类的对象(空间)
        Animal a = new Cat();
        a.eat();
        Animal ad = new Dog();
        ad.eat();
        Math.random();
    }

}
class Animal{
    public void eat() {
        System.out.println("吃饭");
    }
}
class Cat extends Animal{
    public void  eat(){
        System.out.println("猫吃鱼");
    }
}
class Dog extends Animal{
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

多态 成员变量 成员方法如何调用

多态时 成员变量如何调用的？

多态时 当父类引用 调用成员变量

编译需要看父类中有没有这个成员变量 没有编译不会通过

运行 访问的就是父类中的这个成员变量

编译 和 运行 父类访问成员变量看父类(看父类)

思考：Son s = new Son();

s.num 打印的是什么 在内存中如何表现

多态时 如何访问成员方法？

多态调用 成员方法时

编译时 看父类中有没有这个方法 没有 就报错

运行时 运行 运行子类的这个方法

多态调用成员方法时

编译看父类

运行看子类

public class Demo02 {
    public static void main(String[] args) {
        Father f = new Son();
        f.speak();
        System.out.println(f.num);//值是 10

        Son son = new Son();
        System.out.println(son.num);值是 20

    }


}
class Father{
    int num = 10;
    public void speak() {
        System.out.println("Father 说");
    }
}
class Son extends Father{

    int num = 20;
    public void speak() {

        System.out.println("Son 说");
    }

}

多态 利 与 弊

多态

好处：

1.增强代码可以维护性(建立在继承的基础上)

2.增强方法的可扩展性(核心)

弊端：

不能调用直接调用子类特殊方法

public class Demo03 {
public static void main(String[] args) {
// 父类引用指向子类对象
// 骗子 提升逼格 向上转型
Person p = new Lie();
//骗子调用自己的方法 对你洗脑
p.speak();
//向下转型
//注意 ：如果你要向下转型 必须之前有过向上转型
Lie l = (Lie)p;
l.Hit();

    int num = 10;
    byte b = 5;
    num = b;//自动类型 提升转换

    int a =(int)b; // 强制转换


}

}

class Person{

public void speak() {
    System.out.println("人说 聊天");
}

}
class Lie extends Person{
@Override
public void speak() {
// TODO Auto-generated method stub
System.out.println(“骗子说 洗脑”);
}
public void Hit() {
System.out.println(“骗子打人 威胁人”);
}
}

举一个 例子

需求：

武器类 打 挥舞武器

刀 打 挥舞刀 —砍人

练功 —-练刀

剑类 打 挥剑—–刺人

练功 耍剑

public class Demo04 {
    public static void main(String[] args) {

        fun(new Blade());
        fun(new Sword());


    }
    public  static void fun(Weapon w) {

        w.hit();
        //判断 传进来的参数 是哪个类的

        //可以判断 是否属于 那个类的对象
        // w 是否 属于 到累对象
         if (w instanceof Blade) {
             //向下转型 成刀
             Blade dao = (Blade)w;
             dao.pratice();




        }else if (w instanceof Sword) {
            Sword sword = (Sword)w;
            sword.pratice();
        }
    }

}
class Weapon{
    public void hit() {
        System.out.println("挥舞武器");
    }
}
class Blade extends Weapon{
    public void hit() {
        System.out.println("挥舞刀——————打人");
    }
    public void pratice() {
        System.out.println("练刀");
    }
}
class Sword extends Weapon{
    @Override
    public void hit() {
        // TODO Auto-generated method stub
        System.out.println("挥舞剑————————刺人");

    }
    public void pratice() {
        System.out.println("耍剑");

    }
}