关于几个比较常见的设计模式

1. 单例模式

这是一种应用非常广泛的设计模式，应用中许多组件都只需要单个实例,

两个优势：

•  减少创建java实例所带来的系统开销，
• 便于系统跟踪单个java实例的生命周期、实例状态！

具体的代码实现：

  class Singleton{
private static Singleton singleton;

private Singleton(){}:

public static Singleton getSingleton(){

 if(singleton==null){
 singleton=new Singleton();

}

return singleton；

}

}

测试类：

public class TestSingleton{
  public static void main(String args[]){
  //创建实例不能通过构造器，只能通过getSingleton()方法来实现

Singleton s1=Singleton.getSingleton();

Singleton s2=singleton.getSingleton();

System.out.println(s1==s2);//将返回true；

 }

}

 

运用举例：

在javaee的运用中，可能只需要一个数据库引擎访问点，hibernate访问时只需要一个SessionFactory 实例，如果在系统为它们创建多个实例，会加大对系统的开销，同时也没什么意义！

 

 

2.简单工厂模式：将多个类对象交给工厂类来生成的设计方式就是简单工厂模式

什么叫硬编码耦合？

直接通过调用类的类名，一旦系统需要重构，就必须修改类名了！

设计方法：

比如A类要调用b类里的方法,刚开始我们会选择直接通过new关键字来创建一个b实例，然后调用b类的方法，但是我们如果用简单工厂模式的话，就可以这样来实现：

让b类实现以个d接口，而A类只需要D接口耦合----A类并不直接使用new关键字来创建B实例，而是重新定义一个工厂类，DFactory,由该工厂类来负责创建D实例，而A类只需要通过DFactory工厂的方法来得到ib的实例，以后如果A类需要调用E类的方法，只需要E类也实现D接口！并改写DFActory中创建D撕裂的方法，让该工厂产生E实例即可。

 

实例讲解：

工厂类：

public class BuildFactory {
   public Output getOut(){
    return new Computer();//这个方法如同：Output out=(Output)new Computer();
   }
}

接口：

public interface Output {
  public String out();
  public String out2();
}

调用类：

public class Printer implements Output {

 @Override
 public String out() {
  // TODO Auto-generated method stub
 
  BuildFactory factory=new BuildFactory();
  

  return factory.getOut().out();
 }

 @Override
 public String out2() {
  // TODO Auto-generated method stub
  
  return null;
 }

}

 

被调用类：

public class Computer implements Output {

 @Override
 public String out() {
  // TODO Auto-generated method stub
  
  return "abs";
 }

 @Override
 public String out2() {
  // TODO Auto-generated method stub
  
  return "abs2";
 }
  
}

 

工厂方法和抽象工厂：

工厂方法：在简单工厂模式的前提下，做出了如下改进，但使用工厂方法设计模式时，对象调用者需要与具体的工厂类耦合：当需要不同对象时，程序需要调用相应工厂对象的方法来得到所需要的对象。

抽象工厂类：工厂类不制造具体的被调用对象，而是制造不同的工厂对象。

将上例中的工厂抽象为一个接口！

新增加了两个生成实例的接口！

工厂方法具体代码如下：

public interface BuilderFactory {
    Output getOut();
}
public class Computer implements Output  {

 @Override
 public String out1() {
  // TODO Auto-generated method stub
  return "computer";
 }

 @Override
 public void out2() {
  // TODO Auto-generated method stub
  
 }

}

 

public class ComputerFactory implements BuilderFactory{

 @Override
 public Output getOut() {
  // TODO Auto-generated method stub
  return  new Computer();
 }

}

 

public interface Output {
  String out1();
  void out2();
}

 

public class Printer implements Output {

 @Override
 public String out1() {
  // TODO Auto-generated method stub
  return "printer";
 }

 @Override
 public void out2() {
  // TODO Auto-generated method stub
  
 }

}

 

public class PrinterFactory  implements BuilderFactory{

 @Override
 public Output getOut() {
  // TODO Auto-generated method stub
  return new Printer();
 }

}

 

抽象工厂模式的具体代码如下:

与上面不同的在于：

public class OutputFactoryFacotory {
  public static OutputFactory getOutputFactory(){
   return null;//这里就是逻辑代码（通过条件选择要创建的工厂对象）
  }
}

 

 

代理模式：客户端代码不能活不想直接访问被调用对象，而是额外的创建一个代理对象返回给客户端使用

 

 

 

未完待续！！！！