设计模式（bridge模式，Adapter模式，Observe模式，Template模式）

android中读取位图bitmap时，分给虚拟机图片的堆栈8M的大小，很容易发生OutOfMemory异常

1， bridge模式：将抽象和实现分离出来。

它可以解决继承的缺点：如果继承层次很多，并且某一个方法在多层的类中可能出现变化，或者说这个方法不确定，如果某一个继承层次中的类想修改这个方法，就做不到。

因为这样可能对它的子类有影响。

这个时候就可以使用bridge模式，将这个不确定的方法抽象出来，如果要使用的时候搭一个桥过去，使用它。

例子：三种对话框Dialog，这三种对话框都可以实现隐藏hide，闪烁Shrink，跳跃Jump。如果不使用bridge模式需要定义九个类，

使用了bridge模式只需定义六个类。

interface IEffect {

public void doEffect();

}

class HideEffect implements IEffect{

public void doEffect(){

System.out.println("hide");

}

}

class ShrinkEffect implements IEffect{

public void doEffect(){

System.out.println("shrink");

}

}

class JumpEffect implements IEffect{

public void doEffect(){

System.out.println("Jump");

}

}

abstract class Dialog {

IEffect effectImpl;

Dialog(IEffect effectImpl){

this.effectImpl = effectImpl;

}

public IEffect getEffect() {

return this.effectImpl;

}

public abstract void doSomething();

}

class BigDialog extends Dialog {

BigDialog(IEffect effectImpl) {

super(effectImpl);

}

public void doSomething() {

System.out.println("big dialog: ");

this.effectImpl.doEffect();

}

}

class MiddleDialog extends Dialog {

MiddleDialog(IEffect effectImpl) {

super(effectImpl);

}

public void doSomething() {

System.out.println("middle dialog: ");

this.effectImpl.doEffect();

}

}

class SmallDialog extends Dialog {

SmallDialog(IEffect effectImpl) {

super(effectImpl);

}

public void doSomething() {

System.out.println("small dialog: ");

this.effectImpl.doEffect();

}

}

public class Client {

public static void main(String[] args) {

IEffect jump = new JumpEffect();

Dialog smallJump = new SmallDialog(jump);

smallJump.doSomething();

}

}

2， Adapter模式：

将多个不兼容的类组合在一起，利用了java中的多实现的技术。

例子：提供一个类既可以画圆型也可以画方形；

interface ICircle{

public void drawCircle();

}

interface ISquare{

public void drawSquare();

}

class Circle implements ICircle{

public void drawCircle() {

System.out.println("draw circle");

}

}

class Square implements ISquare{

public void drawSquare(){

System.out.println("draw square");

}

}

class HydridShape implements ICircle, ISquare{

private ICircle mCircle;

private ISquare mSquare;

public HydridShape(ICircle circle){

mCircle = circle;

}

public HydridShape(ISquare squre){

mSquare = squre;

}

public void drawCircle() {

mCircle.drawCircle();

}

public void drawSquare(){

mSquare.drawSquare();

}

}

public class Client {

public static void main(String[] args){

HydridShape hs = new HydridShape(new Circle());

HydridShape hs2 = new HydridShape(new Square());

hs.drawCircle();

hs2.drawSquare();

}

}

3，Observe模式：在被观察的对象中关联（保存）了所有观察它的对象，一旦被观察者的状态发生了变化，就通知它上面的所有观察者update

例子：一个购物网站的首页上是由许多的页面构成，但这些页面都会按照不同的方式显示某一个商品的信息。

商品就是被观察的对象，这些UI页面看着是观察者对象，一旦商品信息发生了变化，就需要立即更新这些UI

abstract class UI{

Product product;

UI(Product product){

this.product = product;

}

public abstract void update();

}

class UI1 extends UI{

UI1(Product product){

super(product);

}

public void update(){

System.out.println("update UI1 info - " + "name: " + product.getName() + ", price: " + product.getPrice());

}

}

class UI2 extends UI{

UI2(Product product){

super(product);

}

public void update(){

System.out.println("update UI2 info - " + "name: " + product.getName() + ", price: " + product.getPrice());

}

}

class UI3 extends UI{

UI3(Product product){

super(product);

}

public void update(){

System.out.println("update UI3 info - " + "name: " + product.getName() + ", price: " + product.getPrice());

}

}

abstract class Product{

private String name;

private String price;

List<UI> arrayList = null;

Product(String name, String price){

this.name = name;

this.price = price;

arrayList = new ArrayList<UI>();

}

public void addUI(UI ui){

arrayList.add(ui);

}

public void deleteUI(UI ui){

arrayList.remove(ui);

}

public String getName(){

return this.name;

}

public String getPrice(){

return this.price;

}

public void setName(String name){

this.name = name;

}

public void setPrice(String price){

this.price = price;

}

public void notifyUI(){

for(UI ui : arrayList){

ui.update();

}

}

public abstract void updateProduct(String name, String price);

}

class Laptop extends Product{

Laptop(String name, String price){

super(name, price);

}

public void updateProduct(String name, String price){

setName(name);

setPrice(price);

notifyUI();

}

}

public class Client{

public static void main(String[] args){

Product laptop = new Laptop("kindle", "900");

UI ui1 = new UI1(laptop);

UI ui2 = new UI2(laptop);

UI ui3 = new UI3(laptop);

laptop.addUI(ui1);

laptop.addUI(ui2);

laptop.addUI(ui3);

laptop.updateProduct("kindle", "1000");

}

}

4， Template模式：某一项任务可以分割成多个子任务，将某些任务抽象出来，让它的子类去完成。

比如：排序并打印结果这项任务，就将排序和打印结果分割出来，打印很简单就在父类中完成，排序比较复杂，而且有很多方法来实现，

就抽象出来，让子类根据不同的情况具体实现