一、设计模式分类:
创建型模式:单例模式、工厂模式(简单工厂模式、工厂方法模式、抽象工厂模式)、建造者模式、原型模式。
结构型模式:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
其它:并发型模式、线程池模式。
二、单例模式
1、懒汉式
a)基本案例
class Singleton {
private Singleton() {
}
private static Singleton singleton = null;
public static Singleton newInstance() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}
b)线程安全模式
同步方法
class Singleton {
private Singleton() {
}
private static Singleton singleton = null;
public synchronized static Singleton newInstance() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}
双重检查锁定
class Singleton {
private Singleton() {
}
private static Singleton singleton = null;
public static Singleton getInstance() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
静态内部类(推荐)
class Singleton {
private Singleton() {
}
private static class SingletonBuilder {
private static final Singleton singleton = new Singleton();
}
public static final Singleton newInstance() {
return SingletonBuilder.singleton;
}
}
2、饿汉式
class Singleton {
private Singleton() {
}
private static final Singleton singleton = new Singleton();
public static final Singleton newInstance() {
return singleton;
}
}
三、工厂模式
1、简单工厂模式
public class Client {
public static void main(String[] args) {
CarFactory factory = new CarFactory();
Car bus = factory.getCar("bus");
bus.run();
Car taxi = factory.getCar("taxi");
taxi.run();
}
}
interface Car {
void run();
}
class Bus implements Car {
@Override
public void run() {
System.out.println("Bus Run !");
}
}
class Taxi implements Car {
@Override
public void run() {
System.out.println("Taxi Run !");
}
}
class CarFactory {
public Car getCar(String carType) {
Car car = null;
switch (carType) {
case "bus":
car = new Bus();
break;
case "taxi":
car = new Taxi();
break;
default:
break;
}
return car;
}
}
2、工厂方法模式
public class Client {
public static void main(String[] args) {
CarFactory busFactory = new BusFactory();
Car bus = busFactory.buildCar();
bus.run();
CarFactory carFactory = new TaxiFactory();
Car taxi = carFactory.buildCar();
taxi.run();
}
}
interface Car {
void run();
}
class Bus implements Car {
@Override
public void run() {
System.out.println("Bus Run !");
}
}
class Taxi implements Car {
@Override
public void run() {
System.out.println("Taxi Run !");
}
}
interface CarFactory {
Car buildCar();
}
class BusFactory implements CarFactory{
@Override
public Car buildCar() {
return new Bus();
}
}
class TaxiFactory implements CarFactory{
@Override
public Car buildCar() {
return new Taxi();
}
}
3、抽象工厂模式
public class Client {
public static void main(String[] args) throws Exception {
AbstractFactory abstractFactory = FactoryProducer.getFactory("BMWFactory");
Car bmwCar = abstractFactory.getCar("BMW320");
bmwCar.run();
Car bmwCar1 = abstractFactory.getCar("BMW530");
bmwCar1.run();
AbstractFactory abstractFactory1 = FactoryProducer.getFactory("BenzFactory");
Car benzCar = abstractFactory1.getCar("BenzC200");
benzCar.run();
Car benzCar1 = abstractFactory1.getCar("BenzE300");
benzCar1.run();
}
}
interface BeanMapping {
Map<String, Class<?>> beanCache = new HashMap<>();
}
abstract class Car {
abstract void run();
}
abstract class BMWCar extends Car {
}
class BMW320 extends BMWCar {
public void run() {
System.out.println("BMW320 Run...");
}
}
class BMW530 extends BMWCar {
public void run() {
System.out.println("BMW530 Run...");
}
}
abstract class BenzCar extends Car {
}
class BenzC200 extends BenzCar {
public void run() {
System.out.println("BenzC200 Run...");
}
}
class BenzE300 extends BenzCar {
public void run() {
System.out.println("BenzE300 Run...");
}
}
abstract class AbstractFactory implements BeanMapping {
public abstract Car getCar(String type) throws Exception;
}
class BenzFactory extends AbstractFactory {
public Car getCar(String type) throws Exception {
Class<?> cl = beanCache.get(type);
return (BenzCar) cl.newInstance();
}
public BenzFactory() {
beanCache.put(BenzCar.class.getSimpleName(), BenzCar.class);
beanCache.put(BenzC200.class.getSimpleName(), BenzC200.class);
beanCache.put(BenzE300.class.getSimpleName(), BenzE300.class);
}
}
class BMWFactory extends AbstractFactory {
public Car getCar(String type) throws Exception {
Class<?> cl = beanCache.get(type);
return (BMWCar) cl.newInstance();
}
public BMWFactory() {
beanCache.put(BMWCar.class.getSimpleName(), BMWCar.class);
beanCache.put(BMW320.class.getSimpleName(), BMW320.class);
beanCache.put(BMW530.class.getSimpleName(), BMW530.class);
}
}
class FactoryProducer implements BeanMapping {
static {
beanCache.put(BenzFactory.class.getSimpleName(), BenzFactory.class);
beanCache.put(BMWFactory.class.getSimpleName(), BMWFactory.class);
}
public static AbstractFactory getFactory(String type) throws Exception {
System.out.println("创建工厂" + type);
Class<?> cl = beanCache.get(type);
return (AbstractFactory) cl.newInstance();
}
}
四、原型模式
a)原型模式主要包含如下三个角色:
Prototype:抽象原型类。声明克隆自身的接口。
ConcretePrototype:具体原型类。实现克隆的具体操作。
Client:客户类。让一个原型克隆自身,从而获得一个新的对象。
b)实现 Cloneable 接口,通过调用 clone() 方法进行复制;clone() 方法一般满足如下条件:
对任何的对象x,都有x.clone() !=x,即克隆对象与原对象不是同一个对象。
对任何的对象x,都有x.clone().getClass()==x.getClass(),即克隆对象与原对象的类型一样。
如果对象x的equals()方法定义恰当,那么x.clone().equals(x)应该成立。
c)代码实现:
浅复制(内置对象引用未复制)
public class Client {
public static void main(String[] args) throws Exception {
Company company = new Company("公司一", "地址一");
User user1 = new User("张三", 0, 16, company);
System.out.println(user1);
User user2 = user1.clone();
System.out.println(user2);
System.out.println(user1.equals(user2));
}
}
class Company {
private String name;
private String address;
public Company(String name, String address) {
this.name = name;
this.address = address;
}
@Override
public String toString() {
return "{hashCode:" + this.hashCode() + ",name:" + name + ",address:" + address + "}";
}
}
class User implements Cloneable {
private String name;
private int sex;
private int age;
private Company company;
public User(String name, int sex, int age, Company company) {
this.name = name;
this.sex = sex;
this.age = age;
this.company = company;
}
@Override
public User clone() {
User user = null;
try {
user = (User) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return user;
}
@Override
public String toString() {
return "{hashCode:" + this.hashCode() + ",name:" + name + ",sex:" + sex + ",age" + age + ",company:" + company
+ "}";
}
}
深复制(内置对象引用同时复制,需要内置对象同时实现 Cloneable接口)
public class Client {
public static void main(String[] args) throws Exception {
Company company = new Company("公司一", "地址一");
User user1 = new User("张三", 0, 16, company);
System.out.println(user1);
User user2 = user1.clone();
System.out.println(user2);
System.out.println(user1.equals(user2));
}
}
class Company implements Cloneable{
private String name;
private String address;
public Company(String name, String address) {
this.name = name;
this.address = address;
}
@Override
public Company clone() throws CloneNotSupportedException {
return (Company) super.clone();
}
@Override
public String toString() {
return "{hashCode:" + this.hashCode() + ",name:" + name + ",address:" + address + "}";
}
}
class User implements Cloneable {
private String name;
private int sex;
private int age;
private Company company;
public User(String name, int sex, int age, Company company) {
this.name = name;
this.sex = sex;
this.age = age;
this.company = company;
}
@Override
public User clone() {
User user = null;
try {
user = (User) super.clone();
user.company = company.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return user;
}
@Override
public String toString() {
return "{hashCode:" + this.hashCode() + ",name:" + name + ",sex:" + sex + ",age" + age + ",company:" + company
+ "}";
}
}
五、建造者模式
a)角色分配:
1、Builder:给出一个抽象接口,以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建,并不涉及具体的对象部件的创建。
2、ConcreteBuilder:实现Builder接口,针对不同的商业逻辑,具体化复杂对象的各部分的创建。 在建造过程完成后,提供产品的实例。
3、Director:调用具体建造者来创建复杂对象的各个部分,在指导者中不涉及具体产品的信息,只负责保证对象各部分完整创建或按某种顺序创建。
4、Product:要创建的复杂对象。
b)与工厂模式区别:
工厂类模式提供的是创建单个类的模式,而建造者模式则是将各种产品集中起来进行管理,用来创建复合对象
c)代码实现:
public class Client {
public static void main(String[] args) throws Exception {
PersonBuilder pb = new ManBuilder();
PersonDirector pd = new PersonDirector();
Person man = pd.constructPerson(pb);
System.out.println(man);
}
}
class Person {
private String head;
private String body;
private String foot;
public String getHead() {
return head;
}
public void setHead(String head) {
this.head = head;
}
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public String getFoot() {
return foot;
}
public void setFoot(String foot) {
this.foot = foot;
}
@Override
public String toString() {
return "{head:" + head + ",body:" + body + ",foot:" + foot + "}";
}
}
interface PersonBuilder {
void buildHead();
void buildBody();
void buildFoot();
Person buildPerson();// 组装
}
class ManBuilder implements PersonBuilder {
Person person;
public ManBuilder() {
person = new Person();
}
@Override
public void buildHead() {
person.setHead("画个头");
}
@Override
public void buildBody() {
person.setBody("画个身子");
}
@Override
public void buildFoot() {
person.setFoot("画个脚");
}
@Override
public Person buildPerson() {
return person;
}
}
class PersonDirector {
public Person constructPerson(PersonBuilder pb) {
pb.buildHead();
pb.buildBody();
pb.buildFoot();
return pb.buildPerson();
}
}
六、适配器模式
1、类适配模式
public class Client {
public static void main(String[] args) {
Target adapter = new Adapter();
adapter.request();
}
}
class Adaptee {
public void specificRequest() {
System.out.println("适配执行...");
}
}
interface Target {
public void request();
}
class Adapter extends Adaptee implements Target {
public void request() {
super.specificRequest();
}
}
2、对象适配器模式
public class Client {
public static void main(String[] args) {
Target adapter = new Adapter(new Adaptee());
adapter.request();
}
}
class Adaptee {
public void specificRequest() {
System.out.println("适配执行...");
}
}
interface Target {
public void request();
}
class Adapter implements Target {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
public void request() {
if(adaptee != null) {
adaptee.specificRequest();
}
}
}
七、装饰器模式
与适配器区别(适配器使用不同方法[request/specificRequest],装饰器使用相同的方法[eat])
public class Test {
public static void main(String[] args) {
Person person = new NewPerson(new OldPerson());
person.eat();
}
}
interface Person {
void eat();
}
class OldPerson implements Person {
@Override
public void eat() {
System.out.println("吃饭");
}
}
class NewPerson implements Person {
private OldPerson op;
public NewPerson(OldPerson op) {
this.op = op;
}
@Override
public void eat() {
System.out.println("生火");
System.out.println("做饭");
op.eat();
System.out.println("刷碗");
}
}
八、代理模式
静态代理(怎么跟适配器模式一样)
public class Test {
public static void main(String[] args) {
UserInfo userInfo = new UserProxy(new UserImpl());
userInfo.queryUser();
userInfo.updateUser();
}
}
interface UserInfo {
public void queryUser();
public void updateUser();
}
class UserImpl implements UserInfo{
@Override
public void queryUser() {
System.out.println("query user...");
}
@Override
public void updateUser() {
System.out.println("update user...");
}
}
class UserProxy implements UserInfo{
private UserInfo userInfo;
public UserProxy(UserInfo userInfo) {
this.userInfo = userInfo;
}
@Override
public void queryUser() {
System.out.println("after query user...");
userInfo.queryUser();
System.out.println("before query user...");
}
@Override
public void updateUser() {
System.out.println("after update user...");
userInfo.updateUser();
System.out.println("before update user...");
}
}
动态代理
public class Test {
public static void main(String[] args) {
UserInfo userImpl = new UserImpl();
UserHandler handler = new UserHandler(userImpl);
UserInfo proxy = (UserInfo)Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[] {UserInfo.class}, handler);
proxy.queryUser();
proxy.updateUser();
}
}
interface UserInfo {
public void queryUser();
public void updateUser();
}
class UserImpl implements UserInfo{
@Override
public void queryUser() {
System.out.println("query user...");
}
@Override
public void updateUser() {
System.out.println("update user...");
}
}
class UserHandler implements InvocationHandler{
private UserInfo userInfo;
public UserHandler(UserInfo userInfo) {
this.userInfo = userInfo;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("after...");
Object obj = method.invoke(userInfo, args);
System.out.println("before...");
return obj;
}
}
九、外观模式
public class Test {
public static void main(String[] args) {
Computer computer = new Computer();
computer.start();
computer.shutdown();
}
}
class Cpu {
public void start() {
System.out.println("Cpu start...");
}
public void shutdown() {
System.out.println("Cpu shutdown...");
}
}
class Disk {
public void start() {
System.out.println("Disk start...");
}
public void shutdown() {
System.out.println("Disk shutdown...");
}
}
class Memory {
public void start() {
System.out.println("Memory start...");
}
public void shutdown() {
System.out.println("Memory shutdown...");
}
}
class Computer{
private Cpu cpu;
private Disk disk;
private Memory memory;
public Computer() {
cpu = new Cpu();
disk = new Disk();
memory = new Memory();
}
public void start() {
cpu.start();
disk.start();
memory.start();
}
public void shutdown() {
cpu.shutdown();
disk.shutdown();
memory.shutdown();
}
}
十、桥接模式
public class Client {
public static void main(String[] args) {
RefinedAbstraction ra = new RefinedAbstraction(new ConcreteImplementorA());
ra.operation();
ra.otherOperation();
RefinedAbstraction rb = new RefinedAbstraction(new ConcreteImplementorB());
rb.operation();
rb.otherOperation();
}
}
interface Implementor {
public void operationImpl();
}
abstract class Abstraction {
private Implementor implementor;
public Abstraction(Implementor implementor) {
this.implementor = implementor;
}
public void operation() {
implementor.operationImpl();
}
}
class ConcreteImplementorA implements Implementor {
@Override
public void operationImpl() {
System.out.println("具体实现A");
}
}
class ConcreteImplementorB implements Implementor {
@Override
public void operationImpl() {
System.out.println("具体实现B");
}
}
class RefinedAbstraction extends Abstraction {
public RefinedAbstraction(Implementor implementor) {
super(implementor);
}
public void otherOperation() {
// 实现一定的功能,可能会使用具体实现部分的实现方法,
// 但是本方法更大的可能是使用 Abstraction 中定义的方法,
// 通过组合使用 Abstraction 中定义的方法来完成更多的功能。
}
}
十一、组合模式
组成部分:
Component: 为参加组合的对象声明一个公共接口,不管是组合还是叶结点。
Leaf: 在组合中表示叶子结点对象,叶子结点没有子结点。
Composite: 表示参加组合的有子对象的对象,并给出树枝购件的行为。
public class Test {
public static void main(String[] args) {
final FolderComponent leaf = new FileLeaf("runnable file");
leaf.display();
final FolderComponent folder = new FolderComposite("new folder");
folder.add(new FileLeaf("content1 in new folder"));
folder.add(new FileLeaf("content2 in new folder"));
folder.display();
}
}
abstract class FolderComponent {
private String name;
public String getName() {
return name;
}
public void setName(final String name) {
this.name = name;
}
public FolderComponent() {
}
public FolderComponent(final String name) {
this.name = name;
}
public abstract void add(FolderComponent component);
public abstract void remove(FolderComponent component);
public abstract void display();
}
class FileLeaf extends FolderComponent {
public FileLeaf(final String name) {
super(name);
}
@Override
public void add(final FolderComponent component) {
// ...
}
@Override
public void remove(final FolderComponent component) {
// ...
}
@Override
public void display() {
System.out.println("FileLeaf:" + this.getName());
}
}
class FolderComposite extends FolderComponent {
private final List<FolderComponent> components;
public FolderComposite(final String name) {
super(name);
this.components = new ArrayList<FolderComponent>();
}
public FolderComposite() {
this.components = new ArrayList<FolderComponent>();
}
@Override
public void add(final FolderComponent component) {
this.components.add(component);
}
@Override
public void remove(final FolderComponent component) {
this.components.remove(component);
}
@Override
public void display() {
System.out.println("FolderComposite---name:" + this.getName());
for (final FolderComponent component : components) {
System.out.println("FolderComposite---component-name:" + component.getName());
}
}
}