02-02dart语法

1、类

• Getters 和 setters 方法

每个实例变量都有一个隐式的getter

class Rectangle {
  num left, top, width, height;
  Rectangle(num left,num top,num width,num height){
    this.left = left;
    this.top = top;
    this.width = width;
    this.height = height;
  }

  Rectangle(this.left, this.top, this.width, this.height);
  num get right => left + width;//=> 单行函数简单写法，返回值可有可无
  set right(num value) => left = value - width;

}

• 实现类中的方法，必须有body

• 抽象类中

  abstract class People{
       void eat(){
         print("People =====【 eat 】");
       }
       void walk();
  }
  

2、抽象类

除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

• 如果一个类包含抽象方法，那么该类必须是抽象类。

• 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

• 抽象类中有成员变量、成员方法和构造方法 还可以有抽象方法

  abstract  class People {
  	String name;
  	People(String name) {
  	}
  	void eat() {
  		System.out.println("People =====【 eat 】");
  	}
  	abstract void walk();
  }
  

  Dart 中抽象方法可以省略 abstract

abstract class People {
  String name;
  People({String name}) {
  }
  void eat() {
    print("People =====【 eat 】");
  }
  void walk();
}

• 任何子类必须重写父类的抽象方法，或者声明自身为抽象类

class Student extends People{
  @override
  void walk() {
     eat();
  }
}

Java

class Student extends People {
	Student(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}
	@Override
	void walk() {
		// TODO Auto-generated method stub
	}
}

dart 没有interface 关键字 但是有implements   每一个class (包括abstract class) 都隐含一个接口 都可以使用implement

abstract class Animal{
  void run();
}

 class People {
  String name;
  People({String name})
  void walk(){}
}
class Student implements People{
  @override
  String name;
  @override
  void walk() {
    // TODO: implement walk
  }
}

• 任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

• 1. 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。

• 3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。、

       String name;
     
       People({String name}) {
       }
       void eat() {
         print("People =====【 eat 】");
       }
       void walk();
     }
     
     class Student extends People{
       @override
       void walk() {
          eat();
       }
       
     }
     

• 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。

其他部分见技术分享ppt

3、mixin

mixin是在多个类层次结构中重用代码的一种方式。

mixin Animal{

  void run(){}
}

 mixin People {
  void walk(){}
}

class Student with Animal,People {

  void eat() {
    run();
    walk();
  }
}

4、泛型

• 泛型类

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

• 泛型方法

  泛型参数()允许你在很多地方使用类型参数T

  • 在函数的返回中返回类型(T)

  • 在参数的类型中使用(List)

  • 在局部变量的类型中(T tmp)

  • 限制参数化类型

T first<T>(List<T> ts) {
  // Do some initial work or error checking, then...
  T tmp = ts[0];
  // Do some additional checking or processing...
  return tmp;
}

class Foo<T extends SomeBaseClass> {
  // Implementation goes here...
  String toString() => "Instance of 'Foo<$T>'";
}

class Extender extends SomeBaseClass {...}

可以使用SomeBaseClass 或它的任何子类作为泛型参数:

var someBaseClassFoo = Foo<SomeBaseClass>();
var extenderFoo = F

class GeneralTest<T>{
   T _vari;
   T get myVari{
     return _vari;
   }
   GeneralTest.newVV(){

   }

   GeneralTest(T t){
     this._vari = t;

   }

   void setV(T v){
     _vari = v;
   }

   static T newV<T>(T t){

     return  t;
   }

}

class Test{

  void main(){
    GeneralTest<BT>.newVV();//命名构造函数
//    GeneralTest.newV(BT(i: 2)).name; 静态方法
  }
}

对provider 的封装

import 'package:provide/provide.dart';
import 'package:xxwq_flutter/libs/states/config_state_model.dart';

class ProvierHelper{

  static var providers = Providers();
  static var themeConfigModel = ThemeConfigModel();

  static init({model,child,dispose = true}){

    providers = Providers()
      ..provide(Provider<ThemeConfigModel>.value(themeConfigModel));

    return ProviderNode(child: child, providers: providers,dispose: dispose);
  }

  static connect<T>({builder, child, scope}) {
    return Provide<T>(builder: builder, child: child, scope: scope);
  }
  static T value<T>(context,{scope}){
    return Provide.value<T>(context,scope: scope);
  }
}