flutter入门教程（二）：dart语法介绍

flutter入门教程（二）：dart语法介绍

参考官方介绍https://dart.cn/language/

各大语言入门之------------Hello World （主函数）

每个应用都有一个顶层的 main() 函数(主函数)来作为运行入口。没有指定返回类型的方法的返回类型会推导为 void。

void main() {
  print('Hello, World!');
}

变量

Dart 使用 var、final 和 const 来定义变量。

var name = 'Alice';  // 可变变量
final age = 30;      // 只读变量（初始化后不可改变）
const pi = 3.14;     // 编译时常量

数据类型

Dart 是一种强类型语言，常见的数据类型有：

• int: 整数
• double: 浮点数
• String: 字符串
• bool: 布尔值（true/false）
• List: 列表
• Map: 字典

int count = 10;
double price = 19.99;
String greeting = 'Hello, Dart!';
bool isValid = true;
List<int> numbers = [1, 2, 3];
Map<String, int> scores = {'Alice': 95, 'Bob': 85};

流程控制语句

Dart 支持常见的控制流语句，例如 if、for、while 等

if (year >= 2001) {
  print('21st century');
} else if (year >= 1901) {
  print('20th century');
}

for (final object in flybyObjects) {
  print(object);
}

for (int month = 1; month <= 12; month++) {
  print(month);
}

while (year < 2016) {
  year += 1;
}

你可以阅读更多 Dart 中关于控制流程语句的内容，包括 break 和 continue 关键字、 switch 语句和 case 子句 以及 assert 语句.

函数

函数是 Dart 的基本构建块，可以使用 => 语法简化单行函数。

int add(int a, int b) {
  return a + b;
}

int multiply(int a, int b) => a * b;

类和对象

Dart 是面向对象的，支持类和对象的创建。

class Person {
  String name;
  int age;

  Person(this.name, this.age);

  void introduce() {
    print('My name is $name and I am $age years old.');
  }
}

var person = Person('Alice', 30);
person.introduce();

异步编程

Dart 支持异步编程，可以使用 async 和 await 关键字。

Future<void> fetchData() async {
  await Future.delayed(Duration(seconds: 2));
  print('Data fetched!');
}

void main() async {
  print('Fetching data...');
  await fetchData();
  print('Done!');
}

异常处理

Dart 使用 try、catch 和 finally 来处理异常。

try {
  var result = 10 ~/ 0; // 整数除法
} catch (e) {
  print('Caught an exception: $e');
} finally {
  print('This will always execute.');
}

注释

Dart 通常使用双斜杠 // 作为注释的开始。

// This is a single-line comment.

/*
This is a multi-line comment.
*/

导入

使用 import 关键字来访问在其它库中定义的 API。

// Importing core libraries
import 'dart:math';

// Importing libraries from external packages
import 'package:test/test.dart';

// Importing files
import 'path/to/my_other_file.dart';

枚举类型

枚举类型的取值范围是一组预定义的值或实例

enum PlanetType { terrestrial, gas, ice }

增强枚举

enum Planet {
  mercury(planetType: PlanetType.terrestrial, moons: 0, hasRings: false),
  venus(planetType: PlanetType.terrestrial, moons: 0, hasRings: false),
  uranus(planetType: PlanetType.ice, moons: 27, hasRings: true),
  neptune(planetType: PlanetType.ice, moons: 14, hasRings: true);

  /// A constant generating constructor
  const Planet(
      {required this.planetType, required this.moons, required this.hasRings});

  /// All instance variables are final
  final PlanetType planetType;
  final int moons;
  final bool hasRings;

  /// Enhanced enums support getters and other methods
  bool get isGiant =>
      planetType == PlanetType.gas || planetType == PlanetType.ice;
}

你可以这样使用 Planet 枚举：

final yourPlanet = Planet.earth;

if (!yourPlanet.isGiant) {
  print('Your planet is not a "giant planet".');
}

扩展类（继承）

Dart 支持类的继承，可以通过 extends 关键字创建子类，子类可以继承父类的属性和方法。

class Animal {
  void speak() {
    print('Animal speaks');
  }
}

class Dog extends Animal {
  @override
  void speak() {
    print('Dog barks');
  }
}

