dart基础

flutter 评论

[TOC]

dart

  1. 变量

    dart所有类型都是对象 int i； 不给i赋值，输出的时候就是null

    var关键字：

    在声明的变量赋值那一刻，就决定了它是什么类型。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    //这样的var是可以重新赋值不同的值
    //var 在声明变量赋值的那一刻，就决定了它是什么类型
      var a;
      a = 10;
      a = "sfasdf";

      //这样会出现错误
      var b = 0;
      b = "";

dynamic关键字:

在运行的时候决定类型

1
2
dynamic z = "laaa";
z = 10;

Object关键字：

1
2
Object s = 0;
s = "afafs";

final和const关键字：

  • final 关键字根java 差不多

    运行时常量

  • const 和final差不都

    编译器常量：const效率比较高，确定的值 

    1
    2
    //编译完成之后，所有用到i的地方都变成1了
    const i = 1;
    1
    final 类型可以被const赋值

  1. 内置类型

    • int:
    1
    2
    3
    4
    5
    6
    //int 在java占4个字  dart也认为是4位
    //当成java的short int long类型来使用
    //如果 我们写的dart超过了4个字节,那么dart会将其编译成类似的java 当中的long
    //否则编程java当中的short或者int
    int i = 0xffffffffffffff;
    print(i.bitLength);

    • String

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
       //2.1 格式化
        String str = "发达";
        int num = 10;

       //$符号去拼接字符串
       //建议使用 {} 包起来
        String a = "${str}我要找$num号技师";


      //2.2 单引号,和双引号 都可以声明
        String s = '';
        String s1 = '"test"';
        String s2 = "'sfasf'";
        print(s2);

    • bool

    • List数组

      1
      2
      3
      4
      5
      6
      7
      List<String> list = new List();

      List<String> list = List();
      list.add("asfdsaf");
      //像数组一样取值
      String value = list[0];
      print(value);

  1. 操作符

  2. 方法

    dart 可以不在类里面写方法,这个就叫顶层方法

    • 一等方法对象 typedef关键字

      1
      2
      3
      4
      5
      6
      7
      typedef void OnClick();

      class Button {
        void setOnClick(OnClick onclick) {
          onclick();
        }
      }

  • 可选参数位置

    1
    2
    3
    4
    5
    6
    //可选位置参数  可以使用[] 来进行
    // j = 2 是个默认值
    void fun([int i, int j = 2]) {

    }
    fun(1, 0)

  • 可选命名参数

    1
    2
    3
    4
    5
    6
    7
    //可选命名参数
    void funasdfa({int i, int j = 2}) {

    }

    fun(j:10);
    fun(j:10,i:11);

    可选参数位置; 可选命名参数不需要想java一样写大量的构造函数了

  1. 异常

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34

    void test() {
    //  throw new Exception("sfasfas");
        //万物皆对象 111
      throw 111;
    }

    void main() {
      //介绍cast的参数,可以填写两个参数
      try {
        test();
      } catch (e, s) {
        //就是抛出异常对象
        print(e.runtimeType);
        //调用栈信息
        print(s.runtimeType);
        print(s);
      } finally {
        print("aaaaaa");
      }

      //根据不同的异常类型,进行不同的处理
      // on TYPE catch
      // dart 可以抛出对象
      try {
        test();
      } on Exception catch (e) {
        print(e);
      } on Error catch (e) {
        print(e);
      } on int catch (e) {
        print(e);
      }
    }
  1. 类
1
2
///类 dart 命名规则 小写_小写_小写,风格来命名库和文件名名字
///类名使用 UpperCamelCast

  • 构造函数语法糖

    1
    2
    //构造函数语法
    Preson(this.x,this.y);

  • 命名构造函数

    1
    2
    3
    4
    //命名构造方法 要一个this
     //一看就知道这个
     Point.Xafdasf(this.y);
     Point.Xa(y);

  • 参数初始化列表

    1
复习：

一 变量

  1. final和const

    const 是编译时就确定的

    ​ 一个数组被定义了，就无法再改变了，即使是数组内的数据

    ​ 而final仍然可以进行改变内部的值

    根据const的修饰位置不一样导致表现不一样

    const可以这样修饰

    List list = const []

    表示[]这个在编译时已经确定了，而list还是个指向另一个数组对象

    List list = []； //这样是没有问题的

    修饰在变量的前面,这个list不能被改变,重新赋值的时候回报错
    添加的数据也是会报错

    1
    Unsupported operation: Cannot add to an unmodifiable list

    const List list = [];

    const还可以修饰构造方法, final不能

    final 是运行时确定的

    ​ final修饰是变量的指向的对象已经确定了, 不能直接修饰对象身上而const是可以修饰在对象上面的.

    ​ final List list = []
    ​ list.add(1); //值是可以加入进去的,可以进行增删改查

    1
    2
    final List<int> list2 = [];
    list2..add(1)..add(2)..add(3); //.. 是级联操作
    1
    List<int> list =final [] //这样修饰会报错，这个const的用法就不一样
    名字 区别 相同点
    const 1. const是编译时的
    2. const可以修饰在对象上，表示对象在编译时就已经确定了
    3. const可以修饰在构造方法上面，表示构造方法编译时已经确定了，前提是已经确定的值；必须依靠编译期间就能够计算出来的数据进行创建    		 都是修饰后，不能进行修改。
    final 1.final是运行时的
    2.不能修饰构造方法
    3.不能修饰对象上面 ；如：final [] 是错误的

  2. var object dynamic 三者的区别

    var 是个关键字: 声明变量的那一刻就已经确定了类型

    1
    2
    var p =  Person();
    p = 10; //这个值就不能进行赋值了，编译器会在这行报错
    1
    2
    3
    4
    //这种方式是可以的，以最后个p的赋值为准
    var p;
    p = Person();
    p = 10;

    Object ：万物之主

    1
    2
    3
    //object可以这样使用
    Object p = Person();
    p = 10;
    1
    2
    3
    4
    //这样也是对的
    Object p;
    p = Person();
    p = 10;

    dynamic : 运行时确定类型

    1
    2
    3
    4
    5
    6
    7
    8
    dynamic p = Person();
    p = 10;
    p = 'asfasdf';

    dynamic p ;
    p = Person();
    p = 10;
    p = 'asfasdf';

