部分设计模式案例代码

抽象工厂模式

package abstractFactory;

public class Client {
    public static void main(String[] args) {
        abstractFactory shuijing=new ShuiJingFactory();
        System.out.println(shuijing.newShuiJing("bing").type("bing"));
        System.out.println(shuijing.newShuiJing("zhu").type("zhu"));
        System.out.println(shuijing.newShuiJing("xian").type("xian"));
        System.out.println("===========================");
        abstractFactory bianping=new BianPingFactory();
        System.out.println(bianping.newBianPing("bing").type("bing"));
        System.out.println(bianping.newBianPing("zhu").type("zhu"));
        System.out.println(bianping.newBianPing("xian").type("xian"));
    }

}
abstract class abstractFactory{
    public abstract ShuiJing newShuiJing(String type);
    public abstract BianPing newBianPing(String type);
}
class ShuiJingFactory extends abstractFactory{

    @Override
    public ShuiJing newShuiJing(String type) {
        if(type=="bing"){
            return new SBing();
        }else if (type=="zhu"){
            return new SZhu();
        }else if (type=="xian"){
            return new SXian();
        }return null;
    }

    @Override
    public BianPing newBianPing(String type) {
        return null;
    }
}
class BianPingFactory extends abstractFactory{

    @Override
    public ShuiJing newShuiJing(String type) {
        return null;
    }

    @Override
    public BianPing newBianPing(String type) {
        if(type=="bing"){
            return new BBing();
        }else if (type=="zhu"){
            return new BZhu();
        }else if (type=="xian"){
            return new BXian();
        }return null;
    }
}

interface ShuiJing{
    public String type(String type);
}
class SBing implements ShuiJing{
    @Override
    public String type(String type) {
        return "水晶样式的饼状图。";
    }
}
class SZhu implements ShuiJing{
    @Override
    public String type(String type) {
        return "水晶样式的柱状图。";
    }
}
class SXian implements ShuiJing{
    @Override
    public String type(String type) {
        return "水晶样式的线状图。";
    }
}



interface BianPing{
    public String type(String type);
}
class BBing implements BianPing{
    @Override
    public String type(String type) {
        return "扁平样式的饼状图。";
    }
}
class BZhu implements BianPing{
    @Override
    public String type(String type) {
        return "扁平样式的柱状图。";
    }
}
class BXian implements BianPing{
    @Override
    public String type(String type) {
        return "扁平样式的线状图。";
    }
}

桥

package bridge;

public class Client {
    public static void main(String[] args) {
        ManagerDalao jsionMysql=new jsonLog(new MySQL());
        ManagerDalao xmlMysql=new xmlLog(new MySQL());
        System.out.println(jsionMysql.dBimpl.search());
        System.out.println(jsionMysql.dBimpl.insert());
        System.out.println(jsionMysql.dBimpl.update());
        System.out.println(jsionMysql.dBimpl.delete());
        System.out.println(jsionMysql.log());
        System.out.println(xmlMysql.log());

        System.out.println("-------------------------------");
        ManagerDalao jsionOracle=new jsonLog(new Oracle());
        ManagerDalao xmlOracle=new xmlLog(new Oracle());
        System.out.println(jsionOracle.dBimpl.search());
        System.out.println(jsionOracle.dBimpl.insert());
        System.out.println(jsionOracle.dBimpl.update());
        System.out.println(jsionOracle.dBimpl.delete());
        System.out.println(jsionOracle.log());
        System.out.println(xmlOracle.log());
    }
}

//抽象层
abstract class ManagerDalao{
    DBimpl dBimpl;
    public ManagerDalao(DBimpl dBimpl){
        this.dBimpl=dBimpl;
    }
     abstract String log();
}
class jsonLog extends ManagerDalao{

    //构造方法 初始化父类的变量
    public jsonLog(DBimpl dBimpl) {
        super(dBimpl);
    }

    @Override
    String log() {
        return "输出了jsion日志。";
    }
}
class xmlLog extends ManagerDalao{
    //构造方法 初始化父类的变量
    public xmlLog(DBimpl dBimpl) {
        super(dBimpl);
    }

    @Override
    String log() {
        return "输出了xml日志。";
    }
}

//实现层（封装以复用）
interface DBimpl{
    public String insert();
    public String delete();
    public String search();
    public String update();
}
class MySQL implements DBimpl{

    @Override
    public String insert() {
        return "MySQL添加成功！";
    }

    @Override
    public String delete() {
        return "MySQL删除成功！";
    }

