Java多态

直接上代码看:

---

Pragma mark — NO.1 理解多态--基础代码:

public class Animal {
    public static void main(String[] args){
        //以前的方法创建猫对象
        //这句理解为 创建一个猫对象，猫就是一只猫，不是其它的什么东西
        Cat c = new Cat();
        c.eat();
        //多态的创建方法
        // Animal1 a 是声明了一个父类引用，这个引用指向了子类对象。就是说猫是一个动物。 这就是那句要有父类引用指向子类对象
        //
        Animal1 a = new Cat();
        a.eat();//这个的输出结果还是猫要吃鱼
    }
}
/*
* 多态概述:事物存在的多种形态
* 多态前提:
* 1.要有继承关系
* 2.要有方法重写
* 3.要有父类引用指向子类对象
*
* */

//定义一个动物类
class  Animal1{
    //定义一个吃方法
    public  void  eat(){
        System.out.println("动物吃法");
    }
}
//定义一个猫类继承自Animal
class  Cat extends  Animal1{
    //重写父类的吃的方法
    public  void eat(){
         System.out.println("猫要吃鱼");
    }
}

Pragma mark — NO.2 多态成员变量

public class Polymorphic {

    public static void main(String[] args){
     Father f = new Son();//父类引用指向子类对象
        System.out.println(f.num);
        //这个打印结果是10; 编译看左边/运行看右边
        //解释一下:
        /*
        * 当我们创建new Son() 子类对象的时候，子类对象可以访问分类的成员变量。
        * 是通过super来访问的，对于子类创建好在堆区分配好内存后，就会有两块区域，一块是
        * 父类的成员变量显示初始化为10，通过super访问的
        * 另一块就是子类自己的成员变量初始化为20
        * 对于f.num ,来说这个指针引用是指向father的，所以它只能看到子类中属于自己的
        * 那块区域，所以打印为10
        **/

        //再来
        Son s = new Son();
        System.out.println(s.num);
    }
}

//父类
class  Father{
    //成员变量
    int num = 10;
}
//子类
class  Son extends  Father{
    int num = 20;
}

Pragma mark — NO.3 成员方法

 //成员方法:编译看左边/运行看右边
        Father f = new Son();
        f.print();//打印出来是:我是子类。这个就是动态绑定
        //编译的时候，先去找父类有没有这个print方法，如果有，编译通过，然后运行的时候去子类中找这个print方法

//父类
class  Father{
    //成员变量
    int num = 10;
    //成员方法
    public void print(){
        System.out.println("我是父类");
    }

}
//子类
class  Son extends  Father{
    int num = 20;
    public void print(){
        System.out.println("我是子类");
    }

Pragma mark — NO.4 静态方法

        //静态方法--编译看左边，运行看左边
        Father f = new Son();
        f.method();//打印我是父类静态方法

class  Father{
    //成员变量
    int num = 10;
    //成员方法
    public void print(){
        System.out.println("我是父类");
    }
    //静态方法
    public  static  void method(){
       System.out.println("我是父类静态方法");
    }
}
//子类
class  Son extends  Father{
    int num = 20;
    public void print(){
        System.out.println("我是子类");
    }
    //静态方法
    public  static  void method(){
        System.out.println("我是子类静态方法");
    }
}

Pragma mark — NO.5 超人的例,理解向上和向下转型

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

    Person1 p = new Super();//父类引用指向子类对象，可以理解为超人平时伪装为一个普通人
        //父类引用指向子类对象就是向上转型:就相当于将super这个子类提升到了父类的层次

       //就是说初次见面，超人只会说他是json，来谈生意的，不会是他是超人，但是实际和你谈生意的是超人
        System.out.println(p.name);
        p.takeMethod();

     //然后出现情况，超人要去救人，但是没证明他是超人之前是不会让他去救人的
        //p.fly();//这样调用超人的方法是会出错的，因为当前超人是以普通人身份出现的，他就不具备救人的技能

        //所以我们想要去救人，就得向人们证明你是超人，所以我们得做一个向下转型
        Super s = (Super)p; //这个就是向下转型
        System.out.println(s.name);
        s.fly();

        /*
        * 基本数据类型自动类型提升和强制类型转换
        * */
        int i = 10;
        byte b = 20 ;
        i = b;//这就是自动类型提升
        System.out.println(String.valueOf(i));

        //b = i;//直接将int型赋值给byte类型会报错，是把大类型赋值给小类型，会有精度损失
        b = (byte)i;//强制类型转换
    }
}
//我们通过这个例子描述一个超人的故事
 class  Person1 {
    //平时的时候超人叫json,在谈生意
    String name = "我叫Json";
    public  void takeMethod(){
        System.out.println("我来和你谈生意");
    }

}
//子类--超人
class  Super extends Person1 {
    String name = "我是SuperMan";
    public  void takeMethod(){
        System.out.println("我是超人来和你谈生意");
    }
    //超人特有的方法
    public  void fly(){
        System.out.println("我要去救人了哦");
    }
}

Pragma mark — NO.6 多态的好处

public class Main {

    public static void main(String[] args) {

         //创建猫对象
//        Cat c1 = new Cat();
//        c1.eat();
   //我们想让猫吃的动作执行很多次,我们写个方法

        method(new Cat());
        //method(new Dog());这样写是错误的，狗是一只猫是不行的塞
        method(new Dog());
    }

//    public  static  void method(Cat c){
//        c.eat();
//    }
//
//    public  static  void method1(Dog d){
//
//        d.eat();
//    }
   //看了上面的，思考如果我们还有单独的猪，牛，羊类，意味着这种method方法我们都要去写一遍了。这肯定不好
    //想想解决办法

    //我们直接传入这个父类，当我们传入参数是子类的时候，就相当于父类引用指向子类对象了
   public  static void method(Animal a ){
//       a.eat();
//       //这样写有好的地方，弊端我们看看
//      // a.catchMouse();//这个方法是狗类自己的，编译时在父类中找不到，所以不行
//       //要使用子类独有的方法，我们可以进行向下转型
//       Dog d = (Dog)a;
//       d.lookHome();
       //介绍一个关键字 instanceof:判断前面的引用是否是后面的类型
       if (a instanceof Cat){

           Cat c = (Cat)a;
           c.eat();
           c.catchMouse();

       }else {
           Dog d = (Dog)a;
           d.eat();
           d.lookHome();
           //开发中很少这样去调用子类的特有方法，比较麻烦

       }

   }
}

/*
* 多态的好处:
* a:提高了代码的维护性(继承保证)
* b:提高了代码的扩展性(多态保证)
* B:案例演示:
* 多态的好处
* 可以当做形式参数，可以接收任意子类对象
*
* C:多态的弊端:
* 不能使用子类的特有属性和行为
**/

class Animal {

    public  void eat() {

        System.out.println("动物要吃东西");
    }

}

class  Cat extends  Animal {

    public  void eat(){
        System.out.println("猫要吃鱼");
    }
    public  void catchMouse(){
        System.out.println("猫要抓老鼠");
    }

}

class  Dog extends  Animal{

    public  void eat() {
        System.out.println("狗吃肉");
    }

    public  void lookHome(){

        System.out.println("狗狗会看家");
    }
}