前言

本文主要学习仓颉语言的设计模式和函数

---

一、设计模式

在面向对象编程思想要执行的一个应用的技术栈

单例模式：这个程序运行只能产生一个对象

读取或解析文件，加载数据，数据加载到对象中，一个文件只对应一个对象，只能从这个唯一的对象中再同步数据。（如果是多个对象，造成数据的不一致）

工厂模式：根据用户实际需求生产具体对象

抽象的编程思想来实现

代理模式

1.单例模式

//单例模式  程序只创建这个类的一个对象
public  class  User{

     //主构造函数
     public  User()
     {
       println("创建了对象")
     }


}
public  func   exec1()
{
     //创建User类的对象
     var  u1 :User  =User()
     var  u2 :User = User()
       

}

以上代码创建了多个对象，不是单例模式

//单例模式  程序只创建这个类的一个对象
public class User {

     //饿汉式单例  不管你需不需要这个对象，这个对象已经在程序中生成
    //静态变量只初始化一次
    static var user: User = User()

    //主构造函数
    //设置成私有，外部不能直接访问
    private User() {
        println("创建了对象")
    }
    //static 静态  修饰方法叫做静态方法
    //类名.静态方法名()  call  这样是不是没有创建对象
    public static func createUser(): User {
        user
    }
}

public func exec1() {
    //创建User类的对象，设置成private，报错
    //  var  u1 :User  =User()
    //  var  u2 :User = User()

    var  u1  = User.createUser()
    var  u2  = User.createUser()//结果是只创建了一次对象
}

饿汉式单例

由于静态方法调用静态变量，而静态变量只能初始化一次，即只能创建一次对象

特点是不管你需不需要这个对象，伴随着静态变量的初始化，这个对象已经在程序中生成

//单例模式  程序只创建这个类的一个对象
public class User {

    //懒汉式单例   需要创建对象的时候，程序再去创建对象
    //静态变量只初始化一次
    static var user: User //还没实例化，没占用内存

    //静态构造函数，只能定义一个，只执行一次
    static init() {
        user = User()
    }

    //主构造函数
    private User() {
        println("创建了对象")
    }
    //static 静态  修饰方法叫做静态方法
    //类名.静态方法名()  call  这样是不是没有创建对象
    public static func createUser(): User {
        user
    }
}

public func exec1() {
    //创建User类的对象，设置成private，报错
    //  var  u1 :User  =User()
    //  var  u2 :User = User()

    var u1 = User.createUser()
    var u2 = User.createUser()
}

懒汉式单例

静态变量初始时还未实例化，不占用内存

通过静态构造函数，调用时才对变量进行实例化，节约内存

并且静态构造函数，只能定义一个，只执行一次，即只会创建一次对象

2.工厂模式

package cjdemo5.chapter3

// 工厂模式，根据用户的实际需求生产具体的对象

//抽象的编程思想来实现
public abstract class Product {4

        this.name = name
    }

    //抽象方法
    public open func show(): Unit
}

//具体的A类商品的继承
public class ProductA <: Product {
    public ProductA(name: String) {
        super(name)
    }

    public override func show(): Unit {
        println(this.name)
    }
}

//具体的B类商品的继承
public class ProductB <: Product {
    public ProductB(name: String) {
        super(name)
    }

    public override func show(): Unit {
        println(this.name)
    }
}

//工厂类来根据用户的需求来构建具体的商品子类（A和B）   实例工厂类
public  abstract   class  Factory{

    public  open  func  createProduct():Product
}

public class FactortA<:Factory{
     public    func  createProduct():Product{

        return  ProductA("1.A商品")
     }
}

public class FactortB<:Factory{
     public    func  createProduct():Product{

        return  ProductB("2. B商品")
     }
}

public  func  exec3(){

    //用户要生产B商品
    var pb:Factory = FactortB()
    
    var product :  Product  = pb.createProduct()
    product.show()
}
 

通过抽象的编程思想进行实例化来完成

// 工厂模式，根据用户的实际需求生产具体的对象
 public  open  class Product {
    var name: String

    public Product(name: String) {
        this.name = name
    }

   //为了静态变量的实例化，Product下的可变变量需要初始化

  public init()
    {
        this.name =""
    }
    public open func show(): Unit{}
}

//具体的A类商品的继承
public class ProductA <: Product {
    public ProductA(name: String) {
        super(name)
    }

    public override func show(): Unit {
        println(this.name)
    }
}

//具体的B类商品的继承
public class ProductB <: Product {
    public ProductB(name: String) {
        super(name)
    }

    public override func show(): Unit {
        println(this.name)
    }
}

public class CreateFactory {
    static var p: Product  = Product()//静态函数需要静态变量，进行实例化
//工厂的静态方法
    public static func createProduct(name: String): Product {
        if (name == "A") {
            p = ProductA(name)
        } else if (name == "B") {
            p = ProductB(name)
        }
        p
    }
}

public  func  exec1(){
    var p: Product =CreateFactory.createProduct("A")
    p.show()
}

通过静态方法来实现

二、仓颉的函数和枚举类型

1.面向函数式编程

仓颉函数的基本定义：

首先仓颉函数与JAVA不同，没有强制要求一定要定义在类下

仓颉的函数带参数，可以是非命名参数也可以是命名参数

而当命名参数调用时，若没赋值，调用时函数（命名参数：值），若赋值了，则可直接调用

exec（a1：100）
exec（）

值得注意的是仓颉方法的参数都是不可变变量，不可以修改其值

//仓颉的函数带参数,非命名参数
public func execFun2(a1: Int64) {
    //仓颉的方法的参数都是不可变变量，不能修改其值
    //a1  =100  //错误
}

//仓颉的函数带参数,命名参数 变量名!:类型
public func  execFun3(a1!:Int64=100)
{
     println("1.值为:${a1}")

}

仓颉函数的返回值与JAVA进行对比

在JAVA中没有要求返回值类型，多个返回值时以数组的形式输出

在仓颉中，只能要求一种返回值类型

//Python
def out():
return 1,True,(1,2)
result=out()
print(result[0])
print(result[1])
print(result[2])

//带返回值
public  func  exec5():Unit
{

}
public  func  exec6():Any
{
    
}

仓颉定义的函数，可以有非命名参数和命名参数混合

第一个是命名参数，后面都是命名参数

第一个是命名参数。后面是有非命名参数，编译报错

//定义函数，有非命名参数和命名参数混合
public  func  execFun1(a1:Int64,b1:Int64)
{

}

public  func  execFun2(a1:Int64,b1!:Int64)
{

}

public  func  execFun3(a1!:Int64,b1!:Int64)
{

}
// 仓颉的方法的参数，
// public  func  execFun4(a1!:Int64,b1:Int64)//报错
// {

// }

---

总结

设计模式是软件工程中用于解决常见设计问题的可重用解决方案。它们提供了一种标准化的方式来组织代码，使得代码更易于理解、维护和扩展。初步学习和理解单例模式和工厂模式。并开始对仓颉函数的学习。