Android 设计模式知识点

转载
https://www.runoob.com/design-pattern/memento-pattern.html

转载用于归纳整理知识体系，方便复习用，感谢作者的分享

1、Android 单例模式

• 私有构造方法

• 使用 synchronized 对创建对象代码块进行保护

    // DLC
    public class SingletionDLC {
    	private volatile static SingletionDLC mInstance;
    	private SingletionDLC() {}
    	
    	public static SingletionDLC getmInstance() {
    		if (mInstance == null) {
    			synchronized (SingletionDLC.class) {
    				if (mInstance == null) {
    					mInstance = new SingletionDLC();
    				}
    			}
    		}
    		return mInstance;
    	}
    }
    // 静态内部类
    public class SingletionInternalClass {
    	private SingletionInternalClass() {}
    	
    	public static SingletionInternalClass getInstance() {
    		return SingletionInternalClassHolder.instance;
    	}
  
    	private static class SingletionInternalClassHolder {
    		private static final SingletionInternalClass instance = new SingletionInternalClass();
    	}
    }
  

2、Android Builder模式

• 外部类私有构造方法，带参数Buidler

• Builder静态内部类

    public class Person  {
    	private int ID;
    	
    	private Person(Builder builder) {
    		this.ID = builder.ID;
    	}
    	public static class Builder {
    		private int ID;
    		public Builder setID(int ID) {
    			this.ID = ID;
    			return this;
    		}
    		public Person build() {
    			return new Person(this);
    		}
    	}
    }
  
    Person.Builder buider = new Person.Builder();
    buider.setAge(13);
    buider.setName("jack");
    Person jack = buider.build();
  

3、Android 原形模式(深浅拷贝)

用于创建重复的对象，同时又能保证性能。

1)原型模式就是一个拷贝。

2)实现 implements Cloneable 的 clone() 方法，使得提供类可以clone。

3)int string 这种是值类型，类的对象叫引用类型。

4)数值拷贝没有深浅拷贝之分，注意引用变量拷贝，
  如果没有再次加clone方法，默认是浅拷贝。
  
  浅拷贝：获得变量本身
  深拷贝：获得一个新的一模一样的变量。
	
	//创建原型的模板，具体的原型可以继承这个类
	public abstract class Shape implements Cloneable {
		private String id;
		protected String type;
	   
		abstract void draw();
		...
		public Object clone() {//实现拷贝默认是浅拷贝，深拷贝需要自己实现
			Object clone = null;
			try {
				clone = super.clone();
			} catch (CloneNotSupportedException e) {
				e.printStackTrace();
			}
			return clone;
	    }
	}

	public class ShapeCache {
	   private static Hashtable<String, Shape> shapeMap = new Hashtable<String, Shape>();
	   public static Shape getShape(String shapeId) {
		  Shape cachedShape = shapeMap.get(shapeId);
		  return (Shape) cachedShape.clone();
	   }

	   //加载原型到内存
	   public static void loadCache() {
		  Circle circle = new Circle();
		  circle.setId("1");
		  shapeMap.put(circle.getId(),circle);

		  Square square = new Square();
		  square.setId("2");
		  shapeMap.put(square.getId(),square);

		  Rectangle rectangle = new Rectangle();
		  rectangle.setId("3");
		  shapeMap.put(rectangle.getId(),rectangle);
	   }
	}
	//调用
	public class PrototypePatternDemo {
		public static void main(String[] args) {
			//加载原型到内存
			ShapeCache.loadCache();
			//获取原型的副本
			Shape clonedShape = (Shape) ShapeCache.getShape("1");
			Shape clonedShape2 = (Shape) ShapeCache.getShape("2");
			Shape clonedShape3 = (Shape) ShapeCache.getShape("3");         
	   }
	}

4、Android 工厂模式

• 1)工厂模式分为普通工厂模式、抽象工厂模式。

