4种设计模式

1、工厂设计模式

package objects;

/*
*   工厂模式
*       降低使用者和被使用者之间的依赖:比如被使用者改变了可能会使得使用者报错
*       (原理：通过建立新的工厂类，创建返回父类的方法，参数为子类的名字，具体的返回为实现的子类-多态)
* */
public class FactroyPattern {
    public static void main(String[] args) {
        product phone1 = productFactory.getProduct("phone");
        if (phone1!=null){
            phone1.making();
        }
    }
}

//使用工厂
class productFactory{
    public static product getProduct(String name){
        if ("phone".equals(name)){
            return new phone();
        } else if ("tv".equals(name)) {
            return new tv();
        }else {
            return null;
        }
    }
}


abstract class product{
    abstract public void making();
}
class phone extends product{
    public void making(){
        System.out.println("正在制造手机");
    }
}
class tv extends product{
    public void making(){
        System.out.println("正在制造电视");
    }
}

2、适配器模式

package objects;

/*
*   适配器:
*   (某个方法需要确定的某个类型的接口A，但是现在想要匹配另一种接口B，所以建立适配器类实现接口A，
*   在适配器类中定义新接口属性B，并初始化；在适配器类的实现方法中，传入B的功能。)
*
* */
public class AdapterPattern {
    public static void main(String[] args) {
        //例子1
        animalMethod dog = new dog();
        dog.eat();
        System.out.println("----------");
        //例子2
        EarPhoneTYPEC c = new typec();
        UseEarPhone(c);//使用手机本来的TypeC接口
        System.out.println("----------");
        //-----------------------------------
        //UseEarPhone(old35); //出错，手机不支持3.5mm耳机
        //使用适配器
        EarPhoneOld35 old35 = new Old35();
        Adapter adapter = new Adapter(old35);
        UseEarPhone(adapter);
    }
    //手机仅支持TypeC接口！
    public static void UseEarPhone(EarPhoneTYPEC c){
        System.out.println("请插入耳机...");
        c.insert();
        System.out.println("插入完成...");
    }
}


//1、例子
interface animal{
    public void eat();
    public void shot();
}
// 适配器：通过建立方法和接口一样的抽象类，用子类继承抽象类，就不用实现所有接口中的方法
abstract class animalMethod{
    public void eat(){};
    public void shot(){};
}
class dog extends animalMethod{
    //狗不会开枪，所以如果直接实现接口（需要实现所有行为）会浪费
    public void eat(){
        System.out.println("小狗吃骨头");
    }
}

//2、例子
//适配器：通过建立新的类实现手机支持的TypeC接口,类中定义3.5mm耳机属性
class Adapter implements EarPhoneTYPEC{
    private EarPhoneOld35 old35;
    public Adapter(EarPhoneOld35 old35) {
        this.old35 = old35;
    }
    public void insert(){
        old35.insert();
    }
}

// TypeC接口的耳机
interface EarPhoneTYPEC{
    public void insert();
}
class typec implements EarPhoneTYPEC{
    public void insert(){
        System.out.println("成功插入TypeC口耳机");
    }
}
// 3.5mm的耳机
interface EarPhoneOld35{
    public void insert();
}
class Old35 implements EarPhoneOld35{
    public void insert(){
        System.out.println("成功插入3.5mm耳机");
    }
}

3、代理模式

package objects;

/*
*   静态代理模式
*       为其他对象提供一种代理来控制对这个对象的访问
*       (原理：子类和代理子类继承同一个类或接口，在代理子类中创建使用父类引用属性（组合），重写父类方法，
*       传参的时候可以传入子类)
* */
public class ProxyPattern {
    public static void main(String[] args) {
        proxyWork user1 = new proxyWork(new userWork());
        user1.doWork();
    }
}

//代理类也继承父类
class proxyWork implements work{
    private work target; //被代理的对象（使用接口引用，方便多态）
    //构造函数初始化
    public proxyWork(work target){
        this.target = target;
    }
    //重写
    public void doWork(){
        //这里举例使用检查工作时间
        long beginTime = System.currentTimeMillis();
        target.doWork();
        long endTime = System.currentTimeMillis();
        System.out.println("工作时长："+(endTime-beginTime));
    }

}

interface work{
    public void doWork();
}
class userWork implements work{
    public void doWork(){
        System.out.println("用户开始干活...");
    }
}

4、策略模式

package objects;

/*
*   策略模式
*       定义一系列算法，将每一种算法封装起来并且可以相互替换使用
*       让算法独立于他的客户应用而独立变化
*       一个接口多个实现，可以按运行时需求替换，可维护性变强，新增接口不会影响其它实现类
*   （原理：定义接口及其实现，定义抽象类并在其中创建接口属性，然后实例化接口（构造函数或set），
*    在类方法中调用接口的方法。在psvm中，创建抽象类的子对象，仅需调用类方法，通过实例化的时候，
*    传入不同类型的接口实现类，就可以实现不同的功能。）
* */
public class StrategyPattern {
    public static void main(String[] args) {
        BaseService user01 = new userServie();//多态
        user01.setIsave(new NetSave());//初始化，只需更改这里的参数就实现不同的功能
        user01.add("data");
    }
}
//把可变的行为抽象出来，定义的一系列算法（i.e.一个接口，多个实现）
interface ISave{
    abstract void save(String data);
}
class FileSave implements ISave{
     public void save(String data){
        System.out.println("保存到文件中..."+data);
    }
}
class NetSave implements ISave{
    public void save(String data) {
        System.out.println("保存到网页中..."+data);
    }
}
//
abstract class BaseService{
    //使用组合
    private ISave isave;
    //初始化，这里使用set方法
    public void setIsave(ISave isave){
        this.isave = isave;
    }
    public void add(String data){
        System.out.println("检测数据合法性...");
        isave.save(data);
        System.out.println("保存成功");
    }
}
class userServie extends BaseService{

}