HarmonyOS开发基础 --鸿蒙仓颉语言基础语法入门

仓颉编程语言是华为自主研发的一种面向全场景应用开发的现代编程语言，具有高效编程、安全可靠、轻松并发和卓越性能等特点。本节将简单介绍仓颉语言的部分语法和使用，帮助开发者快速上手。

在这里插入图片描述

1.3.1：数据类型
  1. 整数

仓颉把整数分为有符号和无符号两种类型，有符号整数用 Int8、Int16、Int32、Int64 和 IntNative 来表示，无符号整数用 UInt8、UInt16、UInt32、UInt64 和 UIntNative 来表示。

var count1: Int8 = 6             // 声明count1为Int8类型
var count2: Int64 = 6            // 声明count2为Int64类型
var count3 = 6                   // count3无指定类型时默认推导为Int64类型
if (count3 is Int64) {println("count3是Int64类型"); // 输出count3是Int64类型
}

📢：具体使用哪种类型取决于该程序中需要处理的整数的性质和范围。在 Int64 类型适合的情况下，首选 Int64 类型。具体范围可参见官网。

  1. 小数

仓颉提供了 Float16、Float32 和 Float64 分别表示编码长度为 16-bit、 32-bit 和 64-bit 的小数。

var count1: Float32 = 3.14     // 声明count1为Float32类型
var count2: Float64 = 3.14     // 声明count2为Float64类型
var count3 = 3.14              // 声明count3为默认类型if (count3 is Float64) {println("默认是Float64类型"); // 输出默认是Float64类型
}
if (count3 == count2) {println("count3 == count2");  // 输出count3 == count2
}

📢：在多种浮点类型都适合的情况下，首选精度高的浮点类型 Float64。具体范围可参见官网。

  1. Bool

仓颉提供了 Bool 关键字来表示逻辑值 true 和 false。

let a: Bool = true
let b: Bool = false
  1. Rune

仓颉提供了 Rune 关键字来表示字符，格式为：r"*" 或者 r'*' 的形式。

var char1: Rune = r'a'
var char2 = r"a"if(char1 is Rune) {println("char1 is Rune")   // 输出char1 is Rune
} else {println("char1 isn't Rune")
}
if (char1 == char2) {println("char1 == char2")  // 输出char1 == char2
} else {println("char1 != char2")
}
  1. String

仓颉提供了 String 关键字来表示字符串类型，使用单引号（'）或双引号（"）来表示字符串类型，同时支持插值字符串的表达形式，如 ${a + b}。

let fruit = "apples"
let count = 10
let s = "There are ${count * count} ${fruit}"
  1. Array

仓颉使用 Array 关键字来表示单一类型的有序数组。

var array1: Array<String> = ["1", "2", "3"]
var array2 = [1, 2, 3]println(array1[2])for (e in array2) {println("the element is ${e}")
}
  1. 元组

仓颉提供了元组来表示已知元素数量和类型的数组，元组内的各元素的类型不必相同，但是对应位置的类型必须一致。

var tuple1: (Bool, Float64, String) = (false, 3.14, "cj") // 定义元组tuple1并制定类型
var tuple2 = (123, true, 3.14)                            // 定义元组tuple2由编译器推导类型
println(tuple1[0])                                        // 访问元组，输出false
println(tuple2[2])                                        // 访问元组，输出3.140000
  1. Unit

Unit 是一种特殊的数据类型，适用于只关心副作用而不关心值的表达式，例如，println 函数、赋值表达式、复合赋值表达式、自增和自减表达式、循环表达式，它们的类型都是 Unit。

main(): Int64 {println("unit")testUnit()return 0
}func testUnit(): Unit {var age = 20age++
}
  1. Any

仓颉提供了 Any 接口，它是一个空实现，所有数据均实现了该接口，因此 Any 可作为一种数据类型来看待。

