Java后端笔记18

设计模式

import com.xiye.bean.Camera;
import com.xiye.bean.MySingleMode;
import com.xiye.bean.MyTemplateModeChild;
import com.xiye.factory.impl.AppleFactory;
import com.xiye.factory.impl.PearFactory;
import com.xiye.service.Fruit;

/**
 * Create by xiye on 2019/12/11 11:42
 */
public class Demo2_设计模式 {
    /*设计模式
    *   装饰设计模式：不改变原对象，新的对象扩展原对象没有的一些属性、方法。
    *       其实就是在新的对象中引入原对象作为其属性，新对象在定义自己新的方法、属性之类的
    *   单例模式：创建单实例
    *       饿汉式：间接获取实例，不直接通过new的方式创建获取。缺点是无论是否使用，都会创建实例
    *       懒汉式：优化饿汉式的缺点，就是用的时候再实例一个对象。缺点是存在线程隐患。
    *       登记式：优化懒汉式的缺点
    *   模板设计模式
    *   工厂设计模式：目的实现解耦
    *   适配器设计模式：就是适配器抽象类实现某个接口，并实现接口的部分抽象方法，
    *                这些方法是具体的类不需要的，之后具体类继承适配器抽象类，
    *                实现适配器抽象类没有实现的抽象方法即可（就是实现具体类想要的方法）
    *   策略设计模式、代理设计模式。。。
    *
    * */
    public static void main(String[] args) {
        //singleMode();

        templateMode();

        //factoryMode();

        //adapterMode();
    }

    private static void adapterMode() {
        Camera camera = new Camera();
        camera.photo();
    }

    private static void factoryMode() {
        AppleFactory appleFactory = new AppleFactory();
        Fruit apple = appleFactory.createFactory();
        apple.show();

        PearFactory pearFactory = new PearFactory();
        Fruit pear = pearFactory.createFactory();
        pear.show();
    }

    private static void singleMode() {
        MySingleMode instance = MySingleMode.getInstance();
        System.out.println(instance.hashCode());
        //instance.test();
        MySingleMode instance1 = MySingleMode.getInstance();
        //instance1.test();
        System.out.println(instance1.hashCode());
    }

    private static void templateMode() {
        MyTemplateModeChild mtmc = new MyTemplateModeChild();
        // 调用功能方法，这个就是功能模板
        mtmc.common();
    }
}

单例模式

package com.xiye.bean;

/**
 * Create by xiye on 2019/12/11 12:05
 */
public class MySingleMode {

    private MySingleMode(){}        // 私有防止被访问

    /*// 单例模式——饿汉式
    // 无论是否使用，都会创建一个实例
    private static MySingleMode singleMode = new MySingleMode();


    public static MySingleMode getInstance() {
        return singleMode;
    }

    public void test() {
        System.out.println("单例模式——饿汉式");
    }*/

    /*
    // 单例模式——懒汉式
    private static MySingleMode singleMode;

    public static MySingleMode getInstance() {
        if (singleMode == null) {
            // 优化饿汉式，使用时才会创建实例
            singleMode = new MySingleMode();
        }
        return singleMode;
    }

    public void test() {
        System.out.println("单例模式——懒汉式");
    }*/

    // 单例模式——登记式：解决懒汉式线程隐患问题??????
    private static class InnerClass {
        private static final MySingleMode SINGLE_MODE = new MySingleMode();
    }

    public static MySingleMode getInstance() {
    	// 是否是因为每次都新建一个对象，所以线程安全？？？
        return InnerClass.SINGLE_MODE;
    }

    public void test() {
        System.out.println("单例模式——登记式");
    }
}

模板模式

模板

package com.xiye.bean;

/**
 * Create by xiye on 2019/12/11 15:12
 */
public abstract class MyTemplateMode {
	// 模板功能块
    public final void common() {
        study();
        work();
        love();
    }

    /*
    * 学习要认真
    * */
    public void study(){
        System.out.println("学习拔尖，综合优秀");
    }

    /*
    * 工作要做好
    * */
    public void work(){
        System.out.println("工作兢兢业业");
    }

    /*
    * 爱情是*的
    * */
    public abstract void love();
}

子类继承并重写部分方法

package com.xiye.bean;

/**
 * Create by xiye on 2019/12/11 15:17
 */
public class MyTemplateModeChild extends MyTemplateMode {
    @Override
    public void love() {
        System.out.println("爱情永恒不变");
    }

    @Override
    public void study() {
        System.out.println("学习够用就行");
    }
}

工厂模式

定义水果接口

package com.xiye.service;

/**
 * Create by xiye on 2019/12/11 15:29
 */
public interface Fruit {
    void show();
}

实现接口

package com.xiye.service.impl;

import com.xiye.service.Fruit;

/**
 * Create by xiye on 2019/12/11 15:32
 */
public class Apple implements Fruit {
    @Override
    public void show() {
        System.out.println("我是????");
    }
}

package com.xiye.service.impl;

import com.xiye.service.Fruit;

/**
 * Create by xiye on 2019/12/11 15:32
 */
public class Pear implements Fruit {
    @Override
    public void show() {
        System.out.println("我是梨");
    }
}

定义水果工厂接口

package com.xiye.factory;

import com.xiye.service.Fruit;

/**
 * Create by xiye on 2019/12/11 15:29
 */
public interface FruitFactory {
    Fruit createFactory();
}

实现工厂接口，每个工厂生成（创建）自己的对象

package com.xiye.factory.impl;

import com.xiye.factory.FruitFactory;
import com.xiye.service.Fruit;
import com.xiye.service.impl.Apple;

/**
 * Create by xiye on 2019/12/11 15:31
 */
public class AppleFactory implements FruitFactory {
    @Override
    public Fruit createFactory() {
        return new Apple();
    }
}

package com.xiye.factory.impl;

import com.xiye.factory.FruitFactory;
import com.xiye.service.Fruit;
import com.xiye.service.impl.Apple;
import com.xiye.service.impl.Pear;

/**
 * Create by xiye on 2019/12/11 15:31
 */
public class PearFactory implements FruitFactory {
    @Override
    public Fruit createFactory() {
        return new Pear();
    }
}

适配器模式

定义电子接口

package com.xiye.factory;

/**
 * Create by xiye on 2019/12/11 16:28
 */
public interface Electronics {

    void music();
    void game();
    void call();
    void photo();
}

定义适配器抽象类，去除具体类不需要的功能

package com.xiye.bean;

import com.xiye.factory.Electronics;

/**
 * Create by xiye on 2019/12/11 16:27
 */
public abstract class CameraAdapter implements Electronics {
    /*
    * 实现照相机不需要的功能方法
    * */
    @Override
    public void music() {

    }

    @Override
    public void game() {

    }

    @Override
    public void call() {

    }
}

定义具体类，继承对应适配器，只需实现自己该有的功能

package com.xiye.bean;

/**
 * Create by xiye on 2019/12/11 16:33
 */
public class Camera extends CameraAdapter {
    @Override
    public void photo() {
        System.out.println("照相机只能拍照啦");
    }
}