void main() {
  Dog dog = Dog();
  dog.speak(); // 输出：Dog barks
}

你可以 阅读更多 Dart 中有关类继承的内容，比如可选的 @override 注解等等。

混入(Mixins)

Mixins 是一种特殊的类，可以在多个类中复用代码。使用 with 关键字来引入 mixin。

mixin Swimmer {
  void swim() {
    print('Swimming');
  }
}

mixin Flyer {
  void fly() {
    print('Flying');
  }
}

class Duck with Swimmer, Flyer {
  void quack() {
    print('Quack');
  }
}

void main() {
  Duck duck = Duck();
  duck.swim(); // 输出：Swimming
  duck.fly();  // 输出：Flying
  duck.quack(); // 输出：Quack
}

接口（Interfaces）

Dart 中的所有类都可以作为接口。任何类都可以实现一个或多个接口，使用 implements 关键字。

class Flyer {
  void fly();
}

class Bird implements Flyer {
  @override
  void fly() {
    print('Bird is flying');
  }
}

void main() {
  Bird bird = Bird();
  bird.fly(); // 输出：Bird is flying
}

抽象类（Abstract Class)

抽象类是不能实例化的类，可以包含抽象方法（没有实现的方法）和普通方法。

abstract class Shape {
  double area(); // 抽象方法
}

class Circle extends Shape {
  final double radius;

  Circle(this.radius);

  @override
  double area() {
    return 3.14 * radius * radius; // 实现抽象方法
  }
}

void main() {
  Circle circle = Circle(5);
  print('Area of circle: ${circle.area()}'); // 输出：Area of circle: 78.5
}

运算符

1.算术运算符

+：加法
-：减法
*：乘法
/：除法（返回 double）
~/：整数除法（返回整数）
%：取余（模）

2.关系运算符

==：相等
!=：不相等
>：大于
<：小于
>=：大于或等于
<=：小于或等于

3.逻辑运算符

&&：逻辑与
||：逻辑或
!：逻辑非

4.位运算符

&：按位与
|：按位或
^：按位异或
~：按位非
<<：左移
>>：右移

5.赋值运算符

=：赋值
+=：加赋值
-=：减赋值
*=：乘赋值
/=：除赋值
~/=：整数除赋值
%=：取余赋值
&=：按位与赋值
|=：按位或赋值
^=：按位异或赋值
<<=：左移赋值
>>=：右移赋值

6.条件运算符

? :：三元运算符（条件表达式）

var result = (a > b) ? a : b;

7.空安全运算符

??：如果左侧为 null，返回右侧值。
??=：如果左侧为 null，则赋值右侧值。
!：强制非空操作符，表示该值不为 null。

8.列表和集合运算符

…：展开运算符（用于将列表或集合的内容展开）

var list1 = [1, 2];
var list2 = [...list1, 3, 4]; // 结果为 [1, 2, 3, 4]

9.类型运算符

is：检查对象是否为某类型。
is!：检查对象是否不是某类型。

10.级联运算符
级联运算符..使得你可以在一个对象上连续调用多个方法或设置多个属性，从而提高代码的可读性和简洁性。使用级联运算符时，Dart 会隐式地返回对象本身，因此你可以在一个表达式中链式调用。

class Person {
  String name = '';
  int age = 0;

  void setName(String name) {
    this.name = name;
  }

  void setAge(int age) {
    this.age = age;
  }

  void display() {
    print('Name: $name, Age: $age');
  }
}

void main() {
  var person = Person()
    ..setName('Alice')
    ..setAge(30)
    ..display(); // 输出：Name: Alice, Age: 30
}

Dart 的空安全支持基于以下两条核心原则：

• 默认不可空。除非你将变量显式声明为可空，否则它一定是非空的类型。我们在研究后发现，非空是目前的 API 中最常见的选择，所以选择了非空作为默认值。

• 完全可靠。Dart 的空安全是非常可靠的，意味着编译期间包含了很多优化。如果类型系统推断出某个变量不为空，那么它 永远 不为空。当你将整个项目和其依赖完全迁移至空安全后，你会享有健全性带来的所有优势—— 更少的 BUG、更小的二进制文件以及更快的执行速度。

详细有很多，建议查看官方文档，以官方为准。