    @Override
    public String search() {
        return "MySQL查找成功！";
    }

    @Override
    public String update() {
        return "MySQL更新成功！";
    }
}
class Oracle implements DBimpl{
    @Override
    public String insert() {
        return "Oracle添加成功！";
    }

    @Override
    public String delete() {
        return "Oracle删除成功！";
    }

    @Override
    public String search() {
        return "Oracle查找成功！";
    }

    @Override
    public String update() {
        return "Oracle更新成功！";
    }
}





































interface DrawAPI {
    public void drawCircle(int radius, int x, int y);
}

class RedCircle implements DrawAPI {
    @Override
    public void drawCircle(int radius, int x, int y) {
        System.out.println("画一个红色的圆, radius: "
                + radius +", x: " +x+", "+ y +"]");
    }
}

class GreenCircle implements DrawAPI {
    @Override
    public void drawCircle(int radius, int x, int y) {
        System.out.println("画一个绿色的圆, radius: "
                + radius +", x: " +x+", "+ y +"]");
    }
}

abstract class Shape {
    protected DrawAPI drawAPI;
    protected Shape(DrawAPI drawAPI){
        this.drawAPI = drawAPI;
    }
    public abstract void draw();
}

class Circle extends Shape {
    private int x, y, radius;

    public Circle(int x, int y, int radius, DrawAPI drawAPI) {
        super(drawAPI);
        this.x = x;
        this.y = y;
        this.radius = radius;
    }

    public void draw() {
        drawAPI.drawCircle(radius,x,y);
    }
}

责任链

package chain_of_responsibility;

public class Client {
    public static void main(String[] args) {
        OrderDo orderDo=new A();
        OrderDo orderDo1=new B();
        OrderDo orderDo2=new C();
        orderDo.setOrderDo(orderDo1);
        orderDo1.setOrderDo(orderDo2);
        orderDo.todo(25);
    }
}

abstract class OrderDo{
    private OrderDo orderDo;
    public abstract boolean todo(int day);
    protected boolean toNext(int day){
        if(orderDo!=null){
            return orderDo.todo(day);
        }else {
            System.out.println("责任链处理完成！");
            return true;
        }
    }

    public void setOrderDo(OrderDo next){
        this.orderDo=next;
    }
}

class A extends OrderDo{
    @Override
    public boolean todo(int day) {
        if (day>5){
            System.out.println("大于5天，下一个！");
            //setOrderDo(new B());
            return toNext(day);
        }else {
            System.out.println("小于5天，批准！");
            return true;
        }
    }
}
class B extends OrderDo{
    @Override
    public boolean todo(int day) {
        if (day>10){
            System.out.println("大于10天，下一个！");
            //setOrderDo(new C());
            return toNext(day);
        }else {
            System.out.println("小于10天，批准！");
            return true;
        }
    }
}
class C extends OrderDo{
    @Override
    public boolean todo(int day) {
        if (day>20){
            System.out.println("大于20天，不批！");
            return false;
        }else {
            System.out.println("小于20天，批准！");
            return true;
        }
    }
}

组合

package composite;

import java.util.ArrayList;
import java.util.List;

public class Client {
    public static void main(String[] args) {
        Folder folder1=new Folder("小文件夹");
        Document doc=new Document("啊.doc",100);
        Document pdf=new Document("呵.pdf",200);
        folder1.addFile(doc);
        folder1.addFile(pdf);

        Folder folder2=new Folder("大文件夹");
        folder2.addFile(folder1);
        folder2.addFile(doc);
        folder2.addFile(pdf);

        System.out.println(folder1.getFileName());
        System.out.println(folder1.getSize());
        System.out.println(doc.getFileName());
        System.out.println(doc.getSize());
        System.out.println(pdf.getFileName());
        System.out.println(pdf.getSize());

        System.out.println(folder2.getFileName());
        System.out.println(folder2.getSize());
    }
}

interface Files{
    public String getFileName();
    public int getSize();
}

class Document implements Files{

    private String fileName;
    private int size;

    public Document(String fileName, int size) {
        this.fileName = fileName;
        this.size = size;
    }

    @Override
    public String getFileName() {
        return fileName;
    }

    @Override
    public int getSize() {
        return size;
    }
}

class Folder implements Files{
    private String folderName;

    public Folder(String folderName) {
        this.folderName = folderName;
    }

    List<Files> lists=new ArrayList<Files>();
    public void addFile(Files file){
        lists.add(file);
    }
    public void removeFile(Files file){
        lists.remove(file);
    }

    @Override
    public String getFileName() {
        return folderName;
    }

