Flutter dart基础语法技术分享

import 'package:flutter/material.dart';

///
/// @ProjectName:    plugin_base
/// @Package:        lib.common.global_store
/// @ClassName:      base_appbar
/// @Description:     类作用描述
/// @Author:         aozhaoyang
/// @CreateDate:     2021/8/5 10:18
/// @UpdateDate:     2021/8/5 10:18
/// @UpdateRemark:   更新说明
/// @Version:        1.0



start() {
  // assert(d == 5);
  // debugPrint(j);
  //
  // // printInfo(2,isZero);
  // printInfo(2,isZero1);
  invokMethod();
}





///变量讲解  使用var会进行变量的类型推断  js中var只是表示这是一个变量
/// kotlin中var是可变变量，val是不可变变量
var a = 0;
var b = 12.5;
var c = "xsssx";

///变量类型 num、bool、String、List 和 Map
/// num 又分为 int double  都是64位的

int d = 10;
double e = 28.23565;
int f = e.round();
bool g = d == 5;

///String 是uft-16的字符串组成的
String h = "aaanaab";
String j = '''春眠不觉晓，处处闻啼鸟。
夜来风雨声，花落知多少。 ''';
String k = "帅气"+"英俊";
String l = "叼毛$k";
String m = "靓仔${d.toString()}";

///常量  不可变变量就是常量  在变量前面添加final或者const关键字
///  const 表示在编译期间就可以确定的值
///  final 表示在运行时候确定，一旦赋值就不可改变

final name = 'Andy';
const count = 3;

var x = 70;
var y = 30;
final z = x / y;


///dynamic 和 object
/// object是所有类的基类 ，他们都可以对变量进行任意赋值
dynamicAndObject(){
  dynamic n = 12.5;
  n = "dddd";
  Object o = 33;
  o = "dlfjaljl";

  ///dynamic 和 object 区别 object 只能调用几个api，但是dynamic可以调用变量自己的api
  n.lenght();
  n.toString();
  debugPrint( " n的length ${n.lenght()}");
  // o.length();
  o.toString();
}

///空安全 跟kotlin swift 是差不多的
nullable(){
  int i = 0;//必须赋值
  late int aa; //late 延迟赋值
  int? p;

  i.isOdd;
  p?.isOdd;
}

///函数 dart里面所有的类型都是对象类型，函数也是对象，的它的类型是Function，这意味着函数可以定义为变量

Function isZero1 = isZero;
bool isZero(num number){
  return number == 0;
}


///跟kotlin中的高阶函数 js中的闭包是一样的
void printInfo(int number,Function check){
  print("$number is Zero: ${check(number)}");
}

///dart不支持重载，设计了可选命名参数和可选参数
///可选命名参数 {} 以key：value 的方式传递指定参数
///可选参数 [] 这些参数可以忽略

void invokMethod(){

//要达到可选命名参数的用法，那就在定义函数的时候给参数加上 {}
  void enable1Flags({bool? bold, bool? hidden}) => print("$bold , $hidden");

//定义可选命名参数时增加默认值
  void enable2Flags({bool bold = true, bool hidden = false}) => print("$bold ,$hidden");

//可忽略的参数在函数定义时用[]符号指定
  void enable3Flags(bool bold, [bool? hidden]) => print("$bold ,$hidden");

//定义可忽略参数时增加默认值
  void enable4Flags(bool bold, [bool hidden = false]) => print("$bold ,$hidden");

  //
  void enable5Flags(bool bold, [bool hidden = false, bool? a ,bool? b]) =>
      print("$bold ,hiden $hidden ,a $a, b $b");
//可选命名参数函数调用
  enable1Flags(bold: true, hidden: false); //true, false
  enable1Flags(bold: true); //true, null
  enable2Flags(bold: false); //false, false

//可忽略参数函数调用
  enable3Flags(true, false); //true, false
  enable3Flags(true,); //true, null
  enable4Flags(true); //true, false
  enable4Flags(true,true); // true, true
  enable5Flags(true,false,);//可选参数只能是按照顺序赋值
  ///flutter中大量使用的可选命令参数
}

///普通类

class DartDemo {
  int? x,y,z;
  ///this.x表示传递进来的值，直接赋值给成员变量x
  ///：表示初始化的语句，用，分割多个语句
  DartDemo(this.x, this.y) : z = 0 , assert(x == 0);
}

///dart中没有接口，使用抽象类制定标准
/// 使用extends是继承，只需要重写抽象方法
/// 使用implement是实现接口。属性和已经实现的方法也需要重写
abstract class Anima{
  late int size;
  eat();
  run();
  huxi(){
    print("动物都需要呼吸");
  }
}

class person implements Anima{
  @override
  eat() {
    // TODO: implement eat
    throw UnimplementedError();
  }

  @override
  run() {
    // TODO: implement run
    throw UnimplementedError();
  }

