//*************************单例模式 *************************//
** 第一步声明
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
模块模式 理论上 方法,类,对象,都可以赋值给一个对象以后 再 模块化暴露
var BannerAd = (function () {
var instance;
var BannerAd = function () {
if (instance) {
return instance;
}
var self = this;
}
}
var poly_sdk_config = {
// 平台 id
sdk_key_tt: “tt”,//头条
}
var utils = class{
// 平台 id
}
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 = new UIMgr();
TypeScript 模块
//**1)**模块类
module wlf.AdThird {
export class AdThirdPartUtils {} } 在其他类中 可以直接 wlf.AdThird.AdThirdPartUtils进行使用
//**2)**模块方法
module wlf.tip {
var tipsWin: fairygui.GLabel;
export var tipUrl: string; //3)模块对象
export