    @Override
    public int getSize() {
        int size=0;
        for (int i = 0; i < lists.size(); i++) {
            size=lists.get(i).getSize()+size;
            //System.out.println(size);
        }
        return size;
    }
}

观察者

package observer;

import java.util.ArrayList;

public class Client {
}

//被观察者接口, 让WeatherData(被观察者) 来实现
interface Subjects{
    public void registerObserver(Observers o);
    public void removeObserver(Observers o);
    public void notifyObservers();
}

//观察者接口，由观察者来实现
interface Observers {
    public void update(int temperature, int pressure, int humidity);
}

/**
 * (被观察者)类是核心
 * 1. 包含最新的天气情况信息
 * 2. 含有 观察者集合，使用ArrayList管理
 * 3. 当数据有更新时，就主动的调用   ArrayList, 通知所有的（接入方）就看到最新的信息
 */
class WeatherDatas implements Subjects {
    private int temperatrue;
    private int pressure;
    private int humidity;
    //观察者集合
    private ArrayList<Observers> observers;

    //加入新的第三方
    public WeatherDatas() {
        observers = new ArrayList<Observers>();
    }

    public int getTemperatrue() {
        return temperatrue;
    }

    public int getPressure() {
        return pressure;
    }

    public int getHumidity() {
        return humidity;
    }

    public void dataChange() {
        //调用 接入方的 update
        notifyObservers();
    }

    //当数据有更新时，就调用 setData
    public void setData(int temperature,int pressure, int humidity) {
        this.temperatrue = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        //调用dataChange， 将最新的信息 推送给 接入方 currentConditions
        dataChange();
    }

    //注册一个观察者
    @Override
    public void registerObserver(Observers o) {
        observers.add(o);
    }

    //移除一个观察者
    @Override
    public void removeObserver(Observers o) {
        if(observers.contains(o)) {
            observers.remove(o);
        }
    }

    //遍历所有的观察者，并通知
    @Override
    public void notifyObservers() {
        for(int i = 0; i < observers.size(); i++) {
            observers.get(i).update(this.temperatrue, this.pressure, this.humidity);
        }
    }
}

//第一个客户端
class CurrentConditionss implements Observers {
    // 温度，气压，湿度
    private int temperature;
    private int pressure;
    private int humidity;

    // 更新 天气情况，是由 WeatherData 来调用，我使用推送模式
    public void update(int temperature, int pressure, int humidity) {
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        display();
    }

    // 显示
    public void display() {
        System.out.println("==新浪网站==");
        System.out.println("***今天的 mTemperature: " + temperature + "***");
        System.out.println("***今天的 mPressure: " + pressure + "***");
        System.out.println("***今天的 mHumidity: " + humidity + "***");
    }
}

//第二个客户端
class BaiduSites implements Observers {
    // 温度，气压，湿度
    private int temperature;
    private int pressure;
    private int humidity;

    // 更新 天气情况，是由 WeatherData 来调用，我使用推送模式
    public void update(int temperature, int pressure, int humidity) {
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        display();
    }

    // 显示
    public void display() {
        System.out.println("===百度网站====");
        System.out.println("***百度网站 气温 : " + temperature + "***");
        System.out.println("***百度网站 气压: " + pressure + "***");
        System.out.println("***百度网站 湿度: " + humidity + "***");
    }
}


class Clients {
    public static void main(String[] args) {
        //创建一个WeatherData
        WeatherDatas weatherDatas = new WeatherDatas();

        //创建观察者
        CurrentConditionss currentConditionss = new CurrentConditionss();
        BaiduSites baiduSites = new BaiduSites();

        //注册到weatherData
        weatherDatas.registerObserver(currentConditionss);
        weatherDatas.registerObserver(baiduSites);

        //测试
        System.out.println("通知各个注册的观察者, 看看信息");
        weatherDatas.setData(10, 100, 30);

        weatherDatas.removeObserver(currentConditionss);
        //测试
        System.out.println();
        System.out.println("通知各个注册的观察者, 看看信息");
        weatherDatas.setData(10, 100, 30);
    }
}

单例

package singleton;

public class Client {
    public static void main(String[] args) {
        System.out.println(Configuration.getInstance().string);
        System.out.println(Configuration.getInstance().count(2,3));
    }
}

class Configuration{
    public String string="这是单例模式。";
    protected static Configuration instance=new Configuration();
    private Configuration(){};
    public static Configuration getInstance(){
        return instance;
    }

    public int count(int a,int b){
        return a*b;
    }
}