【两种设计模式概述】

设计方式(对修改关闭，对扩展开放)

模板设计方式（用来理解抽象类）

该模式的主要优点如下：
它封装了不变部分，扩展可变部分。它把认为是不变部分的算法封装到父类中实现，而把可变部分算法由子类继承实现，便于子类继续扩展。
它在父类中提取了公共的部分代码，便于【代码复用】。
部分方法是由子类实现的，因此子类可以通过扩展方式增加相应的功能，符合开闭原则。
该模式的主要缺点如下。
对每个不同的实现都需要定义一个子类，这会导致类的个数增加，系统更加庞大，设计也更加抽象，间接地增加了系统实现的复杂度。
父类中的抽象方法由子类实现，子类执行的结果会影响父类的结果，这导致一种反向的控制结构，它提高了代码阅读的难度。
由于继承关系自身的缺点，如果父类添加新的抽象方法，则所有子类都要改一遍。

public abstract class Prisoner {
    String name;
    abstract void eat() ;
    abstract void play() ;
    abstract void drink() ;
    abstract void happy() ;
    public void fun(){
        eat();
        drink();
        play();
        happy();
    }
}

public class StarPrisoner extends Prisoner{
    public StarPrisoner(String name) {
        this.name=name;
    }
    @Override
    void eat() {
    	System.out.println("妈的"+name+"吃");}
    @Override
    void play() {
    	System.out.println("妈的"+name+"玩");}

    @Override
    void drink() {
        System.out.println("妈的"+name+"喝");
    }
    @Override
    void happy() {
        System.out.println("妈的"+name+"乐");
    }
}

public class vistor {
    public void visit(){
            StarPrisoner starPrisoner=new StarPrisoner("克里斯汀·斯图尔特");
            starPrisoner.fun();
}
    public static void main(String[] args) {
        vistor vistor=new vistor();
        vistor.visit();
    }
}

策略设计方式（用来理解接口类）

对于策略模式能更好的体现出相互的低耦合，高内聚但是代码实现方式也就更不容易

public interface Compare {
    Integer comper(Object object1, Object object2);
}

public class CompareAge implements Compare{

    public Integer comper(Object object1, Object object2) {
        User user1 = null;
        User user2 = null;
        if (object1 instanceof User && object2 instanceof User) {
            user1 = (User) object1;
            user2 = (User) object2;
        } else {
            return null;
        }
        return user1.getAge() - user2.getAge();
    }
}

public class Comparable {
    public void sort(User[] users,Compare compare){
        for (int i = 0; i < users.length-1; i++) {
            for (int j = 0; j <users.length-i-1 ; j++) {
                if (compare.comper(users[j],users[j+1])>0){
                    User temp=users[j];
                    users[j]=users[j+1];
                    users[j+1]=temp;
                }

            }
        }
    }
}

public class User {
    private String name;
    private  Integer age;
    private  Double height;

    public User() {
    }
    public User(String name, Integer age, Double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }
    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Double getHeight() {
        return height;
    }

    public void setHeight(Double height) {
        this.height = height;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }
}

public class Test {
    public static void main(String[] args) {
        User user1=new User("张牛逼",12,1.83);
        User user2=new User("马牛逼",17,1.3);
        User user3=new User("王牛逼",13,1.9);
        User user4=new User("赵牛逼",16,1.45);
        User[] users={user1,user2,user3,user4};
        Comparable comparable=new Comparable();
        comparable.sort(users,new CompareAge());
        for (int i = 0; i < users.length; i++) {
            System.out.println(users[i]);
        }
    }
}