var data: Any = 12;                                     // 定义data为Any类型，默认赋值12if (data is Int64) {                                    // 判断是否是Int64类型log("data is Int64")                                  // 输出data is Int64let value = (data as Int64).getOrDefault({=> -1})     // 取出data内部的值log("value: ${value}")                                // 输出value: 12
}data = 3.14                                             // 给data赋值小数
data = true                                             // 给data赋值Bool
1.3.2：变量声明

变量在使用前必须先声明，仓颉可以使用 var、let、const 修饰符来声明一个变量，格式如下：

修饰符 变量名: 变量类型 = 初始值
修饰符 变量名 = 初始值
  1. var

var 修饰的变量属于可变变量，允许在运行时对变量的值做修改。

var osName: String = "OpenHarmony"
var price1: Int64 = 5
var price2: Float64 = 5.5
var sum = Float64(price1) + price2
println("操作系统名称：${osName}") // 操作系统名字: OpenHarmony
println("第一个价格是：${price1}")   // 第一个价格是: 5
println("第二个价格是：${price2}")   // 第二个价格是: 5.5
println("总价格：${sum}")           // 总价格: 10.5price1 = 3                         // 重置price1的值
price1 = 3.5                       // 编译报错，只能赋值Int64类型的值
osName = "HarmonyOS"               // 重置osName的值
  1. let

let 修饰的变量要求在运行时初始化完毕后不可修改。

let age = 20                  // age初始化后不可修改
let pi: Float64 = 3.141592653 // pi初始化后不可修改
pi = 5                        // 编译时会报错
  1. const

const 修饰的变量要求在编译期完成求值，并且在运行时不可修改。

const PI = 3.1415926 // 编译期确定了PI的值
PI = 10              // 报错，不允许修改
1.3.3：函数
  1. 函数声明

函数就是包裹在花括号中的代码块，前边使用 func 关键字，语法格式如下：

func function_name() {// 执行代码
}

例如声明函数如下：

func log(msg: String) { // 声明一个函数println(msg);         // 代码块
}
  1. 函数调用

函数只有通过调用才可以执行函数内的代码，语法格式如下：

function_name()

样例如下：

func log(msg: String) { // 声明一个函数println(msg);         // 代码块
}
log("Hello, 仓颉");      // 调用函数
  1. 函数返回值

如果希望得到函数的执行结果，可以使用 return 语句，语法如下：

func function_name(): return_type {return value;                     // return语句
}

样例如下：

func sayHi(): String { // 定义sayHi函数，该函数的返回类型为stringreturn "Hello!" 
}func execute() {       // 定义execute函数var msg = sayHi();   // 调用sayHi()函数log(msg);            // 打印sayHi()函数的返回值
}execute();             // 调用execute()函数
  1. 带参数函数

在调用函数时可以向函数传递值，这些值被称为参数，语法如下：

func func_name(param1: paramType, param2: paramType) {
}

样例如下：

func add(x: Int64, y: Int64): Int64 { // 定义add函数，该函数返回类型为nubmer, 接收两个number类型的参数xreturn x + y;
}log("${add(1,2)}")                    // 3
  1. 命名参数

函数定义了参数则必须传递这些参数否则报错，如果不想传递这些参数可以使用命名参数，当不传入该参数时则使用默认值，语法如下：

func func_name(param1: paramType, param2!: paramType = default_value) {
}

样例如下：

func add(x: Int64 = 20, y!: Int64 = 50) { // 设置y有默认值return x + y;
}log("${add(10)}");                          // y使用默认值，输出60
log("${add(10, y: 10)}");                   // y使用10，输出20

📢：如果参数不全是命名参数，那么命名参数的位置必须放在最后。

  1. 变长参数

在不确定要向函数传递多个参数的情况下，可以使用变长参数，变长参数前边以 Array 表示，语法如下：

func func_name(param1: paramType, param2: paramType, param3: Array<paramType>) {
}

样例如下所示：

func add(param1: String, param2: Array<Int64>): Int64 { // 变长参数log("add: ${param1}");var sum = 0for (e in param2) {  // 遍历剩余参数sum += e}return sum
}log("${add("sum", 1, 2, 3, 4)}") // add: sum// 10
1.3.4：类
  1. 定义类

