面试准备——java设计模式

1 总体来说，设计模式分为三大类：

设计模式（design pattern）是对软件设计中普遍存在（反复出现）的各种问题，所提出的解决方案。

创建型模式（五种）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式

结构型模式（七种）：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式

行为型模式（十一种）：策策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

2 常见的设计模式介绍：

Singleton（单例模式）

一句话总结：一个类在Java虚拟机中只有一个对象，并提供一个全局访问点。

解决什么问题：对象的唯一性，性能浪费太多。

项目里面怎么用：数据库连接对象，属性配置文件的读取对象。

模式结构：分为饿汉式和懒汉式（如果考虑性能问题的话，就使用懒汉式，因为懒汉式是在方法里面进行初始化的），构造器私 有化，对外提供方法加同步关键字。

饿汉式代码：

public class HurgrySingleton {
private static HurgrySingleton hurgry=new HurgrySingleton();
private HurgrySingleton(){};
     public static HurgrySingleton getSinletonHurgry(){
         return hurgry;
        }
}

懒汉式代码：

public class LarzySingleton {
   private static LarzySingleton larzy=null;
   private LarzySingleton(){};
   public static synchronized Larzy getSinletonLarzy(){
        if(larzy==null){
              larzy=new LarzySingleton();
        }
        return larzy;
    }
}

Factory（简单的工厂模式）

一句话总结：用一个方法来代替new关键字

解决什么问题：对象产生过多，或者经常有子类替换生成。

项目里面怎么用：对于经常生成的对象，或者父子类替换的对象。

模式结构：写一个对外声明的方法，方法里面使用new关键字代替。

框架里面使用：spring的核心就是工厂模式。

工厂方法模式：

有四个角色，抽象工厂模式，具体工厂模式，抽象产品模式，具体产品模式。不再是由一个工厂类去实例化具体的产品，而是由抽象工厂的子类去实例化产品

// 抽象产品角色
public interface Moveable {
    void run();
}

// 具体产品角色
public class Plane implements Moveable {
    @Override
    public void run() {
        System.out.println("plane....");
    }
}

public class Broom implements Moveable {
    @Override
    public void run() {
        System.out.println("broom.....");
    }
}

// 抽象工厂
public abstract class VehicleFactory {
    abstract Moveable create();
}

// 具体工厂
public class PlaneFactory extends VehicleFactory {
    public Moveable create() {
        return new Plane();
    }
}

public class BroomFactory extends VehicleFactory {
    public Moveable create() {
        return new Broom();
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        VehicleFactory factory = new BroomFactory();
        Moveable m = factory.create();
        m.run();
    }
}

抽象工厂模式：与工厂方法模式不同的是，工厂方法模式中的工厂只生产单一的产品，而抽象工厂模式中的工厂生产多个产品

//抽象工厂类
public abstract class AbstractFactory {
    public abstract Vehicle createVehicle();
    public abstract Weapon createWeapon();
    public abstract Food createFood();
}
//具体工厂类，其中Food,Vehicle，Weapon是抽象类，
public class DefaultFactory extends AbstractFactory{
    @Override
    public Food createFood() {
        return new Apple();
    }
    @Override
    public Vehicle createVehicle() {
        return new Car();
    }
    @Override
    public Weapon createWeapon() {
        return new AK47();
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        AbstractFactory f = new DefaultFactory();
        Vehicle v = f.createVehicle();
        v.run();
        Weapon w = f.createWeapon();
        w.shoot();
        Food a = f.createFood();
        a.printName();
    }
}
   

Proxy（代理模式）

一句话总结：为其他对象提供一个代理，以控制对当前对象的访问。

解决什么问题：不能直接访问该对象，或者太大的资源耗费多。

项目里面怎么用：权限，或者大对象的访问权限。

模式结构：代理类和被代理类实现同一个接口，用户访问的时候先访问代理对象，然后让代理对象去访问被代理对象。

框架里面使用：Spring里面的AOP实现。

代理模式代码：