• 2)普通工厂模式产品用抽象类定义，
  抽象工厂的产品用接口定义。

  区别在于生产的产品上：
  普通工厂创建的都是具体的产品。
  而抽象工厂创建的时接口。因为接口是抽象出来的。所以叫抽象工厂。

    工厂模式是用来创建同一个产品的不同类型的
    抽象工厂模式是用来创建不同类的产品
    产品种类单一，适合用工厂模式；
    如果有多个种类，各种类型时，通过抽象工厂模式来进行创建是很合适的
  

普通工厂

本质是通过传入不同的参数来实现多态，达到实例化不同对象的目的。

public class NokiaFactory extends Factory {
	@Override
	public <T extends NokiaPhone> T createNokia(Class<T> clz) {
		NokiaPhone nokiaPhone = null;
		try {
			nokiaPhone = (NokiaPhone) Class.forName(clz.getName()).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		} 
		return (T) nokiaPhone;
	}
}

抽象工厂

生产的产品是接口

public interface CUP {
	String getName();
}

public interface Battery {
	String getName();
}

public abstract class Factory {
	public abstract CPU createCPU();
	public abstract Battery createBattery();
}

public class IPhone6Factory extends Factory {
	@Override
	public CPU createCPU() {
		return new A9();// class A9 implements CUP {}
	}

	@Override
	public Battery createBattery() {
		return new Battery1000ma();//class Battery1000ma implements Battery{}
	}
}

public class HuaweiPhoneFactory extends Factory {
	@Override
	public CPU createCPU() {
		return new Haisi980();//class Haisi980 implements CPU {}
	}

	@Override
	public Battery createBattery() {
		return new Battery4000ma();//class Battery4000ma implements Battery {}
	}
}

public class FactoryProducer {
	public static Factory getFactory(String choice){
		if(choice.equalsIgnoreCase("huawei")){
			return new IPhone6Factory();
		} else if(choice.equalsIgnoreCase("iphone")){
			return new HuaweiPhoneFactory();
		}
		return null;
   }
}

5、Android 策略模式

public interface IStrategy {
	void createOrder();
}

public NormalStategy implements IStrategy {
	public void createOrder(){}
}

public ThirdpartyStategy implements IStrategy {
	public void createOrder(){}
}
//type 就是策略
IStrategy getStategy(int type) {
	switch(type) {
		case 1:
			return new NormalStategy();
		case 2:
			return new ThirdpartyStategy();
		default:
			break;
	}
}
//调用
getStategy().createOrder();

6、Android 状态模式

根据状态的不同，调用同样的方法却有不同的行为。

与策略模式的区别：思想不同。。。

public interface State {
	public void doAction(Context context);
}

public class StartState implements State {
	public void doAction(Context context) {
		System.out.println("Player is in start state");
		context.setState(this); 
	}
	public String toString(){
		return "Start State";
	}
}

public class StopState implements State {
	public void doAction(Context context) {
		System.out.println("Player is in stop state");
		context.setState(this); 
	}
	public String toString(){
		return "Stop State";
	}
}

public class Context {
	private State state;
	public Context(){
		state = null;
	}
	public void setState(State state){
		this.state = state;     
	}
	public State getState(){
		return state;
	}
}
//使用 Context 来查看当状态 State 改变时的行为变化
public class StatePatternDemo {
	public static void main(String[] args) {
		Context context = new Context();
		//不同的状态，会有不同的行为，context保存了状态
		StartState startState = new StartState();
		startState.doAction(context);
		System.out.println(context.getState().toString());
		//不同状态，不同的行为，执行不同行为后，conetxt中保存的状态也会变化
		StopState stopState = new StopState();
		stopState.doAction(context);
		System.out.println(context.getState().toString());
	}
}

7、Android 责任链模式

链式结构处理，A判断是否处理，如果A处理那么请求终止，
如果A不处理传递给B，这样一直传递。形成链式结构。

