设计模式

设计模式（Designpattern）是一套被反复使用、多数人知晓的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

1.简单工厂模式

工厂模式是由一个工厂对象决定创建出哪一个具体实例，就比若像苹果手机生产6s,把方法给富士康代工厂生产6s。

创建一个手机的抽象父类

public abstract class Phone {
public int size;
public Phone(int size) {
super();
this.size = size;
}
public abstract void descript();
}

public class PhoneFactory {
public static Phone createPhone(){
Phone  phone = null;
phone = new IPhone(256);
return phone;
}
}

public class IPhone extends Phone{
public IPhone(int size) {
super(size);
}
public void descript() {
System.out.println("生产了一个6s");
}
}

public class Test {
public static void main(String[] args) {
Phone iphone6s= PhoneFactory.createPhone();
iphone6s.descript();
}
}

2.工厂模式

工厂模式是简单工厂模式的升级版，比如苹果跟华为旗下手机产品同时交给富士康生产，需要一个抽象工厂父类，两个具体工厂类继承，然后再进行生产。

3.单例模式

单例设计模式分为饿汉式跟懒汉式，一般情况下懒汗式用的比较多

保证当前类有且仅有一个对象，不允许被创建多个实例

public class Student {
public String name;
//1.构造方法私有化
private Student(){}
private Student(String name){
this.name = name;
}
//2.提供唯一的对象
private static Student stu;
//3.提供一个get实例的函数
public static synchronized Student getInstance(String n){
if(stu==null){
stu = new Student(n);
}
return stu;
}
}

3.装饰者模式

在不必改变原类文件和使用的情况下，动态的拓展一个对象的功能他是通过创建一个包装对象，

也就是装饰来包裹真实的对象。

比如我们去买手抓饼，一个原味的手抓饼可以添加青菜、肉丝、鱼、火腿、牛肉来丰富口味。

创建一个手抓饼类

public interface Cake {
public String description();
}

public class GraspCake implements Cake{
public String description() {
return "您点了一个原味手抓饼";
}
}

public abstract class Decorator implements Cake{
private Cake cake;
public Decorator(Cake cake){
this.cake = cake;
}
public String description() {
return cake.description();
}

为手抓饼添加牛排

public class BeefDecorator extends Decorator{
public BeefDecorator(Cake cake) {
super(cake);
}
public String description() {
return super.description()+"+牛排";
}

}

4.观察者模式

左哥给我们上课，左哥是观察者，我们是被观察者。它的好处就像：左哥需要把考试成绩发给我们只需要在QQ群发一次就可以而不需要一个个发。

观察者的抽象父类

public interface Watcher {
public void addObserver(Observer obs);
public void removeObserver(Observer obs);
public void notifys(String msg);
}

被观察者的抽象父类

public interface Observer {
public void reciveMsg(String msg);
}

观察者的实体类

public class Teacher implements Watcher{
private ArrayList<Observer> list = new ArrayList<Observer>();
public void addObserver(Observer obs) {
list.add(obs);
}
public void removeObserver(Observer obs) {
list.remove(obs);
}
public void notifys(String msg) {
//遍历队列，并通知到位每一个被观察对象
for (Observer obs : list) {
obs.reciveMsg(msg);
}
}
}

被观察者的实体类

public class Student implements Observer{
private String name;
public Student(String name) {
this.name = name;
}
public void reciveMsg(String msg) {
System.out.println(name+"收到一条消息:"+msg);

}
}

总结以上几个模式的使用可以可以发现几点好处

降低代码的耦合性，提升软件的拓展，让软件更容易维护。使代码编制真正工程化、统一化