Java实验3 类的多态性和接口

实验3 类的多态性和接口

一、实验目的

理解面向对象的多态性。理解接口和实现接口的类的关系，掌握一个类实现多个接口的声明和使用方法。

二、实验内容

1.程序理解：

接口的应用

//接口的应用
//定义一个PCI接口：
interface PCI {
    void start(); // 定义抽象方法start()

    void stop(); // 定义抽象方法stop()
}

// 定义 NetworkCard类实现PCI接口
class NetworkCard implements PCI {
    // 实现start()方法
    public void start() {
        System.out.println("send...");
    }

    // 实现stop()方法
    public void stop() {
        System.out.println("Network stop.");
    }
}

// 定义 SoundCard类实现PCI接口
class SoundCard implements PCI {
    // 实现start()方法
    public void start() {
        System.out.println("Du Du...");
    }

    // 实现stop()方法
    public void stop() {
        System.out.println("Sound stop.");
    }
}

// 定义MainBoard类
// 将子类对象作为PCI参数传进来：
class MainBoard {
    // 在这里传了一个接口参数p
    // 定义一个userPCICard()方法，接收PCI类型的参数
    public void userPCICard(PCI p) {
        // 正是因为实现了PCI接口里面的方法，才能将对象传给这个引用变量
        p.start(); // 调用传入对象的start()方法
        p.stop(); // 调用传入对象的stop()方法
    }
}

// 使用接口实现的子类对象
public class Example3 {
    public static void main(String[] args) {
        MainBoard mb = new MainBoard(); // 创建MainBoard类的实例对象
        NetworkCard nc = new NetworkCard(); // 创建NetworkCard类的实例对象nc
        mb.userPCICard(nc); // 调用MainBoard对象的userPCICard()的方法，将nc作为参数传入
        SoundCard sc = new SoundCard(); // 创建NetworkCard类的实例对象sc
        mb.userPCICard(sc); // 调用MainBoard对象的userPCICard()的方法，将sc作为参数传入
    }
}

2.编程题：

（1）声明复数类Complex，成员变量包括double类型的实部real和double类型的虚部im，成员方法包括三个重载的构造方法：实部和虚部构造方法Complex(double real, double im)；无参构造方法 Complex()，该无参构造方法内部用this（0,0）调用前一个构造方法；只有实数部分的构造方法Complex(double real)，该构造方法内部用this（real,0）调用两个参数的构造方法。此外，该复数类的成员方法还包括复数加法、复数减法、字符串描述（重写Object的toString方法，输出a+bi的形式）、相等比较(判断两个复数是否相等，需要重写Object的equals方法)等方法。定义测试类，在main方法中进行相应的测试。（程序1）


（2）定义两个接口Area（声明getArea方法求面积）和Volume（声明getVolume方法求体积），声明球类Globe，实现Area和Volume接口，计算球的表面积和体积。设计测试类，在main方法中进行相应的测试。（程序2）


（3）完成如下所示接口的继承和实现结构，定义测试类，在main方法中进行测试。(接口和类名字可以更改)（程序3）


（4）选做题： 设计一个程序，该程序通过使用父类类型变量引用不同的子类对象，从而实现类型的多态。

三、实验结果和分析

说明：请截图给出各个程序的运行结果，并做必要的分析。

(1)程序1运行结果

(2)程序2运行结果

(3)程序3运行结果

(4)程序4运行结果（如选做）

四、实验源代码

说明：请将各程序的源代码复制粘贴到这里。

(1)程序1源代码

 import java.util.Scanner;
//定义复数类Complex
class Complex1 {
    double real;
    double im;

    // 定义实部和虚部构造方法
    Complex1(double real, double im) {
        this.real = real;
        this.im = im;
    }

    // 无参构造方法
    Complex1() {
        this(0, 0);
    }

    // 有实数部分的构造方法
    Complex1(double real) {
        this(real, 0);
    }

    // 定义复数加法的方法
    public Complex1 add(Complex1 c) {
        return new Complex1(this.real + c.real, this.im + c.im);
    }

