Java实验 10  面向对象的几个基本原则

Posted 2021-06-24 吹灭读书灯 一身都是月

实验 10   面向对象的几个基本原则

• 楼房的窗户

1. 相关知识点

所谓面向抽象类编程，是指设计一个类时，不让该类面向具体的类，而是面向抽象类或者接口。“开-闭”原则就是让设计的系统应该对外扩展开放，对修改关闭。其本质是指当系统中增加新的模块时，不需要修改现有的模块。在设计系统时，应当首先考虑到用户需求的变化，将应对用户变化的部分设计为扩展开放，而设计的核心部分是经过精心考虑之后确定下来的基本结构，这部分应当对修改关闭的，即不能因为用户的需求变化而再发生变化，因为这部分不是用来应对需求变化的。

设计某些系统时，要面向抽象来考虑系统的总体设计。在程序设计好后，首先对abstract类的修改关闭，否则，一旦修改abstract类将可能导致它的所有子类都需要作出修改，应当对增加abstract类的子类开放，即再增加新子类时，不需要修改其他面向抽象类的设计的重要类。

1. 实验目的

让学生掌握“开-闭”原则的设计思想

1. 实验要求

楼房需要安装窗户，如果楼房只能安装木制窗户，显然楼房的设计是不完善的。设计一个模拟楼房的类，使得楼房能够安装各种材质的窗户，具体要求如下：

