java常用的设计模式学习总结_jaav假设交通工具car分为公共汽车bus和自行车bike，定义一个抽象类car，在该类中包含一个-CSDN博客

本文链接：https://blog.csdn.net/liliping28/article/details/80916316

设计模式的作用：解耦，复用，减少代码的开发量。为了后期易于维护。

设计模式遵循的原则：1.单一原则（理解例如：狗这个类，只能做狗能干的事。它不能像猫一样上树去抓老鼠）

2.开闭原则（理解例如：对于扩展开发，不可以修改已经开发好的功能）

3.里氏代换原则（理解例如：所有引用父类的地方可以透明的引用子类，但是子类反过来是不可以引用父类的）

4.依赖导致原则：(理解例如：在平时的程序中我们一般只传入实现类为参数，但是如果后期想新增某个功能时，我们往往实现这个接口。这时我们可以将参数修改成这个接口。但是可以通过多态的机制选择具体去调用那个实现)

5.接口隔离原则

6.迪米特原则

设计模式分为四大类型如下：

创建型模式（5种）：工厂方法模式（工厂模式），抽象工厂模式，单例模式，建造者模式，原型模式。

结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。

行为型模式（11种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

这里我挑一些常用的说说：工厂方法模式（工厂模式），抽象工厂模式，单例模式，适配器模式，代理模式

工厂方法模式包含四个部分：

1.抽象产品：产品对象同一的基类，或者是同一的接口。

2.具体的产品：各个不同的实例对象类

3.抽象工厂：所有的子类工厂类的基类，或是同一的接口

4.具体的工厂子类：负责每个不同的产品对象的实际创建

一句话就是，定一个抽象的接口，定义方法，该方法没有返回值。让别的类来实现该接口。在定义一个抽象工厂的接口，定义方法，该方法返回上个定义的抽象类。然后在让其他类实现定义好的抽象工厂，然后实现该抽象工厂的实现工厂类，在实现工厂类里面创建一个抽象接口的实现类。然后返回该抽象接口的实现类。

工厂方法模式（工厂模式）：

package factory.simple;

/**

此类为抽象接口

* 抽象产品角色交通工具接口
*
* @author lilin
*
*/
public interface Car {

/**
* 上班函数
*/
void gotowork();

}

package factory.simple;

/**

抽象接口的实现类

* 具体产品角色，自行车
*
* @author lilin
*
*/
public class Bike implements Car {
@Override
public void gotowork() {
System.out.println("骑自行车去上班！");
}

}

package factory.simple;

/**

抽象接口的实现类

* @author lilin
*
*/
public class Bus implements Car {

@Override
public void gotowork() {
System.out.println("坐公交车去上班！");
}

}

/**

抽象接口的工厂类

*/
package factory.factory;

import factory.simple.Car;

/**
* @author lilin
*
*/
public interface ICarFactory {

/**
* 获取交通工具
*
* @return
*/
Car getCar();

}

/**
*
*/
package factory.factory;

import factory.simple.Bike;
import factory.simple.Car;

/**

工厂的实现类

package factory;

public class ICarFactoryImpl implements ICarFactory{

@Override
public Car getCar(String type) {
if(type.equals("bus")){
return new Bus();
}
if(type.equals("bike")){
return new Bike();
}
return null;
}

}

/**
*
*/
package factory.factory;

import org.testng.annotations.Test;

import factory.simple.Car;

