flutter-初识（基础语法）
前言：笔者学过 java，刚刚接触 flutter，记录下基本的一些语法。
一、认识Flutter
Flutter 是 google 推出的，使用的 Dart 语言，它可以跨平台实现 Android 和 IOS 的移动UI开发。当然，他不止这些特性，但是笔者正是因为这点来学习的。
Flutter 官网：https://flutter.dev/
二、Dart基本语法
Dart 官网：http://dart.goodev.org/
Dart 有一个网页编辑器，如果你还没有安装环境，可以使用 DartPad 体验下 dart 的语法
复制代码
// 接下来笔者将以实际代码来展示 dart 的一些基本语法
//首先现在这就是一个完整的 .dart 文件，如同 .java
//我们把他取名为 firstDart.dart
//这里定义了一个叫做 A 的类
class FirstDart {
//下面定义了些可能常用的类型属性
//注意：dart 中所有对象不赋值的情况下都是 null，null 也是对象
//先看下这两个动态数据类型，它们可以赋值任何对象
var vStr = "字符串";
var vInt = 1;
dynamic dStr = "字符串";
dynamic dInt = 1;
//我们看下数值。
//num，int，double。num 其实就是包含了 int 和 double
num n = 0;
int i = 0;
double d = 0.0;
//dart 中的字符串定义和javascript很类似，非常自由，单双引号都可以
String str1 = "这是字符串";
String str2 = '这是字符串';
//字符串拼接方式也是很多，简单了解下，需要的时候可以大胆多尝试些写法
String str3 = "这是" + "字符串";
String str4 = "这是" "字符串";
String str5 = "这是" '字符串';
String str6 = """
这也是
字符串
""";
//boolean 类型，这个简单就不多说了
bool b = true;
//集合，详细的后面再说，这里简单展示下List的一些定义
List list1 = new List();//默认长度是0
List<String> list2 = new List<String>(3);//dart中也是有泛型的，初始化集合大小
List list3 = new List()..length = 3;//这其实就是一种链式写法，后面再详细介绍
List list4 = [1,'2',3.0,true];//直接初始化集合
List<String> list5 = ['1',"2"];//如果前置类型指定了泛型，初始化就必须是指定的类型
//映射，详细的后面再说，这里简单展示下Map的一些定义
Map map1 = new Map();
Map<int,String> map2 = new Map();//Map的泛型
Map map3 = {"key1" : "value1", 1 : 2};//直接初始化Map
//函数对象，将代码块封装到这个函数对象中可用于传递
//dart 也可以使用 Lambda表达式，不过java是 ->，而dart是 =>
//这个目前发现好像有些和我想的不一样，具体的以后再补充，目前发现里面好像不让用分号，也就是不让写多行代码
Function fun1 = () => print("这里是代码块");
Function fun2 = (String str) => str.trim().toLowerCase();//可以函数对象的入参，不过好像没有检查，可能会引发启动错误
//下面我们再看下常用的一些修饰词
//final 目前来看和java差不多
final String finalStr = "这是一个不可修改的字符串";
//static 目前来看和java差不多
static String staticStr = "这是一个静态字符串";
//static final 组合使用要注意，static 必须修饰在 final 前面，否则会编译错误，java 中是没有问题的
static final String staticFinalStr = "这是一个不可修改的静态字符串";
//const 常量，目前觉得它非常类似 final，但是它只能修饰静态的
static const String constStr = "这是一个常量";
//_ 下滑线，这个可以用于大多数名称（如：变量名，类名等）前，它会将修饰的类或变量私有化，类似 java 的 private
String _privateStr = "这是一个私有的字符串";
//下面看下构造器和方法
//构造器
//FirstDart();//没有定义构造器的时候应该就是这样的一个默认构造器
//注意：dart 一个类中只能定义一个构造器，但是 dart 对于参数非常自由，下面讲方法参数的时候会介绍
FirstDart([String str]) {
if (str != null) {
this._privateStr = str;
}
}
//方法
void method1() { } //无参无返回
String method2() { return "返回字符串"; } //无参有返回
//可以看到返回定义是可以不写的，但是并不推荐，因为这样没有可读性
method3() { } //默认无返回
method4() { return "返回字符串"; } //默认返回字符串类型
//在方法名前加 _ 就可以将方法私有化
void _method5() {
print("控制台打印"); //这个方法是内置的，哪里都可以调用
}
//async 异步，方法参数后定义
void method6() async {
//await 等待，必须在 async 下使用
await print("初始化");
}
//下面看下 dart 中参数可以怎么定义
//[] 表示可选参数，顾名思义 可以传，也可以不传
//注意：可选参数必须定义在一起，放到最后面，传参时是按照方法顺序的
//看到 param4，可以看到参数定义可以不指定类型的，应该默认 Object 的，不过不推荐
//以及最后面多出一个逗号也不会有编译错误，java 的话就比较严格了，不过这并不能说是优点
static void method7(int param1, String param2, [double param3, param4, ]) {
if (param3 != null) { //假设 param1 = 5，param3 = 2.1
//简单看下运算符
print(param1 * param3); //输出：10.5
print(param1 / param3); //输出：2.380952380952381
print(param1 ~/ param3); //取整，输出：2
print(param1 % param3); //输出：0.7999999999999998
//${} 字符串中引入简单操作
print("param1 + param3 = ${param1 + param3}"); //输出：param1 + param3 = 7.1
}
//如果 param2 = "参数二"
print("我们引入${param2}这个字符串"); //输出：我们引入参数二这个字符串
if (param4 != null) { //假设 param4 = "参数四"
//{} 花括号在某些情况是可以不写的，但是不推荐
print("这是param4的值是$param4"); //输出：这是param4的值是参数四
}
}
//{} 表示命名参数，在调用的时候不需要关心参数顺序，但需要指定参数名称，同时他们都是可选的
//例：FirstDart.method8(param2: "参数二", param1: "参数一");
// FirstDart.method8(param1: "参数一");
static void method8({String param1, String param2}) {
}
//也可以这样组合，但是也要注意，命名参数应该都放在一个 {} 中，并放在最后
//命名参数 包含了 可选参数 的功能，所以他们组合自然是没有意义的
//例：FirstDart.method9("参数一", param2: "参数二", param3: "参数三");
// FirstDart.method9("参数一");
static void method9(String param1, {String param2, String param3}) {
}
}
//接下来我们看下类的定义还有哪些东西
//注意：dart 中没有内部类的概念，不可以在 class 中再定义一个 class，但是允许一个 .dart 文件中有多个 class
//A 这是一个类，同时它也可以是一个接口，没有定义构造器的时候还可以是一个"混合类"
class A {
void a() { print("这是A的a方法"); }
}
//extends 继承，和 java 一样，只能单继承
class Ason extends A {
}
//implements 实现，可以多实现，但是必须重写方法
class Aimpl implements A {
@override
void a() { }
}
//with 混合，这对我来说是个新鲜概念
//Amixin 可以使用 with 多个混合类，同时获得他们的所有方法和属性，有点多继承的意思
//它还有很多其他的用法和讲究，后面我再补充
class Amixin with A {
}
//这里定义了一个抽象类 B，这个和 java 差不多
abstract class B {
void b();
void bImpl() { }
}
//这是定义了一个枚举类 C，和 java 有写区别
enum C {
a,b,c
}
//这是定义了一个混合类 D
//注意：混合类没有构造函数
mixin D on B { //on 是一个关键字，它表示混合 D 必须 extends 或 implements B
void a() { print("这是D的a方法"); }
void d1() { }
void d2() { }
void d3() { }
}
//混合 D 必须先继承 B，因为 B 有抽象方法，所以需要实现 b 方法
//同时混合了 D 和 A，它们都有 a 方法，这时候 Dmixin 对象调用的会是 A 的 a 方法
class Dmixin extends B with D,A {
@override
void b() { }
}
复制代码
复制代码
//我们再定义第二个 .dart 文件，取名叫 secondDart.dart，并与 firstDart.dart 是同一目录下
//Dart 没有 package 关键字，但也是有 import 的
//我们使用 import 引入 firstDart.dart，当然同一目录下是默认引入的
import 'package:firstDart.dart';
//as 指定别名，如果引入的两个 dart 中有相同的 class，别名可以解决这个问题
import 'package:firstDart.dart' as first;
//deferred as 指定懒加载，顾名思义
import 'package:firstDart.dart' deferred as first;
//show，只引入 FirstDart 和 A
import 'package:firstDart.dart' show FirstDart,A;
//hide，除了 FirstDart 和 A 其他都引入
import 'package:firstDart.dart' hide FirstDart,A;
//如果 firstDart.dart 在 first 包下，则是这样：import 'package:first/firstDart.dart';
//main 方法，它是程序的入口
void main () {
//如果 first 是懒加载的，每次使用的时候需要调用 loadLibrary() 方法
await first.loadLibrary();
FirstDart firstDart = new first.FirstDart("字符串");
//再看下这些基本操作
//for 循环
for (int i = 0; i < 5; i++) {
//if 判断
if (i >= 3) {
print("i=${i}");
break;
}
}
bool b = true;
//断言，非真条件终止程序，不推荐使用
assert(b);
//while 循环
while(b) {
b = false;
}
int i = 1;
//switch 选择
switch (i) {
case 0:
print("i=0");
break;
case 1:
print("i=1");
break;
default:
print("i=${i}");
}
//List 的一些简单使用
List<String> strList = ["str0", "str1", "str2"];
strList.add("str3");
print(strList.length);//输出：4
strList[0] = "第一个str";
print(strList[0]);//输出：第一个str
strList.forEach((str) => print(str));//遍历
//Map 的一些简单使用
Map<String, String> strMap = {"key1": "value1", "key2": "vlaue2", "key3": "vlaue3"};
strMap.putIfAbsent("key1", () => "newValue1");
strMap.putIfAbsent("key4", () => "value4");
print(strMap.length);//输出：4
print(strMap["key1"]);//输出：value1
strMap["key1"] = "newValue1";
print(strMap["key1"]);//输出：newValue1
strMap.forEach((key,value) => print("${key} = ${value}"));//遍历
}