abstract class Leader {
	public Leader nextLeader; // 上一级领导
	public final void handleLeave(StaffRequestLeave staff) {
		if (staff.getDays() <= getHandleLeaveDays()) {
			handle(staff);
		} else {
			if (nextLeader != null) {
				Log.d("Leader", "不处理，流转");
				nextLeader.handleLeave(staff);
			} else {
				refuseRequest();
			}
		}
	}

	abstract int getHandleLeaveDays(); // 批准请假天数
	abstract void handle(StaffRequestLeave staff); // 处理请假
	abstract void refuseRequest(); // 拒绝请假
}

8、Android 命令模式

“行为请求者”与“行为实现者”解耦。多个命令与行为一一对应。
//行为
public class Stock {
	private String name = "ABC";
	private int quantity = 10;
	
	public void buy(){
		System.out.println("Stock [ Name: "+name+", 
		Quantity: " + quantity +" ] bought");
	}
	
	public void sell(){
		System.out.println("Stock [ Name: "+name+", 
		Quantity: " + quantity +" ] sold");
	}
}
//命令1
public class BuyStock implements Order {
	private Stock abcStock;

	public BuyStock(Stock abcStock){
		this.abcStock = abcStock;
	}

	public void execute() {
		abcStock.buy();
	}
}
//命令2
public class SellStock implements Order {
	private Stock abcStock;

	public SellStock(Stock abcStock){
		this.abcStock = abcStock;
	}

	public void execute() {
		abcStock.sell();
	}
}
//命令调用类
public class Broker {
	private List<Order> orderList = new ArrayList<Order>(); 
	public void takeOrder(Order order){
		orderList.add(order);      
	}
	public void placeOrders(){
		for (Order order : orderList) {
			order.execute();
		}
		orderList.clear();
	}
}

//调用
Stock abcStock = new Stock();
BuyStock buyStockOrder = new BuyStock(abcStock);
SellStock sellStockOrder = new SellStock(abcStock);
Broker broker = new Broker();
broker.takeOrder(buyStockOrder);
broker.takeOrder(sellStockOrder);

broker.placeOrders();

9、Android 观察者模式

一个list合集，提供 add, remove 遍历观察者，
在调用具体方法的时候遍历list里的观察者，并调用观察者的方法

@Override
public void sun() {
    for (WeatherOberver observerListener : list) {
        observerListener.sun();
    }
}

10、Android 备忘录模式

用单独的类来保存和读取状态。避免直接访问数据和内部实现。

1)先创建一个我们要保存的状态集合类，保存歌名，播放模式，播放百分比
	public class Memoto {
		String songName;
		String mode;
		Float percent;
	}

2)创建一个单独管理状态集合类的类,用来保存和读取状态
	public class Caretaker {
		Memoto memoto;//用于保存和恢复数据

		public void saveMemoto (Memoto memoto) {
			this.memoto = memoto;
		}

		public Memoto getMemoto() {
			return memoto;
		}
	}

3)定义Mp3播放类，只是模拟功能，写的很简单
	public class Mp3 {
		private String songName;
		private String mode;
		private float percent;

		public void play() {
			songName = "浮夸";
			Log.d(TAG,"正在听 " + songName);
			mode = "低音炮";
			Log.d(TAG,"当前播放模式 " + mode);
			percent = 0.15f;
			Log.d(TAG,"播放百分比 " + percent);
		}

		public void quit () {
			Log.d(TAG,"退出播放");
		}

		public Memoto saveMemoto() {
			//用一个新的对象来保存状态
			Memoto memoto = new Memoto();
			memoto.songName = songName;
			memoto.mode = mode;
			memoto.percent = percent;
			return memoto;
		}

		public void restore(Memoto memoto) {
			songName = memoto.songName;
			mode = memoto.mode;
			percent = memoto.percent;
		}
	}
4)调用
	Mp3 mp3 = new Mp3();
    Caretaker caretaker = new Caretaker();
    mp3.play();
	//保存状态
    caretaker.saveMemoto(mp3.saveMemoto());
    mp3.quit();
	//恢复状态
    mp3.restore(caretaker.getMemoto());

11、Android 迭代器模式