  @override
  int size = 0;

  @override
  huxi() {
    // TODO: implement huxi
    throw UnimplementedError();
  }

}

class Cat extends Anima{
  @override
  eat() {
    // TODO: implement eat
    throw UnimplementedError();
  }

  @override
  run() {
    // TODO: implement run
    throw UnimplementedError();
  }

}


///当我们需要重用代码的时候，不仅仅是使用extends去继承。我们还可以使用mixin 和with来混入，实现代码重用
abstract class Base{

}
/// on只能用在mixin的类上面，表示该类的方法限定于Base或者它的子类使用。
/// 不加on 不限定类，只要with就可以使用这类的方法。
mixin   Point on Base{
    num? x,y;
    void printInfo(){
      print("x$x,y$y");
    }
}

// class Vector extends Point{
//   num? z;
//   @override
//   void printInfo(){
//     print("x$x,y$y,z$z");
//   }
// }

// class Coordinate implements Point{
//   @override
//   num? x = 0;
//
//   @override
//   num? y = 0;
//
//   @override
//   void printInfo() {
//     print("x$x,y$y");
//   }
//
// }

class Coordinate extends Base with Point{

}

testWith(){
  var yyy = Coordinate();
  /// ..级联运算符
  yyy..x = 1
  ..y = 2;
  print (yyy is Point); //true
  print(yyy is Coordinate); //true

  ///顺便在提两个运算符
  ///a??b  如果a为null 表达式取b的值
  ///a??=b 如果a为null a的值取b

}

///flutter 异步  Future 和Stream
/// Future
  testFuture(){
    Future.delayed(Duration(seconds: 2),(){
return "hi world!";
      // throw AssertionError("Error");
    }).then((data){
//执行成功会走到这里
      print(data);
    }).catchError((e){
//执行失败会走到这里
      print(e);
    }).whenComplete((){
//无论成功或失败都会走到这里
    });

    ///网络请求都是异步的，多个网络请求的合并使用wait
    Future.wait([
      // 2秒后返回结果
      Future.delayed(Duration(seconds: 2), () {
        return "hello";
      }),
      // 4秒后返回结果
      Future.delayed(Duration(seconds: 4), () {
        return " world";
      })
    ]).then((results){
      print(results[0]+results[1]);
    }).catchError((e){
      print(e);
    }).whenComplete(() => print("over"));

    ///有顺序的网络请求，使用future避免多层次的嵌套
//先分别定义各个异步任务
//     Future<String> login(String userName, String pwd){
//       ...
//       //用户登录
//     };
//     Future<String> getUserInfo(String id){
//       ...
//       //获取用户信息
//     };
//     Future saveUserInfo(String userInfo){
//       ...
//       // 保存用户信息
//     };

  ///多层嵌套的写法
    // login("alice","******").then((id){
    //   //登录成功后通过，id获取用户信息
    //   getUserInfo(id).then((userInfo){
    //     //获取用户信息后保存
    //     saveUserInfo(userInfo).then((){
    //       //保存用户信息，接下来执行其它操作
    //       ...
    //     });
    //   });
    // })


    /// 避免多层次的嵌套写法
    // login("alice","******").then((id){
    //   return getUserInfo(id);
    // }).then((userInfo){
    //   return saveUserInfo(userInfo);
    // }).then((e){
    //   //执行接下来的操作
    // }).catchError((e){
    //   //错误处理
    //   print(e);
    // });

    ///完全没有嵌套的写法
    // task() async {
    //   try{
    //     String id = await login("alice","******");
    //     String userInfo = await getUserInfo(id);
    //     await saveUserInfo(userInfo);
    //     //执行接下来的操作
    //   } catch(e){
    //     //错误处理
    //     print(e);
    //   }
    // }


    ///Stream 也是用于接收异步事件数据，和 Future 不同的是，它可以接收多个异步操作的结果（成功或失败）。
    /// 也就是说，在执行异步任务时，可以通过多次触发成功或失败事件来传递结果数据或错误异常。
    /// Stream 常用于会多次读取数据的异步任务场景，如网络内容下载、文件读写等。举个例子：
    /// 常用于事件流，就是当处理一个逻辑，需要多次做处理，并且每次处理都可以监听到结果，类似于Android的Rxjava
    Stream.fromFutures([
      // 1秒后返回结果
      Future.delayed(Duration(seconds: 1), () {
        return "hello 1";
      }),
      // 抛出一个异常
      Future.delayed(Duration(seconds: 2),(){
        throw AssertionError("Error");
      }),
      // 3秒后返回结果
      Future.delayed(Duration(seconds: 3), () {
        return "hello 3";
      })
    ]).listen((data){
      print(data);
    }, onError: (e){
      print(e.message);
    },onDone: (){

    });

    ///I/flutter (17666): hello 1
    /// I/flutter (17666): Error
    /// I/flutter (17666): hello 3

  }