声明一个类
- 使用class关键字, 声明一个类
class Person{
}
类的属性和方法
1.属性会自动生成getter和setter方法, 属性用点运算符访问
2.使用final声明的属性只有getter方法
3.方法不能重载
class Man{
//属性
String name;
int age;
final String sex = "男";
//方法
void say(){
print("我的名字是"+name+", 年龄是"+age.toString()+", 性别是"+sex);
}
}
4.计算属性: 计算而来，本身是不存储值的
class Rectangle{
num width, height;
//计算属性
num get area => width * height;
set area(value){
width = 10;
height = value / width;
}
}
main(){
var r = new Rectangle();
r.area = 65;
print(r.width.toString() + " "+ r.height.toString()); //10 6.5
}
5.静态成员, 使用static关键字来实现类级别的变量和函数, 静态成员不能访问非静态成员, 非静态成员可以访问静态成员
class Person{
static const int age = 11;
static int num = 1;
static void addNum(){
num ++;
}
}
main(){
print(Person.num); //1
Person.addNum();
print(Person.num); //2
print(Person.age); //11
}
类及成员的可见性
1.在Dart中, 可见性是以library(库)为单位, 默认情况下, 一个Dart文件就是一个库
2.使用_表示私有
3.使用import导入库
构造方法
1.没有自定义构造方法, 系统会为我们自动生成一个默认构造方法
2.有自定义构造方法, 默认构造方法失效
3.构造方法不能重载
- 自定义构造函数
class Person{
//属性
String name;
int age;
//自定义构造函数
Person(String name, int age){
this.name = name;
this.age = age;
}
//自定义构造函数的简写形式, 效果跟上面一致
// Person(this.name, this.age);
}
main(){
var person = new Person("张三", 11);
}
- 命名构造函数
构造函数不能重载, 可以使用命名构造函数实现多个构造方法
class Person{
//属性
String name;
int age;
//构造方法
Person(this.name, this.age);
//命名构造方法
Person.withName(this.name);
Person.withNameAndAge(this.name, this.age);
}
main(){
var person1 = new Person("zhangsan", 11);
//命名构造函数
var person2 = new Person.withName("list");
var person3 = new Person.withNameAndAge("wangwu", 12);
}
- 常量构造函数
1.如果类是不可变状态, 可以把对象定义为编译时常量
2.使用const声明构造方法, 并且所有变量都是final
3.使用const声明对象, 也可以省略const
class Person{
final String name;
final int age;
const Person(this.name, this.age);
}
main(){
//const person = const Person("lisi", 11);
const person = Person('lisi', 11); //等价于上一行, const可以省略
}
继承
1.使用extends关键字
2.子类继承父类可见的属性和方法, 不会继承构造方法
3.子类可以重写父类的方法
4.单继承
5.子类的构造方法默认会调用父类的无名无参构造方法, 如果父类没有无名无参构造方法，则需要显示调用父类构造方法
class Animal{
//属性
String name;
int age;
//方法
void run(){
print("run...");
}
}
//Person继承了Animal
class Person extends Animal{
String address;
void study(){
print('study ....');
}
}
//Person继承了Animal, 所有Person有了Animal的方法和属性
main(){
var person = new Person();
person.name = 'zhangsan';
person.age = 11;
person.address = '郑州';
person.run(); //run..
person.study(); //study...
}
抽象类
- 抽象类使用abstract表示，不能直接被实例化
- 抽象方法用abstract表示，无实现
- 抽象类可以没有抽象方法
- 有抽象方法的类一定是抽象类
//抽象类
abstract class Person{
void run();
}
class Student extends Person{
@override
void run() {
// TODO: implement run
print("run ............");
}
}
接口
- 类和接口是统一的，类就是接口
- 每个类都隐式的定义了一个包含所有实例成员的接口
- 如果复用已有类的实现，使用继承extends
- 如果只是使用已有类的外在行为，使用接口implements