根据传入的list额外提供一个遍历方法。
//自定义迭代器
public class IteratorImpl<T> implements Iterator<T> {
	private List<T> list = new ArrayList<T>();
	private int cursor = 0;

	public IteratorImpl(List<T> list) {
		this.list = list;
	}

	@Override
	public boolean hasNext() {
		return cursor != list.size();
	}

	@Override
	public T next() {
		T obj = null;
		if (this.hasNext()) {
			obj = this.list.get(cursor++);
		}
		return obj;
	}
}

//容器
public class ContainerImpl implements Container {
	private List<T> list = new ArrayList<T>();

	public ContainerImpl(List<T> list) {
		this.list = list;
	}
	
	@Override
	public Iterator getIterator() {
		return new IteratorImpl(list);
	}
}

//调用迭代器
ContainerImpl containerImpl = new ContainerImpl(list);
Iterator<String> iterator = containerImpl.iterator();
// 迭代器提供遍历方法，遍历
while (iterator.hasNext()) {
	Log.d("Iterator",iterator.next());
}

12、Android 模板方法模式

流程封装，父类封装不可变方法。子类实现部分或全部可扩展方法。

Activity中的onCreate,onResume就是模板方法模式

13、Android 访问者模式

通过这种方式，元素的执行算法可以随着访问者改变而改变。

1)被访问者不变。
2)根据访问者和被访问者的不同，两两对应达到不同的目的。
3)遍历被访问者实现“访问”。
4)代码结构记忆要点：
	多个访问者都继承Visitor借口。
	根据visit的类型不同，达到不同的目的即：visit里写不同的操作。
//元素接口
public interface ComputerPart {
	public void accept(ComputerPartVisitor computerPartVisitor);
}
//元素1
public class Keyboard  implements ComputerPart {
	@Override
	public void accept(ComputerPartVisitor computerPartVisitor) {
		computerPartVisitor.visit(this);
	}
}
//元素2
public class Monitor  implements ComputerPart {
	@Override
	public void accept(ComputerPartVisitor computerPartVisitor) {
		computerPartVisitor.visit(this);
	}
}
//元素三
public class Computer implements ComputerPart {   
	ComputerPart[] parts;
	public Computer(){
		parts = new ComputerPart[] { new Keyboard(), new Monitor()};      
	} 
	@Override
	public void accept(ComputerPartVisitor computerPartVisitor) {
		for (int i = 0; i < parts.length; i++) {
			parts[i].accept(computerPartVisitor);
		}
		computerPartVisitor.visit(this);
	}
}
//访问者接口
public interface ComputerPartVisitor {
	public void visit(Computer computer);
	public void visit(Keyboard keyboard);
	public void visit(Monitor monitor);
}
//访问者实体
public class ComputerPartDisplayVisitor implements ComputerPartVisitor {
	@Override
	public void visit(Computer computer) {
		System.out.println("Displaying Computer.");
	}

	@Override
	public void visit(Keyboard keyboard) {
		System.out.println("Displaying Keyboard.");
	}

	@Override
	public void visit(Monitor monitor) {
		System.out.println("Displaying Monitor.");
	}
}
//调用
public class VisitorPatternDemo {
	public static void main(String[] args) {
		ComputerPart computer = new Computer();
		computer.accept(new ComputerPartDisplayVisitor());
	}
}

14、Android 中介者模式

中介者模式就是把网状复杂结构优化为一对多结构。起到协调作用。
降低多个对象和类之间的通信复杂性

涉及修改一个对象需要去修改多个对象的时候，使用中介者模式

主要解决：对象与对象之间存在大量的关联关系时解耦

实现：对象执行某个方法如果会触发其他对象的行为，那么该方法调用中介去执行，
	  中介内部协调不同对象的调用。

//不同的对象，公共部分
public abstract class Person {
	public Mediator mediator;//这个是中介者

	public Person(Mediator mediator) {
		this.mediator = mediator;
	}

