Java-exp4B-优快云博客

本文链接：https://blog.youkuaiyun.com/junjun_shi/article/details/145065669

1.抽象类的练习

2、编写下面程序写出运行结果，谈谈成员变量的继承与隐藏，方法的覆盖与重载。

3、（1）理解下面3个类的定义，分析它们之间的关系，写出运行结果。

（2）变量的理解：为什么this.instanceVar可以而this. staticVar不行

4、接口和继承的综合应用（可尝试接口回调的精彩）

5、接口和反射的综合应用(采用Java的反射方法来实现)

代码文件在资源~

【实验要求】

1.抽象类的练习

编写一个程序，在程序中定义一个抽象类Shape，再定义两个抽象方法Area和printArea，定义两个Shape类的子类Rectangle和Circle类，在子类中实现父类的抽象方法。

【实验具体内容】

（1）实验流程图

（2）实验源代码（粘贴源代码）：

// 抽象类 Shape
abstract class Shape {
    // 抽象方法：计算面积
    abstract double area();

    // 抽象方法：打印面积
    abstract void printArea();
}

// Shape类的子类Rectangle
class Rectangle extends Shape {
    double length;
    double width;

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

    // 实现父类的抽象方法：计算面积
    double area() {
        return length * width;
    }

    // 实现父类的抽象方法：打印面积
    void printArea() {
        System.out.println("The area of the rectangle is: " + area());
    }
}
// Shape类的子类Circle
class Circle extends Shape {
    double radius;

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

    // 实现父类的抽象方法：计算面积
    double area() {
        return Math.PI * radius * radius;
    }

    // 实现父类的抽象方法：打印面积
    void printArea() {
        System.out.println("The area of the circle is: " + area());
    }
}

// 主类
public class AbstractPractice {
    public static void main(String[] args) {
        // 创建Rectangle对象
        Rectangle rectangle = new Rectangle(5, 3);
        // 创建Circle对象
        Circle circle = new Circle(4);

        // 打印面积
        rectangle.printArea();
        circle.printArea();
    }
}

（3）实验代码、过程、相应结果（截图）并对实验进行说明和分析：

新建Java项目，新建类AbstractPractice，输入代码，运行结果如下。正确输出矩形、圆面积。

参数为Rectangle(5, 3)、Circle(4)时，结果为：

参数为Rectangle(5.5,3.5)、Circle(2.5)时，结果为：

【实验要求】

2、编写下面程序写出运行结果，谈谈成员变量的继承与隐藏，方法的覆盖与重载。

【实验具体内容】

（1）实验流程图：无

（2）实验源代码（粘贴源代码）：

// 父类 A
class A {
    int sum, num1, num2;

    public A() {
        num1 = 10;
        num2 = 20;
        sum = 0;
    }

    void sum1() {
        sum = num1 + num2;
        System.out.println("sum=" + num1 + "+" +num2 + "=" + sum);
    }

    void sum2(int n) {
        num1 = n;
        sum = num1 + num2;
        System.out.println("sum=" + num1 + "+" +num2 + "=" + sum);
    }
}

// 子类 B 继承自 A
class B extends A {
    // 注意：这里重写了 num2 的定义，但未在构造器中初始化
    int num2;

    public B() {
        num2 = 200; // 子类的构造器改变了 num2 的值
    }

    // 重写了 sum2() 方法，没有参数
    void sum2() {
        sum = num1 + num2;
        System.out.println("sum=" + num1 + "+" +num2 + "=" + sum);
    }

    // 重写了 sum2(int n) 方法，有一个参数
    void sum2(int n) {
        num1 = n;
        sum = num1 + num2;
        System.out.println("sum=" + num1 + "+" +num2 + "=" + sum);
    }

    // 新增方法 sum3(int n)，调用父类的 sum2(int n)
    void sum3(int n) {
        super.sum2(n);
        System.out.println("sum=" + num1 + "+" +num2 + "=" + sum);
    }
}

// 主类
public class Test {
    public static void main(String[] args) {
        B m = new B();
        m.sum1(); // 调用 A 类的 sum1() 方法
        m.sum2(); // 调用 B 类的 sum2() 方法，无参数
        m.sum2(50); // 调用 B 类的 sum2(int n) 方法
        m.sum3(50); // 调用 B 类的 sum3(int n) 方法，
        				//内部调用 A 类的 sum2(int n) 方法
    }
}

（3）实验代码、过程、相应结果（截图）并对实验进行说明和分析：

分析：

m.sum1(); // 调用 A 类的 sum1() 方法

此时 num1 和 num2 的值分别由 A 类的构造器初始化为 10 和 20。

输出：sum=10+20=30

m.sum2(); // 调用 B 类的 sum2() 方法，无参数

num1 的值由 B 类的构造器初始化为 10（因为 B 类构造器没有改变 num1，直接继承了A的），num2 的值由 B 类的构造器初始化为 200。

输出：sum=10+200=210

m.sum2(50); // 调用 B 类的 sum2(int n) 方法

改变 num1 的值为 50，num2 仍为 200。

输出：sum=50+200=250

m.sum3(50); // 调用 B 类的 sum3(int n) 方法，内部调用 A 类的 sum2(int n) 方法

先由B类第一句，super.sum2(n);内部调用A 类的 sum2(int n) 方法，即num1 = 50;num2 = 20;

输出：sum=50+20=70

再继续 B 类的 sum3(int n) 方法，下一句为打印，这里的num1 的值为内部调用A 类后更新后的50，num2 仍为B 类的构造器初始化的200。输出的sum实际上没有经过计算，直接是内部调用A 类更新后的sum，所以为70.

输出：sum=50+200=70

【实验要求】

3、（1）理解下面3个类的定义，分析它们之间的关系，写出运行结果。

注意实际上图中程序有问题，其中import java.io.*;应该放在开头（而且该程序中未使用，可以删掉）

3个类的定义，分析它们之间的关系：

1、SuperClass 是一个基类（父类），它有一个整型成员变量 x 和两个方法：一个构造函数和一个 doSomething 方法。构造函数初始化 x 为 3，并打印一条消息。doSomething 方法打印一条消息。

2、SubClass 是一个继承自 SuperClass 的子类（派生类）。它也有一个整型成员变量 x，并重写了 doSomething 方法。SubClass 的构造函数首先调用父类的构造函数（使用 super()），然后设置 x 为 5，并打印一条消息。在 doSomething 方法中，它首先调用父类的 doSomething 方法，然后打印两条消息，显示父类和子类中 x 的值。

3、Inheritance 是包含 main 方法的主类。在 main 方法中，创建了一个 SubClass的实例，并调用了它的 doSomething 方法。

运行结果：

当 main 方法执行时，它创建了一个 SubClass 的实例 subC。

SubClass 的构造函数首先调用 SuperClass 的构造函数，设置 SuperClass 中的 x 为 3，并打印 "in SuperClass: x=3"。

然后，SubClass 的构造函数将 SubClass 中的 x 设置为 5，并打印 "in SubClass: x=5"。

接下来，main 方法调用 subC.doSomething()。

SubClass 的 doSomething 方法首先调用 SuperClass 的 doSomething 方法，打印 "in SuperClass.doSomething()"。

然后，它打印 "in SubClass.doSomething()"。

最后，它打印 "super.x=3 sub.x=5"，显示了父类和子类中 x 的值。