Dart基础语法

dart 基础语法，很基础所以粗略带过，后面的博客打算只记录一些重要且常用的知识点。

数据类型

1、字符类型

//字符串 --- String
var str1 ='Nice to meet you';
String str2 = "Nice to meet you too";
String str3 = str1 +str2;
print(str3);

2、数值类型Numbers

//int - 必须是整型
int year = 2020;
//double - 整型或者浮点型
double a = 3.1415;
double b = 3;

3、布尔类型

//bool - 布尔类型
bool isOk = false;
if(isOk){
	print("I love you baby!");
}

4、数组/集合—List

//1、直接使用的方式
var l1=['aaa','bbbb','cccc'];
int size = l1.length;
int firstElement = l1[0];
//2、声明方式---不指定类型
var l2 = new List();
l2.add("aaa");
l2.add("bbb");
l2.add("ccc");
//3、声明方式----指定类型
List l3 = new List<String>();
l3.add("aaa");
l3.add("bbb");
l3.add("ccc");

5、字典–Map–键值对

//1、直接使用方式
var demoMap = {
	"name":"czk",
	"age":18,
	"sex":"男"
}
String name = demoMap["name"];
int age = demoMap["age"];
String sex = demoMap["sex"];

//2、声明的方式
Map mp = new Map();
mp["name"] = "czk";
mp["age"] = 18;
mp["sex"] = "男";

6、Runes ----不常用

//Rune是UTF-32编码的字符串。它可以通过文字转换成符号表情或者代表特定的文字。
  var clapping = '\u{1f44f}';
  print(clapping);
  print(clapping.codeUnits);
  print(clapping.runes.toList());
        
  Runes input = new Runes(
  '\u2665  \u{1f605}  \u{1f60e}  \u{1f47b}  \u{1f596}  \u{1f44d}');
  print(new String.fromCharCodes(input));

7、Symbols ----不常用

//Symbol对象表示在Dart程序中声明的运算符或标识符。

8、数据类型转换

//字符型转成数值型 int.parse();double.parse();
var a = int.parse("12");
var b = double.parse("2.34");
// is 关键字可以判断类型
if(a is int){
	print("a是int类型");
}
if(b is double){
	print("b是double类型");
}
//数值型转换成字符型 toString

运算符

1、算术运算符 + - * / ~/ (取整) %（取余）

  int a=13;
  int b=5;
  print(a+b);   //加
  print(a-b);   //减
  print(a*b);   //乘
  print(a/b);   //除
  print(a%b);   //其余
  print(a~/b);  //取整

2、关系运算符 == ！= > < >= <=

  int a=5;
  int b=3;
  print(a==b);   //判断是否相等
  print(a!=b);   //判断是否不等
  print(a>b);   //判断是否大于
  print(a<b);   //判断是否小于
  print(a>=b);   //判断是否大于等于
  print(a<=b);   //判断是否小于等于

3、逻辑运算符 ! && ||

  bool happy = true ;
  bool sad = false ;
  //非
  if(!sad){
  	print('I am very happy !');
  }
  //与
  if(happy&&sad){
    print('I am sad !');
  }
  //或
  if(happy||sad){
    print('I am very happy!');
  }

4、赋值运算符

//赋值运算符 =   ??=     +=     -=    *=   /=   %=  ~/=
// ??= 表示如果为空的话就复制
int data;
data??= 20; //如果data为空就把20 赋值给它
print(data);

条件表达式

**1、if else **

if(true){
	print("条件成立");
}else{
	print("条件不成立");
}

**2、switch case **

   var sex="男";
   switch(sex){
     case "男":
       print('性别是男');
       break;
     case "女":
       print('性别是女');
       break;
     default:
       print('传入参数错误');
       break;
  }

**3、三目运算符 ？： **

  bool flag=false;
  String c=flag?'我是true':'我是false';
  print(c);

循环语句

1、for循环

for (int i = 1; i<=100; i++) {   
    print(i);
  }

2、while循环

int i=1;
var sum=0;
while(i<=100){
	sum+=i;
	i++;
}
print(sum);

3、do while循环

int i=1;
var sum=0;
do{
	sum+=i;
	i++;
}while(i<=100);
print(sum);

4、do while 和 while区别是条件不成立第一次循环也会执行

int i=10;
while(i<2){
print('不会执行');
}

var j=10;	  
do{
 print('会执行');
 }while(j<2);

5、break 和 continue

break：终止循环

for(int i=0;i<10;i++){
	if(i==8){
	print("找到了");
	break;
	}
}

