关于几个比较常见的设计模式
这是一种应用非常广泛的设计模式，应用中许多组件都只需要单个实例,
两个优势：
?减少创建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;//这里就是逻辑代码（通过条件选择要创建的工厂对象）
? }
}
?
?
代理模式：客户端代码不能活不想直接访问被调用对象，而是额外的创建一个代理对象返回给客户端使用
?
?
?
未完待续！！！！
?
?
?