	// 执行
	public abstract void action();
	// 提出需求
	public abstract void changed();
}
//其中一个对象的实现
public class SoftWare extends Person {
	private static final String TAG = SoftWare.class.getSimpleName();

	public SoftWare(Mediator mediator) {
		super(mediator);
	}

	@Override
	public void action() {
		Log.d(TAG,"修改代码");
	}

	@Override
	public void changed() {
		Log.d(TAG,"提出修改软件");
		mediator.method(this);
	}
}

//中介者接口
public abstract class Mediator {
	public abstract void method(Person person);
}
//中介者实体
public class Leader extends Mediator {
	private SoftWare softWare;
	private ProductManager productManager;
	private UI ui;

	@Override
	public void method(Person person) {
		if (person == softWare) {
			Log.d(TAG,"软件提出修改软件，协调ui修改");
			ui.action();
		} else if(person == productManager) {
			Log.d(TAG,"产品经理提出修改需求，协调ui和软件修改");
			softWare.action();
			ui.action();
		} else if (person == ui) {
		   Log.d(TAG,"ui提出修改界面，我觉得不合理，什么都不做");
		}
	}

	public void setSoftWare(SoftWare softWare) {
		this.softWare = softWare;
	}

	public void setProductManager(ProductManager productManager) {
		this.productManager = productManager;
	}

	public void setUi(UI ui) {
		this.ui = ui;
	}
}
//调用
Leader leader = new Leader();
SoftWare softWare = new SoftWare(leader);
ProductManager productManager = new ProductManager(leader);
UI ui = new UI(leader);

leader.setSoftWare(softWare);
leader.setProductManager(productManager);
leader.setUi(ui);

softWare.changed();
productManager.changed();
ui.changed();

15、Android 代理模式

为其他对象提供一种代理以控制这个对象的访问。

分为静态代理和动态代理

静态代理，就是直接创建一个代理类。包含所有需要代理的方法。代理调用一次。
动态代理，是SDK提供方法。等于用java反射来调用的需要代理的方法。

静态代理：
	public interface ProxyInterface {
		void choiceBetterHouse(); //模拟挑选优质房子
		void buyHouse(); //模拟买房子
	}
	
	public class Petter implements ProxyInterface {
		private static final String TAG = Petter.class.getSimpleName();

		@Override
		public void choiceBetterHouse() {
			Log.d(TAG,"挑选优质房子");
		}

		@Override
		public void buyHouse() {
			Log.d(TAG,"买房子");
		}
	}
	//代理类
	public class StaticProxy implements ProxyInterface {
		private Petter petter;

		public StaticProxy(Petter petter) {
			this.petter = petter;
		}

		@Override
		public void choiceBetterHouse() {
			petter.choiceBetterHouse();
		}

		@Override
		public void buyHouse() {
			petter.buyHouse();
		}
	}
	
	//调用
	Petter petter = new Petter();
	StaticProxy agency = new StaticProxy(petter);
	agency.choiceBetterHouse();
	agency.buyHouse();

动态代理：
	//代理实现
	public class DynamicProxy implements InvocationHandler {
		private static final String TAG = DynamicProxy.class.getSimpleName();
		private Object object;

		public DynamicProxy(Object object) {
			this.object = object;
		}

		@Override
		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
			Log.d(TAG,"invoke");
			Object result = method.invoke(object,args);
			return result;
		}
	}
	
	Petter petter = new Petter();
    // Proxy.newProxyInstance()返回一个代理对象
    ProxyInterface proxyPetter = (ProxyInterface) Proxy.newProxyInstance(
            petter.getClass().getClassLoader(),
            petter.getClass().getInterfaces(),
            new DynamicProxy(petter));
    proxyPetter.choiceBetterHouse();
    proxyPetter.buyHouse();

16、Android 组合模式(View与ViewGroup)

将部分、整体的层次结构转换为树状结构
ViewGroup/View