continue：终止本次循环，就行下一次循环

for(int i=0;i<10;i++){
	if(i==8){
	print("不想打印这个");
	continue；
	}
	print(i);
}

函数的使用

 返回类型  方法名称（参数1，参数2,...）{
    方法体
    return 返回值;
  }

1、普通函数

void pleaseSayHello(){
	print('如果在遇见你，请你先说你好，我怕控制不住会给你拥抱');
}

2、有返回值函数

String giveSomeMoney(){
	return "赏你一张大团结";
}

3、普通参数的函数

void song(String musicName){
	pirnt("给老子唱$musicName这首歌");
}

**4、可选参数的函数 **

void introduce(bool loveMe,[String name ,int age,String sex]){
	if(loveMe){
	print("我是$name,性别$sex,今年$age岁了");
	}else{
	print("不喜欢聊个鸡儿");
	}
}

**5、命名参数的函数 **

String introduce({String name ,int age,String sex}){
	return "我是$name,性别$sex,今年$age岁了";
}
//调用的时候
pirnt(introduce(name:"czk",age:18,sex:"男"));

**6、函数也可当做参数 **

//方法
fn1(){
 print('fn1');
}
//方法
fn2(fn){
 fn();
}
//调用fn2这个方法 把fn1这个方法当做参数传入
fn2(fn1);

类

---

面向对象编程(OOP)的三个基本特征是：封装、继承、多态

  封装：封装是对象和类概念的主要特性。封装，把客观事物封装成抽象的类，并且把自己的部分属性和方法提供给其他对象调用, 而一部分属性和方法则隐藏。
            
  继承：面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
        
  多态：允许将子类类型的指针赋值给父类类型的指针, 同一个函数调用会有不同的执行效果 。

Dart所有的东西都是对象，所有的对象都继承自Object类。

Dart是一门使用类和单继承的面向对象语言，所有的对象都是类的实例，并且所有的类都是Object的子类

一个类通常由属性和方法组成。

---

1、类

//无参(默认)构造器
class Person{
  String name="张三";
  int age=23;
  void getInfo(){
      print("${this.name}----${this.age}");
  }
  void setInfo(int age){
    this.age=age;
  }
}
//带参构造器
class Person{
  String name;
  int age; 
  Person(String name,int age){
      this.name=name;
      this.age=age;
  }
   void printInfo(){   
     print("${this.name}----${this.age}");
  }
}
class Person{
  String name;
  int age; 
  //默认构造函数的简写
  Person(this.name,this.age);
  void printInfo(){   
    print("${this.name}----${this.age}");
  }
}
//命名构造器
class Person{
  String name;
  int age; 
  //默认构造函数的简写
  Person(this.name,this.age);
  
  Person.now(){
    print('我是命名构造函数');
  }

  Person.setInfo(String name,int age){
    this.name=name;
    this.age=age;
  }

  void printInfo(){   
    print("${this.name}----${this.age}");
  }
}
//使用方式
Person a = new Person.now();
Person b = new Person.setInfo("张三",18);

//Dart中的静态成员:
//1、使用static 关键字来实现类级别的变量和函数
//2、静态方法不能访问非静态成员，非静态方法可以访问静态成员

//Dart中的对象操作符:
//?     条件运算符(非空)
//as    类型转换
//is    类型判断
//..    级联操作（类似java中的构造者模式）

//Dart中的类的继承：  
//1、子类使用extends关键词来继承父类
//2、子类会继承父类里面可见的属性和方法 但是不会继承构造函数
//3、子类能复写父类的方法 getter和setter
class Person {
  String name;
  num age; 
  Person(this.name,this.age);
  void printInfo() {
    print("${this.name}---${this.age}");  
  }
  work(){
    print("${this.name}在工作...");
  }
}

class Web extends Person{
  Web(String name, num age) : super(name, age);
  void run(){
    print('run');
  }
  //覆写父类的方法
  @override       //可以写也可以不写  建议在覆写父类方法的时候加上 @override 
  void printInfo(){
     print("姓名：${this.name}---年龄：${this.age}"); 
  }
  @override
  work(){
    print("${this.name}的工作是写代码");
  }
}

//使用
Web w=new Web('李四',20);
w.printInfo();
w.work();
w.run();

2、抽象类

Dart中抽象类: Dart抽象类主要用于定义标准，子类可以继承抽象类，也可以实现抽象类接口。
  1、抽象类通过abstract 关键字来定义
  2、Dart中的抽象方法不能用abstract声明，Dart中没有方法体的方法我们称为抽象方法。
  3、如果子类继承抽象类必须得实现里面的抽象方法
  4、如果把抽象类当做接口实现的话必须得实现抽象类里面定义的所有属性和方法。
  5、抽象类不能被实例化，只有继承它的子类可以
