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}"));//遍歷
}