设计模式

工厂设计模式

equalsIgnoreCase()比较字符串和对象的方法，不计大小写
工厂设计模式就是根据if-else包装起来的方法，来生产出想要的东西。

public interface Shape {
    void draw();
}

public class Rectangle implements Shape{
    @Override
    public void draw() {
        System.out.println("我画出了一个矩形");
    }
}

public class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("我画出了一个圆");
    }
}

public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("我画出了一个正方形");
    }
}

public class ShapeFactory {
    public Shape getShape(String shape){
        if(shape == null){
            return null;
        }else if(shape.equalsIgnoreCase("Circle")){
            return new Circle();
        }else if(shape.equalsIgnoreCase("Rectangle")){
            return new Rectangle();
        }else if(shape.equalsIgnoreCase("Square")){
            return new Square();
        }
        return null;
    }
}

public class TestShape {
    public static void main(String[] args){
        ShapeFactory sf = new ShapeFactory();
        Shape shape1 = sf.getShape("Circle");
        shape1.draw();
        Shape shape2 = sf.getShape("Rectangle");
        shape2.draw();
        Shape shape3 = sf.getShape("Square");
        shape3.draw();
    }
}

 抽象工厂设计模式

比工厂设计模式，多了一个创建工厂的工厂。

　　

abstract class AbstractFactory {
    abstract Shape getShape(String shape);

    abstract Printer getPrinter(String print);
}

public interface Shape {
    void draw();
}

public interface Printer {
    void print();
}

class Square implements Shape{
    @Override
    public void draw() {
        System.out.println("我画了一个正方形");
    }
}
class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("我画了一个圆");
    }
}

class PaperPrint implements Printer{
    @Override
    public void print() {
        System.out.println("我用纸输出");
    }
}
class WebPrint implements Printer{
    @Override
    public void print() {
        System.out.println("我用web输出");
    }
}

public class FactoryProducer {
    public static AbstractFactory getFactory(String choice){
        if(choice==null){
            return null;
        }else if(choice.equalsIgnoreCase("Printer")){
            return new PrinterFactory();
        }else if(choice.equalsIgnoreCase("Shape")){
            return new ShapeFactory();
        }
        return null;
    }
}

public class ShapeFactory extends AbstractFactory{
    @Override
    Shape getShape(String shape) {
        if(shape==null){
            return null;
        }else if(shape.equalsIgnoreCase("Square")){
            return new Square();
        }else if(shape.equalsIgnoreCase("Circle")){
            return new Circle();
        }
        return null;
    }

    @Override
    Printer getPrinter(String print) {
        return null;
    }
}

public class PrinterFactory extends AbstractFactory{
    @Override
    Shape getShape(String shape) {
        return null;
    }

    @Override
    Printer getPrinter(String print) {
        if(print==null){
            return null;
        }else if(print.equalsIgnoreCase("WebPrint")){
            return new WebPrint();
        }else if(print.equalsIgnoreCase("PaperPrint")){
            return new PaperPrint();
        }
        return null;
    }
}

public class TestAbstratFactory {
    public static void main(String[] args) {
        AbstractFactory af = FactoryProducer.getFactory("Printer");
        Printer p = af.getPrinter("WebPrint");
        p.print();
        AbstractFactory af1 = FactoryProducer.getFactory("Shape");
        Shape shape = af1.getShape("Circle");
        shape.draw();
    }
}

　　

单例设计模式

单例模式是一种创建模式。

这种模式只涉及一个单独的类，它负责创建自己的对象。

该类确保只创建单个对象。

这个类提供了一种访问其唯一对象的方法。

public class MainWindows {
    //私有化构造器
    private MainWindows(){

    }
    private static MainWindows instance = new MainWindows();

    public  static MainWindows getInstance(){
        return instance;
    }
    public void show(){
        System.out.println("跳支舞吧");
    }
}

    public static void main(String[] args) {
        MainWindows mw = MainWindows.getInstance();
        mw.show();
    }

　　

代理设计模式

在代理模式中，一个类代表另一个类的功能。

代理模式是一种结构模式。

在代理模式中，我们创建具有原始接口的对象，以将其功能暴露给外部世界。

public interface Printer {
    void print();
}

class ConsolePrinter implements  Printer{
    private String fileName;

    public ConsolePrinter(String fileName) {
        this.fileName = fileName;
    }


    @Override
    public void print() {
        System.out.println("display: " + fileName );
    }
}

class ProxyPrinter implements Printer{
    private String fileName;
    private ConsolePrinter cp;

    public ProxyPrinter(String fileName) {
        this.fileName = fileName;
    }

    @Override
    public void print() {
        if(cp == null){
            cp = new ConsolePrinter(fileName);
        }
        cp.print();
    }
}

class test{
    public static void main(String[] args) {
        Printer p = new ProxyPrinter("yhs");
        p.print();
    }
}

　　

观察者设计模式

观察者模式用于在一个对象被修改时通知其相关对象。

观察者模式是一种行为模式类别。

public class MyValue {
    private List<Observer> observers = new ArrayList<Observer>();
    private int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        notifyAllObservers();
    }

    public void attach(Observer observer){
        observers.add(observer);
    }

    public void notifyAllObservers(){
        for (Observer observer:observers) {
            observer.update();
        }
    }
}

abstract class Observer{
    protected  MyValue subject;
    public abstract void update();
}

class PrinterObserver extends Observer{
   public PrinterObserver(MyValue subject){
       this.subject = subject;
       this.subject.attach(this);
   }

    @Override
    public void update() {
        System.out.println("Printer: " + subject.getState() );
    }
}
class EmailObserver extends  Observer{
    public EmailObserver(MyValue subject){
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("Email: " + subject.getState() );
    }
}
class FileObserver extends Observer{
    public FileObserver(MyValue subject){
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("FileObserver: " + subject.getState() );
    }
}

 class main{
     public static void main(String[] args) {
         MyValue subject = new MyValue();
         new FileObserver(subject);
         new EmailObserver(subject);
         new PrinterObserver(subject);

         subject.setState(15);//15 15 15
         subject.setState(10);//10 10 10
     }
}

　　

MVC模式

• Model（模型）- 模型表示携带数据的对象。它也可以具有逻辑来更新控制器，如果其数据改变。

• View（视图）- 视图表示模型包含的数据的可视化。通常它有UI逻辑。

• Controller（控制器） - 控制器引用模型和视图。它控制数据流进入模型对象，并在数据更改时更新视图。它保持视图和模型分开。

public class Employee {
    private String id;
    private String name;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class EmployeeView {
    public void printEmployeeDetails(String name,String no){
        System.out.println("Employee: ");
        System.out.println("Name: " + name);
        System.out.println("ID: " + no);
    }
}

public class EmployeeController {
    private Employee model;
    private EmployeeView view;

    public EmployeeController(Employee model, EmployeeView view) {
        this.model = model;
        this.view = view;
    }

    public void setEmployeeName(String name){
        model.setName(name);
    }
    public String getEmployeeName(){
        return model.getName();
    }
    public void setEmployeeId(String no){
        model.setId(no);
    }
    public String getEmployeeId(){
        return model.getId();
    }
    public void updateView(){
        view.printEmployeeDetails(model.getName(),model.getId());
    }
}

    public static void main(String[] args) {
        Employee model = new Employee();
        model.setName("Tom");
        model.setId("1");
        EmployeeView view = new EmployeeView();
        EmployeeController controller = new EmployeeController(model,view);
        controller.updateView();
        controller.setEmployeeName("New Name");
        controller.updateView();
    }