extends抽象类 和 implements的区别：
  1、如果要复用抽象类里面的方法，并且要用抽象方法约束自类的话我们就用extends继承抽象类
  2、如果只是把抽象类当做标准的话我们就用implements实现抽象类
abstract class Animal{
  eat();   //抽象方法
  run();  //抽象方法  
  printInfo(){
    print('我是一个抽象类里面的普通方法');
  }
}

class Dog extends Animal{
  @override
  eat() {
     print('小狗在吃骨头');
  }
  @override
  run() {
    print('小狗在跑');
  }  
}

3、接口

和Java一样，dart也有接口，但是和Java还是有区别的。
  首先，dart的接口没有interface关键字定义接口，而是普通类或抽象类都可以作为接口被实现。
  同样使用implements关键字进行实现。
  但是dart的接口有点奇怪，如果实现的类是普通类，会将普通类和抽象中的属性的方法全部需要覆写一遍。
 
  而因为抽象类可以定义抽象方法，普通类不可以，所以一般如果要实现像Java接口那样的方式，一般会使用抽象类。

  建议使用抽象类定义接口。

abstract class Db{
    String uri;      
    add(String data);
    save();
    delete();
}

class MsSql implements Db{
  @override
  String uri;
  @override
  add(String data) {
    print('这是mssql的add方法'+data);
  }

  @override
  delete() {
    return null;
  }

  @override
  save() {
    return null;
  }
}



/*
Dart中一个类实现多个接口：
*/

abstract class A{
  String name;
  printA();
}

abstract class B{
  printB();
}

class C implements A,B{  
  @override
  String name;  
  @override
  printA() {
    print('printA');
  }
  @override
  printB() {
    // TODO: implement printB
    return null;
  }

  
}



在Dart中可以使用mixins实现类似多继承的功能


因为mixins使用的条件，随着Dart版本一直在变，这里讲的是Dart2.x中使用mixins的条件：

  1、作为mixins的类只能继承自Object，不能继承其他类
  2、作为mixins的类不能有构造函数
  3、一个类可以mixins多个mixins类
  4、mixins绝不是继承，也不是接口，而是一种全新的特性
*/

class A {
  String info="this is A";
  void printA(){
    print("A");
  }
}

class B {
  void printB(){
    print("B");
  }
}

class C with A,B{
  
}

void main(){
  
  var c=new C();  
  c.printA();
  c.printB();
  print(c.info);


}

泛型

---

通俗理解：泛型就是解决 类 接口 方法的复用性、以及对不特定数据类型的支持(类型校验)

---

1、泛型方法

  getData<T>(T value){
      return value;
  }

2、泛型类

class PrintClass<T>{
      List list=new List<T>();
      void add(T value){
          this.list.add(value);
      }
      void printInfo(){          
          for(var i=0;i<this.list.length;i++){
            print(this.list[i]);
          }
      }
 }

3、泛型接口

abstract class Cache<T>{
  getByKey(String key);
  void setByKey(String key, T value);
}

class FlieCache<T> implements Cache<T>{
  @override
  getByKey(String key) {    
    return null;
  }

  @override
  void setByKey(String key, T value) {
   print("我是文件缓存 把key=${key}  value=${value}的数据写入到了文件中");
  }
}

其他

1、async和await

/*
async和await 这两个关键字的使用只需要记住两点：
1、只有async方法才能使用await关键字调用方法
2、如果调用别的async方法必须使用await关键字
    
async是让方法变成异步。
await是等待异步方法执行完成。
*/
void main() async{
  var result = await testAsync();
  print(result);

}
//异步方法
testAsync() async{
  return 'Hello async';
}

2、部分导入包
部分导入
如果只需要导入库的一部分，有两种模式:
模式一：只导入需要的部分，使用show关键字，如下例子所示：
import ‘package:lib1/lib1.dart’ show foo;
模式二：隐藏不需要的部分，使用hide关键字，如下例子所示：
import ‘package:lib2/lib2.dart’ hide foo;

class Demo{  
  String getName() {
  	return "name";
  }
  int getAge() {
  	return 18;
  }
}

//如果这样引入
import 'lib/Demo.dart' hide getName;
Demo demo = new Demo();
//demo.getName();//这个是不行的
demo.getAge();//可以

---

看完这些基础知识基本上就算入门了吧

---