java常见设计模式（学习记录帖）

学习记录帖，欢迎指正，不胜感激。

 

1、单例模式：

　　public class SingleTon{

　　　　private static singleTon singleIntance; //私有对象

　　　　private void singleTon(){} //私有构造方法，阻止其他途径获取对象；

　　　　public singleTon getIntance(){ //公有方法，获取对象

　　　　　　if(singleIntance==null){ //判断是否已经存在单例对象

　　　　　　　　synchronized(singleTon.class){ //保证线程安全

　　　　　　　　　　if(singleIntance==null){ //此处再次判断是否为空，原因是防止在一个线程刚好执行完new singleTon()，还未返回，另一个线程获取锁之后执行；

　　　　　　　　　　　　singleIntance = new singleTon();

　　　　　　　　　　}

　　　　　　　　}

　　　　　　}

　　　　　　return singleIntance;

　　　　}

　　} 

 

2、工厂模式

工厂模式为生成对象提供了接口，将生成对象的过程隔离起来；

　　工厂模式分为三类：

简单工厂模式（simple Factory）：不符合开闭原则，例如需要增加一个水果类，就需要更改工厂类的代码逻辑；

　　//创建一个水果接口类

　　public interface Fruit{

　　　　public void payFruit();

　　}

　　//水果类，做不同的操作

　　public class Apple implements Fruit{

　　　　public void payFruit(){

　　　　　　System.out.println("吃");

　　　　}

　　}

　　public class Orange implements Fruit{

　　　　public void payFruit(){

　　　　　　System.out.println("榨果汁");

　　　　}

　　}

 

　　//生成对象的工厂类

　　public class Factory{

　　　　public static Fruit getIntance(String name){

　　　　　　if(name.equals("Apple")){

　　　　　　　　return new Apple();

　　　　　　}else if(name.equals("Orange")){

　　　　　　　　return new Orange();

　　　　　　}

　　　　　　return null;

　　　　}

　　}

 

　　//测试类

　　public class Test{

　　　　public static void main(String[] args){

　　　　　　Factory.getIntance("Apple").payFruit();

　　　　　　Factory.getIntance("Orange").payFruit();

　　　　}

　　}

工厂方法模式（method Factory）：

　　工厂方法模式，抽象生成水果的类，用子类实现if中的代码逻辑；

　　//抽象产品类

　　public interface Fruit{

　　　　public void payFruiy();

　　}

　　//不同的水果，不同的操作

　　public class Apple implements Fruit{

　　　　public void payFruit(){

　　　　　　System.out.println("吃");

　　　　}

　　}

　　public class Orange implements Fruit{

　　　　public void payFruit(){

　　　　　　System.out.println("榨果汁");

　　　　}

　　}

　　//工厂接口类（抽象工厂类）

　　public interface FruitFactory{

　　　　public FruitFactory getIntance(){};

　　}

　　//实现工厂接口类

　　public static class GetApple implements FruitFactory{

　　　　public FruitFactory getIntance(){

　　　　　　return new Apple();

　　　　}

　　}

　　public static class GetOrange implements FruitFactory{

　　　　public FruitFactory getIntance(){

　　　　　　return new Orange();

　　　　}

　　}

 　　//如果需要添加新的类型水果，只需要添加新的实现类

　　//测试类

　　public class Test{

　　　　public static void main(String[] args){

　　　　　　GetApple.getIntance.payFruit();

　　　　　　GetOrange.getIntance.payFruit();

　　　　}

　　}

抽象工厂模式（abstract Factory）：

抽象工厂模式和工厂方法模式的区别在于，抽象工厂模式存在多个抽象产品类；

　　//抽象水果类（抽象产品类）

　　public interface Fruit{

　　　　public void payFruiy();

　　}

　　//抽象饮料类（抽象产品类）

　　public interface Drink{

　　　　public void HotRoCold();

　　}

　　//水果产品实现类

　　public class Apple implements Fruit{

　　　　public void payFruit(){

　　　　　　System.out.println("吃");

　　　　}

　　}

　　public class Orange implements Fruit{

　　　　public void payFruit(){

　　　　　　System.out.println("榨果汁");

　　　　}

　　}

　　//饮料产品实现类

　　public class Muilk implements Drink{

　　　　public void HotOrCold(){

　　　　　　System.out.println("cold");

　　　　}

　　}

　　public class Xuebi implements Fruit{

　　　　public void HotOrCold(){

　　　　　　System.out.println("cold");

　　　　}

　　}

　　//抽象水果工厂类

　　public interface FruitFactory{

　　　　public Fruit getAppleFruit(){};

　　　　public Fruit getOrangeFruit(){};

　　}

　　//抽象饮料工厂类

　　public interface DrinkFactory{

　　　　public Fruit getMuilkDrink(){};

　　　　public Fruit getXuebiDrink(){};

　　}

　　//水果工厂实现类

　　public static class GetFruitIntance implements FruitFactory{

　　　　public Fruit getAppleFruit(){

　　　　　　return new Apple();

　　　　}

　　　　public Fruit getOrangeFruit(){

　　　　　　return new Orange();

　　　　}

　　}

　　//饮料工厂实现类

　　public static class GetDrinkIntance implements DrinkFactory{

　　　　public Fruit getMuilkDrink(){

　　　　　　return new Muilk();

　　　　}

　　　　public Fruit getXuebiDrink(){

　　　　　　return new Xuebi();

　　　　}

　　}

　　//测试类

　　public class Test{

　　　　public static void main(String[] args){

　　　　　　GetDrinkIntance.getMuilkDrink().HotOrCold();

　　　　　　GetDrinkIntance.getXuebiDrink().HotOrCold();

　　　　　　GetFruitIntance.getAppleFruit().payFruit();

　　　　　　GetFruitIntance.getOrangeFruit().payFruit();

　　　　}

　　}