美文网首页
Dart 方法与类

Dart 方法与类

作者: wuchao226 | 来源:发表于2021-07-20 19:27 被阅读0次

    方法

    int add(int i,int j) {
      return i + j;
    }
    //也可以选择忽略类型(不推荐)
    add( i, j) {
      return i + j;
    }
    //对于只有一个表达式的方法,可以选择使用缩写语法来定义:
    add(i, j) => i + j;
    //在箭头 (=>) 和分号 (;) 之间只能使用一个 表达式
    

    一等方法对象

    Dart 是一个真正的面向对象语言,方法也是对象并且具有一种类型  `Function`。 这意味着,方法可以赋值给变量,也可以当做其他方法的参数。可以把方法当做参数调用另外一个方法
    
    var list = [1,2,3];
    //将 print 方法 作为参数传递给forEach
    list.forEach(print);
    //可以将方法赋值给一个变量 类型为Funcation
    var p = print;
    list.forEach(p);
    

    在Java中如果需要能够通知调用者或者其他地方方法执行过程的各种情况,可能需要指定一个接口,比如 View 的 onClickListener。而在 Dart 中,我们可以直接指定一个回调方法给调用的方法,由调用的方法在合适的时机执行这个回调。

    void setListener(Function listener){
        listener("Success");
    }
    //或者
    void setListener(void listener(String result)){
        listener("Success");
    }
    
    //两种方式,第一种调用者根本不确定 回调函数的返回值、参数是些什么
    //第二中则需要写这么一大段 太麻烦了。
    
    //第三种:类型定义 将返回值为voide,参数为一个String的方法定义为一个类型。
    typedef  void Listener(String result);
    void setListener(Listener listener){
      listener("Success");
    }
    
    

    方法可以有两种类型的参数:必需的和可选的。 必需的参数需要在参数列表前面, 后面再定义可选参数。

    可选命名参数

    把方法的参数放到 `{}` 中就变成可选 命名参数
    
    int add({int i, int j}) {
      if(i == null || j == null){
         return 0;
      }
      return i + j;
    }
    

    调用方法的时候,可以使用这种形式 paramName: value 来指定命名参数。例如:

    //无必须参数
    add()
    //选择传递参数
    add(i:1)
    //位置无关
    add(i:1, j:2)
    add(j:1, i:2)
    

    可选位置参数

    把方法的参数放到 `[]` 中就变成可选 位置参数,传值时按照参数位置顺序传递
    
    int add([int i, int j]) {
      if(i == null || j == null){
         return 0;
      }
      return i + j;
    }
    // 1赋值给i
    add(1);
    // 按照顺序赋值
    add(1,2);
    

    默认参数值

    在定义方法的时候,可选参数可以使用 `=` 来定义可选参数的默认值。
    
    int add([int i = 1, int j = 2]) => i + j;
    int add({int i = 1, int j = 2}) => i + j;
    

    匿名方法

    没有名字的方法,称之为匿名方法,也可以称之为 lambda 或者 closure 闭包。匿名方法的声明为:
    
    ([Type] param1, …) { 
      codeBlock; 
    }; 
    
    如:
    
    var list = ['apples', 'oranges', 'grapes', 'bananas', 'plums'];
    list.forEach((i) {
      print(list[i]);
    });
    

    示例

    function_learn.dart

    //构造方法
    //实例方法
    //setters 和 getters
    //静态方法
    //抽象方法
    //私有方法
    //匿名方法
    //泛型方法
    
    class TestFunction {
      FunctionLearn functionLearn = FunctionLearn();
    
      void start() {
        functionLearn._learn();
        functionLearn.anonymousFunction();
      }
    }
    
    class FunctionLearn {
      ///方法构成
      ///返回值类型 + 方法名 + 参数
      ///其中:返回值类型可缺省,也可为void或具体的类型
      ///方法名:匿名方法不需要方法名,下文会提到
      ///参数:参数类型和参数名,参数类型可缺省(另外,参数又分可选参数和参数默认值,可参考面向对象一节中构造方法部分的讲解)
      int sum(int val1, int val2) {
        return val1 + val2;
      }
    
      ///私有方法:
      ///通过_开头命名的方法
      ///作用域是当前文件
      _learn() {
        print('FunctionLearn');
      }
    
      ///  匿名方法:
      ///  大部分方法都带有名字,例如 main() 或者 print();
      ///  在Dart中你有可以创建没有名字的方法,称之为 匿名方法,有时候也被称为 lambda 或者 closure 闭包;
      ///  你可以把匿名方法赋值给一个变量, 然后你可以使用这个方法,比如添加到集合或者从集合中删除;
      ///  匿名方法和命名方法看起来类似— 在括号之间可以定义一些参数,参数使用逗号 分割,也可以是可选参数;
      ///  后面大括号中的代码为函数体:
      ///  ([[Type] param1[, …]]) {
      ///     codeBlock;
      ///   };
      anonymousFunction() {
        var list = ['私有方法', '匿名方法'];
        //下面的代码定义了一个参数为i (该参数没有指定类型)的匿名函数
        //list 中的每个元素都会调用这个函数来 打印出来,同时来计算了每个元素在 list 中的索引位置
        list.forEach((i) {
          print(list.indexOf(i).toString() + ': ' + i);
        });
      }
    }
    

    Dart 是一个面向对象编程语言。 每个对象都是一个类的实例,所有的类都继承于 `Object`。
    
    //每个实例变量都会自动生成一个 getter 方法(隐含的)。 非final 实例变量还会自动生成一个 setter 方法。
    class Point {
      num x;
      num y;
    }
    

    构造函数

    由于把构造函数参数赋值给实例变量的场景太常见了, Dart 提供了一个语法糖来简化这个操作:
    
    class Point {
      num x;
      num y;
    
      Point(this.x, this.y);
    }
    

    命名构造函数

    Dart 并不支持构造函数的重载,而采用了命名构造函数为一个类实现多个构造函数:
    
    class Point {
      num x;
      num y;
      Point(this.x, this.y);
      Point(this.y);///错误,不允许重载
      //命名构造函数
      Point.y(this.y) {
        x = 0;
      }
    }
    
    //使用
    var p = Point.y(0);
    

    初始化列表

    在构造函数函数体执行之前会首先执行初始化列表,非常适合用来设置 final 变量的值。 
    
    class Point {
      num x;
      num y;
      Point(this.x, this.y);
      //命名构造函数
      Point.y(this.y) {
        x = 0;
      }
    
      Point.fromMap(Map map)
          : x = map['x'], // : 和c++一样,初始化列表
            y = map['y'];
      
      Point.x(int i)
          : x = i, 
            y = 0;
    }
    

    重定向构造函数

    有时候一个构造函数会调动类中的其他构造函数(在Java中就是 `this(...)`)。 一个重定向构造函数是没有代码的,在构造函数声明后,使用 冒号调用其他构造函数。
    
    class Point {
      num x;
      num y;
    
      Point(this.x, this.y);
      Point.xy(int x,int y):this(x,y); ///调用上面的构造函数
    }
    

    常量构造函数

    如果你的类提供一个状态不变的对象,你可以把这些对象 定义为编译时常量。要实现这个功能,需要定义一个 `const` 构造函数, 并且声明所有类的变量为 `final`。
    
    class ImmutablePoint {
      final num x;
      final num y;
      //常量构造函数
      const ImmutablePoint(this.x, this.y);
    }
    
    void main(){
        //编译器常量
        var p1 = const ImmutablePoint(0,0);
        var p2 = const ImmutablePoint(0,0);
        print(p1 == p2); // true
    }
    

    工厂构造函数

      当实现一个使用` factory` 关键词修饰的构造函数时,这个构造函数不必创建类的新实例。例如,一个工厂构造函数 可能从缓存中获取一个实例并返回,或者 返回一个子类型的实例。(工厂构造函数无法访问 `this`)
    
    class Logger {
      final String name;
      //从缓存获取对象
      static final Map _cache = {};
      //工厂构造函数,无法使用this变量
      factory Logger(String name) {
        if (_cache.containsKey(name)) {
          //工厂构造函数需要返回 Logger 实例对象
          return _cache[name];
        } else {
          final logger = Logger._internal(name);
          _cache[name] = logger;
          return logger;
        }
      }
      //以 _ 开头的函数、变量无法在库外使用
      Logger._internal(this.name);
    }
    
    借助工厂构造函数能够实现单例:
    
    //使用工厂构造实现单例
    class Manager {
      static Manager _instance;
      //和static是一样的, 区别是factory毕竟是构造函数,需要返回一个实例,而static是静态方法。
      factory Manager.getInstance() {
        if (_instance == null) {
          _instance =  new Manager._internal();
        }
        return _instance;
      }
    
    //  static Manager getInstance() {
    //    if (_instance == null) {
    //      _instance = new Manager._internal();
    //    }
    //    return _instance;
    //  }
      Manager._internal();
    }
    

    Getters 和 Setters

    Dart中每个实例变量都隐含的具有一个 getter, 如果变量不是 final 的则还有一个 setter。可以通过实现 getter 和 setter 来创建新的属性, 使用 `get` 和 `set` 关键字定义 getter 和 setter:
    
    class Rect {
      num left;
      num top;
      num width;
      num height;
    
      Rect(this.left, this.top, this.width, this.height);
    
      //使用 get定义了一个 right 属性
      num get right             => left + width;
      set right(num value)  => left = value - width;
    }
    
    void main() {
      var rect = Rect(0, 0, 10, 10);
      print(rect.right); //10
      rect.right = 15;
      print(rect.left);  //5
    }
    

    需要注意的是,在get与set中使用自身会导致Stack Overflow

    可覆写的操作符

    把已经定义的、有一定功能的操作符进行重新定义。可以重新定义的操作符有:
    

    | < | + | | | [] |
    | ---- | ---- | ---- | ----- |
    | > | / | ^ | []= |
    | <= | ~/ | & | ~ |
    | >= | * | << | == |
    | | % | >> | |

    比如:List就重写了 `[]`。
    
    class Point {
      int x;
      int y;
      //返回值 参数随你定义
      Point operator +(Point point) {
        return Point(x + point.x, y + point.y);
      }
    
      Point(this.x, this.y);
    }
    
    var p1 = Point(1, 1);
    var p2 = p1 + Point(2, 2);
    print(p2.x); ///3
    print(p2.y); ///3
    

    抽象类

    使用 `abstract` 修饰符定义一个抽象类。抽象类中允许出现无方法体的方法
    
    abstract class Parent {
      String name;
      void printName(); //抽象方法,不需要在方法前声明 abstract
    }
    
    抽象类不能被实例化,除非定义工厂方法并返回子类。
    
    abstract class Parent {
      String name;
      //默认构造方法
      Parent(this.name);
      //工厂方法返回Child实例
      factory Parent.test(String name){
        return new Child(name);
      }
      void printName();
    }
    // extends 继承抽象类
    class Child extends Parent{
      Child(String name) : super(name);
    
      @override
      void printName() {
        print(name);
      }
    }
    
    void main() {
      var p = Parent.test("Lance");
      print(p.runtimeType); //输出实际类型 Child
      p.printName();        
    }
    

    接口

    与Java不同,Dart中没有`interface`关键字,**Dart中每个类都隐式的定义了一个包含所有实例成员的接口**, 并且这个类实现了这个接口。如果你想 创建类 A 来支持 类 B 的 方法,而不想继承 B 的实现, 则类 A 应该实现 B 的接口。
    
    class Listener{
      void onComplete(){}
      void onFailure(){}
    }
    
    class MyListsner implements Listener{
      MyListsner(){
    
      }
      @override
      void onComplete() {
      }
    
      @override
      void onFailure() {
      }
    }
    

    与继承的区别在于:

    1、单继承,多实现。

    2、继承可以有选择的重写父类方法并且可以使用super,实现强制重新定义接口所有成员。

    可调用的类

    如果 Dart 类实现了 `call()` 函数则 可以当做方法来调用。
    
    class Closure {
      call(String a, String b) => '$a $b!';
    }
    
    main() {
      var c = new Closure();
      var out = c("Hello","Dart");
      print(out);
    }
    

    混合mixins

    Mixins 是一种在多类继承中重用 一个类代码的方法。它的基本形式如下:
    
    //被mixin(混入)的类不能有构造函数
    class A  {
      void a(){}
    }
    class B{
      void b(){}
    }
    class C with A,B{
      void c(){}
    }
    

    with后面跟着需要混入的类,被mixin(混入)的类不能有构造函数。现在的 C拥有了三个方法(a、b与c)。假设A与B 存在相同的方法,以最右侧的混入类为主,比如:

    class A {
      String getMessage() => 'A';
    }
    
    class B {
      String getMessage() => 'B';
    }
    //
    class AB with A, B {}
    
    class BA  with B, A {}
    
    void printMessage(obj) => print(obj.getMessage());
    
    void main() {
      printMessage(AB()); //输出 B
      printMessage(BA()); //输出 A
    }
    

    继承与mixins是兼容的

    class A {
      String getMessage() => 'A';
    }
    
    class B {
      String getMessage() => 'B';
    }
    class P{
      String getMessage() => 'P';
    }
    class AB extends P with A, B {}
    
    class BA extends P with B, A {}
    //可以简写成:
    //class AB = P with A, B;
    //class BA = P with B, A;
    void printMessage(obj) => print(obj.getMessage());
    
    void main() {
      printMessage(AB()); //输出 B
      printMessage(BA()); //输出 A
    }
    
    mixins弥补了接口和继承的不足,继承只能单继承,而接口无法复用实现,mixins却可以多混入并且能利用到混入类的具体实现:
    
    abstract class Swimming{
        void swimming(){
            print("游泳");
        }
    }
    
    abstract class Jump{
        void jump(){
            print("跳跃");
        }
    }
    
    //只能单继承,如果需要Jump,只能以implements的形式
    class Lance extends Swimming implements Jump{
        //实现接口
        void jump(){
            print("跳跃");
        }
    }
    
    //但是实际上,我们经常不需要重新实现Jump方法,复用Jump所实现的jump方法就可以了
    //这时使用混合能够更加方便
    class Lance1 with Swimming, Jump {}
    

    示例

    void _oopLearn() {
        //创建Student的对象
        Student stu1 = Student('清华', 'Jack', 18);
        stu1.school = '985';
        print(stu1.toString());
        Student stu2 = Student('北大', 'Tom', 16, city: '上海', country: '中国');
        print(stu2.toString());
    
        Student.doPrint('_oopLearn');
    
        StudyFlutter sf = StudyFlutter();
        sf.study();
    
        Logger log1 = Logger();
        Logger log2 = Logger();
        print(log1 == log2);
      }
    

    oop_learn.dart

    ///面向对象(OOP)
    class Student extends Person {
      //定义类的变量
      String _school; //通过下划线来标识私有字段(变量)
      String city;
      String country;
      String name;
      static Student instance;
    
      ///构造方法:
      ///通this.school初始化自有参数
      ///name,age交给父类进行初始化
      ///city为可选参数
      ///country设有默认参数
      Student(this._school, String name, int age,
          {this.city, this.country = 'China'})
          //初始化列表:除了调用父类构造器,在子类构造器方法体之前,你也可以初始化实例变量,不同的初始化变量之间用逗号分隔开
          : name = '$country.$city',
            //如果父类没有默认构造方法(无参构造方法),则需要在初始化列表中调用父类构造方法进行初始化
            super(name, age) {
        //构造方法体不是必须的
        print('构造方法体不是必须的');
      }
    
      //命名构造方法:[类名+.+方法名]
      //使用命名构造方法为类实现多个构造方法
      Student.cover(Student stu) : super(stu.name, stu.age) {
        print('命名构造方法');
      }
    
      //命名工厂构造方法:factory [类名+.+方法名]
      //它可以有返回值,而且不需要将类的final变量作为参数,是提供一种灵活获取类对象的方式。
      factory Student.stu(Student stu) {
        return Student(stu._school, stu.name, stu.age,
            city: stu.city, country: stu.country);
      }
    
      @override
      String toString() {
        return 'name:$name school:${this._school},city:$city,country:$country ${super.toString()}';
      }
    
      //可以为私有字段设置getter来让外界获取到私有字段
      String get school => _school;
    
      //可以为私有字段设置setter来控制外界对私有字段的修改
      set school(String value) {
        _school = value;
      }
    
      //静态方法
      static doPrint(String str) {
        print('doPrint:$str');
      }
    
      ///科普小知识:实例方法,对象的实例方法可以访问到实例变量与this,如上述代码中的toString
    }
    
    ///定一个Dart类,所有类都继承自Object
    class Person {
      String name;
      int age;
    
      Person(this.name, this.age);
    
      ///重写父类方法
      @override
      String toString() {
        return 'name:$name, age:$age';
      }
    }
    
    ///工厂构造方法演示
    class Logger {
      static Logger _cache;
    
    //  工厂构造方法:
    //  不仅仅是构造方法,更是一种模式
    //  有时候为了返回一个之前已经创建的缓存对象,原始的构造方法已经不能满足要求
    //  那么可以使用工厂模式来定义构造方法
      factory Logger() {
        if (_cache == null) {
          _cache = Logger._internal();
        }
        return _cache;
      }
    
      Logger._internal();
    
      void log(String msg) {
        print(msg);
      }
    }
    
    ///继承抽象类要实现它的抽象方法,否则也需要将自己定义成抽象类
    class StudyFlutter extends Study {
      @override
      void study() {
        print('Learning Flutter');
      }
    }
    
    ///使用 abstract 修饰符来定义一个抽象类,该类不能被实例化。抽象类在定义接口的时候非常有用,实际上抽象中也包含一些实现
    abstract class Study {
      void study();
    }
    
    ///为类添加特征:mixins
    ///mixins 是在多个类层次结构中重用代码的一种方式
    ///要使用 mixins ,在 with 关键字后面跟一个或多个 mixin 的名字(用逗号分开),并且with要用在extends关键字之后
    ///mixins的特征:实现 mixin ,就创建一个继承 Object 类的子类(不能继承其他类),不声明任何构造方法,不调用 super
    ///猜猜上面的类中哪个是mixin?
    
    class Test extends Person with Study {
      Test(String name, int age) : super(name, age);
    
      @override
      void study() {
        // TODO: implement study
      }
    }
    

    相关文章

      网友评论

          本文标题:Dart 方法与类

          本文链接:https://www.haomeiwen.com/subject/kclrmltx.html