    // 复数减法
    public Complex1 minus(Complex1 c) {
        return new Complex1(this.real - c.real, this.im - c.im);
    }

    // 字符串描述（重写Object的toString方法，输出a+bi的形式）
    public String toString() {
        if (im < 0)
            return real + "" + im + "i";
        else
            return real + "+" + im + "i";

    }

    // 相等比较(判断两个复数是否相等，需要重写Object的equals方法)
    public boolean equals(Object obj) {

        Complex1 c = (Complex1) obj;
        if (real == c.real && im == c.im) {
            return true;
        }
        return false;
    }

}

// 定义测试类
public class Example1 {

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入第一个复数的实部和虚部：");
        double a=sc.nextDouble();
        double b=sc.nextDouble();

        Complex1 c1 = new Complex1(a, b);// 创建Complex对象

        System.out.println("请输入第二个复数的实部和虚部：");
        double c=sc.nextDouble();
        double d=sc.nextDouble();
        /*
        double result;
        double d1 = 1.0;
        double d2 = 1.0;
        BigDecimal bd1 = new BigDecimal(Double.toString(d1));
        BigDecimal bd2 = new BigDecimal(Double.toString(d2));
        result = bd1.add(bd2).doubleValue(); // 加
        result = bd1.subtract(bd2).doubleValue(); // 减
        result = bd1.multiply(bd2).doubleValue(); // 乘
        result = bd1.divide(bd2, 10, BigDecimal.ROUND_HALF_UP).doubleValue(); // 除，除不尽时保留10位后四舍五入
        */
        Complex1 c2 = new Complex1(c, d);// 创建Complex对象

        System.out.println("("+c1.toString()+")+("+c2.toString()+")=" + (c1.add(c2)));// 调用add方法并打印
        System.out.println("("+c1.toString()+")-("+c2.toString()+")=" + c1.minus(c2));// 调用minus方法并打印

        if(c1.equals(c2))//调用toString方法
            System.out.println(c1.toString()+"="+c2.toString());
        else
            System.out.println(c1.toString()+"≠"+c2.toString());
    }

}

(2)程序2源代码

import java.util.Scanner;
import java.text.DecimalFormat;

//定义了Area接口
interface Area {
    double getArea(); // 定义抽象方法getArea()
}

// 定义了Volume接口
interface Volume {
    double getVolume(); // 定义抽象方法getVolume()
}

// 声明球类Globe，实现，计算球的表面积和体积
// Globe类实现了Area和Volume接口
class Globe implements Area, Volume {
    double r;

    public Globe(double r) {
        this.r = r;
    }

    // 实现getArea()方法
    public double getArea() {
        return 4 * Math.PI * r * r;
    }

    // 实现getVolume()方法
    public double getVolume() {
        return 0.75 * Math.PI * r * r * r;
    }
}

// 定义测试类
public class Example4 {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        DecimalFormat df = new DecimalFormat("0.00");
        System.out.println("请输入球的半径：(单位：cm)");
        double rad = sc.nextDouble();
        Globe globe = new Globe(rad);// 创建Globe类对象实例
        System.out.println("此球的表面积为" + df.format(globe.getArea())+"cm2");// 调用Dog类的getArea()方法
        System.out.println("此球的体积为" + df.format(globe.getVolume())+"cm3");// 调用Dog类的getVolume()方法
    }

}

(3)程序3源代码

import java.util.Scanner;
import java.text.DecimalFormat;

//定义了平面图形PlaneGraphics接口
interface PlaneGraphics {
    double area(); // 定义求面积的抽象方法area()

    double perimeter(); // 定义求周长的抽象方法perimeter()
}

// 定义了立体图形SolidGraphics接口
interface SolidGraphics {
    double volume(); // 定义求体积的抽象方法volume()
}

// 定义长方形Rectangle类实现平面图形PlaneGraphics接口
class Rectangle implements PlaneGraphics {
    double a, b;

    // 定义了两个参数的构造函数
    public Rectangle(double a, double b) {
        this.a = a;
        this.b = b;
    }