仓颉是面向对象的编程语言，定义一个类使用关键字 class，类可以包含字段、构造方法和方法。语法如下：

class class_name {// 类作用域
}

样例如下：

class Person {var name: String;var age: Int;init(name: String, age: Int) {this.name = name;this.age = age;}func info(): String {return "name: ${this.name}, age: ${this.age}";}
}
  1. 创建类对象

类定义完后，可以通过 类名(args) 的格式实例化一个类的对象，实例化类对象即调用类的构造方法，语法如下：

var object_name = class_name([ args ])

样例如下：

var person = Person('张三', 20); // 创建一个Person对象
  1. 访问类属性和方法

访问类的属性和方法以 . 号的形式，语法如下：

obj.field_name      // 访问属性
obj.function_name() // 访问方法

样例如下：

var person = Person('harmony', 10); // 创建一个personlog(person.name);                   // harmony
log("${person.age}");               // 10
log(person.info());                 // name: harmony, age: 10
  1. 类的继承

仓颉支持继承类，创建类的时候可以使用 <: 符号继承一个已有的类，这个已有的类称为父类，继承它的类称为子类。子类除了不能继承父类的私有成员（方法和属性）和构造函数，其他的都可以继承。语法如下：

class child_class_name <: parent_class_name {
}

样例如下：

open class Person { // 父类使用open关键字修饰，表示允许子类继承var name: Stringvar age: Intinit(name: String, age: Int) {this.name = namethis.age = age}func info(): String {return "name: ${this.name}, age: ${this.age}"}
}class Zhangsan <: Person { // 子类继承父类init(name: String, age: Int) {super(name, age)}func sayHello() {println("Hello")}
}var person = Zhangsan("张三", 20); // 创建一个person
person.sayHello()                   // Hello
log(person.name);                   // 张三
log("${person.age}");               // 20
log(person.info());                 // name: 张三, age: 20

📢：父类必须使用 open 关键字修饰，并且类的继承只支持单继承，不支持多继承。也就是说子类只能继承一个父类。

  1. 方法重写

子类可以重写父类的方法，在重写父类方法的时候也可以使用 super 关键字调用父类的方法。样例如下：

open class Person { // 父类使用open关键字修饰，表示允许子类继承var name: Stringvar age: Intinit(name: String, age: Int) {this.name = namethis.age = age}func info(): String {return "name: ${this.name}, age: ${this.age}"}
}class Zhangsan <: Person { // 子类继承父类init(name: String, age: Int) {super(name, age)}override func info(): String { // 重写父类方法return "Hello, " + super.info() // 调用父类方法}
}var person = Zhangsan("张三", 20); // 创建一个person
log(person.info());                 // Hello, name: 张三, age: 20
  1. 访问修饰符

仓颉提供了访问控制符来保护对类、变量、方法和构造方法的访问。它支持 4 种不同的访问权限。

  • internal（默认）：受保护，仅当前包及子包内访问。
  • protected：受保护，只能在当前模块和其子类访问。
  • private：私有，只能在 class 内访问。
  • public：公有，可以在任何地方被访问。

样例如下所示：

class Person {var name: String;private var age: Int;             // age为private，外界无法访问init(name: String, age: Int) {this.name = name;this.age = age;}func info(): String {return "name: ${this.name}, age: ${this.age}"}
}var person = Person('harmony', 10); // 创建Person对象
log(person.name);                   // harmony
log("${person.age}");               // 编译报错，age为private
1.3.5：接口
  1. 定义接口

接口是一系列抽象方法的声明，接口定义后需要具体的类实现，语法如下：

interface interface_name {// 抽象方法
}

样例如下：

interface IPerson {              // 定义一个接口func say(): Unit               // 定义say方法，该方法默认是public，返回值为Unit类型
}
  1. 接口继承

