单例设计模板

1.私有化所有的构造方法 不让外部自己创建
2.给外部提供一个静态方法 获取当前类的一个对象
3.必须定义一个静态成员变量来保存当前类的唯一一个对象
4.创建对象：

饿汉式

在定义静态成员变量时，直接创建当前类的一个对象 进行赋值

 private static HttpOperation instance = new HttpOperation();

饿汉式的对象不需要担心线程问题

懒汉式

public class HttpOperation {
    private static HttpOperation instance;
    private HttpOperation(){

    }
    public static HttpOperation getInstance(){
        //判断对象是否有值
        if(instance == null) {
            //加锁
            synchronized (HttpOperation.class) {
                if (instance == null) {

                    //创建一个对象
                    instance = new HttpOperation();
                }
            }
        }
        return instance;
    }
}

懒汉式相对于饿汉式更为麻烦 需要设计加锁步骤，防止创建重复的对象。

抽象类实现模板设计模式

public abstract class Activity {
    private String className;

    public Activity(){
        //子类必须实现的方法
        onCreate();
        //可以选择实现的方法
        onStart();
        onResume();
        onPause();
        onStop();
        onDestroy();
    }

    //界面布局
    public abstract void onCreate();
    //开始启动
    public void onStart(){
    }
    //界面显示出来 可以交互了
    public void onResume(){
    }
    //暂停
    public void onPause(){
    }
    //已经停止
    public void onStop(){
    }
    //销毁
    public void onDestroy(){
    }
    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
}

模板里面定义执行的过程 （有些功能自己可以实现，有些必须子类实现）
1.抽象类使用abstract修饰
2.抽象类不能被实例化 不能使用Activity ad = new Activity();
3.抽象类里面可以定义成员变量方法 抽象方法必须使用abstract修饰 而且不能实现只能被子类实现
4.子类继承与抽象类：
子类实现抽象类里面的抽象方法，如果不想实现，也可以将自己变成抽象类。
子类继承：

public class MainActivity extends Activity {
    //抽象方法必须实现
    @Override
    public void onCreate() {
        System.out.println("创建首页界面");
    }
    //子类可以重写父类方法
    @Override
    public void onResume() {
        System.out.println("界面启动了，开始交互");
    }
}