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

 

posted @ 2019-06-29 18:42 slipover 阅读(...) 评论(...) 编辑 收藏