    // 实现求面积的抽象方法area()
    public double area() {
        return a * b;
    }

    // 实现求周长的抽象方法perimeter()
    public double perimeter() {
        return 2 * (a + b);
    }
}

// 定义长方体Cuboid类继承长方形Rectangle类的同时实现立体图形SolidGraphics接口
class Cuboid extends Rectangle implements SolidGraphics {
    double c;

    // 定义了三个参数的构造函数
    public Cuboid(double a, double b, double c) {
        super(a, b);
        this.c = c;
    }

    // 实现求表面积的抽象方法area()
    public double area() {
        return 2 * (a * b + b * c + a * c);
    }

    // 实现求体积的抽象方法volume()
    public double volume() {
        return a * b * c;
    }
}

// 定义测试类
public class Example6 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        DecimalFormat df = new DecimalFormat("0.00");

        System.out.println("请输入长方形的长和宽：（单位：cm）");
        double recLength = sc.nextDouble();
        double recWidth = sc.nextDouble();
        // 创建Rectangle类对象
        Rectangle rectangle = new Rectangle(recLength, recWidth);

        System.out.println("此长方形的面积为：" + df.format(rectangle.area())+"cm2");
        System.out.println("此长方形的周长为：" + df.format(rectangle.perimeter())+"cm");

        System.out.println("请输入长方体的长、宽、高：（单位：cm）");
        double cubLength = sc.nextDouble();
        double cubWidth = sc.nextDouble();
        double cubHeight = sc.nextDouble();
        // 创建Cuboid类对象
        Cuboid cuboid = new Cuboid(cubLength, cubWidth, cubHeight);

        System.out.println("此长方体的表面积为：" + df.format(cuboid.area())+"cm2");
        System.out.println("此长方体的体积为：" + df.format(cuboid.volume())+"cm3");

    }
}

(4)程序4源代码（如选做）

//定义接口Plan
interface Plan {
    void eat(); // 定义抽象eat()方法

    void play(); // 定义抽象play()方法
}

// 定义Saturday类实现Plan接口
class Saturday implements Plan {

    // 实现抽象eat()方法
    public void eat() {
        System.out.println("            吃甜品");
    }

    // 定义抽象play()方法
    public void play() {
        System.out.println("            骑自行车");
    }
}

// 定义Sunday类实现Plan接口
class Sunday implements Plan {

    // 实现抽象eat()方法
    public void eat() {
        System.out.println("            吃寿司");
    }

    // 定义抽象play()方法
    public void play() {
        System.out.println("            爬山");
    }
}

// 定义测试类
public class Example9 {
    public static void main(String[] args) {
        weekend(new Saturday());
        weekend(new Sunday());
    }

    // 定义静态的weekend()方法，接收一个Plan类型的参数
    public static void weekend(Plan p) {
        // 判断所属类型进而使用其特有方法
        if (p instanceof Saturday) {
            System.out.println("星期六：");
        } else {
            System.out.println("星期天：");
        }
        p.eat();
        p.play();

    }
}
时间： 2024-11-07 14:28:46

Java实验3 类的多态性和接口的相关文章

Java入门(一)——类、抽象类和接口

Java是一门面向对象语言,可以看出"对象"在Java有着举足轻重的位置.那么,"对象"从何而来呢?那必须是丈母娘造出来的,下面我们就先来说说这个丈母娘--类. Java类 对象: 对象具有状态和行为. 例如:一只狗的状态有:颜色,名称,品种,它的行为有:摇尾巴,吠叫,吃东西. 对象是类的实例 类: 类是一个模板,它描述一类具有相同状态和行为的对象.比如人类,都具有思考这个行为,而植物没有. 类可以看成是创建Java对象的模板,下面简单定义一个类: public c

java实验2 类的继承性

