软件工程及设计模式

最新推荐文章于 2024-05-06 17:14:17 发布

m0_69836134

最新推荐文章于 2024-05-06 17:14:17 发布

阅读量234

点赞数

文章标签：软件工程设计模式 uml

本文链接：https://blog.csdn.net/m0_69836134/article/details/128102720

版权

软件工程

软件工程学是指，用工程学的方法进行软件的开发与维护，并对软件生产过程进行工程化的管理。

软件危机

在计算机软件的开发和维护过程中遇到的一系列问题，使软件开发者陷入困境，人们称之为“软件危机”。

软件生命周期

可行性分析阶段
- 成果：可行性分析报告
需求分析阶段
- 成果：软件需求规格说明书
系统设计阶段
- 概要设计是以需求分析的结果为依据定义系统的主要构成成分和他们之间的关系。
- 详细设计是定义每个系统成分内部的构造细节
- 成果：概要设计说明、详细设计说明书、数据库设计说明书
系统实现阶段
- 成果：通过单元测试的源代码。
测试阶段
- 成果：软件测试报告
维护阶段
- 成果：软件问题报告、软件变动记录、软件维护记录

软件开发过程

软件开发过程是在软件生命周期的软件系统开发过程中，一系列活动和软件生成结果的集合。它包括软件规格说明。软件设计和开发，软件确认，软件改进等活动。

软件过程模型

瀑布模型
- 软件生存期各阶段明确任务、自上而下、顺序固定、逐级过渡的结构模式，各阶段的联系就像瀑布流水一样自上而下不可逆返，适用于需求被清晰定义的情况。适合制作产品软件
喷泉模型
- 各个阶段之间没有严格的界限，其活动可以交叠和回溯。每次迭代过程中包含项目的风险评估。
  
  有些工作既可在OOA中进行，也可在OOD进行。
  
  适合于开发需求需要更改的项目软件。

统一建模语言UML

专门用来进行软件系统设计和架构建模的一门可视化建模语言，它通过各种图示展示了软件系统的方方面面。

UML常见符号

访问修饰符
- -：表示私有(private)
- +：表示共有(public)
- #：表示受保护(protected)
- ~：表示默认
抽象类、抽象方法以斜体表示
接口：<>
类和类的关系
- 实现：一个类实现一个接口、UML中，以虚线加三尖角表示
- 泛化：一个类继承另一个类；UML中，以实线加三尖角表示
- 关联
  - 依赖：一个类是另一个类的方法参数、返回类型、方法局部变量；UML中，以虚线箭头表示
  - 聚合：一个类是另一个类的属性，是整体和部分的关系，UML中，以实线空心菱形表示
  - 组合：一个类是另一个类的属性，是整体不可分割的一部分，是强聚合。UML中，以实线实心菱形表示

设计模式

设计模式描述的是在软件系统的某一局部不断重现的核心解决方案

创建模式

涉及对象的创建

单例模式

单例模式也属于创建模式。让一个类产生对象，只有唯一一个。其目的是，减少内存消耗。

立即加载

在类加载时，马上产生实例

public class Single {
    private static Single s = new Single();

    private Single() {
    System.out.println("构造方法")
    }
    public static Single getSingle() {
        return s;
    }
}

延迟加载
- 在类加载时，不产生实例。在使用时再产生实例

工厂模式

建造者模式

建造者模式是一种创建模式，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
建造者模式的角色
- Product:最终要生成的对象。
- Builder：构建者的抽象基类或接口
- ConcreteBuilder：Builder的子类或实现类
- Director：决定如何构建最终产品的算法

创建商品

public class Computer {
    private String cpu;//必须
    private String ram;//必须
    private int usbCount;//可选
    private String mouse;//可选
    private String keyborder;//可选

创建构建者接口

public interface IBuilder {
    public void builderUsbCount();
    public void builderMouse();
    public void builderKeyborder();
    public Computer getComputer();
}

创建构建者接口实现类

public class AsusComputer implements IBuilder {
    public Computer computer;

    public AsusComputer(String cpu, String ram) {
        this.computer = new Computer(cpu, ram);
    }

    @Override
    public void builderUsbCount() {
        computer.setUsbCount(2);
    }

    @Override
    public void builderMouse() {
        computer.setMouse("华硕光电鼠标");
    }

    @Override
    public void builderKeyborder() {
        computer.setKeyborder("华硕彩色键盘");
    }

    @Override
    public Computer getComputer() {
        return this.computer;
    }
}

指挥者

public class Diector {
    public void createComputer(IBuilder builder){
        builder.builderUsbCount();
        builder.builderMouse();
        builder.builderKeyborder();
    }
}

测试

