Dart是一个面向对象的语言，面向对象中非常重要的概念就是类，类产生了对象。今天，我们就具体来学习Dart 中重要的面向对象的一些特性
类与对象
- 使用关键字
class声明一个类 - 使用关键字
new创建一个对象 ,new可以省略 - 所有对象都继承于
Object类
类通常有两部分组成:成员（member）和方法（method）。
定义类的伪代码:
class 类名 {
类型 成员名;
返回值类型 方法名(参数列表) {
方法体
}
}
构造方法
Dart 构造方法有以下几种实现方式:
- 默认构造方法
- 命名构造方法
Class.name(var param) - 调用父类构造方法
- 不可变对象,定义编译时常量对象,构造函数前加
const - 工厂构造函数:
factory
默认构造函数
往往是我们最常见的也是最简单的:
class User {
String name;
int age;
User(String name, int age) {
this.name = name;
this.age = age;
}
//等同于:
// User(this.name, this.age);
}
当类中没有明确指定构造方法时，将默认拥有一个无参的构造方法。
当有了自己的构造方法时，
默认的构造方法将会失效，不能使用
当然，你可能希望明确的写一个默认的构造方法，但是会和我们自定义的构造方法冲突；
这是因为Dart本身不支持函数的重载（名称相同, 参数不同的方式）。
命名构造方法
Dart 并不支持构造函数的重载，而采用了命名构造函数为一个类实现多个构造函数：
main(List<String> args) {
var user1 = User("小白", 15);
var user2 = User.age(13);
print(user1);
//name = 小白, age = 15
print(user2);
//name = 大白, age = 13
}
class User {
String name;
int age;
User(String name, int age) {
this.name = name;
this.age = age;
}
//等同于:
// User(this.name, this.age);
// User(String name); //错误,因为不准重载
User.age(this.age) {
name = "大白";
}
@override
String toString() {
// TODO: implement toString
return "name = $name, age = $age";
}
}
重定向构造函数
在某些情况下, 我们希望在一个构造方法中去调用另外一个构造方法, 这个时候可以使用重定向构造方法：
在一个构造函数中，去调用另外一个构造函数（注意：是在冒号后面使用this调用）
class Person {
String name;
int age;
Person(this.name, this.age);
Person.fromName(String name) : this(name, 0);
}
常量构造方法
在某些情况下，传入相同值时，我们希望返回同一个对象，这个时候，可以使用常量构造方法.
默认情况下，创建对象时，即使传入相同的参数，创建出来的也不是同一个对象
main(List<String> args) {
var p1 = Person('lilei');
var p2 = Person('lilei');
print(identical(p1, p2)); // false
}
class Person {
String name;
Person(String name) {
this.name;
}
}
如果将构造方法前加const进行修饰，那么可以保证同一个参数，创建出来的对象是相同的
这样的构造方法就称之为常量构造方法。
main(List<String> args) {
var animal1 = const Animal("cat");
var animal2 = const Animal("cat");
print(identical(animal1, animal2));//true
}
class Animal {
final String name;
const Animal(this.name);
}
*注意点:注意点:*
- 注意一：拥有常量构造方法的类中，所有的成员变量必须是final修饰的.
- 注意二: 为了可以通过常量构造方法，创建出相同的对象，不再使用 new关键字，而是使用const关键字
工厂构造方法
main(List<String> args) {
//工厂构造方法
var p1 = Person("lilei");
var p2 = Person("lilei");
print(identical(p1, p2)); //true
}
class Person {
String name;
static final Map<String, Person> _cache = <String, Person>{};
factory Person(String name) {
if (_cache.containsKey(name)) {
return _cache[name];
} else {
final person = Person._internal(name);
_cache[name] = person;
return person;
}
}
Person._internal(this.name);
}
setter 和 getter
Dart中每个实例变量都隐含的具有一个
getter， 如果变量不是final的则还有一个setter。可以通过实现getter和setter来创建新的属性， 使用 get 和 set 关键字定义getter和setter：
main(List<String> args) {
var rect = Rect(0, 0, 10, 10);
print(rect.right);//10
rect.right = 15;
print(rect.left);//5
}
class Rect {
int left;
int top;
int width;
int height;
Rect(this.left, this.top, this.width, this.height);
//使用get 定义了一个right 属性
int get right => left + width;
set right(int value) => left = value - width;
}
类的继承
面向对象的其中一大特性就是继承，继承不仅仅可以减少我们的代码量，也是多态的使用前提。
Dart中的继承使用extends关键字，子类中使用super来访问父类。
父类中的所有成员变量和方法都会被继承,，但是构造方法除外。
main(List<String> args) {
var p1 = Person();
p1.age = 18;
p1.run();
//正在奔跑
}
class Animal {
int age;
run() {
print("正在奔跑");
}
}
class Person extends Animal {}
子类可以拥有自己的成员变量, 并且可以对父类的方法进行重写：
class Person extends Animal {
String name;
@override
run() {
print("$name 正在奔跑");
}
}
子类中可以调用父类的构造方法，对某些属性进行初始化：
子类的构造方法在执行前，将隐含调用父类的无参默认构造方法（没有参数且与类同名的构造方法）。
如果父类没有无参默认构造方法，则子类的构造方法必须在初始化列表中通过super显式调用父类的某个构造方法。
main(List<String> args) {
var p1 = Person("xiaowang", 18);
p1.age = 18;
p1.name = "xiaowang";
p1.run();
//xiaowang 正在奔跑
}
class Animal {
int age;
Animal(this.age);
run() {
print("正在奔跑");
}
}
class Person extends Animal {
String name;
Person(String name, int age)
: name = name,
super(age);
@override
run() {
print("$name 正在奔跑");
}
@override
String toString() {
return "name = $name, age = $age";
}
}
抽象类
在Dart中没有具体实现的方法(没有方法体)，就是抽象方法。
- 抽象方法，必须存在于抽象类中
- 抽象类是使用
abstract声明的类。
abstract class Shape {
getArea();
}
class Circle extends Shape {
double r;
Circle(this.r);
@override
getArea() {
return r * r * 3.14;
}
}
class Rectangle extends Shape {
double w;
double h;
Rectangle(this.w, this.h);
@override
getArea() {
return w * h;
}
}
注意事项:
- 抽象类不能实例化.
- 抽象类中的抽象方法必须被子类实现, 抽象类中的已经被实现方法, 可以不被子类重写.
隐式接口
Dart中的接口比较特殊, 没有一个专门的关键字来声明接口.
默认情况下，定义的每个类都相当于默认也声明了一个接口，可以由其他的类来实现(因为Dart不支持多继承)
在开发中，我们通常将用于给别人实现的类声明为抽象类:
abstract class Runner {
run();
}
abstract class Flyer {
fly();
}
class SuperMan implements Runner, Flyer {
@override
run() {
print('超人在奔跑');
}
@override
fly() {
print('超人在飞');
}
}
Mixin混入
在通过implements实现某个类时，类中所有的方法都必须被重新实现(无论这个类原来是否已经实现过该方法)。
但是某些情况下，一个类可能希望直接复用之前类的原有实现方案，怎么做呢?
使用继承吗？但是Dart只支持单继承，那么意味着你只能复用一个类的实现。
Dart提供了另外一种方案: Mixin混入的方式
- 除了可以通过class定义类之外，也可以通过mixin关键字来定义一个类。
- 只是通过mixin定义的类用于被其他类混入使用，通过with关键字来进行混入。
main(List<String> args) {
var duck = Duck();
duck.doDuckSomething();
var clownfish = ClownFish();
clownfish.doClownFishSomething();
}
mixin Swimming {
swim() {
print("游泳");
}
}
//Bird
abstract class Bird {
shout() {
print("shouting");
}
}
//duck
class Duck extends Bird with Swimming {
doDuckSomething() {
shout();
swim();
print("鸭子不玩了.");
}
}
abstract class Fish {}
class ClownFish extends Fish with Swimming {
doClownFishSomething() {
swim();
print("鱼不玩了..");
}
}
类成员和方法
我们在类中定义的成员和方法都属于对象级别的, 在开发中, 我们有时候也需要定义类级别的成员和方法
在Dart中我们使用static关键字来定义:
main(List<String> args) {
var m = Person("大白", 11);
// m.date 实例对象不能访问类成员
// m.run(); 实例对象不能访问类方法
m.walk();
//走路...
Person.date = "上午";
Person.run();
//跑步
}
class Person {
String name;
int age;
static String date;
Person(this.name, this.age);
walk() {
print("走路...");
}
static run() {
print("跑步");
}
}
网友评论