《Android源码设计模式解析与实》读书笔记

第一章：面向对象的六大原则

1.单一职责原则（single responsibility principle）：一个类而言，应该仅有一个引起变化的原因。就是说类应该具有高度的内聚性，一个类负责一个功能（职能），但这个职责的划分不一。

2.开闭原则(open close principle)：软件中对象（类、模块、函数等）对于扩展是开放的，对于修改是封闭的。就是说尽量依靠扩展的方式来升级和维护现有系统。因为在源码上进行修改，可能会引入错误，致使已经测试通过的版本出现bug。扩展主要有：类继承、接口实现。

参考文献   http://blog.csdn.net/zhengzhb/article/details/7296944

3.里氏替换原则（Liskov Substitution principle）：所有引用基类的地方必须能透明的使用其子类的对象。

子类可以扩展父类的功能，但不能改变父类原有的功能   

参考文献    http://blog.csdn.net/zhengzhb/article/details/7281833

个人感觉太过绝对了，android中经常会重写父类已实现的方法。如果完全按这个来：MainActivity 的oncreate应该写成，oncreate1（）{ super.oncreate();  xxxx}；这样子类会多出多少函数来。

4.依赖倒置原则（dependence inversion principle）：高层次的模块不依赖于低层次的模块的实现细节，都应该依赖抽象（接口或者抽象类）。依赖倒置原则的核心就是面向接口编程。

参考文献   http://blog.csdn.net/zhengzhb/article/details/7289269

5.接口隔离原则（InterfaceSegregation princple）：类间的依赖关系应该建立在最小的接口上。就是说将非常庞大的接口拆分成更小的接口。

6.迪米特原则（law of Demeter）：一个对象应该对其他对象有最少的了解。只与直接的朋友通信，，我们称出现成员变量、方法参数、方法返回值中的类为直接的朋友，而出现在局部变量中的类则不是直接的朋友。也就是说，陌生的类最好不要作为局部变量的形式出现在类的内部。

参考文献  http://blog.csdn.net/zhengzhb/article/details/7296930

总结：6大原则都是围绕面向对象的特性:封装、继承、抽象、多态。

第二章 应用最广的模式——单例模式

优点：节省资源，

缺点：一般没有接口使用，难以扩展；单例持有context，容易引发内存泄露，最好传个单例的是Application 的context.

1应用场景：确保某个类有且只有一个实例，避免产生多个实例而消耗过多资源。

2.实现：构造方法私有化；通过类静态方法返回实例。

3.静态内部类实现：把静态成员变量封装在静态内部类中，延迟其初始化，只有调用getInstance()时后才初始化。这是因为静态内存类只有使用时才加载，若是静态成员会再类加载时初始化。

public class Singleton {

private Singleton() {
}

private static class Holder {
private static final Singleton INSTANCE = new Singleton();
}

public static Singleton getInstance(){
return Holder.INSTANCE;
}
}

4.android中单例模式：很多系统服务在适合的时候？以单例的形式注册在系统中?在ContextImpl可以看到静态块，注册各种ServiceFetcher，保存到一个hashMap中（SYSTEM_SERVICE_MAP ）。通过key值获得对应的ServiceFetcher对象，获取对应服务。例如：

 static {
        registerService(ACCESSIBILITY_SERVICE, new ServiceFetcher() {
                public Object getService(ContextImpl ctx) {
                    return AccessibilityManager.getInstance(ctx);
                }});

        registerService(ACTIVITY_SERVICE, new ServiceFetcher() {
                public Object createService(ContextImpl ctx) {
                    return new ActivityManager(ctx.getOuterContext(), ctx.mMainThread.getHandler());
                }});

 private static final HashMap<String, ServiceFetcher>SYSTEM_SERVICE_MAP =
            new HashMap<String, ServiceFetcher>();


    private static int sNextPerContextServiceCacheIndex = 0;
    private static void registerService(String serviceName, ServiceFetcher fetcher) {
        if (!(fetcher instanceof StaticServiceFetcher)) {
            fetcher.mContextCacheIndex = sNextPerContextServiceCacheIndex++;
        }
        SYSTEM_SERVICE_MAP.put(serviceName, fetcher);
    }

.......

第三章Builder模式

优点：封装性好；构造者独立，使用接口，易于扩展。

缺点;会产生多余的Builider对象。

1.应用场景：构建过程复杂，要将构建和表示分离；

2.android中例子;AlertDialog.Builder.

WindowManager：实现类WindowManagerImpl。

ViewRootImpl是Framework层和native层通信桥梁，

Window的实现类PhoneWindow中有DecorView类的成员变量，这是window的根视图。

第四章 原型模式

1.通过拷贝实现对象的创建。

2.使用场景：类初始化需要消耗很多资源；new一个对象需要非常繁琐的数据准备或者访问权限；一个对象需求提供给其他对象访问，而且这些对象可能会修改其值（保护性拷贝）；

3.android中例子：Intent.clone(); 但这里使用的构造新的对象，而不是复制。

Intent查找和匹配：

PackageManagerService类中会扫描所有已安装的app信息，解析AndroidManifest.xml文件，把activity、service、receiver和provider存在mActivities ，mReceivers ，mServices ，mProviders 。

 final ActivityIntentResolver mActivities =
            new ActivityIntentResolver();

    // All available receivers, for your resolving pleasure.
    final ActivityIntentResolver mReceivers =
            new ActivityIntentResolver();

    // All available services, for your resolving pleasure.
    final ServiceIntentResolver mServices = new ServiceIntentResolver();

    // Mapping from provider base names (first directory in content URI codePath)
    // to the provider information.
    final HashMap<String, PackageParser.Provider> mProviders =
            new HashMap<String, PackageParser.Provider>();

启动某个activity，会调用PackageManagerService中的resolveIntent方法——>queryIntentActivities方法返回符合该intent的List<ResolveInfo>，chooseBestActivity会返回最合适的。

public ResolveInfo resolveIntent(Intent intent, String resolvedType,int flags, int userId) {
        if (!sUserManager.exists(userId)) return null;
        List<ResolveInfo> query = queryIntentActivities(intent, resolvedType, flags, userId);
        return chooseBestActivity(intent, resolvedType, flags, query, userId);
    }

第五章 工厂方法模式

简单工厂模式：一个工厂类根据传入的参数决定创建哪一种的产品类。Factory类使用静态方法返回Product实例。

可以使用反射，这样有新的Product，也不要修改Factory类。

工厂方法模式：工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。

android：

android应用程序的入口：ActivityThread的main方法，它管理应用进程的主线程的执行(相当于普通Java程序的main入口函数)

参考文档 http://blog.csdn.net/myarrow/article/details/14223493

  public static void main(String[] args) {
        SamplingProfilerIntegration.start();

        // CloseGuard defaults to true and can be quite spammy.  We
        // disable it here, but selectively enable it later (via
        // StrictMode) on debug builds, but using DropBox, not logs.
        CloseGuard.setEnabled(false);

        Process.setArgV0("<pre-initialized>");

        Looper.prepareMainLooper();
        if (sMainThreadHandler == null) {
            sMainThreadHandler = new Handler();
        }

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        AsyncTask.init();

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

ActivityThread中有H类实现内部消息处理。

private class H extends Handler{

public void handleMessage(Message msg) {

启动actvity，PAUSE_ACTIVITY......

}

}

第六章 抽象工厂模式

抽象工厂模式：应对多个等级的产品创建。比如：奔驰、宝马等有普通和高级之分。

一个具体工厂负责一个等级的产品创建。