设计模式----单例模式-＞工厂模式-＞装饰器模式-＞代理模式-＞观察者模式-＞模块化模式，以FairyGUI的Ts模块为案例使用模块

最新推荐文章于 2022-05-18 19:59:19 发布

qq_42838904

最新推荐文章于 2022-05-18 19:59:19 发布

阅读量585

点赞数

分类专栏：设计模式面向对象数据结构

本文链接：https://blog.csdn.net/qq_42838904/article/details/104932496

版权

//单例模式 //

** 第一步声明
var Instance;** 在类外的最上边

var AudioCtrl = cc.Class({})

第二步在类里面获取
statics: {
getIns: function () {
return Instance;
}
},
第三步在类里onLoad()的里面赋值
onLoad() {
Instance = this;
},
第四步在类里外的最后暴露出去
如果是 javaScript 脚本 module.exports = AudioCtrl;
如果是 typeScript 脚本 export default AudioCtrl;

第五步在其他类里面引入
如果是 javaScript 脚本 var AudioCtrl = require(“AudioCtrl”);
如果是 typeScript 脚本 import AudioCtrl from “…/…/AudioCtrl” //这里直接打出 AudioCtrl，代码就自动引用了 import AudioCtrl from "…/…/AudioCtrl

第六步直接使用 AudioCtrl.getIns().playButton(); 如果是javaScript 脚本，鼠标放上去会不显示getIns().playButton(); 的属性，这也没关系，可以直接使用

懒汉模式
getpublic static ins:SprManager;
public static ins():SprManager{
if(!SprManager.ins){
SprManager.ins = new SprManager();
}
return SprManager.ins;
}

饿汉模式
getpublic static ins:SprManager = new SprManager();

TypeScript 单例
get public static ins:SprManager;
onLoad () {
SprManager.ins = this;
}

JavaScript 单例
var ins:SprManager;
onLoad () {
SprManager.ins = this;
}
JavaScript 单例实际项目中的使用成功的单例例子
private static _instance: SoundHelp;
public static get instance(): SoundHelp {
if (!this._instance) {
this._instance = new SoundHelp();
}
return this._instance;
}

//工厂模式 // 属于创建型模式

在这里插入图片描述
意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
主要解决：主要解决接口选择的问题。
优点：
1、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
2、一个调用者想创建一个对象，只要知道其名称就可以了。
3、屏蔽产品的具体实现，调用者只关心产品的接口。
缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，
使得系统中类的个数成倍增加

Rectangle.java
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println(“Inside Rectangle::draw() method.”);
}
}
Square.java
public class Square implements Shape {

@Override
public void draw() {
System.out.println(“Inside Square::draw() method.”);
}
}
Circle.java
public class Circle implements Shape {

@Override
public void draw() {
System.out.println(“Inside Circle::draw() method.”);
}
}
步骤 3
创建一个工厂，生成基于给定信息的实体类的对象。
ShapeFactory.java
public class ShapeFactory {

//使用 getShape 方法获取形状类型的对象
public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase(“CIRCLE”)){
return new Circle();
} else if(shapeType.equalsIgnoreCase(“RECTANGLE”)){
return new Rectangle();
} else if(shapeType.equalsIgnoreCase(“SQUARE”)){
return new Square();
}
return null;
}
}
步骤 4
使用该工厂，通过传递类型信息来获取实体类的对象。
FactoryPatternDemo.java
public class FactoryPatternDemo {

public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();

  //获取 Circle 的对象，并调用它的 draw 方法
  Shape shape1 = shapeFactory.getShape("CIRCLE");

  //调用 Circle 的 draw 方法
  shape1.draw();

  //获取 Rectangle 的对象，并调用它的 draw 方法
  Shape shape2 = shapeFactory.getShape("RECTANGLE");

  //调用 Rectangle 的 draw 方法
  shape2.draw();

  //获取 Square 的对象，并调用它的 draw 方法
  Shape shape3 = shapeFactory.getShape("SQUARE");

