Java程序设计实验4 | 面向对象（下）

*本文是博主对Java各种实验的再整理与详解，除了代码部分和解析部分，一些题目还增加了拓展部分（⭐）。拓展部分不是实验报告中原有的内容，而是博主本人自己的补充，以方便大家额外学习、参考。

（解析部分还没更完，过几天补上）

一、实验目的

1、理解继承的概念；

2、掌握方法的重写；

3、掌握super、final关键字的使用；

4、掌握抽象类和接口的使用；

5、掌握多态的使用；

6、掌握内部类的使用；

7、掌握异常处理方式，能够自定义异常类；

8、了解Object类。

---

二、实验内容

1、实验题目：类的继承和方法重写

定义一个基类作为父类，再定义一个继承父类的子类，在子类中重写父类的方法，使用super关键字调用父类的方法，测试其功能。

本题是类的继承的练习。在继承中，super关键字可以在子类中调用父类的成员变量、成员方法和构造方法。注意：在子类构建的过程中，会调用父类的构造方法。默认情况下，子类会调用父类无参的构造方法：super()。

源代码：

public class S4_1 {
    public static void main(String[] args) {
        //创建一个Animal对象
        Animal animal = new Animal("动物");
        //调用父类的方法
        animal.show();
        animal.say();
        //创建一个Cat对象
        Cat cat = new Cat("小猫！");
        //调用重写的父类的方法
        cat.show();
        cat.say();
    }
}

class Animal {
    public String name;
    public int age;

    public Animal(String name) {
        this.name = name;
    }
    public void show() {
        System.out.println("一个Animal类！");
    }
    public void say() {
        System.out.println("你好" + name);
    }
}

class Cat extends Animal{
    public Cat(String name) {
        //调用父类的构造方法
        super(name);
    }
    public void show() {
        super.show();   //调用父类的方法
        System.out.println("父类的age是："+super.age);   //调用父类的age成员变量
        System.out.println("一个Cat类！");
    }
    public void say() {
        super.say();    //调用父类的方法
        System.out.println("喵喵" + name);
    }
}

列出测试数据和实验结果截图： 

---

2、定义一个类，在类中声明成员变量和成员方法，尝试使用final关键词修饰类中的变量、方法及该类，测试并查看结果，必要时加以注释。

1、没有final修饰时：

public class S4_2 {
    public static void main(String[] args) {
        Child child = new Child();
        child.print();
    }
}
class Father {
    String name;
    int age;
    void print(){
        System.out.println("hello world!");
    }
}

class Child extends Father{
    public Child(){
        super();
    }
    void print(){
        System.out.println("goodbye!!");
    }
}

调用了子类重写父类的方法print()，并成功输出子类的方法内容。 

2、有final修饰父类中的方法时

class Father {
    String name;
    int age;
    final void print(){
        System.out.println("hello world!");
    }
}

class Child extends Father{
    public Child(){
        super();
    }
    void print(){
        System.out.println("goodbye!!");
    }
}

程序报错，无法正常运行。因为被final修饰的方法不能被子类重写。 

3、final修饰变量

public class S4_2 {
    public static void main(String[] args) {
        final double PI = 3.14;
        PI = 666;
        System.out.println("PI is "+PI);
    }
}

PI被final修饰，此时PI为常量，必须在定义时赋值且只能赋值一次，在运行时值不能改变。 

如图，当为PI第二次赋值时，程序会报编译错误。

4、final修饰类

final class Father {
    String name;
    int age;
    void print(){
        System.out.println("hello world!");
    }
}

class Child extends Father{
    public Child(){
        super();
    }
    void print(){
        System.out.println("goodbye!!");
    }
}

由于final修饰的类不能被继承，因此在父类Father前用final修饰，继承操作会报编译错误。

3、实验题目：研究生薪资管理

（注：在职研究生继承学生类，实现雇员接口）

在学校中，学生每个月需x要交相应的生活费（2000元），雇员每个月有相应的工资（1000~3000随机生成），而在职研究生（on-the-job postgraduate）既是雇员又是学生，所以在职研究生既需要交学费又会有工资。下面要求编写一个程序来统计在职研究生的收入与学费，如果收入无法满足交学费，则输出“撸起袖子加油干！”信息。（思考：如果使用抽象类，是否能完成该要求？）

import java.util.Scanner;


public class S4_3 {
    public static void main(String[] args) {
        System.out.println("请输入该研究生姓名:");
        Scanner in = new Scanner (System.in);
        String name = in.nextLine();

        postGraduate s = new postGraduate();
        s.setName(name);

        System.out.println("请输入该研究生学费:");
        int fee =in.nextInt();
        s.setFee(fee);

        System.out.println("请输入该研究生薪资:");
        int salary=in.nextInt();
        s.setSalary(salary);
        if(s.getSalary() >= s.getFee()) {
            System.out.println("薪资超过学费");
        }else{
            System.out.println("撸起袖子加油干！");
        }
    }
}


class Student {
    private String name;
    private int fee;
    public void setFee(int fee) {
        this.fee=fee;
    }
    public int getFee() {
        return fee;
    }

    public void setName(String name) {
        this.name=name;
    }

    public String getName() {
        return name;
    }

}

interface Salary{
    public abstract void setSalary(int salary);
    public abstract int getSalary();
}

