java基础8&实战开发Day5/单例设计模式和模板设计模式（抽象类）/2020-05-02

目录

1.单例设计模式
2.抽象类Abstract模板设计模式
3.抽象类实现造房子

1.单例设计模式

简介:
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
特点:
1.私有化所有构造方法,不让外部自己去创建对象;
2.给外部提供一个方法（必须是静态方法）获取当前类的一个对象;
3.必须定义一个静态成员变量来保存当前类唯一的一个对象;
4.创建对象:

饿汉式：在定义静态成员变量时，直接创建当前类的一个对象，进行赋值
懒汉式：默认不创建，当调用的时候才会创建

下面演示一下饿汉式和懒汉式两种不同的创建方法
a.饿汉式

    //饿汉式
    private static HttpOperation instance = new HttpOperation();

b.懒汉式

    //懒汉式
    public static HttpOperation getInstane(){
        //判断对象是否有值
        if (instance == null){
            //加锁保证输入正确
            synchronized (HttpOperation.class){
                if (instance == null){
                    //创建一个对象
                    instance = new HttpOperation();
                }
            }
        }
        return instance;
    }

2.抽象类Abstract模板设计模式

模板里面定义执行的过程（有些功能自己可以实现有些必须子类实现）

抽象类使用abstract修饰
抽象类不能被实例化

3.抽象类里面可以定义成员变量|方法

抽象方法必须使用abstract修饰
而且不能被实现，只能在子类中实现

4.子类继承于抽象类

子类实现抽象类里面的抽象方法
如果不想实现，可以将自己也变成抽象类

这里我们做了一个小Demo来演示一下抽象类Abstract模板设计模式:
Step1.首先创建一个抽象类模板Activity

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;
    }
}

可以看到：在父类方法中，我们把onCreate方法定义为抽象类，则子类里面就必须要有这个方法，其他方法随意使用
Step2.创建子类MainActivity并继承父类Activity

public class MainActivity extends Activity {
    //抽象方法必须实现
    @Override
    public void onCreate() {
        System.out.println("创建首页的界面");
    }

    //子类可以重写父类的方法
    @Override
    public void onResume() {
        System.out.println("界面启动了，开始交互");
    }
}

可以看到：父类中抽象方法必须实现，其他方法可供重写
Step3.在主程序MyClass中创建子类MainActivity的对象mActivity，实现MainActivity()方法

public void activity(){
        //创建一个抽象类
        MainActivity mActivity = new MainActivity();
    }

打印结果：创建首页的界面
         界面启动了，开始交互

3.抽象类实现造房子

抽象类和普通类的区别：
抽象类不能实例化，普通类可以
抽象类里面可以有抽象方法（只申明不实现），普通类不行

这里我们单独做一个Demo来加深对抽象类模板的理解：

Step1.造房子首先需要图纸，定义一个DrawMap类作为抽象类模板，并定义三个抽象类方法供子类使用（方法颜色材料）

public abstract class DrawMap {
    public void buildHouse(){
        //造什么方法
        String type = getHouseType();
        //选择颜色
        String color = getHouseColor();
        //材料
        String material = getMaterial();

        System.out.println("即将使用" + material + "造一个" + color + "的" + type);
    }

    public abstract String getHouseType();
    public abstract String getHouseColor();
    public abstract String getMaterial();
}

Step2.定义一个子类Worker，并实现抽象类方法

public class Worker extends DrawMap{
    @Override
    public String getHouseType() {
        return "乡村小别墅";
    }

    @Override
    public String getHouseColor() {
        return "五颜六色";
    }

    @Override
    public String getMaterial() {
        return "钢筋水泥";
    }
}

Step3.最后我们在主程序MyClass中创建子类Worker的一个对象xw，实现父类方法build()

public static void main(String[] args) {
        Worker xw = new Worker();
        xw.buildHouse();
    }

打印结果：即将使用钢筋水泥造一个五颜六色的乡村小别墅

总结

1.单例设计模式全程最多涉及一个对象的创建和销毁，对性能和内存影响小，不容易出现错误；
2.抽象类Abstract模板设计模式可以为子类提供一个公用的模板，可以随意创建对象并使用抽象方法，体现了代码的简介性。