实验2 类的继承性 一.实验目的 掌握面向对象的继承性在Java中的实现方法:掌握super关键字的用法,体会抽象类和抽象方法的作用. 二.实验内容 1.程序理解: 1)类的继承 2)第4章课后编程第1题 class Student { public String name; public int age; public Student(String name,int age){ this.name=name; this.age=age; } public void show(){ System

JAVA实验4 类与对象（封装继承多态等机制的使用）

实验四 类与对象(封装.继承.多态等机制的使用) 实验内容: 1. 编写一个名为TwoDimensionalShape的抽象类,拥有属性area和circumference表示面积和周长,以及抽象方法getArea()和getCircumference(),用于获取面积和周长. 2. 编写Printable接口,包括一个抽象方法printShapeInfo,用于输出图形信息. 3. 分别编写Rectangle.Triangle.Circular三个类,用于描述矩形.三角形和圆形,要求继承于Two

深入理解Java虚拟机笔记---类索引,父类索引,接口索引集合

类索引(this_class)和父类索引(super_class)都是u2类型的数据,而接口索引(interfaces)是一组u2类型的数据集合,class文件中由这三项数据来确定这个类的继承关系.类索引用于确定这个类的全限定名,父类索引用于确定这个类的父类的全限定名.由于Java语言不允许多继承,所以父类索引只有一个,除了java.lang.Object之外,所有的Java类都有父类,因了除了java.lang.Object之外,所有Java类的父类索引都不为0.接口索引集合用来描述这个实现实

JAVA实验3 类与对象

实验要求: 掌握类与对象的基本思想 能够熟练地使用Java设计并编写类 能够灵活运用各种对象 实验内容: 希腊神话中,宙斯战胜了泰坦之后成为众神之王,以此为背景,通过构造相应对象.属性和方法,并用随机的方式,模拟宙斯与泰坦的战斗过程. 构建类Titan,要求如下: 整形字段HP,以及相应的getter和setter 空参数列表构造方法Titan(),创造出的HP默认为700 带参数构造方法Titan(int HP),创造出指定HP的对象 方法attack(Zues z),参数为宙斯对象,每次调用

Java中的类继承机制、接口

1)声明一个Person类,有name(String类型).age(int类型).sex(char类型)属性,通过构造方法进行赋值.一个show方法,返回String类型,内容如下: 某某 男(女) 年龄 2)声明一个Student类,继承Person类,增加id(int,学号)属性,通过构造方法,利用super调用父类构造方法来进行变量赋值.Override父类的show方法,返回String类型,内容如下: 某某 男(女) 年龄 学号 (提示:利用super调用父类的show方法得到除学号部

Java中的类和接口

类有两种: 普通类  : 抽象类(abstract): 抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量.成员方法和构造方法的访问方式和普通类一样. 由于抽象类不能实例化对象,所以抽象类必须被继承(extends),才能被使用.也是因为这个原因,通常在设计阶段决定要不要设计抽象类. 父类包含了子类集合的常见的方法,但是由于父类本身是抽象的,所以不能使用这些方法. 在Java中抽象类表示的是一种继承关系,一个类只能继承一个抽象类,而一个类却可以实现多个接口. 抽象方法 如果你想设计这样

【总结】Effective java经验之谈，类与接口

转载请注明出处:http://blog.csdn.NET/supera_li/article/details/44940563 Effective Java系列 1.Effective java经验之谈,创建和销毁对象 2.Effective java经验之谈,泛型 3.Effective java经验之谈,类与接口 4.Effective java经验之谈,通用方法 5.Effective java经验之谈,枚举,注解,方法,通用设计,异常 6.Effective java经验之谈,并发编程

Java中继承thread类与实现Runnable接口的区别

Java中线程的创建有两种方式: 1．  通过继承Thread类,重写Thread的run()方法,将线程运行的逻辑放在其中 2．  通过实现Runnable接口,实例化Thread类 在实际应用中,我们经常用到多线程,如车站的售票系统,车站的各个售票口相当于各个线程.当我们做这个系统的时候可能会想到两种方式来实现,继承Thread类或实现Runnable接口,现在看一下这两种方式实现的两种结果. Java代码   package com.threadtest; class MyThread e