java的多态性学习代码

1、下面的代码是定义一个抽象类Shape，然后Circel和Square类继承Shape类，实现Shape中的方法MianJi();  

  

public class ShapeDemo {  

    public static void main(String[] args) {  

      

    //向上转型，创建一个父类Shape的引用，让引用指向子类  

        Shape shape =  new Square(2);  

          

        //如果shape引用的对象是Square类型的对象，返回true,否则为false  

        if(shape instanceof Square) {  

              

            //将shape对象想下转型为子类的对象  

            Square square = (Square)shape;  

              

            //在show方法中，以子类对象sqaure为参数，求出求出子类的面积  

            show(square);  

        }  

           

        //向上转型，创建父类的引用，指向子类Circel的对象  

        Shape shape1 = new Circle(2);  

        //在show方法中，以父类Shape1参数调用方法，求出子类的面积  

        show(shape1);  

          

          

          

          

          

}  

      

//定义静态方法show来调用父类或则子类的MianJi()方法  

public static void show(Shape s) {  

        s.MianJi();  

}  

  

}  

  

//定义一个抽象类Shpe，给出抽象方法MianJi，不给出具体实现  

abstract class Shape{  

    float r;  

      

    abstract void MianJi();  

}  

  

  

      

//定义一个Square正方形类，继承父类Shape类，给出父类MainJi方法的具体实现  

class Square extends Shape{  

    //定义参数边长  

    float r;  

      

    //默认参数构造方法来初始化Square，  

    Square(float r){  

        super();  

        this.r = r;  

    }  

      

    //求出正方形的面积  

    void  MianJi() {  

        System.out.println( "我是正方形，面积是：" +r * r);  

    }  

}  

  

//定义圆类，继承父类Shape  

class Circle extends Shape{  

    //定义参数半径  

    float r;  

      

    //构造方法初始化  

    Circle(float r){  

        super();  

        this.r = r;  

    }  

      

    //求出圆的面积  

    void MianJi(){  

        System.out.println("我是圆形，面积是：" +3.14 * r *r);  

    }  

}

运行结果：  

我是正方形，面积是：4.0  

我是圆形，面积是：12.56  

2.定义一个Animal父类，子类Cat和Dog继承Animal类  

public class Demo{  

    public static void main(String[] args) {  

      show(new Cat());  // 以 Cat 对象调用 show 方法  

      show(new Dog());  // 以 Dog 对象调用 show 方法  

                  

      Animal a = new Cat();  // 向上转型    

      a.eat();               // 调用的是 Cat 的 eat  

      Cat c = (Cat)a;        // 向下转型    

      c.work();        // 调用的是 Cat 的 work  

          

  }    

              

    public static void show(Animal a)  {  

      a.eat();    

        // 类型判断  

        if (a instanceof Cat)  {  // 猫做的事情   

            Cat c = (Cat)a;    

            c.work();    

        }   

    else if (a instanceof Dog) { // 狗做的事情   

            Dog c = (Dog)a;    

            c.work();    

        }    

    }    

}  

   

//定义一个抽象Animal类，为父类  

abstract class Animal {    

    //定义一个抽象的父类eat方法，子类必须具体实现这个方法  

    abstract void eat();    

}    

    

//继承父类Animal  

class Cat extends Animal {    

    //实现父类的抽象方法  

    public void eat() {    

        System.out.println("我是猫， 吃鱼");    

    }    

    //定义子类自己的方法  

    public void work() {    

        System.out.println("我是猫，抓老鼠");    

    }    

}    

    

//继承父类Animal，实现自己的方法  

class Dog extends Animal {    

    //实现父类的方法  

    public void eat() {    

        System.out.println("我是狗，吃骨头");    

    }    

    //定义自己的方法  

    public void work() {    

        System.out.println("我是狗，看家");    

    }    

}

我是猫， 吃鱼  

我是猫，抓老鼠  

我是狗，吃骨头  

我是狗，看家  

我是猫， 吃鱼  

我是猫，抓老鼠  

总结

以上是生活随笔为你收集整理的java的多态性学习代码的全部内容，希望文章能够帮你解决所遇到的问题。

如果觉得生活随笔网站内容还不错，欢迎将生活随笔推荐给好友。