您的当前位置：首页正文

实验四 Java 语言接口与抽象类应用练习(课内实验)

来源：哗拓教育

一、实验目的

本次实验的主要目的是通过查看程序的运行结果和编写程序，练习使用应接

口和抽象类完成程序的方法。

二、实验要求

三、实验内容

A.程序一

B.程序二

package org.example;

public class Main {
    public static void main(String[] args) {
        Employee e = new Manager();
        e.work();
        Employee e1 = new CommonEmployee();
        e1.work();
    }
}
class CommonEmployee extends Employee{
    public void work(){
        System.out.println("在流水线工作");
    }
}
class Manager extends Employee{
    private double bonus;
    public double getBonus() {
        return bonus;
    }
    public void setBonus(double bonus) {
        this.bonus = bonus;
    }public void work(){
        System.out.println("监督员工的工作，提高效率");
    }
}
abstract class Employee{
    private String name;
    private int id;
    private double salary;
    public abstract void work();
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
}

C.程序三

package org.example;

public class Main {
    
        public static void main(String [] args)
        {
            circle c1=new circle(2.5);
            c1.draw();
            c1.getarea();
        }
    }
    interface shap
    {
        void draw();}
    interface Area
    {
        double PI=3.14;
        void getarea();
    }
    class circle implements shap,Area
    {
        private double r;
        circle(double r)
        {
            this.r=r;
        }
        public void draw()
        {
            System.out.println("The r is "+r+" circle");
        }
        public void getarea()
        {
            System.out.println("This is circle area is "+(PI*r*r));
        }
    }

D. 程序四

package org.example;

public class Main {
        public static void main(String[] args) {
            Duck d = new Duck();
            Main.test1(d);
            Main.test2(d);
            Main.test3(d);
        }
        public static void test1(Runner r){
            r.run();//虚拟方法调用
        }
        public static void test2(Swimmer s){
            s.swim();
        }
        public static void test3(Flier f){
            f.fly();
        }
    }
    interface Runner{
        public abstract void run();}
    interface Swimmer{
        void swim();
    }
    interface Flier{
        void fly();
    }
    class Duck implements Runner,Swimmer,Flier{
        public void fly() {
            System.out.println("丑小鸭也可以变成白天鹅！");
        }
        public void swim() {
            System.out.println("红掌拨清波");
        }
        public void run() {
            System.out.println("鸭子屁股扭扭的走路");
        }
    }

2.完成下列程序，查看运行结果

package org.example;

public class Main {

