携手创作，一起成长！这是我参加「日新方案 8 月更文应战」的第6天，点击查看活动概况

面向对象是一种重要的编程思想。比方你需求指明 Jimmy 在说话，那么你先得从人这个类中实例化 Jimmy 出来：

void main() {
  var person = new Person();
  person.sayHi('Jimmy');
}
class Person {
  sayHi(String name) {
    print(name + ' is speaking...'); // Jimmy is speaking...
  }
}

引荐使用线上编辑器 dartpad.cn 进行学习，测验～

Dart 是一门面向对象的编程言语，具有类和基于混入的承继。所有的类都派生自 Object。

面向对象基本特征

讨论面向对象，了解它们的特征，很重要。这也是面试过程中，面试官喜爱考察的一个常识点。

封装

封装便是把内部的完成隐藏起来，然后仅仅露出必要的办法让外部调用。露出的办法咱们称之为接口。

还是拿方才的示例来阐明：

class Person {
  sayHi(String name) {
    print(name + ' is speaking...'); // Jimmy is speaking...
  }
}

这里我常识露出出了一个 sayHi 的办法，你不需求管里边是怎么完成的，完成有多简略或者多复杂，你只要依照要求调用这个接口就行了，比方：

/*
* 调用 sayHi 接口
* @Function sayHi
* @param <String> name
* @return void
*/

承继

所谓的承继，便是使得子类具有父类等的各种揭露的办法和特点。比方：

// 父类承继
void main() {
  var dog = new Dog('Tom');
  dog.sleep(); // Tom must go to sleep.
}
class Animal {
  String name;
  Animal(this.name);
  sleep() {
    print(this.name + ' must go to sleep.');
  }
}
class Dog extends Animal {
  Dog(String name) : super(name);
  barking() {
    print('Dog is barking.');
  }
}

多态

多态能够理解为相同的行为，不同的完成办法。比方：狗日子 live 在陆地上，鱼儿日子 live 在水里，如下：

void main() {
  var dog = new Dog();
  var fish = new Fish();
  dog.live(); // Jimmy living on land.
  fish.live(); // Tom living in water.
}
// 界说一个笼统类
abstract class Animal {
  late String name;
  live(); // 生计
}
class Dog extends Animal {
  @override
  String name = 'Jimmy';
  @override
  live() {
    print(this.name + ' living on land.');
  }
}
class Fish extends Animal {
  @override
  String name = 'Tom';
  @override
  live() {
    print(this.name + ' living in water.');
  }
}

笼统

咱们一般说面向对象的三个特征：封装，承继和多态。笼统也是面向对象的一个本质特征。比方咱们上面举的多态的例子中，咱们能够找到 Dog 和 Fish 的共性，并将他们笼统出来表明。

// 界说一个笼统类
abstract class Animal {
  late String name; // 名字
  live(); // 生计（笼统办法）
  eat() { // 非笼统办法
    print('Can eat.');
  }
}

类声明

Dart 中，一个类的完成包括类声明和类体。类声明的语法格局：

[ abstract ] class className [extends superClassName] [implements interfaceName] [with className1, className2, ...] {
  // 类体
}
  • abstract 表明该类是笼统类，此关键字可省掉，引荐加上
  • extends 是承继类的关键字，superClassName 是父类类名
  • implements 是完成某个接口的关键字，interfaceName 是接口称号
  • with 是混入多个类的关键字，多个类用 , 分离隔

类构成

Dart 中类的构成，包括：

  • 类名
  • 成员变量
  • 成员办法
  • 构造办法

类名

声明一个类的时分，关键字 class 后边的 className 称号便是类名…

成员变量

声明类中成员变量的格局，如下：

class className {
  // 成员变量
  [static][const][final] type name;
}
  • type 是成员变量的数据类型
  • name 是成员变量名
  • [static][const][final] 是成员变量的修饰符

    • static 表明成员变量在类本身能够使用，在类的实例上不可用
    • const 用来界说常量，值不可改变
    • final 表明单一赋值，赋值后不能更改 final 变量的值

⚠️ const 和 final 的区别在于：const 比 final 更加严格。final 仅仅要求变量在初始化后值不变，但是通过 final 无法在编译时（运行之前）知道这个变量的值，而 const 是修饰编译时的常量，从一开始就知道它的值。

成员办法

声明类中成员办法的格局，如下：

class className {
  // 成员办法
  [static][type] methodName(paramType: paramName, ...) [async] {
    // 办法体
  }
}
  • type 表明函数办法返回值的数据类型
  • methodName 表明办法名
  • static 是办法修饰符，表明该办法只能是类本身调用，不能在实例上可用
  • paramType 表明办法参数类型，paramName 表明办法参数称号；能够有多个参数，用 , 来分离隔
  • async 表明办法是异步的

构造办法

构造办法是类中的特殊的办法。在类进行初始化的时分执行，比方：

void main() {
  var person = new Person('Jimmy', 100);
  person.sayHi(); // Hello Jimmy.
}
class Person {
  String name = '';
  double height = 0.0;
  // 构造函数
  Person(this.name, this.height);
  sayHi() {
    print('Hello ' + this.name + '.');
  }
}

关于构造函数，后边会有文章具体介绍…

往期精彩引荐

  • Dart 常识点 – 数据类型
  • Flutter 开发呈现的那些 Bugs 和解决方案「继续更新… 」

如果读者觉得文章还能够，不防一键三连：关注➕点赞➕保藏