关于JAVA23种模式设计

你们好！今天我分享一下JAVA中23种模式几个常用的模式。我简单介绍观察者模式、工厂模式、装饰模式、单例模式这4种模式。

观察者模式定义：一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知，此种模式通常被用来实现事件处理系统。

一般这种模式的架构创建观察者抽象父类和被观察者抽象父类，在子类写具体方法。

具体介绍一下：

例如：

/**

* 被观察者的父类抽象

*

*/

public interface Subject {

public ArrayList<Observer> obsList = new ArrayList<Observer>(); //建立一个数组存信息

public void addObserver(Observer obs); //创建3个类，会在具体类进行描述。

public void removeObserver(Observer obs);

public void notifyObserver(float price);

}

/**

* 被观察者的具体类

*

*/

public class IPhone20 implements Subject{

// 添加观察对象

public void addObserver(Observer obs) {

obsList.add(obs);

}

// 移除观察对象

public void removeObserver(Observer obs) {

obsList.remove(obs);

}

// 通知所有观察对象

public void notifyObserver(float price) {

for(Observer obs : obsList){

obs.eventOne(price);

}}}

/**

* 观察者父类抽象

*

*/

public interface Observer {

public void eventOne(float price);

}

/**

* 观察者的具体类

*

*/

public class Student implements Observer{

private String name;

public Student(String name){

this.name = name;

}

@Override

public void eventOne(float price) {

System.out.println(name+"同学你很幸运，苹果20周年降价了，现价："+price);

}}

//主函数，进行测试

public class Test {

public static void main(String[] args) {

//被观察者对象

Subject iphone = new IPhone10();

//观察者对象

Observer stu = new Student("小吴");

//观察者观察被观察者

iphone.addObserver(stu);

//手机降价了

iphone.notifyObserver(5999);

System.out.println("过了几天.....");

iphone.notifyObserver(4999);

2. 工厂模式：介绍一下静态工厂模式，顾名思义就是用静态方法实现的，比较简单！ 工厂模式是由一个工厂对象决定创建出哪一个具体实例。

具体例子：

/**

* 工厂类，用于代工生产实体对象

*

*/

public class Factory {

public static Computer createComputer(String model,String type,String size){

Computer computer = null;

//跟进传递的参数，创建不同类型的对象

if("taishi".equals(model)){

computer = new TaishiCompter(type,size);

}else if("nodebook".equals(model)){

computer = new NodeBookCompter(type,size);

}else if("pad".equals(model)){

computer = new PadComputer(type,size);

}else{

System.out.println("您提供的要求，我们完成不了，没这个技术!后续继续改进");}

return computer;

}}

/**

* 电脑类

*

*/

public abstract class Computer {

public String type;

public String size;

public Computer(String type, String size) {

super();

this.type = type;

this.size = size;}

//运行游戏的函数

public abstract void runGame();}

//电脑类的子类，笔记本电脑。

public class NodeBookCompter extends Computer{

public NodeBookCompter(String type, String size) {

super(type, size);

}

public void runGame() {

System.out.println(type+size+"运行游戏还行!");

}}

//电脑类的子类，台式电脑。

public class TaishiCompter extends Computer{

public TaishiCompter(String type, String size) {

super(type, size);

}

public void runGame() {

System.out.println(type+size+"运行游戏就是爽!");

}}

//测试类

public class Test {

public static void main(String[] args) {

//原始创建对象，耦合性太高

//工厂模式可以解耦，降低耦合性

//需要两台电脑

Computer comput1 = Factory.createComputer("taishi","戴尔","8G");

Computer comput2 = Factory.createComputer("nodebook","联想","16G");

comput1.runGame();

comput2.runGame();

3. 装饰模式：动态地给一个对象添加一些额外的职责。就增添功能来说，Decorator模式相比生成子类更为灵活。

/**

* 饼类，抽象父类

*

*/

public interface Cake {

//价格获取

public float price();

//描述

public String description();

}

public class CrasphingCake implements Cake{

public float price() {

return 3.0f;

}

public String description() {

return "ԭζ˖ץҽ";

}

}

/**

* 装饰者类

*

*/

public abstract class Decorator implements Cake{

//强关联Cake

private Cake cake;

public Decorator(Cake cake){

this.cake = cake;

}

public float price() {

return cake.price();

}

public String description() {

return cake.description();

}}

/**

* 鸡蛋装饰实体

*

*/

public class Egg extends Decorator{

public Egg(Cake cake) {

super(cake);

}

public float price() {

return super.price()+1.5f;

}

public String description() {

return super.description()+"+鸡蛋";

}}

/**

* 牛排装饰实体

*

*/

public class Beef extends Decorator {

public Beef(Cake cake) {

super(cake);

}

public float price() {

return super.price() + 2.0f;

}

public String description() {

return super.description()+"+牛排";

}

public String fire(){

return "牛排需要三分熟";

}}

public class Test {

public static void main(String[] args) {

//有个客户要买原味手抓饼

CrasphingCake cc = new CrasphingCake();

Beef bef = new Beef(cc);

bef.fire();

bef.price();

bef.description();

System.out.println("您选购的是："+bef.description());

System.out.println("您要支付："+bef.price()+"元");

}}

4.单例模式：保证当前类有且仅有一个对象，不允许被创建多个实例。

分类：饿汉式、懒汉式

实现思路：构造函数私有化

声明一个本类对象静态引用

提供获取当前实例的静态方法

/**

*

*单例模式

*/

public class Student {

private static Student stu = new Student();// 饿汉式

private Student() {

}

public static Student getInstance() {

return stu;

}}

public class Student1 {

private static Student1 stu;

private Student1() {

}

public static Student1 getInstance() {//
懒汉式 用线程使它出错 ,加上synchronized锁住就不会错

if (stu == null) {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

stu = new Student1();

}

return stu;

}}

public class Test {

// 单例

public static void main(String[] args) {

Student stu = Student.getInstance();

Student stu1 = Student.getInstance();

System.out.println(stu == stu1);

}

}

public class Test1 {

static Student1 stu, stu1;

public static void main(String[] args) {

Thread thread_A = new Thread() {

public void run() {

stu = Student1.getInstance();

System.out.println("-------A------");

}};

Thread thread_B = new Thread() {

public void run() {

stu1 = Student1.getInstance();

System.out.println("-------B------");

}};

thread_A.start();//
启动

thread_B.start();//
启动

try {

Thread.sleep(3000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(stu == stu1);

这些仅仅是自己学到与自己的见解，如果有不对的地方请多多指导，谢谢！