设计模式的分类：分类标准是根据目的准则
1 创建型：与对象的创建有关
2 结构型：处理类与对象之间的组合
3 行为型：描述类与对象如何交互及如何分配职责
一共有23中设计模式
创建型：
1.抽象工厂模式AbstractFactory
2.建造者模式Builder
3.工厂方法模式FactoryMethod
4.原型模式Prototype
5.单例模式Singleton
结构型：
1.适配器模式Adapter
2.桥接模式Bridge
3.组合模式Composite
4.装饰模式Decorator
5.外观模式Facade
6.享元模式Flyweight
7.代理模式Proxy
行为型：
1.职责链模式Chainof
Responsibility
2.命令模式Command
3.解释器模式Interpreter
4.迭代器模式Iterator
5.中介者模式Mediator
6.备忘录模式Memento
7.观察者模式Observer
8.状态模式State
9.策略模式Strategy
10.模板方法模式TemplateMethod
11.访问者模式Visitor
重点学习以下四种模式：工厂模式、单例模式、观察者模式、代理模式
1 工厂模式
特点：
1.1 简单工厂模式
1.2 工厂方法模式
1.3 抽象工厂模式
开闭原则：对程序扩展开放，对程序修改关闭
使用各种程序设计模式的最主要目的：提高程序的扩展性、可维护性
使用工厂模式的两种情况：
1. 不能预见将要创建的那种类的实例
2. 系统不关心对象被创建的具体细节
代码示例：
<<简单工厂>>
/**
* 简单工厂
* 1 工厂类角色
* 2 抽象产品类角色
* 3 具体产品类角色
* */
// 抽象产品类角色
interface Car{
public void drive();
}
//具体产品类角色
class RedCar implements Car{
public void drive(){
System.out.println("I'm driving a red Car.");
}
}
//具体产品类角色
class BlackCar implements Car{
public void drive(){
System.out.println("I'm driving a Black Car.");
}
}
//这里可以扩展其他的颜色的产品...
//工厂类角色
class SimpleFactory{
Car car;
String color;
public SimpleFactory(String color){
this.color=color;
}
public Car getObject(){
if(color.equals("red")){
car=new RedCar();
return car;
}else if(color.equals("black")){
car=new BlackCar();
return car;
}
else{
System.out.println("no related Chioce!");
return null;
}
}
}
public class FactoryDemo {
public static void main(String agrs[]){
SimpleFactory f1=new SimpleFactory("red");
SimpleFactory f2=new SimpleFactory("black");
RedCar redCar=(RedCar)f1.getObject();
redCar.drive();
f1.getObject().drive();
f2.getObject().drive();
}
}
<<抽象工厂>>
/**
* 工厂方法模式
* 1 抽象工厂角色
* 2 具体工厂角色
* 3 抽象产品角色
* 4 具体产品角色
*
* 说明：由于业务的复杂，利用简单工厂模型不再适用，因为当增加产品时，对于产品符合开闭原则，
* 但是对于工厂角色则明显不符合开闭原则，所有现在需要将工厂角色也抽象出来，可以是抽象
* 类或者借口实现
* */
//抽象工厂角色
interface AbstractFactory{
public Car getObject(String color);
}
//具体工厂角色
class Factory1 implements AbstractFactory{
Car car;
public Car getObject(String color){
if(color.equals("red")){
car=new RedCar();
return car;
}
else if(color.equals("black")){
car=new BlackCar();
return car;
}
else {
System.out.println("there is no related Option!");
return null;
}
}
}
//具体工厂角色
class Factory2 implements AbstractFactory{
Car car;
public Car getObject(String color){
if(color.equals("yellow")){
car=new YellowCar();
return car;
}
else if(color.equals("blue")){
car=new BlueCar();
return car;
}
else {
System.out.println("there is no related Option!");
return null;
}
}
}
//这里可以添加很多具体工厂。。。
// 抽象产品角色同上
// 具体产品角色可以在扩展，比如说下面再扩展两个具体的产品角色YellowCar,BlueCar
// 抽象产品类角色
interface Car{
public void drive();
}
//具体产品类角色
class RedCar implements Car{
public void drive(){
System.out.println("I'm driving a red Car.");
}
}
//具体产品类角色
class BlackCar implements Car{
public void drive(){
System.out.println("I'm driving a Black Car.");
}
}
//具体产品角色
class YellowCar implements Car{
public void drive(){
System.out.println("I'm driving a yellow Car.");
}
}
//具体产品角色
class BlueCar implements Car{
public void drive(){
System.out.println("I'm driving a blue Car.");
}
}
public class FactoryDemo {
public static void main(String agrs[]){
Factory1 ff1=new Factory1();
ff1.getObject("red").drive();
ff1.getObject("black").drive();
Factory2 ff2=new Factory2();
ff2.getObject("yellow").drive();
ff2.getObject("blue").drive();
}
}
2 单例模式
特点：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供该实例
代码示例：
//懒汉式
class Singleton2{
private Singleton2(){} // 避免类被外部实例化
private static Singleton2 singleton;
public static Singleton2 getInstance(){
if(singleton==null)
singleton=new Singleton2();
return singleton;
}
}
// 饿汉式
class Singleton1{
private Singleton1(){}
private static Singleton1 singleton1=new Singleton1();
static Singleton1 getInstance(){
return singleton1;
}
}
3 观察者模式
特点：简单地说就是有一个或多个观察者对一个被观察者进行监视，当被观察者发生变化时则通知所有的观察者更新，达到这样一个效果。
(更详细的参考：点击打开链接)
代码示例
package org.wb.pattern;
import java.util.Vector;
/**
* 1 观察者
* 1.1 抽象观察者：可以由抽象类或接口实现，实现一个update()方法，更新操作
* 1.2 具体观察者：继承或实现抽象观察者
*
* 2 被观察者
* 2.1 抽象被观察者：可以由抽象类或接口实现，包括观察者列表、添加、删除观察者、通知观察者更新
* 2.2 具体被观察者：继承或实现抽象被观察者
* */
public class ObserverDemo {
public static void main(String agrs[]){
Observer1 observer1=new Observer1();
Observer2 observer2=new Observer2();
Observered observered=new Observered();
observered.addObserver(observer1);
observered.addObserver(observer2);
observered.notifyObserver();
}
}
//抽象观察者
interface AbstractObserver{
public void update();
}
//具体观察者
class Observer1 implements AbstractObserver{
public void update(){
System.out.println("Observer1 get it!!");
}
}
//具体观察者
class Observer2 implements AbstractObserver{
public void update(){
System.out.println("Observer2 get it!!");
}
}
//抽象被观察者
interface AbstractObservered{
//在具体实现中需要加上观察者列表
public void addObserver(AbstractObserver observer);
public void deleteObserver(AbstractObserver observer);
public void notifyObserver();
}
//具体被观察者
class Observered implements AbstractObservered{
Vector <AbstractObserver> vactorList=new Vector<AbstractObserver>();
public void addObserver(AbstractObserver observer){
if(!vactorList.contains(observer)){
vactorList.add(observer);
}
}
public void deleteObserver(AbstractObserver observer){
if(vactorList.contains(observer)){
vactorList.remove(observer);
}
}
//通知观察者列表中所有的观察者更新
public void notifyObserver(){
if(vactorList.size()!=0){
for(AbstractObserver observer:vactorList){
observer.update();
}
}
}
}
4 代理模式
特点：在有些情况下，一些客户对象不能直接或者不需要直接访问另一个对象，而是用代理对象来完成对真实对象的访问的情况
代码示例
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 1 抽象类角色：真实类或代理类需要继承或实现的角色
* 2 真实类角色：最终要被引用的对象，代理类角色所代表的对象
* 3 代理类角色：代理类对象中包含有对真实类对象的引用，对真实类进行操作，同时也可以添加一些额外的操作
* 简单的说就是对真实类进行封装
* 4 客户端角色：客户端对象通过对代理类的访问来达到操作真实类的母的，比如说有些情况我们不能直接访问到
* 真实类，那么我们只能利用代理的方式
*
* 5 动态代理：简单地说就是在程序运行时才产生代理类对象
*
* 6 下面将实现一般代理和动态代理
*
* */
public class ProxyDemo {
// public static void main(String agrs[]){
// RealSubject rs=new RealSubject();
// ProxySubject ps=new ProxySubject(rs);
// ps.option();
// }
public static void main(String args[]){
RealSubject rs=new RealSubject();
DynamicProxy dp=new DynamicProxy(rs);
Class<? extends RealSubject> cls=rs.getClass();
AbstractSubject abstractSubject=(AbstractSubject)Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),dp);
abstractSubject.option();
}
}
//抽象类角色
interface AbstractSubject{
public void option();
}
//真实类角色
class RealSubject implements AbstractSubject{
public void option(){
System.out.println("来自真实类角色对象的操作！");
}
}
//代理类角色
class ProxySubject implements AbstractSubject{
RealSubject realSubject;//在代理类中必须要包含被真实代理的对象
public ProxySubject(RealSubject realSubject){
this.realSubject=realSubject;
}
public void option(){
before();
if(realSubject!=null){
realSubject.option();
}
after();
}
public void before(){
System.out.println("在代理操作前的准备！");
}
public void after(){
System.out.println("在代理操作后的处理！");
}
}
/**
* 动态代理示例：动态代理和一般代理的区别是，动态代理可以在程序运行时生成代理类实例对象
*
* */
//代理类角色
class DynamicProxy implements InvocationHandler{
RealSubject realSubject;
public DynamicProxy(RealSubject realSubject){
this.realSubject=realSubject;
}
public Object invoke(Object obj,Method method,Object[] args){
before();
try {
method.invoke(realSubject, args);
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
after();
return null;
}
public void before(){
System.out.println("在代理操作前的准备！");
}
public void after(){
System.out.println("在代理操作后的处理！");
}
}
总结：对于设计模式在平时写代码的过程中没有怎么用，这次特意整理一下，方便以后再学习或者遇到的时候能有点印象