  //调用 Square 的 draw 方法
  shape3.draw();

}
}
步骤 5
执行程序，输出结果：
Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.

//装饰器模式 // 属于结构型模式

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。
这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。
我们通过下面的实例来演示装饰器模式的用法。其中，我们将把一个形状装饰上不同的颜色，同时又不改变形状类。

在这里插入图片描述
步骤 1
创建一个接口：

Shape.java
public interface Shape {
void draw();
}
步骤 2
创建实现接口的实体类。
Rectangle.java
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println(“Shape: Rectangle”);
}
}
Circle.java
public class Circle implements Shape {

@Override
public void draw() {
System.out.println(“Shape: Circle”);
}
}
步骤 3
创建实现了 Shape 接口的抽象装饰类。
ShapeDecorator.java
public abstract class ShapeDecorator implements Shape {
protected Shape decoratedShape;

public ShapeDecorator(Shape decoratedShape){
this.decoratedShape = decoratedShape;
}

public void draw(){
decoratedShape.draw();
}
}
步骤 4
创建扩展了 ShapeDecorator 类的实体装饰类。
RedShapeDecorator.java
public class RedShapeDecorator extends ShapeDecorator {

public RedShapeDecorator(Shape decoratedShape) {
super(decoratedShape);
}

@Override
public void draw() {
decoratedShape.draw();
setRedBorder(decoratedShape);
}

private void setRedBorder(Shape decoratedShape){
System.out.println(“Border Color: Red”);
}
}
步骤 5
使用 RedShapeDecorator 来装饰 Shape 对象。
DecoratorPatternDemo.java
public class DecoratorPatternDemo {
public static void main(String[] args) {

  Shape circle = new Circle();
  ShapeDecorator redCircle = new RedShapeDecorator(new Circle());
  ShapeDecorator redRectangle = new RedShapeDecorator(new Rectangle());
  //Shape redCircle = new RedShapeDecorator(new Circle());
  //Shape redRectangle = new RedShapeDecorator(new Rectangle());
  System.out.println("Circle with normal border");
  circle.draw();

  System.out.println("\nCircle of red border");
  redCircle.draw();

  System.out.println("\nRectangle of red border");
  redRectangle.draw();

}
}
步骤 6
执行程序，输出结果：

Circle with normal border
Shape: Circle

Circle of red border
Shape: Circle
Border Color: Red

Rectangle of red border
Shape: Rectangle
Border Color: Red

//代理模式 // 属于结构型模式。

意图：为其他对象提供一种代理以控制对这个对象的访问。
主要解决：在直接访问对象时带来的问题，比如：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。
优点：
1、职责清晰。
2、高扩展性。
3、智能化。

缺点：
1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。
2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。
在这里插入图片描述
Image.java
public interface Image {
void display();
}
步骤 2
创建实现接口的实体类。
RealImage.java
public class RealImage implements Image {

private String fileName;

public RealImage(String fileName){
this.fileName = fileName;
loadFromDisk(fileName);
}

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

private void loadFromDisk(String fileName){
System.out.println("Loading " + fileName);
}
}
ProxyImage.java
public class ProxyImage implements Image{

private RealImage realImage;
private String fileName;

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

@Override
public void display() {
if(realImage == null){
realImage = new RealImage(fileName);
}
realImage.display();
}
}
步骤 3
当被请求时，使用 ProxyImage 来获取 RealImage 类的对象。
ProxyPatternDemo.java
public class ProxyPatternDemo {

public static void main(String[] args) {
Image image = new ProxyImage(“test_10mb.jpg”);

  // 图像将从磁盘加载
  image.display(); 
  System.out.println("");
  // 图像不需要从磁盘加载
  image.display();

}
}
步骤 4
执行程序，输出结果：
Loading test_10mb.jpg
Displaying test_10mb.jpg

Displaying test_10mb.jpg

//观察者模式 // 属于行为型模式。