    public static void main(String[] args) {
        IBuilder asus=new AsusComputer("I5处理器","12G");
        Diector diector=new Diector();
        diector.createComputer(asus);
        System.out.println(asus.getComputer());

原型模式

结构模式

涉及类和对象的组合

外观模式

代理模式

代理模式属于结构模式，在目标方法执行前，或执行后，添加非功能性操作。

静态代理

定义接口

public interface IEat {
    public void eat();
    public void drink();
}

定义目标对象

public class BossChen implements IEat {
    @Override
    public void eat() {
        System.out.println("吃火锅");
    }

    @Override
    public void drink() {
        System.out.println("喝红牛");
    }
}

定义代理对象

public class MissLai implements IEat {
    private IEat iEat;

    public MissLai(IEat iEat) {
        this.iEat = iEat;
    }

    @Override
    public void eat() {
        System.out.println("订餐");
        //调用目标对象的目标方法
        this.iEat.eat();
        System.out.println("结账，开放票");
    }

    @Override
    public void drink() {
        System.out.println("订餐");
        this.iEat.drink();
        System.out.println("结账开发票");
    }
}

测试

public class TestProxy {
    public static void main(String[] args) {
        IEat iEat = new MissLai(new BossChen());
        iEat.eat();
        iEat.drink();
    }
}

动态代理

创建接口

public interface IBossEat {
    public void eat();

    public void drink();
}

创建目标对象

public class BossWang implements IBossEat{
    @Override
    public void eat() {
        System.out.println("吃满汉全席");
    }

    @Override
    public void drink() {
        System.out.println("喝人头马");
    }
}

创建代理工厂类

public class MissYang implements InvocationHandler {
    private Object targetObj;

    public MissYang(Object targetObj) {
        this.targetObj = targetObj;
    }

    public Object getProxy() {
        return Proxy.newProxyInstance(
                targetObj.getClass().getClassLoader(),//目标对象类加载器
                targetObj.getClass().getInterfaces(),//目标对象实现的接口列表，代理对象和目标对象实现相同的接口
                this//InvocationHandler接口实现类对象，调用代理对象方法时
                //会执行InvocationHandler接口实现类对象的invoke方法
        );
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("订餐");
        //执行目标方法（method），传入执行方法的参数（arg），得到方法执行后的返回值（returnObj）
        Object returnObj = method.invoke(targetObj, args);
        System.out.println("结账开发票");
        return returnObj;
    }
}

测试

    public static void main(String[] args) {
        MissYang yang = new MissYang(new BossWang());
        //得到地阿里对象，代理对象和目标对象实现相同的接口
        IBossEat bossEat = (IBossEat) yang.getProxy();
        bossEat.eat();
        bossEat.drink();
    }

适配器模式

装饰模式

装饰器模式属于结构模式，对象功能的扩展能够根据需要来动态地实现。

创建主料接口

public interface IProduct {
    /**
     * 得到商品描述
     *
     * @return
     */
    public String info();

    /**
     * 得到商品价格
     * @return
     */
    public int getPrice();
}

创建主料实现类

public class IrichCoffee implements IProduct{
    @Override
    public String info() {
        return "爱尔兰咖啡";
    }

    @Override
    public int getPrice() {
        return 15;
    }
}

创建辅料接口

/**
 * 辅料接口
 */
public interface Iaccesories extends IProduct{

}

创建辅料实现类

public class Milk implements Iaccesories {
    public IProduct product;

    public Milk(IProduct product) {
        this.product = product;
    }

    @Override
    public String info() {
        return product.info() + "加上牛奶";
    }

    @Override
    public int getPrice() {
        return product.getPrice() + 3;
    }
}

测试

    //加了两份糖一份冰块的爱尔兰咖啡
public static void main(String[] args) {
        IProduct p = new IrichCoffee();
        p = new Sugar(p);
        p = new Sugar(p);
        p = new Ice(p);
        System.out.println(p.info() + p.getPrice());
    }

行为模式

刻画了类和对象数据交互，及分配职责的方式。主要目标是解耦。

观察者模式

观察者模式是一种订阅模式，属于行为模式。让多个观察者对象同时监听某一个主题对象，这个主题对象在状态发生变化的时候，会通知所有的观察者对象，使他们能够自动更新自己。

定义观察者接口

    /**
     * 主题更新方法
     * @param valueObj 更新后的值
     */
    public void update(Object valueObj);
}

定义主题父类

public class ObsServer {
    /**
     * 观察者集合
     */
    private List<IWatch> watchList = new ArrayList<>();

    /**
     * 添加观察者
     * @param watch
     */
    public void addWatch(IWatch watch) {
        watchList.add(watch);
    }

    /**
     * 主题更新后，通知观察者
     * @param newValue
     */
    public void notifyWatch(Object newValue){
        for (IWatch watch:watchList){
            watch.update(newValue);
        }
    }
}

定义具体主题

public class Product extends ObsServer {
    private double price;

    public double getPrice() {
        return price;
    }

    public void setPrice(double price){
        this.price=price;
        //通知观察者主题的变化
        this.notifyWatch(price);
    }
}

定义观察者实现类

public class Watch1 implements IWatch {
    private double price;

    public Watch1() {
    }

    public Watch1(double price) {
        this.price = price;
    }

    public double getPrice() {
        return price;
    }

    @Override
    public void update(Object valueObj) {
        double factoryPrice = (Double) valueObj;
        this.price = factoryPrice * 1.2;
    }
}

测试

    public static void main(String[] args) {
        Product p = new Product();
        Watch1 w1 = new Watch1();
        Watch2 w2 = new Watch2();
        p.addWatch(w1);
        p.addWatch(w2);
        p.setPrice(20);
        System.out.println(w1.getPrice()+"  "+ w2.getPrice());
        p.setPrice(30);
        System.out.println(w1.getPrice()+"  "+ w2.getPrice());
    }
}