结合实例的单例模式,装饰者模式,观察者模式学习

Design Pattern

单例模式

控制一个类只能创建一个实例:把构造函数定义成private类

public class Person {
	private String name;
	private static Person instance =null;
	private Person() {
		name="";//把构造函数写成private
	}
	public static Person getInstance() {
		if(instance==null) {
			instance= new Person();
		}
		return instance;
	}
}
public class Test {
	public static void main(String[] agrs) {
		Person p=Person.getInstance();
		System.out.println(p);
	}
}
//当不多不少刚好需要5个的时候 就像一下这样写
import java.util.Vector;
public class Person {
	private String name;
	private static final int Max_Num=5;
	private static Vector<Person> instances=new Vector<Person>();
	private Person() {
		name="";
	}
	public static Person getInstance() {
		Person px=null;
		if(instances.size()<Max_Num) {
			px= new Person();
			instances.add(px);
		}
		return px;
	}
}

结合实例的单例模式,装饰者模式,观察者模式学习_第1张图片

策略模式

灰字的来源:菜鸟教程

意图:定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。

主要解决:在有多种算法相似的情况下,使用 if…else 所带来的复杂和难以维护。

何时使用:一个系统有许多许多类,而区分它们的只是他们直接的行为。

如何解决:将这些算法封装成一个一个的类,任意地替换。

关键代码:实现同一个接口。

结合实例的单例模式,装饰者模式,观察者模式学习_第2张图片
结合实例的单例模式,装饰者模式,观察者模式学习_第3张图片

  • 将父类的必要方法写出来 flyBehavior,quackBehavior 两个属性用接口

    • public abstract class Duck {
         QuackBehavior quackBehavior;//quackBehavior不是对象,可以当做一个能使用方法的属性
         FlyBehavior flyBehavior;
         public Duck() { }
         public void performQuack() {
            quackBehavior.quack();    }
         public void performFly() {
            flyBehavior.fly();    }
         public void swim() {
            System.out.println("All ducks float."); }
      }
      //以下是一个接口 及其子类(关于鸭子的“飞”)
      public interface FlyBehavior {	void fly();}
      public class FlyNoWay implements FlyBehavior {
      	public void fly() {   System.out.println("I can not fly."); }
      }
      public class FlyWithWings implements FlyBehavior {
      	public void fly() {   System.out.println("I am flying!");   }
      }
      //以野鸭为例子 来理解
      public class MallardDuck extends Duck {
      	public MallardDuck() {
      	      quackBehavior = new Quack();//可以叫
      	      flyBehavior = new FlyWithWings();//可以飞
      	   }
      }
      
  • 这两个接口都有2~3个子类,在实例化Duck子类的时候,可以从接口的子类中自由选择所需要的,以实现所需要的方法 (第23、24行) 接口的使用用association

工厂类

把所有创建对象的工作放到一个里面

public class SimplePizzaFactory {
    public Pizza createPizza(String type) {
        Pizza pizza = null;
        if (type.equals(“cheese”)) {
            pizza = new CheesePizza();
        } else if (type.equals(“pepperoni”)) {
            pizza = new PepperoniPizza();
        } else if (type.equals(“clam”)) {
            pizza = new ClamPizza();
        } else if (type.equals(“veggie”)) {
            pizza = new VeggiePizza();
        }
        return pizza;
    }
}
//一般还会存在一个借口 比如OnePizza()  然后子类CheesePizza等来重写创造方法
**
**
//可以迅速切换到其他地点  比如NewYorkPizzaFacttory 里面可以创建不同类型的pizza对象

Decorators(同时具备继承和关联)

使一个对象逐步扩大,不断增添东西。而增添的一部分和最大的类基友继承又有关联,使其构成一个圈,把之前的对象圈起来。

灰字的来源:菜鸟教程

意图:动态地给一个对象添加一些额外的职责。就增加功能来说,装饰器模式相比生成子类更为灵活。

主要解决:一般的,我们为了扩展一个类经常使用继承方式实现,由于继承为类引入静态特征,并且随着扩展功能的增多,子类会很膨胀。

何时使用:在不想增加很多子类的情况下扩展类。

如何解决:将具体功能职责划分,同时继承装饰者模式。

关键代码: 1、Component 类充当抽象角色,不应该具体实现。 2、修饰类引用和继承 Component 类,具体扩展类重写父类方法。

  • Beverage
    • DarkRoast
    • Condiment
      • Whip
      • Mocha
      • Milk
      • ……

结合实例的单例模式,装饰者模式,观察者模式学习_第4张图片

//不断把b赋予新的对象,使b包含的视野不断的变大
//不断给对象b 装饰新的特性
Beverage/*为了之后能够顺利扩大,这里要用继承的大类*/ b = new DarkRoast();
b = new Mocha(b);
b = new Whip(b);
//最后相当于b->whip->mocha->darkroast
***
//其中cost 方法的写法
public double cost(){
	return 0.99;					//<----
}// DarkRoast						//	  |
public double cost(){				//	  |
	return 0.2 + beverage.cost();	//<----	这时的传入Mocha中的beverage是darkroast
}									 //	  |
public double cost(){				//    |
	return 0.1 + beverage.cost();  //------   不断找到最初的方法  这时传入的beverage是mocha

}

观察者模式

灰字的来源:菜鸟教程

意图:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。

主要解决:一个对象状态改变给其他对象通知的问题,而且要考虑到易用和低耦合,保证高度的协作。建立一种触发机制。

何时使用:一个对象(目标对象)的状态发生改变,所有的依赖对象(观察者对象)都将得到通知,进行广播通知。

如何解决:使用面向对象技术,可以将这种依赖关系弱化。

关键代码:在抽象类里有一个 ArrayList 存放观察者们。

形象举例 广场舞大妈总是跟着领舞跳

  • 创建subject 类
import java.util.ArrayList;
import java.util.List;
public class Subject {
   private List<Observer> observers 
      = new ArrayList<Observer>();//创建观察者列表
   private int state; 
   public int getState() {
      return state;
   } 
   public void setState(int state) {
      this.state = state;
      notifyAllObservers();
   }
   public void attach(Observer observer){
      observers.add(observer);      
   } 
   public void notifyAllObservers(){//通知观察者
      for (Observer observer : observers) {
         observer.update();//触发更新
      }
   }  
}
//观察者抽象类
public abstract class Observer {
   protected Subject subject;
   public abstract void update();
}
//二进制观察者
public class BinaryObserver extends Observer{ 
   public BinaryObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);//添加观察者
   }
   public void update() {//更新操作
      System.out.println( "Binary String: " 
      + Integer.toBinaryString( subject.getState() ) ); 
   }
}
//八进制观察者
public class OctalObserver extends Observer{
   public OctalObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }
   public void update() {
     System.out.println( "Octal String: " 
     + Integer.toOctalString( subject.getState() ) ); 
   }
}
//在以上代码中 只要subject的status一改变  二进制观察者和八进制观察者的值就一起改变

你可能感兴趣的:(学习笔记)