目录
- 实例化成员变量
- 构造函数
- 读取和写入对象 setters 和 Getters
- 重载操作
- 继承类
- 抽象类
- 对象call方法
1.实例化成员变量
定义一个User类，添加两个成员变量，类定义中的所有变量都会隐式的定义 setter 方法，针对非空的变量会额外增加getter方法。代码如下：
class User {
String name;
int age;
}
main () {
var user = new User();
user.name = 'isyang'; // 相当于使用了name的setter方法
user.age = 21;
}
2. 构造函数
- 常规构造函数
构造函数用来构造当前类的函数，是一种特殊的函数，函数名称必须要和类名相同。
class User {
String name;
int age;
User(String name, int age) {
this.name = name;
this.age = age;
}
}
this 关键字指向了当前类的实例。简化代码为：
class User {
String name;
int age;
User(this.name, this.age);
}
- 命名的构造函数
命名构造函数从另一类或现有的数据中快速实现构造函数，代码如下：
class User {
String name;
int age;
User(this.name, this.age);
// 命名构造函数
User.fromJson(Map json) {
name = json['name'];
age = json['age'];
}
}
- 默认情况下，子类只能调用父类的无名、无参数的构造函数，例如：
class Person {
String firstName;
// 无参数的，非命名的构造函数
Person() {
print('in Person');
}
}
class Son extends Person {
// 因为父类有无参数的，非命名的构造函数，所以可以不用手动调用父类的构造函数
Son.fromDictionary(Map data) {
print('in Son');
}
}
- 如果父类不显示提供无名无参数构造函数的构造函数，在子类中必须手动调用父类的一个构造函数。在
:后面构造函数体之前指定要调用的父类构造函数
class Person {
Person.fromJson(Map data) {
print('in Person');
}
}
class Employee extends Person {
// Person 没有默认构造函数
// 所以必需指定 super.fromJson(data) 构造函数
Employee.fromJson(Map data) : super.fromJson(data) {
print('in Employee');
}
}
main() {
var emp = new Employee.fromJson({});
// 打印结果：
// in Person
// in Employee
}
- 构造函数初始化列表
除了调用父类的构造函数，也可以通过初始化列表在子类的构造函数运行前来初始化实例的成员变量值，代码如下：
class User {
final String name;
final int age;
User(name, age)
: name = name,
age = age;
}
main () {
var p = new User('张三', 20);
}
3. 读取和写入对象 setters 和 Getters
get() 和 set() 方法是专门用于读取和写入对象的属性的方法，每个类的实例，系统都隐式的包含有get()和set()方法。
class Rectangle {
num left;
num top;
num width;
num height;
Rectangle(this.left, this.top, this.width, this.height);
// 获取right值
num get right => left + width;
// 设置right值 同时left也发生变化
set right(num value) => left = value - width;
// 获取bottom值
num get bottom => top + height;
// 设置bottom值 同时top 也发生变化
set bottom(num value) => top = value - height;
}
main() {
var rect = new Rectangle(3, 4, 20, 15);
rect.right = 12;
print('更改right的值为12')
}
4. 重载操作
重载 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
重写 是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。
class Vector {
final int x;
final int y;
const Vector(this.x, this.y);
// 重载加号
Vector operator +(Vector v) {
return new Vector(x + v.x, y + v.y);
}
// 重载减号
Vector operator -(Vector v) {
return new Vector(x - v.x, y - v.y);
}
}
main() {
final v = new Vector(2, 3);
final w = new Vector(2, 2);
final r1 = v + w;
print(r1.x.toString());
print(r1.y.toString());
final r2 = v - w;
print(r2.x.toString());
print(r2.y.toString());
}
5. 继承类
// 动物类
class Animal {
void eat() {
print('动物会吃');
}
void run() {
print('动物会跑');
}
}
// 人类
class Human extends Animal {
void say() {
print('人类会说');
}
@override
void eat() {
print('人类也会吃');
}
}
main() {
print('实例化一个动物类');
var animal = new Animal();
animal.eat();
animal.run();
print('实例化一个人类');
var human= new Human ();
human.eat();
human.say();
human.run();
}
6. 抽象类
// 数据库操作抽象类
abstract class DataBaseOperate {
void insert(); // 定义插入的方法
void delete(); // 定义删除的方法
void update(); // 定义更新的方法
void query(); // 定义一个查询的方法
}
// 数据库操作实现类
class DataBaseOperateImpl extends DataBaseOperate {
void insert() {
print('实现插入的方法')
}
void delete() {
print('实现删除的方法')
}
// .....
}
main() {
var db = new DataBaseOperateImpl();
db.insert();
db.delete();
//.....
}
7.对象call方法
如果类实现了call()方法，则该类的对象可以作为方法使用
代码如下：
class User {
String name;
int age;
// void work() {
// print("Name is $name, Age is $age");
// }
// 名称必须为call
void call() {
print("Name is $name, Age is $age");
}
}
void main () {
var user = new User();
user.name = 'isyang';
user.age = 21;
// user.work();
user(); // 作为方法调用
}
网友评论