class postGraduate extends Student implements Salary {
    private String name;
    private int fee;
    private int salary;
    public void setSalary(int salary) {
        this.salary=salary;
    }

    public int getSalary() {
        return salary;
    }
}

4、实验题目：创建一个抽象交通工具Vehicle类，它有 wheelNum 和 seatNum 两个成员变量以及抽象方法 display()。 类 Bus 和类 Motorcycle 继承自Vehicle类，实现打印成员变量的 display()方法。在主函数中分别生成Bus对象和Motorcycle对象，上转型为Vehicle对象调用 display()方法。 

//抽象类
abstract class Vehicle {
    int wheelNum;
    int seatNum;
    protected abstract void display();
}

class Bus extends Vehicle{
    public Bus(int a, int b) {
        this.wheelNum = a;
        this.seatNum = b;
    }
    @Override
    public void display(){
        //重写抽象方法
        System.out.println("公交车轮子："+this.wheelNum+"个；座位："+this.seatNum+"个。");
    }
}

class Motorcycle extends Vehicle{
    public Motorcycle(int a, int b) {
        this.wheelNum = a;
        this.seatNum = b;
    }
    @Override
    //重写抽象方法
    public void display(){
        System.out.println("摩托车轮子："+this.wheelNum+"个；座位："+this.seatNum+"个。");
    }
}

public class S4_4 {
    public static void main(String[] args) {
        Vehicle bus = new Bus(4,35);
        Vehicle motorcycle = new Motorcycle(2, 2);
        bus.display();
        motorcycle.display();
    }
}

修改程序中传入构造函数的参数：

 

5、实验题目：经理与员工工资，主要考察多态

某公司的人员分为员工和经理两类，但经理也属于员工中的一类，公司员工和经理都有自己的姓名，年龄，工号、工资、工龄等属性（通过属性无法区分员工和经理）和工资上涨函数。假设每次给员工涨工资一次能涨10%，经理能涨20%。要求利用多态实现给员工和经理涨工资，测试并通过。

public class S4_5 {
    public static void main(String[] args) {
        Employee employee = new Employee(1000);
        Employee manager = new manager(1000);

        System.out.println("原工资为："+ employee.getSalary());
        //调用Employee中的raise方法
        employee.raise();
        //调用manager类中重写的raise方法
        manager.raise();

        System.out.println("员工增长10%后为："+employee.getSalary());
        System.out.println("经理增长20%后为："+manager.getSalary());
    }
}

class Employee{
    protected  String name;
    protected int age;
    protected int id;
    protected double salary;
    protected int workage;

    public Employee() {
    }

    public Employee(double salary) {
        this.salary = salary;
    }

    public void raise(){
        this.salary += this.salary*0.1;
    }

    public double getSalary() {
        return salary;
    }
}

class manager extends Employee{
    public manager() {
    }
    public manager(double salary) {
        this.salary = salary;
    }
    public void raise(){
//重写Employee中的raise（）方法
        this.salary += this.salary*0.2;
    }
    @Override
    public double getSalary() {
        return salary;
    }
}

更改传入构造函数的工资数值（将1000改为6000）：

 

6、实验题目：把下面的代码补充完整，输出结果为“实现了Inner接口的匿名内部类！”，并测试输出结果。

interface Inner{

  void introduce();

}

class Outer{

       //补齐代码，完成方法主要功能

    

}

class InnerClassTest{

  public static void main(String[] args){

       Outer.method().introduce ();

}

}

interface Inner{
    void introduce();
}

class Outer {
    public static Inner method(){
        return new Inner() {
            @Override
            public void introduce() {
                System.out.println("实现了Inner接口的匿名内部类！！！");
            }
        };
    }
//补齐代码，完成方法主要功能
}

class S4_6{
    public static void main(String[] args){
        Outer.method().introduce();
    }
}

7、实验题目：设计一个类，在类中能够处理自定义异常类并测试。（选做）

import java.util.Scanner;

public class S4_7 {
    public static void main(String[] args) throws MyExcept {
        myTest.fun();
    }
}
class MyExcept extends Exception {
    private int num;

    public MyExcept(int a) {
        this.num = a;
    }

    //打印异常
    @Override
    public String toString() {
        return "出现异常！！"+num+"大于1000";
    }
}
class myTest {
    static void fun() throws MyExcept {
        int i = 0;
        System.out.println("请输入一个不大于1000的数：");
        Scanner scanner = new Scanner(System.in);
        i = scanner.nextInt();
        System.out.println("输入的数为：" + i);

        if (i > 1000) {
            //如果输入大于1000则抛出异常
            throw new MyExcept(i);
        }
        System.out.println("正常运行！！没有出现异常。");
    }
}

 

 

三、实验总结

1. 实验过程中，我对Java类的继承与多态的运用更加熟练了。

2. 我对权限修饰符的了解更深了。在第五题中用protected修饰员工employee的属性，protected修饰的成员被称为保护成员，它可以被同一个包中的其他类和这个类的派生类访问，可以在该类的子类内部进行访问。

3. final关键字可以修饰变量包括成员变量和局部变量、方法和类。final就是“最终”的意思，它修饰的方法不能被子类重写；final修饰的变量会变成常量，不可对其值进行修改；final修饰类时，该类不可被继承。