软件设计的目标

た入场券 2022-06-15 08:53 144阅读 0赞

一.面向对象编程

1、可维护性

当日后代码需要修改逻辑的时候，只需要修改某些类或者增加某些类，对主程序和大部分代码不需要修改，体现为可维护性。

2、可复用性

将一定的代码进行封装，在多处可以重复使用。

3、可扩展性

当增加新的功能模块时，只需要增加某些代码，对整体代码架构不需要做太多修改。

4、高灵活性

通过封装、继承、多态把程序的耦合度降低，耦合度降低后，使代码的使用更加灵活，更容易修改，易于复用。

二.分别用简单工厂模式和工厂方法模式实现软件的可维护性和提高可复用性

1.简单工厂模式

专门定义一个工厂类负责创建其他类的实例，最大的优点在于工厂类中包含了必要的逻辑，根据客户需要的条件动态实例化相关的类

\# UML图

![Center][]

\# 程序：

Fruit.java(接口)

package com.simple;
    
    //实现水果类 Fruit.java
    public interface Fruit{
      void plant();        //定义种植方法
      void grow();           //定义生长方法
      void harvest();
    }

SimpleFactory.java

package com.simple;
    
    //新建一个简单工厂类 SimpleFactory.java
    public class SimpleFactory{
      public static Fruit getFruitObj(String type){
       Fruit obj = null;
       if(type.equals("apple")){
    		obj = (Fruit) new Apple();
       }
    	return obj;
      }
    }

Apple.java

package com.simple;
    
    //实现苹果类 Apple.java
    public class Apple implements Fruit{
     @Override
    	public void plant() {
    		// TODO Auto-generated method stub
    		System.out.print("种植了苹果");
    		
    	}
    
    	@Override
    	public void grow() {
    		// TODO Auto-generated method stub
    		System.out.print("苹果生长了");
    	}
    
    	@Override
    	public void harvest() {
    		// TODO Auto-generated method stub
    		System.out.print("苹果结果了");
    		
    	}
    }

main.java

package com.simple;
    
    //客户端接口
    public class main{
      public static void main(String args[]){
       Fruit fu =SimpleFactory.getFruitObj("apple");
    		fu.plant();
    		System.out.println();
    		fu.grow();
    		System.out.println();
    		fu.harvest();
      }
    }

结果：

种植了苹果  
苹果生长了  
苹果结果了

2.工厂方法模式

创建对象的接口，让子类去决定具体实例化的对象，把简单的内部逻辑判断移到了客户端代码。工厂方法克服了简单工厂违背开放\-封闭原则的缺点，又保持了封装对象创建过程的优点。

\# UML 图

![Center 1][]

程序：

Fruit.java

package com.Factory;
    
    //实现水果类 Fruit.java
    public interface Fruit{
        void plant();        //定义种植方法
        void grow();           //定义生长方法
        void harvest();
    }

Factory.java

package com.Factory;
    
    //定义一个抽象工厂方法
    public abstract class Factory {
    	public abstract Fruit getapple();
    	public static Factory getFruitFactory(String type){
    		Factory f = null;
    		if(type.equals("apple")){
    			f=new AppleFactory();
    			f.getapple();
    		}
    		return f;	
       }
    }

AppleFactory.java

package com.Factory;
    
    //定义一个苹果的工厂
    public class AppleFactory extends Factory{
    public Apple getapple(){
            //返回苹果的对象
    	return new Apple();
     }
    }

Apple.java

package com.Factory;
    
    //定义一个苹果。与上面简单工厂相同
    public class Apple implements Fruit{
    
    	@Override
    	public void plant() {
    		// TODO Auto-generated method stub
    		System.out.print("123");
    	}
    
    	@Override
    	public void grow() {
    		// TODO Auto-generated method stub
    		System.out.print("苹果生长了");
    	}
    
    	@Override
    	public void harvest() {
    		// TODO Auto-generated method stub
    		System.out.print("苹果结果了");
    	}
    
    }

client.java

package com.Factory;
    //定义主函数
    public class client {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		//执行 方法
    		Fruit f =(Fruit) Factory.getFruitFactory("apple");
    		f.plant();
    		f.grow();
    		f.harvest();		
    	}
    }

[Center]: /images/20220615/e3a85b9289e44e38b3c98b90540b0516.png
[Center 1]: /images/20220615/6f085d85f82449febb695225db0357bf.png