Java23种设计模式

JAVA中使用设计模式写代码能使代码重用、直观、可靠，共有23种设计模式，分别是：

创建型模式：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式；

结构型模式：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式；

行为型模式：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式，
工厂设计：在Java中，接口是实现多重继承的途径，而生成按照某个接口的对象的方式就是工厂设计模式，我们在工厂对象上调用其定义的静态方法，工厂将生成接口的某个实现的对象。通过这种方式，我们可以实现把代码和接口的实现分离。并且，如果把主方法看作客户端，那么，对于程序的修改就不应该影响或改动客户端

interface Fruits{           //定义一个吃水果的接口  
    public void eat();  
}  
  
class Apple implements Fruits{  
    public void eat(){  
        System.out.println("吃苹果");  
    }  
};  
  
class Orange implements Fruits{  
    public void eat(){  
        System.out.println("吃橘子");  
    }  
};  
  
class Factory{      //定义工厂类  
    public static Fruits getInstance(String className){  
        Fruits f =null;     //定义接口对象  
        if("apple".equals(className))  //判断是否是Apple类的标记  
            f = new Apple();  
        if("orange".equals(className))  //判断是否是Orange类的标记  
            f = new Orange();  
        return f;  
    }  
      
};  
  
public class ExceptionTest1 {  
    public static void main(String args[]){  
        Fruits f = null;  
        f = Factory.getInstance("apple");  
        f.eat();  
    }  
} 

可以发现在更改调用的 Fruits子类的时候，主函数不用发生任何变化。这种设计模式就称为工厂设计模式。

但是，每当客户端再增加了一个需求的时候，在工厂里都会被动的增加一段代码来与新增加的需求所对应，比如客户端想吃香蕉就被要求增加一个Banana类实现接口，这样显得工厂处于一种被动的地位，并且违反了开放—关闭的原则，所以，在这里介绍一种新的工厂设计模式，就是工厂方法模式。

package 测试;

abstract class Market{		//创建水果市场的接口  
    public abstract Fruit GetFruit();  
}  
  
abstract class Fruit{		//创建水果的接口  
    public abstract void ShowFruit();  
}  
  
class Apple extends Fruit{		//水果1  
    public void ShowFruit() {		//客户所需要的结果  
        System.out.println("eat apple");  
    }  
}  
  
class Orange extends Fruit{		//水果2  
    public void ShowFruit() {  	
        System.out.println("eat orange");  
    }  
}  
  
class Market1 extends Market{//提供苹果的市场子类  
    public Fruit GetFruit() {		//实例化
        return  new Apple();  
    }  
}  
  
class Market2 extends Market{   //生产橘子的市场子类  
  
    public Fruit GetFruit() {  
        return new Orange();  
    }  
}  
  
public class Demo {    //主函数（客户端）  
    public static void main(String[] args) {  
        Market mone = new Market1();//创建一个市场对象，用提供苹果的子类实例化  
        mone.GetFruit().ShowFruit();//生产一个苹果  
        Market mtwo = new Market2();//创建一个市场对象，用提供橘子的子类实例化  
        mtwo.GetFruit().ShowFruit();//生产一个产橘子  
    }  
}  

这种设计方式可以保证了工厂方法内的对修改关闭，解决了简单工厂模式的问题。但是再增加新的产品（需求）的时候，我们也同样要增加对应的市场子类和水果子类，这样做在一定程度上增加了程序的复杂性
第二种，根据网上搜索通过对子类的实例化的调用接口子类实现对用户需要的满足，个人认为第一种比较好，return new Orange()的意思是
Orange orange=new Orange（）
return orange
两种各有利弊
1：当一个类不知道它所需要的对象的类时，在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要调用对应的工厂类或者工厂方法即可；
2：当一个类希望通过其子类来指定创建对象时，在工厂方法模式中，抽象工厂类只被指定提供一个产品；