/**

测试类

* @author lilin
*
*/
public class TestFactory {

@Test
public void test() {
ICarFactory icar=new ICarFactoryImpl();
icar.getCar("bus").getWord();
icar.getCar("bike").getWord();

}

打印结果如下：

坐公交车去上班！

骑自行车去上班！

抽象工厂模式：

package abstractFactory;
/**
*
* @author CIACs
*
*/
public interface Gift {
//声明产品赠品的接口，当然也可以是抽象类，同样为了简单就不声明方法了

}

package abstractFactory;
/**
*
* @author CIACs
*
*/
public class GiftA implements Gift {
public GiftA()
{
System.out.println("GiftA");
}

}

package abstractFactory;
/**
*
* @author CIACs
*
*/
public class GiftB implements Gift {
public GiftB()
{
System.out.println("GiftB");
}

}

package abstractFactory;
/**
*
* @author CIACs
*声明Product类工厂和Gift类工厂的工同工厂接口
*/
public interface Factory {
public Product createProduct();
public Gift createGift();

}

package abstractFactory;
/**
*
* @author CIACs
*FactoryA可以生成ProductA和GiftA
*/
public class FactoryA implements Factory {
@Override
public Product createProduct()
{
return new ProductA();
}
@Override
public Gift createGift()
{
return new GiftA();
}

}

package abstractFactory;
/**
*
* @author CIACs
*FactoryB可以生成ProductB和GiftB
*/
public class FactoryB implements Factory {
@Override
public Product createProduct() {
return new ProductB();
}
@Override
public Gift createGift() {
return new GiftB();
}

}

package abstractFactory;
/**
*
* @author CIACs
*
*/
public class Client {
public static void main(String[] args) {
Factory factory;
factory = new FactoryA();
factory.createProduct();
factory.createGift();
factory = new FactoryB();
factory.createProduct();
factory.createGift();
}

}

工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类可以创建多个具体产品类的实例。   ：
一个抽象产品类，可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类可以创建多个具体产品类的实例。

区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。   
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。   
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

http://www.runoob.com/design-pattern/factory-pattern.html这个是设计模式地址

https://blog.csdn.net/heirenheiren/article/details/7354108这个是解析xml工具类的用法（saxbuilder）

https://blog.csdn.net/jcy472578/article/details/18401357这个是spring通过工厂模式的思想用saxbuilder这个工具类来将bean实例化

spring中BeanFactory和FactoryBean的区别：

BeanFactory：以Factory结尾，表示它是一个工厂类，是用于管理Bean的一个工厂

区别：BeanFactory是个Factory，也就是IOC容器或对象工厂，FactoryBean是个Bean。在Spring中，所有的Bean都是由BeanFactory(也就是IOC容器)来进行管理的。但对FactoryBean而言，这个Bean不是简单的Bean，而是一个能生产或者修饰对象生成的工厂Bean,它的实现与设计模式中的工厂模式和修饰器模式类似。

1、 BeanFactory

BeanFactory定义了IOC容器的最基本形式，并提供了IOC容器应遵守的的最基本的接口，也就是Spring IOC所遵守的最底层和最基本的编程规范。在Spring代码中，BeanFactory只是个接口，并不是IOC容器的具体实现，但是Spring容器给出了很多种实现，如 DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext等，都是附加了某种功能的实现。

2、FactoryBean
一般情况下，Spring通过反射机制利用<bean>的class属性指定实现类实例化Bean，在某些情况下，实例化Bean过程比较复杂，如果按照传统的方式，则需要在<bean>中提供大量的配置信息。配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个org.springframework.bean.factory.FactoryBean的工厂类接口，用户可以通过实现该接口定制实例化Bean的逻辑。
FactoryBean接口对于Spring框架来说占用重要的地位，Spring自身就提供了70多个FactoryBean的实现。它们隐藏了实例化一些复杂Bean的细节，给上层应用带来了便利。从Spring3.0开始，FactoryBean开始支持泛型，即接口声明改为FactoryBean<T>的形式。

3、区别
BeanFactory是个Factory，也就是IOC容器或对象工厂，FactoryBean是个Bean。在Spring中，所有的Bean都是由BeanFactory(也就是IOC容器)来进行管理的。但对FactoryBean而言，这个Bean不是简单的Bean，而是一个能生产或者修饰对象生成的工厂Bean,它的实现与设计模式中的工厂模式和修饰器模式类似。

学习地址https://blog.csdn.net/u014604403/article/details/50515588