Dart随笔-生活工作点滴

Dart --类

2019-07-12  本文已影响1人  小懒豆

类概述

Object

构造函数(Constructors)

抽象类

setters 和 Getters

class Rectangle {
   num left;
   num top;
   num width;
   num height;

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

   // 定义两个计算属性: right and bottom.
   num get right => left + width;
   set right(num value) => left = value - width;
   num get bottom => top + height;
   set bottom(num value) => top = value - height;
}

main() {
   var rect = new Rectangle(3, 4, 20, 15);
   assert(rect.left == 3);
   rect.right = 12;
   assert(rect.left == -8);
}

静态变量和静态函数

class Class11{
  static int a = 3;//静态变量
  int b = 4;//实例变量

  //静态方法
  static void fun01(int c){
    print(c);
    //print(b);//这里报错，静态方法内不能使用实例变量
  }
  //实例方法
  void fun02(){
    print(b);
  }
}
void main(){
    var class11 = new Class11();
    //实例变量和函数
    print(class11.b);
    class11.fun02();
    //调用静态变量和函数
    Class11.fun01(44);
    print(Class11.a);
}

枚举类


'''声明一个枚举类型需要使用关键字 enum ：'''；
 enum Color {
    red,
    green,
    blue
 }

'''
在枚举中每个值都有一个 index getter 方法，它返回一个在枚举声明中从 0 开始的位置。
例如，第一个值索引值为 0 ，第二个值索引值为 1 。
''';
assert(Color.red.index == 0);
assert(Color.green.index == 1);
assert(Color.blue.index == 2);

'''要得到枚举列表的所有值，可使用枚举的 values 常量。''';

  List<Color> colors = Color.values;
  assert(colors[2] == Color.blue);   

'''
你可以在 switch 语句 中使用枚举。
如果 e 在 switch (e) 是显式类型的枚举，那么如果你不处理所有的枚举值将会弹出警告：
''';

  Color aColor = Color.blue;
  switch (aColor) {
      case Color.red:
         print('Red as roses!');
         break;
         
      case Color.green:
         print('Green as grass!');
         break;
    
      default: // Without this, you see a WARNING.
         print(aColor);  // 'Color.blue'
   }

继承

使用extends 关键字表示继承。
构造方法不能被继承。
使用@override重写函数。
如果继承的是抽象类，要实现所有抽象函数。

class Fruit{
  String name;
  int nums;
  Fruit(this.name);//定义构造函数
  Fruit.num(this.name,this.nums);//定义命名构造函数
  Fruit.con(num){//定义命名构造函数
    nums = num*2;
  }
  void fun1(){
    print(name);
  }
  void fun2(){
    print(nums);
  }
}

class Apple extends Fruit{
  String name;
  int nums;
  int color;
  //至少需要定义一个构造函数调用父类的任一构造函数
  Apple(String name) : super(name);
  Apple.con1(this.color,this.name): super.num(name,3);
  Apple.con2() : super.con(3){
    color = 3;
  }
  //重写父类的fun2函数
  @override
  void fun2() {
    print(color);
    super.fun2();//调用父类的fun2方法
  }
  //子类自己的方法
  void fun3(){
    print(nums);
  }
}



//使用 extends 创建一个子类，同时 supper 将指向父类：
 class Television {
    void turnOn() {
       _illuminateDisplay();
        _activateIrSensor();
    }
    // ...
 }

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

  class A {
    // 如果你不重写 noSuchMethod 方法, 就用一个不存在的成员，会导致NoSuchMethodError 错误。
    void noSuchMethod(Invocation mirror) {
        print('You tried to use a non-existent member:' + 
            '${mirror.memberName}');
     }
  }

你可以使用 @override 注释来表明你重写了一个成员。
 class A {
    @override
    void noSuchMethod(Invocation mirror) {
       // ...
    }
 }

'''
如果你用 noSuchMethod() 实现每一个可能的 getter 方法，
setter 方法和类的方法，那么你可以使用 @proxy 标注来避免警告。
''
 @proxy
 class A {
    void noSuchMethod(Invocation mirror) {
        // ...
    }
 }

mixins

class With1 {
  String getName() => 'With1';//三个类都有该方法
  String getAge()=> "With1   10" ;//该类独有
}

class With2 {
  String getName() => 'With2';//三个类都有该方法
  String getColor() => "With2   red";//该类独有
  int getNum()=> 6;//该类和OtherClass都有
  String getFruit()=>"With2   banana";
}

class OtherClass {
  String getName() => 'OtherClass';//三个类都有该方法
  int getNum() => 3; //该类和With2都有
  int getDesk() => 333;//该类独有

  String getPhone()=>"OtherClass   huawei";//该类和子类
  String getFruit()=>"OtherClass   apple";

}

class Child1 extends OtherClass with With1 ,With2 {
  //重写父类
  @override
  String getPhone() {
    return "Child1   iphone";
  }
  @override
  String getFruit() {
    return "Child1  oriange";
  }
}
class Child2 extends OtherClass with With2, With1 {}

void main(){
    print("class Child1 extends OtherClass with With1 ,With2 {}");
    Child1 c1 = Child1();

    //Child1   iphone     重写了函数，调用时用的是自身的函数
    print(c1.getPhone());

    //Child1  oriange     重写了函数，调用时用的是自身的函数
    print(c1.getFruit());

    //333      调用的是OtherClass的函数  With1 With2中没有同名函数
    print(c1.getDesk());
    print(c1.getNum());//6       调用的是With2中的函数
    print(c1.getAge());//With1   10        调用的是With1中的函数
    print(c1.getColor());//With2   red       调用的是With2中的函数

    //With2          调用的是With2中的函数    With2在声明顺序中更靠后
    print(c1.getName());

    print("-----------------------");
    print("class Child2 extends OtherClass with With2, With1 {}");
    Child2 c2 = Child2();
    //OtherClass   huawei     没有重写函数，调用时用的是OtherClass的函数
    print(c2.getPhone());

    //With2   banana    没有重写函数，调用时用的是With2的函数
    //虽然OtherClass也有，但With2在声明顺序中更靠后
    print(c2.getFruit());

    //333     调用的是OtherClass的函数  With1 With2中没有同名函数
    print(c2.getDesk());
    print(c2.getNum());//6     调用的是With2中的函数
    print(c2.getAge());//With1   10       调用的是With1中的函数
    print(c2.getColor());//With2   red      调用的是With2中的函数

    //With1      调用的是With1中的函数    With1在声明顺序中更靠后
    print(c2.getName());
}

隐式接口

class X {
  int x= 19;
  void funX(){
    print("X-X");
  }
}
class Y {
  String y = "yyy";
  void funY(){
    print("Y-Y");
  }
}
class Z implements X,Y{
  @override
  int x=33;
  @override
  String y="33333";

  @override
  void funX() {
    print("Z-X");
  }
  @override
  void funY() {
    print("Z-Y");
  }
}
上一篇下一篇

猜你喜欢

热点阅读