Java 实验案例（多态）

实验任务

• 任务一：图形面积周长计算小程序
• 任务二：饲养员喂养动物程序

实验内容：

任务一： 图形面积周长计算

任务目的：

1. 掌握多态的含义及应用场合
2. 掌握上转型对象和多态的实现
3. 掌握abstract关键字的使用

任务描述：

　　设计一个小程序，可以计算圆形和长方形的面积及周长，其中

定义抽象类 图形类为圆形和长方形的父类，在图形类中定义抽象方

法获取面积方法和获取周长方法。定义面积和周长计算器，可以计

算不同图形的面积和周长。程序要具备良好的可扩展性和可维护性

程序运行结果参考如下图片：

实施步骤：

任务分析：

　　定义父类Shape作为抽象类，并在类中定义抽象方法求周长和面积

　　定义Shape子类圆形（circle），具有半径属性和常量PI，同时必须实现父类中的抽象方法

　　定义Shape子类长方形（rectangle），具有长和宽的属性，同时必须实现父类的抽象方法

　　创建图形面积周长计算器（ShapeCalculate），具有计算不同图形面积和周长的方法。

　　创建测试类TestShape类，在其main（）方法中对ShapeCalculate计算面积和周长方法进行测试

代码实现：

/* 抽象类：几何图形 */

public abstract class Shape {

    // 抽象方法： 获取面积
    public abstract double getArea();
    
    // 抽象方法：获取周长
    public abstract double getPerimeter();
}

 /* 子类 Circle类 */

public class Circle extends Shape {
    
    private double radius = 0;    // 圆的半径
    private final static double PI = 3.14;    // 常量，圆周率
    
    // 有参构造，初始化圆半径
    public Circle(double radius) {   
        this.radius = radius;
    }

    // 求圆面积
    public double getArea() {
        return PI*radius*radius;
    }

    // 求圆周长
    public double getPerimeter() {
        return 2*radius*PI;
    }

}

/* 子类Rectangle */

public class Rectangle extends Shape {

    private double length = 0;    // 长方形的长
    private double width = 0;     // 长方形的宽
    
    // 有参构造，初始化长方形的长和宽
    public Rectangle(double length, double width) {
        super();
        this.length = length;
        this.width = width;
    }

    public double getArea() {
        return this.length*this.width;
    }

    public double getPerimeter() {
        return 2*(this.length+this.width);
    }

}

/* 面积周长计算器 */

public class ShapeCaculate {

    // 可以计算任意shape子类的面积
    public void calArea (Shape shape) {
        System.out.println(shape.getArea());
    }
    
    // 可以计算任意shape子类的周长
    public void calPerimeter(Shape shape) {
        System.out.println(shape.getPerimeter());
    }
}

/* 测试类 */

public class TestShape {

    public static void main(String[] args) {
        
        // 创建图形计算器
        ShapeCaculate sc = new ShapeCaculate();
        
        // 创建长方形和圆形对象
        Shape rectangle = new Rectangle(3, 4);         // <-------多态
        Circle circle = new Circle(3);
        
        // 求长方形和圆形的面积
        System.out.println("求长方形的面积：");
        sc.calArea(rectangle);
        System.out.println("求圆形的面积：");
        sc.calArea(circle);
        
        // 求长方形和圆形的周长
        System.out.println("求长方形的周长：");
        sc.calPerimeter(rectangle);
        System.out.println("求圆形的周长：");
        sc.calPerimeter(circle);
    }
}

任务二：饲养员喂养动物

任务目的：

1. 掌握多态的含义及应用场合。
2. 掌握上转型对象和多态的实现
3. 体会多态带来的好处
4. 掌握instanceof运算符的使用

实施步骤：

　　在Java实验案例（继承）任务三中，饲养员每拿一种食物喂养相应的动物都需要

建立相应的方法，程序的可扩展性和可维护性较差，通过多态可以对程序进行优化，

修改feed（）方法的参数为父类的类型，使程序具有较好的可扩展性和可维护性。

代码实现：

动物父类

public class Animal {

    public void eat(Food food) {
        System.out.println("吃饭时间到了！");
        System.out.println(this + "喜欢吃" +food);
    }
}

Animal子类Dog类

public class Dog extends Animal {

    // 重写Animal从Object中继承的toString（）方法
    public String toString() {
        return "Dog";
    }
    
    // 新增算算术方法
    public void arithmetic() {
        System.out.println(this+"算算术表演！");
    }
}

Animal子类Cat类

public class Cat extends Animal {

    // 从写Animal从Object中继承的toString方法
    public String toString() {
        return "Cat";
    }
    
    // 新增跳环方法
    public void jumpRing() {
        System.out.println(this+"开始表演跳环！");
    }
}

食物Food类

public class Food {

    private int weight;  // 食物重量
    public Food(int weight) {
        this.weight = weight;
    }
    
    public int getWeight() {
        return weight;
    }
}

Bone子类

public class Bone extends Food {

    public Bone(int weight) {    // 调用父类的构造方法
        super(weight);
    }
    
    public String toString() {   
        return "Bone";
    }
}

Fish子类

public class Fish extends Food {

    public Fish(int weight) {
        super(weight);
    }
    
    public String toString() {
        return "Fish";
    }
}

饲养员Feeder类

public class Feeder {

    private String name;
    public Feeder(String name) {
        this.name = name;
    }
    
    public void feed(Animal a, Food f) {
        a.eat(f);
        System.out.println("饲养员"+name+"拿着"+f.getWeight()+"克"+f+"喂养"+a+"。");
    }
    
    public void perform(Animal a) {
        if (a instanceof Dog){
            ((Dog) a).arithmetic();
        }
        
        if(a instanceof Cat) {
            Cat c = (Cat) a;
            c.jumpRing();
        }
    }
}

测试类

public class TestFeed {

    public static void main(String[] args) {
        Feeder fd = new Feeder("张三");
        Dog dog = new Dog();
        Bone bone = new Bone(500);
        fd.feed(dog, bone);
        System.out.println("-----------------");
        fd.feed(new Cat(), new Fish(100));
        
        fd.perform(dog);
        fd.perform(new Cat());
    }
}

 运行结果如下图：