意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。
优点：
1、观察者和被观察者是抽象耦合的。
2、建立一套触发机制。
缺点：
1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间
在这里插入图片描述

步骤 1
创建 Subject 类。
Subject.java
import java.util.ArrayList;
import java.util.List;

public class Subject {

private List observers
= new ArrayList();
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();
}
}
}
步骤 2
创建 Observer 类。
Observer.java
public abstract class Observer {
protected Subject subject;
public abstract void update();
}
步骤 3
创建实体观察者类。
BinaryObserver.java
public class BinaryObserver extends Observer{

public BinaryObserver(Subject subject){
this.subject = subject;
this.subject.attach(this);
}

@Override
public void update() {
System.out.println( "Binary String: "
+ Integer.toBinaryString( subject.getState() ) );
}
}
OctalObserver.java
public class OctalObserver extends Observer{

public OctalObserver(Subject subject){
this.subject = subject;
this.subject.attach(this);
}

@Override
public void update() {
System.out.println( "Octal String: "
+ Integer.toOctalString( subject.getState() ) );
}
}
HexaObserver.java
public class HexaObserver extends Observer{

public HexaObserver(Subject subject){
this.subject = subject;
this.subject.attach(this);
}

@Override
public void update() {
System.out.println( "Hex String: "
+ Integer.toHexString( subject.getState() ).toUpperCase() );
}
}
步骤 4
使用 Subject 和实体观察者对象。

ObserverPatternDemo.java
public class ObserverPatternDemo {
public static void main(String[] args) {
Subject subject = new Subject();

  new HexaObserver(subject);
  new OctalObserver(subject);
  new BinaryObserver(subject);

  System.out.println("First state change: 15");   
  subject.setState(15);
  System.out.println("Second state change: 10");  
  subject.setState(10);

}
}
步骤 5
执行程序，输出结果：

First state change: 15
Hex String: F
Octal String: 17
Binary String: 1111
Second state change: 10
Hex String: A
Octal String: 12
Binary String: 1010

模块模式理论上方法，类，对象，都可以赋值给一个对象以后再模块化暴露

}
module.exports = {
BannerAd: new BannerAd(), **//1）**模块化方法
sdkConfig: poly_sdk_config, **//2）**模块化对象
utils :utils , **//3）**模块化类
platformEventCallback :platformEventCallback,

}
cc.LieYingSDK = cc.LieYingSDK || {};
cc.LieYingSDK.PolySDK = module.exports;

项目案例如 3_20包《我的守卫战斗》
模块化对于模块类 var CG = CG||{}; 声明对象 CG.lockingEnEmy = null; //锁定怪物赋值 module.exports = CG; //暴露去使用

对于普通类什么要不用暴露在start启动类里面引入，或者直接在本类中暴露模块化（类 —和--- 工具模块） function initMgr() {
cc.vv = {};

var CG = require("config");
cc.vv.CG = CG;

var Tool = require("Tool");
cc.vv.tool = Tool;

var pp = cc.sys.localStorage.getItem("pp");
if(pp && pp!="null" &&JSON.parse(pp).GuideSate !=0){
    cc.vv.pp = {};
    cc.vv.PP = JSON.parse(pp);

}else{
    var property = require("carProperty");
    cc.vv.PP= property;
}

var CarsMgr = require("CarsManager");
cc.vv.CarsMgr = new CarsMgr();

var UIMgr = require("UIMgr");
cc.vv.UIMgr =

最低0.47元/天解锁文章

qq_42838904

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
设计模式----单例模式-＞工厂模式-＞装饰器模式-＞代理模式-＞观察者模式-＞模块化模式，以FairyGUI的Ts模块为案例使用模块

单例模式懒汉模式getpublic static ins:SprManager;public static ins():SprManager{if(!SprManager.ins){SprManager.ins = new SprManager();}return SprManager.ins;}饿汉模式getpublic static ins:SprManager = new...
复制链接

扫一扫