Dart 是一门实用类和单继承的面向对象语言，所有的对象都是类的实例，并且所有的类都是Object的子类。
构造函数
定义一个Person类：
class Person {
String name;
int age;
}
- 默认构造函数为：
class Person {
String name;
int age;
//默认构造函数
Person() {
print("这是Person构造函数");
}
}
- 自定义构造函数：
class Person {
String name;
int age;
Person(String name, int age) {
this.name = name;
this.age = age;
print("$name $age");
}
//简写方式
//Person(this.name, this.age);
}
Person(String name, int age){}
可简写为
Person(this.name, this.age);
- 命名构造函数：
class Person {
Person.eat() {
print("我是命名构造函数");
}
}
main(){
var p2 = new Person.eat();
p2.run();
}
ps:一个类只能有一个默认构造函数/自定义构造函数，但是可以有多个命名构造函数
定义 私有 方法及属性
修饰符： Dart中没有public、private等这些访问修饰符
但是我们可以使用 ```_ ``` 把一个属性或者方法定义成私有，
注意：同一文件中，即便设置_,也仍可访问
非同一文件中才起作用，使用时，需要将文件导入：import 'Class/Animal.dart';
A.dart文件中：
class Animal {
String name;
String _height;
}
B.dart文件中：
import 'Class/Animal.dart';
class Person {
String name;
int age;
String _address;
// 计算属性pName, set get
get pName {
return this.name;
}
set pName(name) {
this.name = name;
}
}
main(List<String> args) {
Person p = Person("lisi", 28);
p.name = "张三";
p.age = 22;
p._address = "北京"; //同一文件中，即便设置_ ,也仍可访问
p.run();
p.pName = "老王";
var pname = p.pName;
print("========$pname");
var p2 = new Person.eat();
p2.run();
var p3 = new Person("wangwu", 30);
p3.run();
//非本文件中的 _
Animal ani = Animal();
ani.name = "河马";
// ani._height = "" // 无法访问 该属性
}
初始化列表
//初始化列表：在Person实例化之前，进行赋值
Person(): name = "laowang", age = 33 {
print("这是Person构造函数：($name) -- ($age)");
}
类方法/类属性
在类中可以使用 static 关键字来实现类级别的变量和方法。
class Person {
String name = "Uzi";
static String age = "19";
static void run() {
print("static age:" + age);
}
void eat() {
print(this.name + " " + age);
}
}
main() {
Person p = Person();
p.eat();
Person.run();
}
类的继承和多态
-
继承
（单继承）
&emspDart 类的继承需用关键字 extends 进行声明，例如A继承自B，示例：Class A extends B{}， 子类继承父类所有非私有方法和属性。
class Animal {
String name;
int age;
String _height;
Animal(this.name, this.age);
//命名构造函数
Animal.init(this.name, this.age);
void printInfo() {
print("Animal printInfo: $name $age");
}
void onlyTest() {
print("Animal test");
}
}
import 'Animal.dart';
class Dog extends Animal {
int weight;
Dog(String name, int age, int weight) : super(name, age) {
this.weight = weight;
}
//也可以使用命名构造函数进行初始化（功能与上面一致）
/*
Dog(String name, int age, int weight) : super.init(name, age) {
this.weight = weight;
}
*/
run() {
print("$name is running, age = $age , weight = $weight");
}
@override // 子类重写父类方法
void printInfo() {
// TODO: implement printInfo
// super.printInfo();
print('Dog PrintInfo: $name $age $weight');
}
}
main(List<String> args) {
var dog = Dog("大黄", 6, 40);
dog.printInfo(); //Dog PrintInfo: 大黄 6 40
dog.run();//大黄 is running, age = 6 , weight = 40
dog
..name = "二哈"
..age = 3
..weight = 30
..run(); //二哈 is running, age = 3 , weight = 30
dog.onlyTest(); // Animal test
dog.printInfo(); //Dog PrintInfo: 二哈 3
}
-
多态
- 子类的实例赋值给父类引用，即父类指针指向子类对象
- 调用同一个函数会有不同执行效果
class Animal {
eat() {
print('Animal eat');
}
}
class Dog extends Animal {
@override
eat() {
print("小狗 吃 🦴");
}
}
class Cat extends Animal {
@override
eat() {
print('小猫 吃 🐭');
}
}
main(List<String> args) {
Animal a1 = Dog();
a1.eat();//小狗 吃 🦴
Animal a2 = Cat();
a2.eat();//小猫 吃 🐭
}
Mixins特性
Dart 是一种单继承，并非多继承，但是可以使用 mixins 实现类似多继承的功能。
Dart2.x 中 mixins 使用的条件：
- 作为 mixins 的类只能继承自 Object，不能继承自其他类。
- 作为 mixins 的类，除了默认构造函数以外，不能包含其他的构造函数。
- 一个类可以 mixins 多个mixins类。
特别注意： mixins 不是继承，也不是接口，而是一种全新的特性。
class Person {
String name;
int age;
Person(this.name, this.age);
}
class A {
String title = "this is A";
void printA() {
print('print A');
}
void run() {
print('A run');
}
}
class B {
void printB() {
print('print B');
}
void run() {
print('B run');
}
}
class C extends Person with A, B {
C(String name, int age) : super(name, age);
printC() {
print('$name ----- $age');
}
}
main(List<String> args) {
C c = C('xiaoming', 18);
c.printA();//print A
c.printB();//print B
c.printC();//xiaoming ----- 18
c.run();//B run
print(c.title);//this is A
}
疑问？： 这里class C有A、B两个mixins类，且A、B中都有run方法，但最终为何c.run输出结果为：B run ？
答：当一个类多个mixins类时，切方法名有重复时，后者的会覆盖前者
