Flutter开发Dart极速入门 (类和对象)

最新推荐文章于 2024-04-14 10:01:06 发布

smile_shaco

最新推荐文章于 2024-04-14 10:01:06 发布

阅读量217

点赞数

分类专栏： Flutter 文章标签： Dart Android Flutter

本文链接：https://blog.csdn.net/smile_shaco/article/details/105780531

版权

Flutter 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

文章目录

类

一般构造函数

main() {
  Point point;
  point = Point(1, 2);
  print('${point.x} ${point.y}');	// print: 1 2
}
class Point {
  int x;
  int y;
  // 基本写法
  Point(this.x, this.y);
}

命名构造函数

main() {
  Point point;
  point = Point.myPoint(1, 10);
  print('${point.x} ${point.y}');	// print: 1 10
}
class Point {
  int x;
  int y;
  // 命名构造函数
  Point.myPoint(this.x, this.y);
}

重定向构造函数

main() {
  Point point;
  point = Point.rePoint(2);
  print('${point.x} ${point.y}');	// print: 0 3
}
class Point {
  int x;
  int y;
  // 重定向构造函数, 使用 ":" 调用其他函数
  Point.rePoint(n) : this(0, n);
}

初始化列表

main() {
  Point point;
  point = Point(1, 2);
  print('${point.x} ${point.y}');	// print: 1 3
}
class Point {
  int x;
  int y;
  // 类初始化列表
  Point(x, y)
      : x = x,
        y = y + 1;
}

调用超类的构造函数

main() {
  Child(2, 4);
  Child.cons(2, 4);
}
class Parent {
  int x;
  int y;

  Parent.cons(this.x, this.y) {
    print('Parent 构造函数');
  }
}

class Child extends Parent {
  int x;
  int y;

  // 如果超类没有默认构造函数， 则你需要手动的调用超类的其他构造函数
  Child(x, y): x = x, y = y, super.cons(x, y){
    print('子类构造函数 x:${this.x}, y:${this.y}');
  }
    
  // 超类命名构造函数不会传递，如果希望使用超类中定义的命名构造函数创建子类，则必须在子类中实现该构造函数
  Child.cons(x, y)
      : x = x,
        y = x * y,
        super.cons(x, y) {
    print('子类构造函数 x:${this.x}, y:${this.y}');
  }
}

常量构造函数

main() {
  var p2 = Point2(0,0); // 创建的是非常量构造函数
  var p21 = const Point2(0,0);  // 常量构造函数
  var p22 = Point2.point2;  // 常量构造函数

  print(identical(p21, p2));  // print: false
  print(identical(p21, p22)); //print: true
}
// 常量构造函数
class Point2 {
  // 定义const构造函数要确保所有变量都是final
  final num x;
  final y;
  static final Point2 point2 = const Point2(0, 0);
  // const关键字放在构造函数名之前, 不能有函数体
  const Point2(this.x, this.y);

  @override
  String toString() {
    return 'Point2(x = $x, y = $y)';
  }
}

工厂构造函数

工厂构造函数实现单例

main() {
  var single1 = SingleInstance('Android');
  var single2 = SingleInstance('dart');
  print(identical(single1, single2)); // print: true; single1.name,single2.name的值都是Android
}
// 工厂构造函数实现单例
class SingleInstance {
  String name;
  static SingleInstance _instance;

  SingleInstance._newInstance(this.name);

  factory SingleInstance([name = "factory: single instance"]) =>
      SingleInstance._instance ??= SingleInstance._newInstance(name);
}

工厂模式

main() {
  Message("Android").doMessage();	// print: FlutterMessage.
  Message("Dart").doMessage();		// print: DartMessage.
  Message("Flutter").doMessage();	// print: FlutterMessage.
}

abstract class Message {
  factory Message(type) {
    switch (type) {
      case 'Dart':
        return DartMessage();
      case 'Flutter':
      default:
        return FlutterMessage();
    }
  }
  void doMessage();
}

class DartMessage implements Message {
  @override
  void doMessage() {
    print('DartMessage.');
  }
}

