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