二 7大内置类型

  1. num: int , double

    万物皆对象: 在int 和 double 值如果没赋值就是null

  1. String : 注意一个三引号

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
       
    /**
      * 字符串
      * 不推荐使用 + 来进行字符串拼接, 会创建很多string对象
      *
      */
     //2.1 格式化
     String str = "发达";
     int num = 10;
       
     String a = "${str}我要找$num号技师";
       
     //2.2 单引号,和双引号 都可以声明
       
     String s = '';
     String s1 = '"test"';
     String s2 = "'sfasf'";
     print(s2);
     String s3 = "沙发斯蒂芬\n沙发斯蒂芬";
     //r前缀 row：原始
     String s5 = r"\n";
     print(s5);
     print(s3);
       
     // 三引号 多行字符串声明
     // 大厂思维, 不要用小厂思维
     String s6 = """sssss
     sfasfas
     sfasfas
     sfasfasdfs""";
       
     print(s6);

  1. list : 数组,跟java 的list不一样,和java数组差不多

    1
    2
    3
    4
    5
     List<String> list = new List();
    //  List<String> list = List();
      list.add("asfdsaf");
      String value = list[0];
      print(value);

  1. map

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
      /**
       * 映射集合
       *
       */
      Map<int, int> map = {1: 1, 2: 2, 10: 4};

      print(map[10]);

      //Unhandled exception:
      //Unsupported operation: Cannot set value in unmodifiable Map
    //  var map1 = const {1: 1, 2: 2};
    //  map1[3] = 10;
      for (var o in map.keys) {
        print(o);
      }

  1. bool

  2. Runes

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    /**
      * Runes : 特殊字符表示类:  Unicode32
      *
      */
     Runes ss = Runes("sfasdf");
     print(ss);
       
     // java String 本身是16位
     //超过4位就要用 {} 这个括起来
     // String 代码点，代码单元   String.length() 表现的跟字符长度一样的
     // 后面增加到32位  一开始java设计string类的时候只有16位，认为这么多就可以了
     // String.length() utf-8个个数
     var clapping = '\u{1f44f}';
     print(clapping);

  1. Symbols 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    /**
       * symbols 标识符
       *
       */

      var aaa = #sfaf;

      switch (aaa) {
        case #afa:
          break;
      }

三 操作符

  1. 类型转换和类型判断操作符 (as 和 is is! )

    as 相当于 java中的强制转换

    is 相当于 instanceof 这个关键字

    is! 表示不是这个类的类型

  2. 赋值操作符

    //这个叫安全赋值

    objec x = A ??= B : 如果A是null的情况下选择B，否则选择A

  3. 条件表达式

    1
    2
    3
      * A ?? B  如果A 为null， 就返回B
      *         如果A不为null，就返回A
    A ?? A

  4. 级联操作

    final List list2 = [];
    list2..add(1)..add(2)..add(3); //.. 是级联操作

  5. 安全操作符

    kotlin里面貌似也常用这个操作符
    ?.

    1
    2
    3
    4
    5
    6
    /**
      * ?. 安全操作符
      *
      */
     String str;
     print(str?.length);

三 方法

  1. 一等方法对象

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    typedef Function My(int x, int y);

    void fun(My f) {
      f(10, 21);
    }

    void main() {
      Function f = (int i, int j) {
        print("11111" + i.toString());
      };
      fun(f);
    }

  1. 可选位置参数 []

    1
    2
    3
    void fun2([int x, int y]) {
      print(x);
    }

  1. 可选命名参数

    1
    2
    3
    void fun3({int x, int y}) {
      print(x);
    }

  2. 默认参数值

    1
    2
    3
    void fun4({int x, int y = 10}) {
      print(x);
    }

  1. 匿名方法

    相当于lambda表达式

    (v) {

    }

    1
    2
    3
    var func = () {
        print("Hello");
      };

四 异常

  • dart中的异常和java差不多

    1

Zhou SaitoAndroid Developer & Designer

Android开发工程师,半音阶口琴爱好者