        public static void main(String[] args) {
            Rect r = new Rect(15, 25);
            r.print();
            r.area();
        }
    }

    class Shape {
        public void area() {
            System.out.println("Area calculation not available for generic shape");
        }

        void print() {
            System.out.println("This is shape");
        }
    }

    class Rect extends Shape {
        double x, y;

        Rect(double x, double y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public void area() {
            System.out.println("Rect area is " + (x * y));
        }

        @Override
        void print() {
            super.print(); // Call the print method of the superclass
        }
    }

四、编写程序完成下列功能

(1)定义一个接口 Area，其中包含一个计算面积的方法 CalsulateArea()，然后设计 MyCircle 和 MyRectangle 两个类都实现这个接口中的方法 CalsulateArea()，分别计算圆和矩形的面积, 最后写出测试以上类和方法的程序。

package org.example;

//定义一个接口 Main 包含一个计算面积的方法 CalculateArea()
interface Fyt {
    double calculateArea();
}

// 实现 Main 接口的圆类 MyCircle
class MyCircle implements Fyt {
    private double radius;

    public MyCircle(double radius) {
        this.radius = radius;
    }

    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

// 实现 Main 接口的矩形类 MyRectangle
class MyRectangle implements Fyt {
    private double length;
    private double width;

    public MyRectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    public double calculateArea() {
        return length * width;
    }
}
public class Main {
    public static void main(String[] args) {
        // 创建一个圆对象
        MyCircle circle = new MyCircle(3.0);
        // 创建一个矩形对象
        MyRectangle rectangle = new MyRectangle(4.0, 5.0);

        // 输出圆的面积
        System.out.println("圆的面积: " + circle.calculateArea());

        // 输出矩形的面积
        System.out.println("矩形的面积: " + rectangle.calculateArea());
    }
}

（2）定义一个有抽象方法 display()的超类 SuperClass，以及提供不同实现方法的子类 SubClassA 和 SubClassB，并创建一个测试类 PolyTester，分别创建 SubClassA 和 SubClassB 的对象。调用每个对象的 display()。

要求：输出结果为：

display A

display B

package org.example;
// 定义有抽象方法 display() 的超类 SuperClass
abstract class SuperClass {
    // 抽象方法 display
    public abstract void display();
}

// 提供不同实现方法的子类 SubClassA
class SubClassA extends SuperClass {
    public void display() {
        System.out.println("display A");
    }
}

// 提供不同实现方法的子类 SubClassB
class SubClassB extends SuperClass {
    public void display() {
        System.out.println("display B");
    }
}

// 测试类 PolyTester
public class Main {
    public static void main(String[] args) {
        // 创建 SubClassA 对象并调用 display()
        SuperClass a = new SubClassA();
        a.display();

        // 创建 SubClassB 对象并调用 display()
        SuperClass b = new SubClassB();
        b.display();
    }
}

（ 3 ）编程题 :

利用接口做参数，写个计算器，能完成加减乘除运算。

A．定义一个接口 Compute 含有一个方法 int computer(int n, int m)。

B．设计四个类分别实现此接口，完成加减乘除运算。

C．设计一个类 UseCompute，类中含有方法：public void useCom(Compute com, int one,

int two)，此方法能够用传递过来的对象调用 computer 方法完成运算，并输出运算的结果。

D．设计一个主类 Test，调用 UseCompute 中的方法 useCom 来完成加减乘除运算。

package org.example;// 定义接口 Compute 含有一个方法 int computer(int n, int m)
interface Compute {
    int computer(int n, int m);
}

// 实现加法的类
class Add implements Compute {
    public int computer(int n, int m) {
        return n + m;
    }
}

// 实现减法的类
class Subtract implements Compute {
    public int computer(int n, int m) {
        return n - m;
    }
}

// 实现乘法的类
class Multiply implements Compute {
    public int computer(int n, int m) {
        return n * m;
    }
}

// 实现除法的类
class Divide implements Compute {
    public int computer(int n, int m) {
        if (m != 0) {
            return n / m;
        } else {
            return -1; // 此处返回 -1 表示除数为 0
        }
    }
}

// 类 UseCompute，含有方法：public void useCom(Compute com, int one, int two)
class UseCompute {
    public void useCom(Compute com, int one, int two) {
        int result = com.computer(one, two);
        System.out.println("运算结果为：" + result);
    }
}

// 主类 Test，调用 UseCompute 中的方法 useCom 来完成加减乘除运算
public class Main {
    public static void main(String[] args) {
        UseCompute use = new UseCompute();

        // 加法
        Compute add = new Add();
        use.useCom(add, 5, 3);

        // 减法
        Compute subtract = new Subtract();
        use.useCom(subtract, 5, 3);

        // 乘法
        Compute multiply = new Multiply();
        use.useCom(multiply, 5, 3);

        // 除法
        Compute divide = new Divide();
        use.useCom(divide, 6, 3);
    }
}

（ 4 ）按如下要求编写 Java 程序：

A．定义接口 A，里面包含值为 3.14 的常量 PI 和抽象方法 double area()。

B．定义接口 B，里面包含抽象方法 void setColor(String c)。

C．定义接口 C，该接口继承了接口 A 和 B，里面包含抽象方法 void volume()。

D．定义圆柱体类 Cylinder 实现接口 C，该类中包含三个成员变量：底圆半径 radius、

圆柱体的高 height、颜色 color。

E.创建主类来测试类 Cylinder。

package org.example;// 定义接口 Compute 含有一个方法 int computer(int n, int m)
// 定义接口 A
interface A {
    double PI = 3.14;  // 常量 PI
    double area();     // 抽象方法
}

// 定义接口 B
interface B {
    void setColor(String c);  // 抽象方法
}

// 定义接口 C，继承接口 A 和 B
interface C extends A, B {
    void volume();  // 抽象方法
}

// 圆柱体类 Cylinder 实现接口 C
class Cylinder implements C {
    private double radius;  // 底圆半径
    private double height;  // 圆柱体的高
    private String color;   // 颜色

    public Cylinder(double radius, double height, String color) {
        this.radius = radius;
        this.height = height;
        this.color = color;
    }

    public double area() {
        return 2 * PI * radius * radius + 2 * PI * radius * height; // 圆柱体表面积
    }

    public void setColor(String c) {
        this.color = c;
    }

    public void volume() {
        double volume = PI * radius * radius * height; // 圆柱体体积
        System.out.println("圆柱体的体积为：" + volume);
    }
}

// 主类来测试类 Cylinder
public class Main {
    public static void main(String[] args) {
        Cylinder cylinder = new Cylinder(3.0, 5.0, "red");
        double area = cylinder.area();
        System.out.println("圆柱体的表面积为：" + area);
        cylinder.setColor("blue"); // 修改颜色
        cylinder.volume(); // 计算并输出圆柱体的体积
    }
}

五、实验总结

本次实验的主要目的是通过实践来学习如何使用接口和抽象类来完成程序。在实验中，我们通过编写程序来实现接口和抽象类的功能，从而加深对它们的理解和应用。

在实验中，我们学习了接口的定义和使用方法。接口定义了一组方法的规范，所有实现了该接口的类都必须实现这些方法。这样可以实现不同类之间的解耦，提高代码的灵活性和可维护性。

因篇幅问题不能全部显示，请点此查看更多更全内容

查看全文