class FlutterMessage implements Message {
  @override
  void doMessage() {
    print('FlutterMessage.');
  }
}

Setter和Getter

//每个实例变量都隐含的具有一个 getter， 如果变量不是 final 的则还有一个 setter
//可以通过实行 getter 和 setter 来创建新的属性， 使用 get 和 set 关键字定义 getter 和 setter
class Rectangle {
  num left;
  num top;
  num width;
  num height;

  Rectangle(this.left, this.top, this.width, this.height);

  // getter 和 setter 的好处是，可以开始使用实例变量，后面可以把实例变量用函数包裹起来，而调用你代码的地方不需要修改。
  //获取right值
  num get right => left + width;
  //设置right值，同时left也发生变化
  set right(num value) => left = value - width;
  //获取bottom值
  num get bottom => top + height;
  //设置bottom值，同时top也发生变化
  set bottom(num value) => top = value - height;
}

扩展类

使用 extends 创建一个子类，同时 supper 将指向父类

class Television {
  void turnOn() {
    _illuminateDisplay();
    _activateIrSensor();
  }
}

class SmartTelevision extends Television {
  void turnOn() {
    super.turnOn();
    _bootNetworkInterface();
    _initializeMemory();
    _upgradeApps();
  }
}

多继承
```
class AB extends P with A, B {}
```
如果2个或多个超类拥有相同签名的A方法, 那么子类会以继承的最后一个超类中的A方法为准

如果子类自己重写了A方法则以本身的A方法为准

可调用类

可调用类, 允许像函数一样调用Dart类

main() {
  var iClazz = new InvokeClass();
  var out = iClazz('Android', 'Dart', 'Flutter');
  print('$out');  // print: Android, Dart, Flutter
  print(iClazz.runtimeType);  // print: InvokeClass
  print(out.runtimeType); // print: String
  print(out is Function); // print: false
}

class InvokeClass {
  call(String a, String b, String c) => '$a, $b, $c';
}

Mixin

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

如下示例, Student 和 Painter分别可以’写作业’和’画画’, 同时也都可以’跑步’

main() {
  Student('Tom').say();
  Painter('Jack').say();
}

abstract class Person {
  var name;

  Person(this.name);

  say();
}

mixin Run {
  run() => '跑步';
}

mixin HomeWork {
  work() => '写作业';
}

mixin Painting {
  work() => '画画';
}

class Student extends Person with Run, HomeWork {
  Student(name) : super(name);

  @override
  say() {
    print('Student name is $name, 他可以${work()}');
    print('Student ${run()}');
  }
}

class Painter extends Person with Run, Painting {
  Painter(name) : super(name);

  @override
  say() {
    print('Painter name is $name, 他可以${work()}');
    print('Painter ${run()}');
  }
}

Mixin on

超类约束

如下, HomeWork 声明了 Eat 上的超类约束, 表示如果要使用 HomeWork, 这个类就必须继承或实现 Eat. (要让Student写作业, 就必须要让Student吃饭)

main() {
  Student('Tom').say();
  Painter('Jack').say();
}
abstract class Person {
  var name;
  Person(this.name);
  say();
}

mixin Eat {
  String doEat();
}

mixin HomeWork on Eat{	// 声明超类约束
  work() => '写作业';
}

mixin Painting {
  work() => '画画';
}

// 要使用HomeWork必须实现Eat
class Student extends Person with Eat, HomeWork{	
    
  Student(name) : super(name);

  @override
  say() {
    print('Student name is $name, 他可以${work()}, 但是要先${doEat()}');
  }

  @override
  doEat() => '吃饭';
}

class Painter extends Person with Painting{

  Painter(name) : super(name);

  @override
  say() {
    print('Painter name is $name, 他可以${work()}');
  }
}

smile_shaco

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Flutter开发Dart极速入门 (类和对象)

类一般构造函数main() { Point point; point = Point(1, 2); print('${point.x} ${point.y}'); // print: 1 2}class Point { int x; int y; // 基本写法 Point(this.x, this.y);}命名构造函数main() { Point ...
复制链接

扫一扫