创建一个接口：

public interface SellHouse {
    void sell(double money);
}

创建一个被代理类：

public class Hoster implements SellHouse {
        @Override
        public void sell(double money) {
            System.out.println("祝你居住愉快");
        }
    }

创建一个代理类：

public class Medium implements SellHouse {
    SellHouse hoster=new Hoster();
    @Override
    public void sell(double money) {
        if(money>=1000){
            hoster.sell(money);
        }else{
            System.out.println("你的价格太低了");
        }
    }
}

测试类：

public class Renter {
    public static void main(String[] args) {
        SellHouse renter=new Medium();
        renter.sell(500);
    }
}

Strategy（策略模式）

一句话总结：定义一系列算法并可以互相替换。

生活中的例子：图片的格式，压缩文件的格式。

解决什么问题：做一件事情有很多种方法。

项目里面怎么用：购物车里面的付款方式。

模式结构：声明一个顶级接口，定义一个策略方法，具体的实例都要实现这个接口。

定义一个顶级接口：

public interface Person {
    void repast();
}

具体的实例类1：

public class African implements Person {
    @Override
    public void repast() {
        System.out.println("非洲人用手吃饭");
    }
}

具体的实例类2：

public class America implements Person {
    @Override
    public void repast() {
        System.out.println("美国人用刀叉吃饭");
    }
}

具体的实例类3：

public class Chinese implements Person {
    @Override
    public void repast() {
        System.out.println("中国人用筷子吃饭");
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        Person chinese=new Chinese();
        Person america=new America();
        Person african=new African();
        chinese.repast();
        america.repast();
        african.repast();
    }
}

Adapter（适配器模式）

一句话总结：将两个原来不兼容的类兼容起来一起工作。

解决什么问题：已经存在的相同功能的代码，但是接口不兼容，不能直接调用。

项目里面怎么用：在使用旧的API的时候，没有源码，和新的不能兼容。

模式结构：分为类适配器和对象适配，一般常用的就是对象适配器，因为组合由于继承。

public class Test {
    public static void main(String[] args) {
        Phone phone = new Phone();
        VoltageAdapter adapter = new VoltageAdapter();
        phone.setAdapter(adapter);
        phone.charge();
    }
}

// 手机类
class Phone {

    public static final int V = 220;// 正常电压220v，是一个常量

    private VoltageAdapter adapter;

    // 充电
    public void charge() {
        adapter.changeVoltage();
    }

    public void setAdapter(VoltageAdapter adapter) {
        this.adapter = adapter;
    }
}

// 变压器
class VoltageAdapter {
    // 改变电压的功能
    public void changeVoltage() {
        System.out.println("正在充电...");
        System.out.println("原始电压：" + Phone.V + "V");
        System.out.println("经过变压器转换之后的电压:" + (Phone.V - 200) + "V");
    }
}

装饰者模式 

一句话总结：对已有的业务逻辑进一步的封装，使其增加额外的功能

Food类

public class Food {

    private String food_name;

    public Food() {
    }

    public Food(String food_name) {
        this.food_name = food_name;
    }

    public String make() {
        return food_name;
    };
}

几个子类

//面包类
public class Bread extends Food {

    private Food basic_food;

    public Bread(Food basic_food) {
        this.basic_food = basic_food;
    }

    public String make() {
        return basic_food.make()+"+面包";
    }
}

//奶油类
public class Cream extends Food {

    private Food basic_food;

    public Cream(Food basic_food) {
        this.basic_food = basic_food;
    }

    public String make() {
        return basic_food.make()+"+奶油";
    }
}

//蔬菜类
public class Vegetable extends Food {

    private Food basic_food;

    public Vegetable(Food basic_food) {
        this.basic_food = basic_food;
    }

    public String make() {
        return basic_food.make()+"+蔬菜";
    }

}

Test类

public class Test {
    public static void main(String[] args) {
        Food food = new Bread(new Vegetable(new Cream(new Food("香肠"))));
        System.out.println(food.make());
    }
}