接口可以使用 <: 符号继承其它接口来扩展自己，接口既支持单继承又支持多继承，多继承时接口间使用逗号 & 分隔。语法如下：

// 接口单继承
interface Child_interface_name <: super_interface_name {
}// 接口多继承
interface Child_interface_name <: super_interface_name1 & super_interface_name2 {
}

样例如下：

interface IPlay {                    // 定义IPlay接口func play(): Unit
}interface IRun {                     // 定义IRun接口func run(): Unit
}interface ITeacher <: IPlay & IRun { // 定义ITeacher接口，并继承IPlay和IRun接口func teach(): Unit
}
  1. 类实现接口

类可以使用 <: 关键字实现一个接口，一个类实现接口后必须实现接口定义的方法，语法如下：

class class_name <: interface_name {
}

样例如下所示：

interface IPlay {                    // 定义IPlay接口func play(): Unit                  // 定义play方法
}interface IRun {                     // 定义IRun接口func run(): Unit                   // 定义run方法
}interface ITeacher <: IPlay & IRun { // 定义ITeacher接口并继承IPlay和IRun接口func teach(): Unit                 // 定义teach方法
}class Teacher <: ITeacher {          // 类Teacher实现ITeacher接口public func teach(): Unit {        // 实现方法println("teach")}public func play(): Unit {         // 实现方法log("play")}public func run(): Unit {          // 实现方法log("run")}
}let teacher = Teacher()              // 创建Teacher实例
teacher.play()                       // 输出play
teacher.run()                        // 输出run
teacher.teach()                      // 输出teach
1.3.6：扩展
  1. 直接扩展

仓颉支持对已经存在的类做直接扩展，常用在扩展方法的场景，语法如下：

extend class_name {func func_name(): return_type {} // 添加扩展方法
}

样例如下：

class Teacher {                                    // 定义Teacher类public var name: String                          // 添加name属性public var age: Int                              // 添加age属性init(name!: String = "lisi", age!: Int64 = 30) { // 添加构造方法并初始化属性this.name = namethis.age = age}func teach(): Unit {                             // 添加teach方法println("teach")}
}extend Teacher {                                   // 对Teacher进行扩展func updateInfo(name: String, age: Int): Unit {  // 给Teacher添加updateInfo()方法this.name = namethis.age = age}func printInfo() {                               // 给Teacher添加printInfo()方法println("teacher info, name = ${this.name}, age = ${this.age}")}
}let teacher = Teacher()
teacher.printInfo()            // teacher info, name = lisi, age = 30
teacher.updateInfo("lisi", 18)// 更改信息
teacher.printInfo()            // teacher info, name = lisi, age = 18
  1. 接口扩展