1. 定义一个抽象类Window(窗户）。Window类有4个非抽象方法

public double getWidth()、public double getHeight()、public void setWidth (double w)、public void setHeight (double w)和一个抽象方法String getMaterial()。

1. 定义Building类(楼房)，该类中有一个Window类型的ArrayList属性windows。定义一个

1. public void use(ArrayList<Window> windowlist),该方法将windowlist中每个元素调用getWidth()和getLength()方法返回窗口的尺寸是否符合要求，如果符合要求，把相应的元素复制给windows里的元素。窗户的尺寸是一个常量（宽为109.98，高为156.98）。比较的算法如下：

Math.abs(w.getWidth()-width)<=1E-2&&

Math.abs(w.getHeigh()-height)<=1E-1;

1. public void showWindow()方法，显示楼房安装的所有窗户。并输入每个窗户的详细信息。格式如下：

第1扇窗户是: 木制窗户 宽是 : 109.98 高是 : 156.89

1.  编写若干个Window的子类

WoodWindow: String getMaterial() 返回“木制窗户”

AluminumWindow: String getMaterial() 返回“铝合金窗户”

运行结果效果如下：

第1扇窗户是: 木制窗户 宽是 : 109.98 高是 :  156.89

第2扇窗户是: 木制窗户 宽是 : 109.98 高是 :  156.89

第3扇窗户是: 木制窗户 宽是 : 109.98 高是 :  156.89

第4扇窗户是: 木制窗户 宽是 : 109.98 高是 :  156.89

1.  请绘制出上述系统的类图，注意抽象类要用斜体表示
2.  请完成（1）-（3）中的三个类的代码

 

1. 实验指导

如果将实验中的Window类、Building类以及WoodWindow和AluminumWindow类看作一个小的开发框架，将Application.java看做使用该框架进行应用开发的用户程序，那么框架满足“开-闭”原则，该框架相对用户的需求比较容易维护，因为当用户程序需要其他材质的窗户时，系统只需要简单地扩展框架，即在框架中增加一个Window的子类，无须修改框架中其他的类。

 

abstract class Window {
    private double width;
    private double height;

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public abstract String getMaterial();
}

//楼房
class Building {
    private final double windowWidth = 109.98;
    private final double windowHeight = 156.98;
    private ArrayList<Window> windows = new ArrayList<>();

    public void use(ArrayList<Window> windowList) {
        for (Window w : windowList) {
            if (Math.abs(w.getWidth() - windowWidth) <= 0.01 && Math.abs(w.getHeight() - windowHeight) <= 0.1) {
                windows.add(w);
            }
        }
    }

    public void showWindow() {
        for (int i = 0; i < windows.size(); i++) {
            System.out.println("第 " + (i + 1) + "扇窗户是"
                    + windows.get(i).getMaterial() + " 宽是：" + windows.get(i).getWidth() + " 高是：" + windows.get(i).getHeight());
        }
    }
}

class WoodWindow extends Window {
    @Override
    public String getMaterial() {
        return "木制窗户";
    }
}

class AluminumWindow extends Window {
    @Override
    public String getMaterial() {
        return "铝合金窗户";
    }
}


public class Application {
    public static void main(String[] args) {
        Building schoolBuilding = new Building();
        ArrayList<Window> windows = new ArrayList<Window>();
        for (int i = 0; i < 7; i++) {
            if (i % 2 == 0) {
                windows.add(new WoodWindow());
                windows.get(i).setWidth(109.98);
                windows.get(i).setHeight(156.89);
            } else {
                windows.add(new AluminumWindow());
                windows.get(i).setWidth(109.99);
                windows.get(i).setHeight(156.87);
            }
        }
        schoolBuilding.use(windows);
        schoolBuilding.showWindow();
    }
}

• 搭建流水线 

1. 相关知识点

如果一个对象a组合了对象b,那么对象a就可以委托对象b调用其方法，即对象a以组合的方式复用对象b的方法。通过组合对象来复用方法的优点是：通过组合对象来复用方法也称为“黑盒”复用，因为当前对象只能委托包含的对象调用其方法，这样一来，当前对象所包含的对象方法的细节对当前对象是不可见的。另外，对象与包含的对象属于弱耦合关系，因为如果修改当前对象所包含的对象的类的代码，不必修改当前对象的类的代码。

1. 实验目的

本实验目的是让学生掌握一个对象怎样组合另一个对象。

1. 实验要求

流水线的作用是，用户只需要将处理的数据交给流水线，即一次让流水线上

的对象来处理数据。例如，在歌手比赛中，只需要将评委给出的分数交给设计好的流水线，就可以得到选手的最后分数，流水线的第一个对象负责录入裁判给选手的分数，第二个对象负责去掉一个最高分和一个最低分，最后一个对象负责计算出平均成绩。具体要求如下：

1. 编写InputScore、DelScore、ComputerAverage和Line类
2. InputScore类的对象负责录入分数，InputScore类组合了DelScore类的对象
3. DelScore类的对象负责去掉一个最高分和一个最低分，DelScore组合了CoputerAverage类的对象
4. CoputerAverage类的对象负责计算平均值
5. Line组合了InputScore、DelScore、ComputerAverage这3个类的实例
6. 在主类中用Line创建一个流水线对象，并将裁判的分数交给流水线
7. 请绘制出上述系统的类图
8.  请完成（2）-（5）中的四个类的代码

 

public class SingGame {
    public static void main(String[] args) {
         Line line = new Line();
         line.givePersonScore();
    }
}
class InputScore{
    DelScore del;
    InputScore(DelScore del){
    this.del = del;
    }
    public void inputScore(){
    System.out.println("请输入评委数");
    Scanner read = new Scanner(System.in);
    int count = read.nextInt();
    System.out.println("请输入各个评委的分数");
    double[] a = new double[count];
    for(int i =0 ; i<count; i++){
      a[i] = read.nextDouble();
    }
   del.doDelect(a);
 }
}
class DelScore{
    ComputerAverage computerAve;
    public DelScore(ComputerAverage computerAve) {
        super();
        this.computerAve = computerAve;}
    public void doDelect(double[] a){
        java.util.Arrays.sort(a);
        System.out.println("去掉一个最高分: "+a[a.length-1]+ ",");
        System.out.println("去掉一个最高分: "+a[0]+ "。");
        double b[] = new double[a.length-2];
        System.arraycopy(a, 1, b, 0, a.length-2);
        computerAve.giveAver(b);
    }
}
class ComputerAverage{
    public void giveAver(double[] b){
        double sum =0;
        for(int i =0 ; i<b.length;i++){
            sum = sum +b[i];
        }
        double aver = sum/b.length;
        System.out.println("选手最后得分 "+aver);
    }
}
class Line{
    InputScore one;
    DelScore two;
    ComputerAverage three;
    Line(){
        three = new ComputerAverage();
        two = new DelScore(three);
        one = new InputScore(two);
    }
    public void givePersonScore(){
        one.inputScore();
    }
}