//抽象出方法
public abstract class Component {
	String name;
	public Component(String name){
		this.name = name;
	}
	public abstract void print();
	public abstract void addChild(Component component);
	public abstract void removeChild(Component component);
	public abstract Component getChild(int index);
}
//一个部分
public class Node extends Component {
	private static final String TAG = Node.class.getSimpleName();
	private List<Component> list = new ArrayList<>();

	public Node(String name) {
		super(name);
	}

	@Override
	public void print() {
		Log.d(TAG,name);
		for (Component component:list) {
			component.print();
		}
	}

	@Override
	public void addChild(Component component) {
		list.add(component);
	}

	@Override
	public void removeChild(Component component) {
		list.remove(component);
	}

	@Override
	public Component getChild(int index) {
		return list.get(index);
	}
}

//一个部分
public class Leaf extends Component {
	public Leaf(String name) {
		super(name);
	}

	@Override
	public void print() {
		Log.d(TAG,name);
	}

	@Override
	public void addChild(Component component) {
		Log.d(TAG,"叶子节点，没有子节点");
	}

	@Override
	public void removeChild(Component component) {
		Log.d(TAG,"叶子节点，没有子节点");
	}

	@Override
	public Component getChild(int index) {
		Log.d(TAG,"叶子节点，没有子节点");
		return null;
	}
}

//调用
Component root = new Node("XX公司");
Component software = new Node("软件部");
Component hardware = new Node("硬件部");

Component androidSoftware = new Leaf("android");
Component iosSoftware = new Leaf("ios");
Component layout = new Leaf("layout");

root.addChild(software);
root.addChild(hardware);
software.addChild(androidSoftware);
software.addChild(iosSoftware);
hardware.addChild(layout);

root.print();

17、Android 适配器模式(ListView与Adapter)

将一个类的接口转换成客户希望的另一个接口。
适配器模式让那些接口不兼容的类可以一起工作

public interface BigOutlet {
	void bigOutlet();
}

public interface SmallOutlet {
	void smallOutlet();
}

public class BigWaterTap implements BigOutlet {
	private static final String TAG = WaterTap.class.getSimpleName();

	@Override
	public void bigOutlet() {
		Log.d(TAG,"bigOutlet");
	}
}

//类适配器
public class ClassWaterTapAdapter extends BigWaterTap implements SmallOutlet {

	@Override
	public void smallOutlet() {
		Log.d(TAG,"smallOutlet");
	}
}
//对象适配器
public class ProxyWaterTapAdapter implements SmallOutlet {
	private BigWaterTap bigWaterTap;

	public ProxyWaterTapAdapter(BigWaterTap bigWaterTap) {
		this.bigWaterTap = bigWaterTap;
	}

	public void adapterBigOutlet() {
		bigWaterTap.bigOutlet();
	}

	@Override
	public void smallOutlet() {
		Log.d(TAG,"smallOutlet");
	}
}

//调用类适配器
ClassWaterTapAdapter classAdapter = new ClassWaterTapAdapter();
classAdapter.bigOutlet();
classAdapter.smallOutlet();
//调用对象适配器
ProxyWaterTapAdapter proxyAdapter = new ProxyWaterTapAdapter(new BigWaterTap());
proxyAdapter.adapterBigOutlet();
proxyAdapter.smallOutlet();

18、Android 装饰者模式

在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。

public abstract class Person {
	public abstract void eat();
}
//被装饰者
public class XiaoMing extends Person {
	private static final String TAG = XiaoMing.class.getSimpleName();
	@Override
	public void eat() {
		Log.d(TAG,"eat");
	}
}
//装饰者
public abstract class Decorator extends Person{
	private Person person;
	//这里是重点，必须持有一个被装饰者对象。
	public Decorator(Person person) {
		this.person = person;
	}

	@Override
	public void eat() {
		person.eat();
	}
}
//实现装饰者
public class ConcreteDecorator extends Decorator {
	public ConcreteDecorator(Person person) {
		super(person);
	}

	@Override
	public void eat() {
		dessert();
		super.eat();  // 拓展时，前后都可以加方法
		drinkTea();
	}
  