仓颉支持对已经存在的类做接口扩展，它既可以扩展方法，也可以扩展属性，步骤如下：

  • 定义接口

    interface interface_name {func method_name(): return_typemut prop prop_name: prop_typeprop prop_name: prop_type
}

    样例如下所示：

    interface IInfo {          // 定义IInfo接口func info(): Unit        // 定义info方法mut prop address: String // 定义address属性prop email: String       // 定义email属性
}

    📢：此处的 mut 表示允许给 address 赋值。

  • 实现扩展

    extend class_name <: interface_name {public mut prop prop_name: prop_type {get() {prop_type}set(value) {// 赋值操作}}public prop prop_name: prop_type {get() {prop_type}}public func func_name(): return_type {}
}

    样例如下所示：

    extend Teacher <: IInfo {public mut prop address: String {get() {"Beijing"}set(value) {address = value}}public prop email: String {get() {"arkui.club@cj.com"}}public func info(): Unit {println("teacher info, name = ${this.name}, age = ${this.age}, address = ${address}")}
}

完整样例如下所示：

package arkui_cjclass TeacherA {public var name: Stringpublic var age: Intinit(name!: String = "lisi", age!: Int64 = 30) {this.name = namethis.age = age}func teach(): Unit {println("teach")}
}extend TeacherA {func updateInfo(name: String, age: Int): Unit {this.name = namethis.age = age}func printInfo() {println("teacher info, name = ${this.name}, age = ${this.age}")}
}interface IInfo {func info(): Unitmut prop address: Stringprop email: String
}extend TeacherA <: IInfo {public mut prop address: String {get() {"Beijing"}set(value) {address = value}}public prop email: String {get() {"arkui.club@cj.com"}}public func info(): Unit {println("teacher info, name = ${this.name}, age = ${this.age}, address = ${address}")}
}main(): Int64 {let teacher = TeacherA()teacher.teach()teacher.printInfo()teacher.updateInfo("Zhangsan", 18)teacher.printInfo()teacher.info()teacher.address = "Shanghai"teacher.info()println(teacher.email)return 0
}
1.3.7：小结

本节简单介绍了仓颉基础语法部分，掌握这些基础部分可以支撑日常简单应用开发了。对于仓颉更多其它用法，读者请参考官网。

通过以上介绍，希望你对仓颉编程语言有了一个初步的了解，并能够开始编写简单的HarmonyOS应用。随着你对仓颉的深入学习，你将能够更高效地利用其强大功能，开发出更加丰富和高质量的应用。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若转载，请注明出处：http://www.pswp.cn/diannao/88369.shtml
繁体地址，请注明出处：http://hk.pswp.cn/diannao/88369.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Excel文件比较器v1.3，html和js写的

Excel文件比较器v1.3，html和js写的

Excel文件比较器v1.3 版本说明&#xff1a;v1.3 1添加支持文件格式&#xff1a;CSV。 2&#xff0c;添加60条历史记录保存功能 - 用于保存比对结果。历史记录保存在浏览器的localStorage中&#xff0c;这是一个浏览器提供的本地存储机制&#xff0c;数据会一直保留直到用户…
阅读更多...
Kimi“新PPT助手” ，Kimi全新自研的免费AI生成PPT助手

Kimi“新PPT助手” ，Kimi全新自研的免费AI生成PPT助手

大家好&#xff0c;这里是K姐。 一个帮你用AI轻松生成精美PPT的女子。 前段时间给大家分享了一期用智能体做PPT的对比测评&#xff0c;很多友友都表示&#xff1a;那 Kimi 呢&#xff1f; 今天偶然发现 Kimi 新增了一个叫“新PPT助手”的功能&#xff0c;立马上手体验了一下…
阅读更多...
MySQL DATETIME类型存储空间详解：从8字节到5字节的演变

MySQL DATETIME类型存储空间详解：从8字节到5字节的演变

在MySQL数据库设计中&#xff0c;DATETIME类型用于存储日期和时间信息&#xff0c;但其存储空间大小并非固定不变&#xff0c;而是随MySQL版本迭代和精度定义动态变化。本文将详细说明其存储规则&#xff0c;并提供清晰的对比表格。 一、核心结论 MySQL 5.6.4 是分水岭&#…
阅读更多...
Gartner发布中国企业应用生成式AI指南：避免12 个 GenAI 陷阱

Gartner发布中国企业应用生成式AI指南：避免12 个 GenAI 陷阱

GenAI 技术&#xff08;例如 AI 代理和 DeepSeek&#xff09;的快速迭代导致企业抱有不切实际的期望。本研究借鉴了我们与中国 AI 领导者就常见的 GenAI 陷阱进行的讨论&#xff0c;并提供了最终有助于成功采用的建议。 主要发现 接受调查的首席信息官表示&#xff0c;生成式人…
阅读更多...
Vue3中ref和reactive的区别与使用场景详解

Vue3中ref和reactive的区别与使用场景详解

在 Vue 3 中&#xff0c;响应式系统进行了全新设计&#xff0c;ref 和 reactive 是其中的核心概念。 ### 一、ref 的使用 ref 适用于基本数据类型&#xff0c;也可以用于对象&#xff0c;但返回的是一个带 .value 的包装对象。 js import { ref } from vue const count ref(…
阅读更多...
React性能优化：父组件如何导致子组件重新渲染及避免策略

React性能优化：父组件如何导致子组件重新渲染及避免策略

目录 React性能优化&#xff1a;父组件如何导致子组件重新渲染及避免策略什么是重新渲染&#xff1f;父组件如何"无辜"地让子组件重新渲染&#xff1f;示例 1: 基础父组件状态变更示例 2: 传递未变化的原始类型Prop示例 3: 传递引用类型Prop&#xff08;对象&#xf…
阅读更多...
图的拓扑排序管理 Go 服务启动时的组件初始化顺序

图的拓扑排序管理 Go 服务启动时的组件初始化顺序

在构建复杂的 Go 应用程序时&#xff0c;服务的启动过程往往涉及多个组件的初始化&#xff0c;例如日志、配置、数据库连接、缓存、服务管理器、适配器等等。这些组件之间通常存在着复杂的依赖关系&#xff1a;日志可能需要配置信息&#xff0c;数据库连接可能依赖日志和追踪&a…
阅读更多...
【物理重建】SPLART：基于3D高斯泼溅的铰链估计与部件级重建

【物理重建】SPLART：基于3D高斯泼溅的铰链估计与部件级重建

标题&#xff1a;《SPLART: Articulation Estimation and Part-Level Reconstruction with 3D Gaussian Splatting》 项目&#xff1a;https://github.com/ripl/splart 文章目录 摘要一、引言二、相关工作2.1 数据驱动的铰链学习2.2 物体重建的表征方法2.3 铰链物体重建 三、方…
阅读更多...
vscode中vue自定义组件的标签失去特殊颜色高亮

vscode中vue自定义组件的标签失去特殊颜色高亮

遇到的问题 最近接触了一个历史遗留项目时&#xff0c;我遭遇了堪称"史诗级屎山"的代码结构——各种命名混乱的自定义组件和原生HTML标签混杂在一起&#xff0c;视觉上完全无法区分。这让我突然想起&#xff0c;之前在使用vue或者其他框架开发的时候&#xff0c;只要…
阅读更多...
【Dify精讲】第19章：开源贡献指南

【Dify精讲】第19章：开源贡献指南

今天&#xff0c;让我们深入 Dify 的开源贡献体系&#xff0c;看看这个项目是如何在短短时间内聚集起一个活跃的开发者社区的。作为想要参与 Dify 开发的你&#xff0c;这一章将是你的实战指南。 一、代码贡献流程&#xff1a;从想法到合并的完整路径 1.1 贡献前的准备工作 …
阅读更多...
Web攻防-CSRF跨站请求伪造Referer同源Token校验复用删除置空联动上传或XSS

Web攻防-CSRF跨站请求伪造Referer同源Token校验复用删除置空联动上传或XSS

知识点&#xff1a; 1、Web攻防-CSRF-原理&检测&利用&防御 2、Web攻防-CSRF-防御-Referer策略隐患 3、Web攻防-CSRF-防御-Token校验策略隐患 一、演示案例-WEB攻防-CSRF利用-原理&构造 CSRF 测试功能点 删除帐户 更改电子邮件 如果不需要旧密码&#xff0c;请…
阅读更多...
Drag-and-Drop LLMs: Zero-Shot Prompt-to-Weights

Drag-and-Drop LLMs: Zero-Shot Prompt-to-Weights

“拖拽式大模型定制”&#xff08;Drag-and-Drop LLMs: Zero-Shot Prompt-to-Weights&#xff09;。 核心问题&#xff1a; 现在的大模型&#xff08;比如GPT-4&#xff09;很厉害&#xff0c;但想让它们专门干好某个特定任务&#xff08;比如解数学题、写代码&#xff09;&am…
阅读更多...
抖音视频怎么去掉抖音号水印保存

抖音视频怎么去掉抖音号水印保存

随着抖音成为短视频平台的领军者&#xff0c;越来越多的人喜欢在上面拍摄、观看和分享各种创意内容。对于用户来说&#xff0c;下载抖音视频并去除水印保存&#xff0c;以便后续使用或分享成为了一种常见需求。抖音号水印的存在虽然能帮助平台追溯视频源头&#xff0c;但也让许…
阅读更多...
【RAG技术（1）】大模型为什么需要RAG

【RAG技术（1）】大模型为什么需要RAG

文章目录 为什么需要RAG&#xff1f;RAG的工作原理关键的Embedding技术 RAG vs 模型微调&#xff1a;选择的核心逻辑RAG的关键挑战与解决思路1. 检索质量决定一切2. 上下文长度限制 实际应用场景分析企业知识问答技术文档助手法律咨询系统 构建RAG系统的关键步骤总结 为什么需要…
阅读更多...
JS红宝书笔记 - 8.1 理解对象

JS红宝书笔记 - 8.1 理解对象

对象就是一组没有特定顺序的值&#xff0c;对象的每个属性或者方法都可由一个名称来标识&#xff0c;这个名称映射到一个值。可以把对象想象成一张散列表&#xff0c;其中的内容就是一组名值对&#xff0c;值可以是数据或者函数 创建自定义对象的通常方式是创建Object的一个新…
阅读更多...
Meson介绍及编译Glib库

Meson介绍及编译Glib库

一.概述 1.Meson 的简介 Meson&#xff08;The Meson Build System&#xff09;是个项目构建系统&#xff0c;类似的构建系统有 Makefile、CMake、automake …。 Meson 是一个由 Python 实现的开源项目&#xff0c;其思想是&#xff0c;开发人员花费在构建调试上的每一秒都是…
阅读更多...
Qt元对象系统实践指南：从入门到应用

Qt元对象系统实践指南：从入门到应用

目录 摘要 元对象系统核心概念 项目示例&#xff1a;动态UI配置工具 元对象系统在项目中的应用 1. 信号与槽机制 2. 动态属性系统 3. 运行时反射能力 4. 属性绑定与响应 实际项目应用场景 动态UI配置 对象序列化 插件系统 性能优化建议 结论 参考资料 摘要 本文…
阅读更多...
Kafka 与其他 MQ 的对比分析：RabbitMQ/RocketMQ 选型指南（一）

Kafka 与其他 MQ 的对比分析：RabbitMQ/RocketMQ 选型指南（一）

消息队列简介 在当今的分布式系统架构中&#xff0c;消息队列&#xff08;Message Queue&#xff0c;MQ&#xff09;扮演着举足轻重的角色。随着业务规模的不断扩大和系统复杂度的日益提升&#xff0c;各个组件之间的通信和协同变得愈发关键 。消息队列作为一种异步的通信机制…
阅读更多...
[创业之路-441]：行业 - 互联网+移动互联网和大数据时代的100个预言：技术个性、商业变革、社会重构、文化娱乐、环境、教育、健康医疗、未来生活方式

[创业之路-441]：行业 - 互联网+移动互联网和大数据时代的100个预言：技术个性、商业变革、社会重构、文化娱乐、环境、教育、健康医疗、未来生活方式

目录 一、技术革新 二、商业变革 三、社会重构 四、文化与娱乐 六、环境与可持续发展 七、教育与知识传播 八、健康与医疗 九、伦理与法律 十、未来生活方式 十一、终极预言 结语 在移动互联网和大数据时代&#xff0c;技术革新正以前所未有的速度重塑社会、经济与文…
阅读更多...
基于STM32单片机WIFI无线APP控灯亮度灭设计

基于STM32单片机WIFI无线APP控灯亮度灭设计

基于STM32单片机控灯设计 &#xff08;程序&#xff0b;原理图&#xff0b;设计报告&#xff09; 功能介绍 具体功能&#xff1a; 本设计由STM32F103C8T6单片机核心电路两位白色高亮LED灯电路WIFI模块ESP8266电路电源电路组成。 1、stm32实时监测wifi数据&#xff0c;解析数…
阅读更多...
最新文章

Copyright @ 2022~2023