设计模式(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);
}
}
总结以上几个模式的使用可以可以发现几点好处
降低代码的耦合性,提升软件的拓展,让软件更容易维护。使代码编制真正工程化、统一化