软件代码开发技术（代码优化改进）

（1）读下面的代码，说明TightCoupling2的TightCoupling()方法与TightCouping的ShowWelcomeMsg()方法是怎样的耦合关系？能改进吗？

解答： TightCoupling2的TightCoupling()方法与TightCouping的ShowWelcomeMsg()方法之间的关系是强耦合关系（明显是简单工厂方法模式），因为TightCoupling2类的构造TightCoupling()方法的实现必须要用到TightCouping类的实例化并且通过引用调用和执行ShowWecomeMsg()方法。即通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
简单工厂将对象的创建过程进行了封装，用户不需要知道具体的创建过程，只需要调用工厂类获取对象即可。
这种简单工厂的写法是通过switch-case来判断对象创建过程的。在实际使用过程中，违背了 开放-关闭原则，当然有些情况下可以通过反射调用来弥补这种不足所以一般我们不建议使用这种方法。因为以后如果逻辑复杂了那么整个系统代码不好扩展，只能在switch-case里面硬编码其实也是一种硬伤。
改进方法：运用java设计模式中的工厂方法模式。
以下是代码实现：

package test;

    //定义上级工厂的接口
    public interface ShowWelcomeMsg {
      public void writeLine();
    }
    
    /**
    * 工厂方法  为每个对象生成一个工厂类
    */
    public class TightCoupling2 implements  ShowWelcomeMsg{
    
      @Override
      public void writeLine() {
        System.out.println("Good M");
      }
    }
    public class TightCoupling3 implements  ShowWelcomeMsg{
    
    	  @Override
    	  public void writeLine() {
    	    System.out.println("Good E");
    	  }
    	}
    public class TightCoupling4 implements  ShowWelcomeMsg{
    
    	  @Override
    	  public void writeLine() {
    	    System.out.println("Good N");
    	  }
    	}
    public interface TightCoupling
    {
    	public ShowWelcomeMsg showwelcomemsg();
    }
    //以下再建立三个问候语工厂

（2）下面的方案存在问题
问题是：其实设计方案要实现的就是一个用户支付转账的过程，方案中存在三个类；转账功能实现类，账号接口实现类，消费者类。
消费者类·直接与账户相关联。

（6）有，

    package test;
    import javax.mail.Message;
    public abstract class  EmailMessage{
    	
    	private String sendT0;
    	private String subject;
    	private String message;
    	private String username;
    	private String password;
    	
    	//无参构造器
    	protected EmailMessage() { }
    	 
    	//有参数构造器
    	protected EmailMessage(String to,String subject,String message)
    	{
    		super();
    		
    		this.sendT0=to;
    		
    		this.subject=subject;
    		
    		this.message=message;
    	}
    	//定义发送消息的抽象接口
    	public abstract	void SendMessage();
    	
    	
    	public boolean Login(String username,String password)
    	{
    		this.username=username;
    		
    		this.password=password;
    	}
    
    }

（7）不符合面向对象的思想，整个设计过程中没有体现封装，继承以及多态的设计实现。
改正如下：

    package test;
    class manager
    {
    	private String name;
    	
    	private int age;
    	
    	public String getName()
    	{
    		return name;
    	}
    	
    	public manager()
    	{
    		
    	}
    	
    	public manager(String name,int age)
    	{
    		this.name=name;
    		
    		this.age=age;
    	}
    }
    public class getmanager
    {
    	manager Dohko=new manager("Dohko",55);
    	
    	manager Shion=new manager("Shion",35);
    	
    }

（8）

    public class BorrowerList{
    	
    	private Borrower bo;
    	
    	private List<Borrower> list=new ArrayList<>();//用集合模拟数据库,默认已添加多个实例
    	
    	private String changetime;
    	
    	
    	
    	//根据id查询用户
    	public  Borrower queryboById(Integer bo_id)
    	{
    		bo=new Borrower(bo_id);
    		if(list.contains(bo))
    		{
    			return bo;
    		}else {
    			return null;
    		}
    	}
    	
    	//删除用户
    	public  void  removebo(Integer  bo_id)
    	{
    		bo=new Borrower(bo_id);
    	
    		if(list.contains(bo))
    		{
    			list.remove(bo);
    		}else {
    			return ;
    		}
    	}
    	
    	//添加用户
    	public void addBo(Borrower bo)
    	{
    		if(list.contains(bo))
    		{
    			return ;
    		}else {
    			list.add(bo);
    		}
    	
    }
    }
    class Borrower
    {
    	private int id;
    	private String name;
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public Borrower(int id)
    	{
    		this.id=id;
    	}
    }

（9）王同学的设计方案没有体现面向对象的设计方法，本科生，研究生，教师之间存在的复用关系没有充分利用。对封装，继承，多态均未设计，造成代码的冗余，逻辑复杂。

借阅者的设计类图：

（10）设计1是一种简单的继承关系。设计2一种利用接口方法的实现。

继承的好处:让共同部分,可以复用.避免重复编程.

继承的不好:耦合性高.一旦超类添加一个新方法,子类都继承,拥有此方法,

若子类相当部分不实现此方法,则要进行大批量修改.

继承时,子类就不可继承其它类了.

接口的好处:解决了继承耦合性高的问题.

  且可让实现类,继承或实现其它类或接口.

接口的不好:不能真正实现代码的复用.

如果雇员的支付方式会随时发生变换，比如从钟点工转为月薪制。那么设计2更为合适，因为一个系统中会存在多个雇员，如果使用简单的继承实现方法的话修改量会比较巨大。而使用接口的方法的话，每次只需要修改很少量的代码。（面向接口编程的优势）

（11）不符合面向对象的思想。（从继承，封装，多态分析）每次执行操作都必须new一个引用catalog，这是比较爆炸的。
修改之后：

    package test;
    
    import java.util.ArrayList;
    
    public class Libary extends Catalog
    {
    	public int countCatalog() {
    		
    		return getBookList().size();
    	}
    }
    class Catalog
    {
    	ArrayList<Book> list=new ArrayList<Book>();
    	
    	public ArrayList<Book> getBookList()
    	{
    		return list;
    	}
    	
    	
    }
    class Book
    {
    	private int id;
    	
    	private String name;
    
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	
    	
    	public Book() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    
    	public Book(int id, String name) {
    		super();
    		this.id = id;
    		this.name = name;
    	}
    	
    	
    }

喜欢的记得点赞关注我哦！