03_dart 类和对象

类

• dart 是一个面向对象的语言;面向对象有 (1)继承 (2)封装 (3)多态
• dart的所有东西都是对象，所有的对象都是继承自object类
• 一个类通常是由属性和方法组成的；

命名规范

• 使用lowercase_with_underscores风格来命名库和文件名名称
• 类名使用大驼峰(和java一样)
• 变量名和方法名使用小驼峰(和java一样)

//每一个实例变量都会自动生成一个geter方法(隐式的)。非final修饰实例变量自动生成一个seter方法.
class Point{
  int x = 0;
  
  int y = 0;
}

构造函数

由于把构造函数参数赋值给实例变量的场景太常见了,Dart提供了—个语法糖来简化这个操作

//每一个实例变量都会自动生成一个geter方法(隐式的)。非final修饰实例变量自动生成一个seter方法.
class Point{
  int x=0;
  int y=0;
  //构造方法
  Point(this.x,this.y);
}

命名构造函数

drat中没有重载构造函数，只有命名构造方法

class Point {
  //此时为public修饰
  int x = 0;
  //使用_开头命名，相当于java的private修饰
  int _y = 0;

  Point(this.x, this._y);

  //命名构造方法,名字随便取
  Point.X(this.x);
  //私有命名构造方法，类似java用private修饰，在其他文件里面不能创建
  Point._Y(this._y);
  Point.Cool(int y){
    this._y=y;
    print('我好酷啊');
  }
  int getpY(){
    return _y;
  }
}

调用

import 'package:flutter_app/point.dart';

void main(){
  var point=new Point(2,3);
  print(point.x);
  var point2=new Point.X(5);
  print(point2.x);
  var point3=new Point.Cool(9);
  print(point3.getpY());
}

输出

2
5
我好酷啊
9

私有构造方法

命名构造方法前面用_修饰则为私有构造方法
调用

//私有命名构造方法，类似java用private修饰，在其他文件里面不能创建
  Point._Y(this._y);

参数初始化列表

初始化类属性

//参数初始化列表，可以不写方法体
  Point.XY()
      : x = 1,
        _y = 1 {
    print('参数初始化列表');
  }

调用

var point4=new Point.XY();
  print('${point4.getpY()}');

输出

参数初始化列表
1

重定向构造方法

命名构造函数，调用普通构造函数

class View{
  View(int context,int attr);
  //重定向构造方法
View.a(int context):this(context,0);

/*java写法
  View(int context){
    this(context,0);
  }*/
}

常量构造方法

属性用final修饰，构造方法用const修饰。就是常量构造方法

class ImmutabelPoint{
  final int x;
  final int y;
  //常量构造方法
  const ImmutabelPoint(this.x, this.y);
}
void main(){
  //使用new来创建常量构造方法和普通的对象没区别
  var imm1=new ImmutabelPoint(1, 1);
  var imm2=new ImmutabelPoint(1, 1);
  print(imm1==imm2);
  //使用const来对象对象，如果传递的参数一样，就表示是同一个编译常量对象(必须定义常量构造函数)
  var imm3=const ImmutabelPoint(1, 1);
  var imm4=const ImmutabelPoint(1, 1);
  print(imm3==imm4);
}

输出

false
true

工厂构造方法

用factory修饰的构造方法

class Manager{
  //必须要有普通构造方法
  Manager();
  //工厂构造方法
  factory Manager.get(){
    return new Manager();
  }
  //工厂方法和此方法在使用方面没什么区别
  // static Manager get(){
  //   return new Manager();
  // }
}

修饰符

使用_开头命名类和变量，相当于java中用private修饰

class Point{
  //此时为public修饰
  int x;
  //使用_开头命名，相当于java的private修饰
  int _y;
  Point(this.x,this.y);
  
}

get和set

每一个实例变量都会自动生成一个geter方法(隐式的)。非final修饰实例变量自动生成一个seter方法.

class Point2{
  //每一个实例变量都会自动生成一个geter方法(隐式的)。非final修饰实例变量自动生成一个seter方法.
  int x=20;
  int _y=30;

  
//会报错，表示x已经有了一个隐式的getx方法，不能在写一个相同的方法
  // int get _x(){
  //   return x;
  // }
  //会报错，表示x已经有了一个隐式的setx方法，不能在写一个相同的方法
  // void set x(int x){
  //   this.x=x;
  // }
  
  //私有的属性则可以添加get和set方法。y为方法名可以随便定义
  int get y => _y;
  void set y(int value) {
    _y = value;
  }
}
void main(){
  var point2=new Point2();
  //调用get
  print(point2.x);
  //set
  point2.x=23;
  print(point2.x);
  point2._y=14;
}

操作符重载

只重载运算里面的逻辑，对于运算符的优先级不会变，先乘除后加减不变

class Point2 {
  //每一个实例变量都会自动生成一个geter方法(隐式的)。非final修饰实例变量自动生成一个seter方法.
  int x = 20;
  int _y = 30;

  //操作符重载:重载加号：point2是方法返回值的类型
  Point2 operator +(Point2 other) {
    var point =new Point2();
    point.x=this.x+other.x;
    return point;
  }
}
void main() {
  var point1 = new Point2();
  var point2 = new Point2();
  point1.x = 1;
  point2.x = 2;
  //调用重载的+号
  var point3 = point1 + point2;
  //输出3
  print('${point3.x}');
}

抽象类

使用abstract修饰符定义一个抽象类。抽象类中允许出现没有方法体的方法

abstract class Parent{
  String name;
  void pintName();//抽象方法，不需要在方法前声明abstract
}

抽象类不能被实例化，除非定义工厂方法并返回子类

接口

与java不同，Dart中没有interface关键字。dart中每一个类都隐式定义了一个包含所有实例成员的接口。并且这个类实现了这个接口。如果你想创建类A来支持类B的方法，而不是继承B的实现。则类A应该实现leiB的接口。

class Listener{
  void onComplete(){}
  void onFailure(){}
}
//把类Listener看成是一个接口，直接实现，然后需要实现里面所有的方法
class MyListener implements Listener{
//实现Listener的方法
  @override
  void onComplete() {
    // TODO: implement onComplete
  }
//实现Listener的方法
  @override
  void onFailure() {
    // TODO: implement onFailure
  }
}

可调用的类

• 如果一个类他包含一个call方法，则此类为可调用的类。可以快速调用call方法。
• 要求方法名必须是call，参数和返回值不做要求

void main(){
  var t=new Test();
  t(2);//快速调用call方法
}
//可以调用的类
class Test{

  void call(int x){
    print('call$x');
  }
}

混合mixins

mixins是一种在多类继承中重用一个类代码的方法。它的基本形式如下：

//被mixin(混入)的类不能有构造函数
class A{
  void a(){}
}
class B{
  void b(){}
}
class C with A,B{
  void c(){}
}

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

//被mixin(混入)的类不能有构造函数
class A {
  void a() {}

  String getMessage() => "A";
}

class B {
  void b() {}

  String getMessage() => "B";
}
//满足了多继承的需求
class C with A, B {
  void c() {}

  C() {}
}
//当c类不需要有自己的方法的时候则可以写成如下方式
//class C=Object with A,B;
void main() {
  var c = new C();
  //第一优先级为自身，如果自身没有则以右侧为主：输出b
  print('${c.getMessage()}');
}