   // 装饰方法，甜品
	public void dessert() {
		Log.d(TAG,"dessert");
	}

	// 装饰方法，喝茶
	public void drinkTea() {
		Log.d(TAG,"drink tea");
	}
}
//调用
XiaoMing xiaoMing = new XiaoMing();
ConcreteDecorator concreteDecorator = new ConcreteDecorator(xiaoMing);
concreteDecorator.eat();

19、Android 享元模式

缓存池思想“共享”对象，避免重复创建。

1)用map缓存，有就直接取用，没有时创建并push到map里。
2)Message单链表重复利用表头也可以。

public class ShapeFactory {
   private static final HashMap<String, Shape> circleMap = new HashMap<>();
   public static Shape getCircle(String color) {
		Circle circle = (Circle)circleMap.get(color);
		if(circle == null) {
			circle = new Circle(color);
			circleMap.put(color, circle);
			System.out.println("Creating circle of color : " + color);
		}
		return circle;
   }
}

20、Android 外观模式

提供一个接口，使得客户端只通过接口访问。隐藏内部子系统的实现。

public abstract class Context {
	public abstract void sendBroadcast(@RequiresPermission Intent intent);
	public abstract ComponentName startService(Intent service);
	...

	class ContextImpl extends Context {
		@Override
		public void sendBroadcast(Intent intent, String receiverPermission) {
			warnIfCallingFromSystemProcess();
			String resolvedType = intent.resolveTypeIfNeeded(getContentResolver());
			String[] receiverPermissions = receiverPermission == null ? null
					: new String[] {receiverPermission};
			try {
				intent.prepareToLeaveProcess(this);
				ActivityManager.getService().broadcastIntent(
						mMainThread.getApplicationThread(), intent, resolvedType, null,
						Activity.RESULT_OK, null, null, receiverPermissions, AppOpsManager.OP_NONE,
						null, false, false, getUserId());
			} catch (RemoteException e) {
				throw e.rethrowFromSystemServer();
			}
		}
		
		@Override
		public ComponentName startService(Intent service) {
			warnIfCallingFromSystemProcess();
			return startServiceCommon(service, false, mUser);
		}
		...
	}
}

21、Android 桥接模式

将抽象部分与实现部分分离，使它们都可以独立的进行变化。

主要解决：在有多种可能会变化的情况下，用继承会造成类爆炸问题，扩展起来不灵活。

• 实现部分

    public interface Color {
    	public void coloring();
    }
  
    public class White implements Color {
    	private static final String TAG = White.class.getSimpleName();
  
    	@Override
    	public void coloring() {
    		Log.d(TAG,"模拟正在涂上白色...");
    	}
    }
  
    public class Black implements Color {
    	private static final String TAG = Black.class.getSimpleName();
    	@Override
    	public void coloring() {
    		Log.d(TAG,"模拟正在涂上黑色...");
    	}
    }
  

• 抽象部分

    public abstract class Shape {
    	protected Color color;
  
    	public Shape(Color color) {
    		this.color = color;
    	}
  
    	public abstract void draw();
    }
  
    public class Square extends Shape {
    	private static final String TAG = Square.class.getSimpleName();
  
    	public Square(Color color) {
    		super(color);
    	}
  
    	@Override
    	public void draw() {
    		Log.d(TAG,"模拟正在画正方形...");
    		color.coloring();
    	}
    }
  
    public class Square extends Shape {
    	private static final String TAG = Square.class.getSimpleName();
  
    	public Square(Color color) {
    		super(color);
    	}
  
    	@Override
    	public void draw() {
    		Log.d(TAG,"模拟正在画正方形...");
    		color.coloring();
    	}
    }
  

• 调用

    White white = new White();
    Black black = new Black();
  
    Square square = new Square(white);
    Rectangle rectangle = new Rectangle(black);
    Circular circular = new Circular(white);
  
    square.draw();
    rectangle.draw();
    circular.draw();