二、Dart基础语法|二、Dart基础语法 (二)运算符 类
一、运算符
这里只列举比较简单的特殊的运算符，其余的运算符不浪费时间。
1、除法/整除、取模
var num = 7;
print(num / 3);
//2.33333 除法操作
print(num ~/ 3);
//2 整除操作
print(num % 3);
//1 取模操作
2、??= 赋值操作
dart有一个很多语言都不具备的赋值运算符：
- 当变量为null时，使用后面的内容进行赋值。
- 当变量有值时，使用自己原来的值。
var name1 = 'zzq';
print(name1);
// var name2 = 'kobe';
var name2 = null;
name2 ??= 'james';
print(name2);
3、条件运算符
Dart中包含一直比较特殊的条件运算符：expr1 ?? expr2
- 如果expr1是null，则返回expr2的结果;
- 如果expr1不是null，直接使用expr1的结果。
var temp = 'why';
var temp = null;
var name = temp ?? 'kobe';
print(name);
4、级联语法:
..
- 某些时候，我们希望对一个对象进行连续的操作，这个时候可以使用级联语法
main(List args) {
final obj = Person();
obj.run();
obj.jump();
obj.speak();
final zzq = Person()
..run()
..jump()
..speak();
}class Person {
run() {
print("run");
}speak() {
print("speak");
}jump() {
print("jump");
}
}
二、流程控制
和大部分语言的特性比较相似，这里就不再详细赘述，看一下即可。1、if和else
不支持非空即真或者非0即真，必须有明确的bool类型
var name = "zzq";
if (name) {//报错：Conditions must have a static type of 'bool'.
print(name);
}
2、循环操作
while和do-while和其他语言一致
break和continue用法也是一致
for的用法也是一致
switch-case的用法也是一致
在Dart中，定义类用
class关键字类通常有两部分组成：成员（
member）和方法（method）class 类名{
类型 成员名;
返回值类型 方法名(参数列表) {
方法体
}
}
下面是示例代码：
class Person {
String name;
int age;
int sex;
run() {
print("run");
}
}
2、构造方法
2.1 普通构造方法 【二、Dart基础语法|二、Dart基础语法 (二)运算符 类】当通过类创建一个对象时，会调用这个类的构造方法。
- 当类中
没有明确指定构造方法时，将默认拥有一个无参的构造方法。 - 前面的Person中我们就是在调用这个构造方法.
- 当有了自己的构造方法时，
默认的构造方法将会失效，不能使用
main(List args) {
final person = Person("name", 10);
print(person);
}class Person {
String name;
int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
//Person(this.name, this.age);
//Dart提供一种更简单的语法糖形式@override
String toString() {
//重写了toString方法
return "name is $name, age is $age";
}
}
2.2 命名构造方法
- 因为不支持方法（函数）的重载，所以我们没办法创建相同名称的构造方法。
main(List args) {
final person = Person("name", 10);
print(person);
final person2 = Person.withArgments("zzq", 20);
print(person2);
final person3 = Person.withMap({'name': "wll", 'age': 30});
print(person3);
}class Person {
String name;
int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
//Person(this.name, this.age);
//Dart提供一种更简单的语法糖形式Person.withArgments(String name, int age) {
this.name = name;
this.age = age;
}Person.withMap(Map map) {
this.name = map['name'];
this.age = map['age'];
}@override
String toString() {
//重写了toString方法
return "name is $name, age is $age";
}
}
2.3 初始化列表 下面初始化变量的方法，我们称之为：
初始化列表(Initializer list)main(List args) {
final circle = Circle(10, 2);
print(circle);
}class Circle {
int length;
int num;
int distance;
Circle(this.length, this.num) : distance = length * num;
@override
String toString() {
return '$length, $num, $distance';
}
}
2.4 重定向构造方法 在我们需要在一个构造方法中去调用另一个构造方法时，需要使用
重定向方法class Circle {
int length;
int num;
int distance;
Circle(this.length, this.num);
Circle.fromLength(int name) : this(name, 10);
}
2.5 常量构造方法 在某些情况下，传入相同值时，我们希望返回同一个对象，这个时候，可以使用常量构造方法.
默认情况下，创建对象时，即使传入相同的参数，创建出来的也不是同一个对象。
main(List args) {
var p1 = Person('why');
var p2 = Person('why');
print(identical(p1, p2));
// false通过identical函数比较
}class Person {
String name;
Person(this.name);
}
如果将构造方法前加
const进行修饰，那么可以保证同一个参数，创建出来的对象是相同的，这样的构造方法就称之为常量构造方法。main(List args) {
var p1 = const Person('why');
var p2 = const Person('why');
print(identical(p1, p2));
// true
}class Person {
final String name;
const Person(this.name);
}
常量构造方法有一些注意点:
- 注意一：拥有常量构造方法的类中，所有的成员变量必须是final修饰的.
- 注意二: 为了可以通过常量构造方法，创建出相同的对象，不再使用 new关键字，而是使用const关键字
- 如果是将结果赋值给const修饰的标识符时，const可以省略.
factory关键字, 用于通过工厂去获取对象main(List args) {
var p1 = Person('why');
var p2 = Person('why');
print(identical(p1, p2));
// true
}class Person {
String name;
static final Map _cache = {};
factory Person(String name) {
if (_cache.containsKey(name)) {
return _cache[name];
} else {
final p = Person._zzInternal(name);
}
}
Person._zzInternal(this.name);
}
3、setter 和 getter方法
默认情况下，Dart中类定义的属性可以直接被外界访问
但是有时候，监控这个
类的属性被访问的过程时，可以使用setter和gettermain(List args) {
var dog = Dog('blue');
dog.setColor = 'MC hot';
dog.getColor;
}class Dog {
String color;
set setColor(String color) {
print("set dog color : $color dog");
this.color = color;
}get getColor {
print("get dog color : $color dog");
return color;
}Dog(this.color);
}
4、类的继承
Dart中继承使用
extends关键字，子类中使用super来访问父类。父类的所有成员变量和方法都会被子类继承，除了
构造方法。子类可以添加自己的
成员变量, 并对父类的方法进行重写：main(List args) {
final person = Person('zzq');
person.run();
}class Animal {
String age;
run() {
print('Animal run');
}
}class Person extends Animal {
String name;
Person(this.name);
@override
run() {
print("$name is running");
}
}
子类中可以调用父类的构造方法，对某些属性进行初始化：
- 子类的构造方法在执行前，将隐含调用父类的
无参默认构造方法（没有参数且与类同名的构造方法）。 - 如果父类没有
无参默认构造方法，则子类的构造方法必须在初始化列表中通过super显式调用父类的某个构造方法。
main(List args) {
final person = Person('zzq', 25);
person.run();
}class Animal {
int age;
run() {
print('Animal run');
}Animal(this.age);
}class Person extends Animal {
String name;
Person(String name, int age)//显示调用父类的构造方法
: this.name = name,
super(age);
@override
run() {
print("$name is running");
}
}
5、抽象类
抽象类是通过
abstract声明，在抽象类中，没有具体实现的方法，叫做抽象方法(必须存在于抽象类中)- 抽象类不可以被实例化
- 抽象类中可以实现方法，没有实现的方法，必须在子类中实现
main(List args) {
final Shape cir = Sphere(20);
//父类指针指向子类对象
final Shape cir2 = Cube(20);
print(cir.getVolume());
//调用相同的方法 结果不同
print(cir2.getVolume());
//调用相同的方法 结果不同
}abstract class Shape {
double getVolume();
}class Sphere extends Shape {
int radius;
Sphere(this.radius);
@override
double getVolume() {
return radius * radius * radius * 3.14 * 4 / 3;
}
}class Cube extends Shape {
int radius;
Cube(this.radius);
@override
double getVolume() {
return radius * radius * radius * 1.0;
}
}
6、隐式接口
默认情况下，定义的每个类都相当于默认也声明了一个接口，可以由其他的类来实现
通过
implements实现某个类时，类中所有的方法都必须被重新实现(无论这个类原来是否已经实现过该方法)通常将用于给别人实现的类声明为抽象类
main(List args) {
final person = Person();
person.fly();
person.run();
}abstract class Runner {
run() {}
}abstract class Flyer {
fly() {}
}class Person implements Runner, Flyer {
@override
run() {
print("run");
}@override
fly() {
print('fly');
}
}
7、Mixin混入
但一个类需要直接复用之前类的原有实现方案时，使用
Mixin混入的方式- 除了可以通过class定义类之外，也可以通过
mixin关键字来定义一个类。
- 只是通过
mixin定义的类用于被其他类混入使用，通过with关键字来进行混入。
main(List args) {
final person = Person();
person.fly();
person.run();
}mixin Runner {
run() {
print("run");
}
}mixin Flyer {
fly() {
print("fly");
}
}class Person with Runner, Flyer {}
8、类成员和方法
使用
static关键字来定义属性和方法main(List args) {
var stu = Student();
stu.name = 'zzq';
stu.sno = 110;
stu.study();
Student.time = '晚上6点';
// stu.time = '晚上6点';
错误做法, 实例对象不能访问类成员
Student.attendClass();
// stu.attendClass();
错误做法, 实现对象不能访问类方法
}class Student {
String name;
int sno;
static String time;
study() {
print('$name在学习');
}static attendClass() {
print('去上课');
}
}
四、枚举类型 Dart的枚举类型没有Swift那么强大，仅仅是定义一个固定的值而已，提高易读性
枚举类型中有两个比较常见的属性:
- index: 用于表示每个枚举常量的索引, 从0开始.(不能自定义索引值)
- values: 包含每个枚举值的List.
main(List args) {
print(Colors.red.index);
print(Colors.green.index);
print(Colors.blue.index);
print(Colors.values);
print(Colors.values.runtimeType);
//List
}enum Colors { red, green, blue }
五、泛型 1、List和Map的泛型
//List的定义
abstract class List implements EfficientLengthIterable
//Map
abstract class Map
示例：
// 创建List的方式
var names1 = ['why', 'kobe', 'james', 111];
print(names1.runtimeType);
// List2、类定义的泛型
如果我们需要定义一个类, 用于存储位置信息Location, 但是并不确定使用者希望使用的是int类型,还是double类型, 甚至是一个字符串, 这个时候如何定义呢?
- 一种方案是使用Object类型, 但是在之后使用时, 非常不方便
- 另一种方案就是使用泛型.（推荐使用）
main(List args) {
Location l2 = Location(10, 20);
print(l2.x.runtimeType);
// intLocation l3 = Location('aaa', 'bbb');
print(l3.x.runtimeType);
// String
}class Location {
T x;
T y;
Location(this.x, this.y);
}
main(List args) {
Location l1 = Location(10, 20);
print(l1.x.runtimeType);
// intLocation l2 = Location("12.3456", '12.3456');
//报错
print(l2.x.runtimeType);
// String
}
如果我们希望类型只能是num类型, 怎么做呢?
class Location {
T x;
T y;
Location(this.x, this.y);
}
3、泛型方法的定义
泛型方法的新语法允许在方法和函数中使用类型参数。
main(List args) {
var names = ['why', 'kobe'];
var first = getFirst(names);
print('$first ${first.runtimeType}');
// why Stringvar scores = [12, 23, 45];
var firstScore = getFirst(scores);
print('$firstScore ${firstScore.runtimeType}');
// 12 int
}T getFirst(List ts) {
return ts[0];
}
六、库的使用 import语句用来导入一个库，后面跟一个字符串形式的Url来指定表示要引用的库，语法如下：
import '库所在的uri';
常见的库URI有三种不同的形式:
- 来自dart标准版，比如dart:io、dart:html、dart:math、dart:core(默认已导入)
//dart:前缀表示Dart的标准库，如dart:io、dart:html、dart:math
import 'dart:io';
- 使用相对路径导入的库，通常指自己项目中定义的其他dart文件
//当然，你也可以用相对路径或绝对路径的dart文件来引用
import 'utils/dart02.dart';
//同级目录
import './dart02.dart';
//从上级目录
import '../hellodart/utils/dart02.dart';
//从根目录开始
- Pub包管理工具管理的一些库，包括自己的配置以及一些第三方的库，通常使用前缀package
//Pub包管理系统中有很多功能强大、实用的库，可以使用前缀 package:
import 'package:flutter/material.dart';
1、库文件中内容的显示和隐藏 如果希望
只导入库中某些内容，或者刻意隐藏库里面某些内容，可以使用show和hide关键字- show关键字：可以显示某个成员（屏蔽其他）
- hide关键字：可以隐藏某个成员（显示其他）
import '../hellodart/utils/dart02.dart' hide getFirst;
import 'lib/student/student.dart' show Student, Person;
库中内容和当前文件中的名字冲突，可以使用2、库的定义— library关键字 通常在定义库时，我们可以使用as关键字来使用命名空间
import 'lib/student/student.dart' as Stu; Stu.Student s = new Stu.Student();
library给库起一个名字。但是目前库的名字并不影响导入，因为import语句用的是字符串URI。
library dart.math;
//math库的头部
3、库的管理 官方不推荐使用
part关键字，库非常大，用到export关键字将每一个dart文件作为库文件，使用export关键字在某个库文件中单独导入, 然后再将汇总的库声明给其他文件使用
dart02.dart文件：T getFirst(List ts) {
return ts[0];
}
helloDart.dart文件：getName(String name) {
print('$name');
}
total.dart文件：export './helloDart.dart';
export './utils/dart02.dart';
student.dart文件：//其他文件
import '../hellodart/total.dart';
//导入`total.dart` 可使用上面2个库的方法main(List args) {
print(getName("name"));
print(getFirst(['1', '2', '3']));
}
案例学习：购物车 在不使用任何Dart特有语法的情况下，写一个购物车的案例：
//定义商品Item类
class Item {
double price;
String name;
Item(name, price) {
this.name = name;
this.price = price;
}
}//定义购物车类
class ShoppingCart {
String name;
DateTime date;
String code;
List- bookings;
price() {
double sum = 0.0;
for(var i in bookings) {
sum += i.price;
}
return sum;
}ShoppingCart(name, code) {
this.name = name;
this.code = code;
this.date = DateTime.now();
}getInfo() {
return '购物车信息:' +
'\n-----------------------------' +
'\n用户名: ' + name+
'\n优惠码: ' + code +
'\n总价: ' + price().toString() +
'\n日期: ' + date.toString() +
'\n-----------------------------';
}
}void main() {
ShoppingCart sc = ShoppingCart('张三', '123456');
sc.bookings = [Item('苹果',10.0), Item('鸭梨',20.0)];
print(sc.getInfo());
}
通过这两天的学习，我们运用Dart语法的特性，进行Dart式的改造：（中间的优化过程自己对比理解）
main(List args) {
ShopingCart car = ShopingCart.withCode("张三", code: "123456")
..bookings = [Item('苹果', 12.98)]//级联语法
..printInfo();
ShopingCart car2 = ShopingCart("李四")
..bookings = [Item('梨子', 12.98)]
..printInfo();
}class Meta {//抽取公共方法、属性到父类
double price;
String name;
Meta(this.name, this.price);
}class Item extends Meta with PrintHelper {
Item(name, price) : super(name, price);
//构造方法Item operator +(Item item) => Item(name + item.name, price + this.price);
//重载 + 运算符@override
getInfo() {}
}abstract class PrintHelper {//抽象类：用途 公共打印
printInfo() => print(getInfo());
getInfo();
}class ShopingCart extends Meta with PrintHelper {
DateTime date;
String code;
List- bookings;
double get price =>
bookings.reduce((value, element) => value + element).price;
ShopingCart(name) : this.withCode(name, code: null);
//重定向构造方法ShopingCart.withCode(name, {this.code})//命名可选参数
: date = DateTime.now(),
super(name, 0);
//赋值默认值@override
printInfo() {
// TODO: implement printInfo
return super.printInfo();
}@override
getInfo() => '''
购物车信息:
-------------------
用户名：$name
优惠码：${code ?? "没有"}
总价：$price
Date:$date
-------------------
''';
}
这里面用到了：
1、Dart类的命名可选构造方法
2、类的继承，抽象类的使用，混入
3、运算符的重载
4、字符串的插入
5、级联语法
推荐阅读
- EffectiveObjective-C2.0|EffectiveObjective-C2.0 笔记 - 第二部分
- 一个人的碎碎念
- 野营记-第五章|野营记-第五章 讨伐梦魇兽
- 遇到一哭二闹三打滚的孩子，怎么办┃山伯教育
- Shell-Bash变量与运算符
- 赢在人生六项精进二阶Day3复盘
- 清明，是追思、是传承、是感恩。
- 2019年12月24日
- 陇上秋二|陇上秋二 罗敷媚
- 牛人进化+|牛人进化+ 按自己的意愿过一生