1.单例模式
1.1定义
确保某个类只有一个实例，而且自行实例化并向整个系统提供者个实例。
1.2单例的形式
- 饿汉模式：第一次就加载,用空间换时间。
public class SingleTon {
private static SingleTon instance = new SingleTon();
//构造函数不对外开放
private SingleTon() {
}
//通过静态方法或枚举进行调用
public static SingleTon getInstance() {
return instance;
}
}
- 懒汉模式：只有在调用的时候才进行加载，但是第一次比较慢，用时间换空间，效率不高，并且线程不安全。
public class SingleTonLH {
private static SingleTonLH instance;
//构造函数不对外开放
private SingleTonLH() {
}
//通过静态方法或枚举进行调用
public static synchronized SingleTonLH getInstance() {
if(instance == null){
instance = new SingleTonLH();
}
return instance;
}
}
- 双重加锁模式：使用volatile和synchronized进行修饰。
public class SingleTonDCL {
private static volatile SingleTonDCL instance;
//构造函数不对外开放
private SingleTonDCL() {
}
//通过静态方法或枚举进行调用
public static SingleTonDCL getInstance() {
if(instance == null){
synchronized (SingleTonDCL.class) {
if (instance == null){
instance = new SingleTonDCL();
}
}
}
return instance;
}
}
- 静态内部类：线程安全，并且什么时候使用什么时候调用。
public class SingleTonFinal {
// 构造函数不对外开放
private SingleTonFinal() {
}
// 通过静态方法或枚举进行调用
public static SingleTonFinal getInstance() {
return SingleTonHolder.sinstance;
}
//反序列化
private Object readResolve() throws ObjectStreamException {
return SingleTonHolder.sinstance;
}
/**
* 静态类部类
*/
private static class SingleTonHolder {
private static final SingleTonFinal sinstance = new SingleTonFinal();
}
}
- 枚举单例：
/**
* 枚举单例
*/
public enum SingleTonEnum {
INSTANCE;
public void dosamething(){
}
}
/**
* 调用方式
*/
class SingleTon {
private SingleTon(){
SingleTonEnum.INSTANCE.dosamething();
}
}
- 容器单例：
/**
* 容器实现单例模式
*/
public class SingleTonManger {
private static Map objMap = new HashMap();
// 构造函数不对外开放
private SingleTonManger() {
}
public static void registerService(String key, Object instance) {
if (!objMap.containsKey(key)) {
objMap.put(key, instance);
}
}
public static Object getService(String key) {
return objMap.get(key);
}
}
1.3优缺点
优点：全局一个，节约资源。在读文件方面，可以防止同时操作。
缺点：不易扩展，如果要扩展需要修改代码，违背了开闭原则。
1.4 Android源码对应模式
我们经常在Activity中通过getSystemService(String name)这个函数来获取系统服务，比如WMS,AMS，LayoutIlater等，这些服务都会在某一个时刻以容器单例的形式保存在应用中。在源码中我们知道各个服务都是保存在ContextImpl类中，在其中定义了一个SystemServiceRegistry类
final class SystemServiceRegistry {
// 存储所有系统服务的集合
private static final HashMap, String> SYSTEM_SERVICE_NAMES =new HashMap, String>();
private static final HashMap> SYSTEM_SERVICE_FETCHERS =
new HashMap>();
// 一个注册服务的并添加到结合的方法
private static void registerService(String serviceName, Class serviceClass,
ServiceFetcher serviceFetcher) {
SYSTEM_SERVICE_NAMES.put(serviceClass, serviceName);
SYSTEM_SERVICE_FETCHERS.put(serviceName, serviceFetcher);
}
// 静态语句块, 只在类第一次被加载的时候调用, 保证了服务只被添加一次.
static {
// 注册了LayoutInflate服务
registerService(Context.LAYOUT_INFLATER_SERVICE, LayoutInflater.class,
new CachedServiceFetcher() {
@Override
public LayoutInflater createService(ContextImpl ctx) {
return new PhoneLayoutInflater(ctx.getOuterContext());
}});
registerService(Context.ACTIVITY_SERVICE, ActivityManager.class,
new CachedServiceFetcher() {
@Override
public ActivityManager createService(ContextImpl ctx) {
return new ActivityManager(ctx.getOuterContext(), ctx.mMainThread.getHandler());
}});
/**
* 后面省略一大坨的注册的服务代码
**/
}
//获得服务
public static Object getSystemService(ContextImpl ctx, String name) {
ServiceFetcher fetcher = SYSTEM_SERVICE_FETCHERS.get(name);
return fetcher != null ? fetcher.getService(ctx) : null;
}
}
2.Buider模式
2.1定义
把一个复杂的类的构建过程和它的表示进行分离
构建模式
2.2说明
- Director：统一组装过程
- Product：产品抽象类
- builder：抽象的builder类，规范产品的组建
- concreteBuilder：具体的builder类
一般实现
1,Product 建立抽象类
/**
* @describe 用户抽象类
*/
public abstract class Product {
protected String name;
protected String cardID;
protected int age;
protected String address;
//定义抽象方法
public abstract void setCardID();
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setAddress(String address) {
this.address = address;
}
//显示的内容让子类去实现
protected abstract String showProductInfo();
}
2.具体产品类
/**
* @describe product具体实现类
*/
public class SysProduct extends Product {
@Override
public void setCardID() {
//设置默认ID
cardID="10086";
}
@Override
protected String showProductInfo() {
return "User [name =" + name + ",cardID=" + cardID + ",age=" + age
+ "," + "address=" + address + "]";
}
}
3.定义抽象的buider类
/**
* @describe 抽象构造类
*/
abstract class Builder {
Product product;
public void buildName(String name) {
product.setName(name);
}
public void buildCardID() {
product.setCardID();
}
public void buildAge(int age) {
product.setAge(age);
}
public void buildAddress(String address) {
product.setAddress(address);
}
protected abstract void creat();
}
4.具体的buider实现类
/**
* @describe 具体的builder类
*/
public class AccountBuilder extends Builder {
SysProduct sysProduct;
@Override
protected void creat() {
sysProduct = new SysProduct();
sysProduct.setName("嘻嘻嘻");
sysProduct.setAge(20);
sysProduct.setCardID();
sysProduct.setAddress("中国");
System.out.println("Info : " + sysProduct.showProductInfo());
}
}
5.统一组装类director
/**
* @describe 统一组装类
*/
public class Director {
Builder mBuilder = null;
public Director(Builder builder) {
this.mBuilder = builder;
this.mBuilder.creat();
}
}
6.调用
/**
* @describe 测试类
*/
public class Test {
public static void main(String[] args) {
//统一组装
new Director(new AccountBuilder());
}
}
使用链式,简化Director
public class ChainProduct extends Product {
@Override
public void setCardID() {
// 设置默认ID
cardID = "10086";
}
@Override
protected String showProductInfo() {
return "Info : " + "User [name =" + name + ",cardID=" + cardID + ",age=" + age
+ "," + "address=" + address + "]";
}
public static class Builder {
ChainProduct product;
public Builder() {
product = new ChainProduct();
}
public Builder buildName(String name) {
product.setName(name);
return this;
}
public Builder buildAge(int age) {
product.setAge(age);
return this;
}
public Builder buildAddress(String address) {
product.setAddress(address);
return this;
}
public Builder buildCardID() {
product.setCardID();
return this;
}
public void creat() {
System.out.println(product.showProductInfo());
}
}
}
调用方式
new ChainProduct.Builder().buildAge(20).buildAddress("中国").creat();
2.3使用场景
- 相同的方法，不同的执行顺序，产生不同的事件结果
- 多个部件或者零件，都可以配装到一个对象，但是产生的运行结果不同
- 当初始化一个对象特别复杂，参数多，且很多参数默认的时候
2.4 优缺点
优点：封装性良好，使用可以使客户端不必知道产品内部组成细节。建造者独立易扩展。
缺点：会产生多余的builder对象和Director对象，消耗内存
2.5 android中使用
Director这个角色经常会被忽略. 而直接使用一个Builder来进行对象的封装, 并且这个Builder通常为链式调用, 它的每个setter方法都会返回this自身, 比如我们常用的AlertDialog。
// 一个粗略的创建dialog
// 创建构建者builder角色
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setIcon(android.R.drawable.sym_def_app_icon)
.setTitle("标题")
.setMessage("message")
// 设置点击等..
.setPositiveButton("确定", null);
// 构建
AlertDialog alertDialog = builder.create();
// 显示
alertDialog.show();
AlerDialog源代码：
public class AlertDialog extends Dialog implements DialogInterface {
// AlertController 这个对象会保存Builder对象中的各个参数
private AlertController mAlert;
// 实际上操作的是上面这个变量中的属性
@Override
public void setTitle(CharSequence title) {
super.setTitle(title);
mAlert.setTitle(title);
}
public void setMessage(CharSequence message) {
mAlert.setMessage(message);
}
// 省略一坨代码如各种setter等
// Builder以内部类的形式存在
public static class Builder {
// 1.存储AlertDialog的各个参数 如title,icon等
private final AlertController.AlertParams P;
// 构造函数
public Builder(Context context) {
this(context, resolveDialogTheme(context, 0));
}
// 2. 设置参数, 我们构建的Builder设置的参数就是这些方法
public Builder setTitle(int titleId) {
P.mTitle = P.mContext.getText(titleId);
return this;
}
public Builder setTitle(CharSequence title) {
P.mTitle = title;
return this;
}
// ....
// 3.构建AlertDialog, 传递参数
public AlertDialog create() {
// 4.因为已经通过builder设置了参数, 接下来就可以创建真正需要的AlertDialog对象
final AlertDialog dialog = new AlertDialog(P.mContext, mTheme, false);
// 5.将Builder类中的成员变量P应用到AlertDialog类中
P.apply(dialog.mAlert);
dialog.setCancelable(P.mCancelable);
if (P.mCancelable) {
dialog.setCanceledOnTouchOutside(true);
}
dialog.setOnCancelListener(P.mOnCancelListener);
dialog.setOnDismissListener(P.mOnDismissListener);
if (P.mOnKeyListener != null) {
dialog.setOnKeyListener(P.mOnKeyListener);
}
return dialog;
}
}
}
可以看到Android源码中的AlertDialog并没有遵循GOF设计模式中经典的实现方式, 而是进行了变种, 但却使其使用更加的方便. 这里AlertDialog.Builder这个类同时扮演了范例中的builder,具体实现builder,Director的角色. 简化了Builder设计模式, 因为模块比较稳定不会存在变化, 根据具体场景简化模式, 正是体现了灵活运用设计模式的实例.
3.原型模式
3.1定义
用原型实例指定创建对象的种类，通过拷贝这个原型创建新的对象
原型模式
3.2说明
Client：客户端用户
Prototype：抽象类或者接口，声明具备clone能力。
concretePrototype:具体实现原型。
3.3使用场景
- 类的初始化需要消耗很多资源
- 通过new产生一个对象需要非常繁琐的数据准备或者访问权限
- 一个对象需要提供给其他对象访问，而且其他各个调用者都需要修改其值，可以通过原型拷贝多个对象提供给调用者调用。
3.4涉及到的知识点
- 赋值：对一个对象赋值一个对象，相当于两个对象对原来的对象都有控制权炒作一个另一个也有变化
//继承Cloneable类 相当于prototype接口。wordDocument相当于ConcreteProttype拥有赋值调用
public class WordDocument implements Cloneable {
// 文字
private String mText = "";
// 图片
private List mImages = new ArrayList();
public String getText() {
return mText;
}
public void setText(String mText) {
this.mText = mText;
}
public List getImages() {
return mImages;
}
public void setImages(List mImages) {
this.mImages = mImages;
}
public void addImage(String img) {
this.mImages.add(img);
}
/**
* 打印文档内容
*/
public void showDocument() {
System.out.println("----------- Word Content Start -----------");
System.out.println("Text : " + mText);
System.out.println("Images List: ");
for (String imgName : mImages) {
System.out.println("image name : " + imgName);
}
System.out.println("----------- Word Content End -----------");
}
}
赋值
- 浅拷贝：重写clone()方法，但是没有对引用类型进行拷贝，造成一个对象的引用类型发生变化另一个也会变化
//在类中添加clone 进行浅拷贝
@Override
protected WordDocument clone() {
try {
WordDocument doc = (WordDocument) super.clone();
doc.mText = this.mText;
doc.mImages = this.mImages;
return doc;
} catch (Exception e) {
}
return null;
}
浅拷贝
- 深拷贝：对引用类型再次进行clone()
//进行深度拷贝
ArrayList重写了clone的方法
@SuppressWarnings("unchecked")
@Override
protected WordDocument clone() {
try {
WordDocument doc = (WordDocument) super.clone();
doc.mText = this.mText;
//对mImages调用clone进行深度拷贝
doc.mImages = ((List) ((ArrayList) this.mImages).clone());
return doc;
} catch (Exception e) {
}
return null;
}
深拷贝
3.5 Android源码对应实现
- ArrayList源码中的clone()
public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable{
transient Object[] elementData;
private int size;
public Object clone() {
try {
ArrayList v = (ArrayList) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
- Intent中实现
1.intent实现了Cloneable
public class Intent implements Parcelable, Cloneable {
}
2.对clone()重写
Intent
没有调用super.clone()使用了new Intent(this).当消耗不大的时候可以使用new
4.简单工厂模式
4.1定义
定义一个用于创建对象的接口，让子类决定实例化那个类
工厂方法模式
4.2使用场景
在任何需要创建复杂对象的地方，都可以使用工厂模式。但是能用new创建对象无需使用工厂方法模式。
4.3实现方式
一般实现流程
1.定义抽象产品类product
/**
* @describe 抽象产品类
*/
public abstract class Product {
/**
* 产品类的抽象方法，由具体的产品类去实现
*/
public abstract void method();
}
2、具体的产品实现类
/**
* @describe 具体实现类A
*/
public class ConcreteProductA extends Product {
@Override
public void method() {
System.out.println("我是具体的产品实现A");
}
}
/**
* @describe 具体实现类B
*/
public class ConcreteProductB extends Product {
@Override
public void method() {
System.out.println("我是具体的产品实现B");
}
}
3.抽象工厂类 factory
/**
* @describe 抽象工厂类
*/
public abstract class Factory {
/**
* 抽象工厂类方法
* @return
*/
public abstract Product CreateProuct();
}
4.具体实现工厂类
/**
* @describe 抽象工厂类的具体实现方法
*/
public class ConcreteFactory extends Factory {
@Override
public Product CreateProuct() {
return new ConcreteProductA();
}
}
5.客户端调用
/**
* @describe 调用类
*/
public class Client {
public static void main(String[] args) {
// 创建工厂
Factory factory = new ConcreteFactory();
// 创建产品
Product product = factory.CreateProuct();
// 调用产品的方法
product.method();
}
}
使用反射的方法进行工厂方法模式
1.创建反射工厂抽象类
/**
* @describe 使用反射的方便调用
*/
public abstract class Factory {
public abstract T createFactory(Class clz);
}
2.具体的实现工厂类
/**
* @describe 具体的实现工厂类
*/
public class ConCreateFactory extends Factory{
@SuppressWarnings("unchecked")
@Override
public T createFactory(Class clz) {
Product p = null;
try {
p = (Product) Class.forName(clz.getName()).newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return (T) p;
}
3.调用方法
/**
* @describe 调用类
*/
public class Client {
public static void main(String[] args) {
// 创建工厂
Factory factory = new ConCreateFactory();
// 创建产品
Product product = factory.createFactory(ConcreteProductB.class);
// 调用产品的方法
product.method();
}
}
}
4.3 android中的简单工厂方法模式
onCreate是一个工厂方法
public class MainActivity extends Activity {
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(new FrameLayout(this));
}
}
通过onCrete这个方法，我们可以构建出任何样式的根布局。我们在不同的Activity#onCreate()方法将设置的布局通过setContentView()函数传递给frameworks并显示出来. 这不就是一个工厂模式的结构. 方法内部可以创建不同的对象, 产生不同的实例.
service中的onBind()也可以看成工厂方法模式
5.抽象工厂模式
5.1定义
为创建一组相关或者相互依赖的对象提供一个接口，而不需要指定它们的具体类
抽象工厂模式
5.2Android源码对应实现
抽象工厂在Android实现较少，基本上都可以用工厂方法模式解决。MediaPlayer底层使用的是抽象工厂模式
MediaPlayer