main(List<String> args) {
int number = 18;
String name = "xiaoming";
double salary = 150300.56;
bool isDoorOpen = true;
}
2.3 const和final声明常量
main(List<String> args) {
final int number = 42;
const String name = "xiao ming";
//Omit explicitly defining data types
final salary = 150300.56;
const isDoorOpen = true;
}
main(List<String> args) {
//Numbers
int x = 100;
double y = 1.1;
int z = int.parse('10');
double d = double.parse('44.4');
//Strings
String s = "This is a string";
String backslash = "I can't speak";
//String interpolation
String interpolated = "Value of x is $x"; //Prints: Value of x is 100
String interpolated2 = "Value of s is ${s.toLowerCase()}";
//Prints: Value of s is this is a string
//Booleans
bool isDoorOpen = false;
}
3.2 常用方法
3.2.1 number 取值范围：-2^53 to 2^53
// String -> int
var one = int.parse('1');
// String -> double
var onePointOne = double.parse('1.1');
// int -> String
String oneAsString = 1.toString();
// double -> String 注意括号中要有小数点位数，否则报错
String piAsString = 3.14159.toStringAsFixed(2);
3.2.2 string
'''...'''，"""..."""表示多行字符串(连续三个单引号或双引号)
r'...',r"..."表示“raw”字符串（字符串前加字母 r 则不处理转义）
可用${}引用表达式，或直接$引用标识符
示例代码：
String s = "FRONT END DEVELOPER";
print ("A Commpany has a $s, which is good idea." ==
"A Commpany has a Front End Developer," +
" which is good idea.");
print("I am a " +
"${s.toUpperCase()} is very hornor!" ==
"I am a " +
"FRONT END DEVELOPER is very hornor!");
3.2.3 bool
Dart 是强 bool 类型检查，只有bool 类型的值是true 才被认为是true
3.2.4 List
声明 List 用 new List() 或者简单的赋值
下面是一些基本操作
main(List<String> args) {
// 声明
var vegetables = new List();
//或者简单赋值声明
var fruits = ["apples", "peaches"];
// 添加元素
fruits.add("bananas");
// 添加多个元素
fruits.addAll(["grapes","oranges"]);
// 获取第一元素
fruits.first
// 获取最后一个元素
fruits.last
// 查找某个元素的索引号
assert(fruits.indexOf("apples") === 0);
// 删除指定位置的元素，返回删除的元素
fruits.removeAt(index);
// 删除指定元素，成功返回 true ，失败返回 false
fruits.remove("oranges");
// 删除最后一个元素，返回删除的元素
fruits.removeLast
// 删除指定范围的元素，含头不含尾。成功返回 null
fruits.removeRange(start, end);
// 删除指定条件的元素，成功返回null
fruits.removeWhere((item) => item.length > 6);
//删除所有元素
fruits.clear();
// sort()排序 传入一个函数作为参数，return <0 表示有小到大，>0 表示由大到小；
fruits.sort((a, b) => a.compareTo(b));
//常量 List
var list = const [1,2,3,4]; //Cannot alter elements of this list
}
//一个简单的类
class Point {
num x;
num y;
}
void main() {
var point = Point();
point.x = 4; // Use the setter method for x.
assert(point.x == 4); // Use the getter method for x.
assert(point.y == null); // Values default to null.
}
还记得吗： dart中一切未赋值的变量值都是 null；
7.1.2 构造函数
通过创建一个与类同名的函数来声明构造函数；
class Cat {
String name;
int age;
Cat(String name, int age) {
this.name = name;
this.age = age;
}
}
void main() {
Cat Tom = new Cat("Tom", 2);
print(Tom.name);
}
dart 提供了语法糖，以更简单的方式来生成构造函数；
class Cat {
String name;
int age;
Cat(this.name ,this.age)
}
void main() {
Cat Tom = new Cat("Tom", 2);
print(Tom.name);
}
main(List<String> args) {
Pug p = new Pug.small('Duffy');
print(p.name);
}
class Dog {
String name;
int age;
Dog(this.name, this.age);
Dog.newBorn() {
name = 'Doggy';
age = 0;
}
}
class Pug extends Dog {
Pug(String name, int age): super(name, age);
Pug.small(Stirng name): this(name, 1);
Pug.large(Stirng name): this(name, 3);
}
class Employee extends Person {
// Person does not have a default constructor;
// you must call super.fromJson(data).
Employee.fromJson(Map data) : super.fromJson(data) {
print('in Employee');
}
}
7.3 类中的函数
定义函数：在类里定义函数和单独定义函数是一样的；
main(List<String> args) {
Cat Tom = new Cat("Tom", 1);
Tom.eat();
}
class Cat {
String name;
int age;
Cat(this.name ,this.age)
Cat.newBorn(){
name = "Cherry";
age = 0;
}
eat(){
print("I like eating fish！");
}
}
- 函数重写
main(List args){
Cat Cherry = new Garfield.small("jiafei");
Cherry.eat();
}
// 父类 -- 猫
class Cat{
String name;
int age;
Garfield(String name, int age): super(name,age);
Garfield.small(String name, int age): this(name, 1);
Garfield.large(String name, int age): this(name, 3);
@override
eat(){
print("I like eating small can！");
}
// Define two calculated properties: right and bottom.
num get right => left + width;
set right(num value) => left = value - width;
num get bottom => top + height;
set bottom(num value) => top = value - height;
}
void main() {
var rect = Rectangle(3, 4, 20, 15);
assert(rect.left == 3);
rect.right = 12;
assert(rect.left == -8);
}
void main(){
print(greetBob(Person("Kathy")));// Output: Hello, Bob. I am Kathy.
print(greetBob(Imposter())); // Output: Hi Bob. Do you know who I am?
}
class A {
// Unless you override noSuchMethod, using a
// non-existent member results in a NoSuchMethodError.
@override
void noSuchMethod(Invocation invocation) {
print('You tried to use a non-existent member: ' +
'${invocation.memberName}');
}
}
Flutter 基础—— Dart 入门
Flutter简介
Flutter类似且优于Html、React Native、Weex等跨平台解决方案。ReactNative将JSX生成的代码最终都渲染成原生组件，JS与原生通过JSBridge传递数据。而Flutter则采用完全不同的设计，底层是一套独立的渲染引擎–Skia，所有组件也都是独立于平台的Widget组件，可以在最大程度上保证了跨平台体验的一致性。
Dart
Flutter 使用 Dart 作为开发语言，在深入flutter框架前应该先对dart语言有所了解。据说，dart语言里的API 90%以上与 Java 相同，如果你有 Java 基础，几乎可以很快上手，没有 Java 基础也不用担心，它的 API 很简单，学过 JavaScript 也可以轻松get✅；
几个重要的点：
List <int>（整数列表）或List <dynamic>（任何类型的对象列表）。(Dart支持顶级函数（例如main（）），以及绑定到类或对象的函数（分别是静态和实例方法）。您还可以在函数内创建函数（嵌套函数或本地函数）)。
这里简单介绍下：
Hello World
变量声明
数据类型
函数
流程控制
异常处理
类
泛型
异步操作
1. Hello World
和 Java 程序一样，dart程序也有一个入口函数 main ，把上面的程序保存为
hello_world.dart, 在命令行运行：安装之后需要配置环境变量
启动 dart 程序
2. 变量声明
变量声明关键字：
var、const、final、int、String、double(浮点型)、bool2.1 var 声明变量 —— 不指定类型
和 JavaScript 一样, 可以用
var声明变量不一样的是，
dart自带类型推断，一旦给变量赋值，它的类型就不可变了。2.2
int、String、double(浮点型)、bool声明变量——指定变量类型2.3
const和final声明常量3. 数据类型
3.1 dart提供基本的数据类型：
3.2 常用方法
3.2.1 number 取值范围：-2^53 to 2^53
3.2.2 string
${}引用表达式，或直接$引用标识符示例代码：
3.2.3 bool
Dart 是强 bool 类型检查，只有bool 类型的值是true 才被认为是true
3.2.4 List
声明 List 用 new List() 或者简单的赋值
下面是一些基本操作
3.2.5 map 散列表
基本操作
4. 函数
Dart是一种真正的面向对象语言，因此即使是函数也是对象并且具有类型Function。这意味着函数可以分配给变量或作为参数传递给其他函数。您也可以像调用函数一样调用Dart类的实例。
函数声明无需 function 关键字；
函数名前可标注函数返回类型，没有返回值的函数返回类型可设为void； 函数的参数可设定类型也可以不设
支持箭头函数
命名参数
调用命名参数的函数时，如果没有指定参数的名字，程序会崩溃报错。
参数默认值
为命名参数的某个参数指定默认值，这个参数就会变成可选参数。如上面的函数指定默认参数后可以这样调用：
5. 流程控制
这个流程控制语句使用和 JavaScript 没什么差异
6. 异常处理
try...catch...finaly 也跟 JavaScript 差不多。。。
7. 类 Class
7.1 类的定义
7.1.1 一个简单的类
还记得吗： dart中一切未赋值的变量值都是 null；
7.1.2 构造函数
通过创建一个与类同名的函数来声明构造函数；
dart 提供了语法糖，以更简单的方式来生成构造函数；
上面的代码只用一行代码就完成了构造函数，第一个参数，对应到name,第二个参数对应age；
命名构造函数（构造函数标识符）
上面的代码，构造函数有了一个名字（newBorn）, 这样在初始化时更清楚使用了哪个类
7.2 继承
dart 的类通过 extends 关键字实现继承
调用父类构造函数
Garfield类继承了Cat类，并且在Garfield的构造函数里用SUPER关键字调用了Cat类的构造函数，重定向构造函数：有时构造函数的唯一目的是重定向到同一个类中的另一个构造函数。重定向构造函数的主体是空的，构造函数调用出现在冒号（:)之后。
上面定义了两个命名构造函数， small 调用了自身的构造函数，而自身又调用了dog的构造函数。
7.3 类中的函数
class Cat { String name; int age;
}
main(List args){
Cat Cherry = new Garfield.small("jiafei");
Cherry.eat();
}
// 父类 -- 猫
class Cat{
String name;
int age;
} // 子类 -- 加菲猫 class Garfield extends Cat{
}
class Rectangle { num left, top, width, height;
Rectangle(this.left, this.top, this.width, this.height);
// Define two calculated properties: right and bottom. num get right => left + width; set right(num value) => left = value - width; num get bottom => top + height; set bottom(num value) => top = value - height; }
void main() { var rect = Rectangle(3, 4, 20, 15); assert(rect.left == 3); rect.right = 12; assert(rect.left == -8); }
abstract class Doer { // 实例的变量和方法...
void doSomething(); }
class EffectiveDoer extends Doer { void doSomething() { // 提供了函数体，所以这不是一个抽象方法 } }
class Person{ final _name; // 这是一个接口，但只能在本类中访问
}
Class Imposter Implements Person{ get _name => ""
String greet(String who) => "Hi $who, do you know who I am ?"; }
String greetBob(Person person) => person.greet("Bob");
void main(){ print(greetBob(Person("Kathy")));// Output: Hello, Bob. I am Kathy. print(greetBob(Imposter())); // Output: Hi Bob. Do you know who I am? }
class A { // Unless you override noSuchMethod, using a // non-existent member results in a NoSuchMethodError. @override void noSuchMethod(Invocation invocation) { print('You tried to use a non-existent member: ' + '${invocation.memberName}'); } }
class Dog { String name; int age;
Dog(this.name, this.age);
static bark() { print('Bow Wow'); } }
main() { Dog.bark(); }
import 'dart:math';
class Point { num x, y; Point(this.x, this.y);
static num distanceBetween(Point a, Point b) { var dx = a.x - b.x; var dy = a.y - b.y; return sqrt(dx dx + dy dy); } }
void main() { var a = Point(2, 2); var b = Point(4, 4); var distance = Point.distanceBetween(a, b); assert(2.8 < distance && distance < 2.9); print(distance);//2.8284271247461903
}
enum Color { red, green, blue }
assert(Color.red.index == 0); assert(Color.green.index == 1); assert(Color.blue.index == 2);
List colors = Color.values;
assert(colors[2] == Color.blue);
mixin Musical { bool canPlayPiano = false; bool canCompose = false; bool canConduct = false;
void entertainMe() { if (canPlayPiano) { print('Playing piano'); } else if (canConduct) { print('Waving hands'); } else { print('Humming to self'); } } }
class Musician extends Performer with Musical { // ··· }
class Maestro extends Person with Musical, Aggressive, Demented { Maestro(String maestroName) { name = maestroName; canConduct = true; } }
// 构造函数的参数化类型 var names = List();// 代表字符串列表
names.addAll(['Seth', 'Kathy', 'Lars']);
names.add(42); // Error
var gifts = Map<String, String>(); gifts['first'] = 'partridge'; gifts['second'] = 'turtledoves'; gifts['fifth'] = 'golden rings'; gifts[17] = 'argon'; //Error
// 使用字面量集合 var name =['Seth', 'Kathy', 'Lars'];
var gifts = ,{
'first': 'partridge',
'second': 'turtledoves',
'fifth': 'golden rings'
}
main(List args) {
DataHolder dataHolder = new DataHolder('Some data');
print(dataHolder.getData());
dataHolder.setData('New Data');
print(dataHolder.getData());
}
class DataHolder {
T data;
DataHolder(this.data);
getData() { return data; }
setData(data) { this.data = data; } }
使用
async/await关键字执行异步操作，使用try,catch和finally来处理使用await的代码中的错误； 用async关键字修饰函数体就声明了该函数是异步函数；处理流 Stream 可用await for等待遍历stream的所有值，但要小心使用：
表达式的值必须具有Stream类型。执行过程如下:
保证
await、await for要处在异步操作中参考文档：