1.类的基本使用
void main(List<String> args) {
// Dart所有的东西都是对象，所有的对象都继承自Object类。
// Dart中的类都是单继承的
Person person = new Person();
// 调用方法
person.show();
// 修改属性
person.name = "jack";
person.age = 18;
// 访问属性
print(person.name + ', ${person.age}');
person.show();
}
// 定义类
class Person {
String name = "";
int age = 0;
void show() => print("$name, $age");
}
2.构造函数
void main(List<String> args) {
// 构造函数的功能主要用于在类的对象创建时定义`初始化`的状态
// Dart语言中的构造函数分为`默认构造函数`和命名构造函数
// 构造函数的命名必须和类名`完全相同`, 没有返回值
// 1. 如果不显式写构造函数，默认提供一个无参构造
// 默认的缺省构造
// Person p = Person(); // new 关键字可以不写
// print(p);
// 2. 一旦显式提供构造函数，默认的缺省构造将不再提供，
// 构造函数有且只能有一个
// 构造函数可以简写
Person p = Person('jack', 18);
print(p);
// 3. 命名构造可以有一堆 类名.xxx
Person p2 = Person.init();
print(p2);
p2 = Person.setupInfo('rose', 22);
print(p2);
// 4.常量构造
// 要使用常量构造方法，创建出相同的对象，使用const关键字
// 如果是将结果赋值给const修饰的标识符时，const可以省略.
Point point3 = const Point(10, 20);
const point4 = Point(10, 20);
print(identical(point3, point4));
}
// ========
class Person {
var name;
int age = 0;
// 构造函数可以简写
Person(this.name, this.age);
// Person(var name, int age) {
// print('有参构造');
// this.name = name;
// this.age = age;
// }
// Person(); // 构造函数只能有一个，因为不能重载
// 命名构造
Person.setupInfo(var name, int age) {
this.name = name;
this.age = age;
}
Person.init({var name, int age = 0}) {
this.name = name;
this.age = age;
}
}
class Point {
final int x;
final int y;
// 在构造函数前加上 const 变成常量构造
const Point(this.x, this.y);
}
3.初始化列表
void main(List<String> args) {
// 初始化列表，在C++中有类似的语法
// Dart中我们也可以在构造函数体运行之前初始化实例变量
// 所有的成员变量都是final, C++是有包含有const的成员
Rect r = Rect(10, 20);
print(r.circle);
}
class Rect {
final int width;
final int height;
final int circle; // 周长
// Rect(this.width, this.height) {
// this.circle = width * height; // 'circle' can't be used as a setter because it's final.
// }
// 上面的方法不行，除非三个值全部用构造，除了这个方法，我们还可以使用初始化列表
Rect(this.width, this.height) : circle = ((width + height) * 2) {
print("初始化列表");
}
}
4. 重定向构造与工厂构造
void main(List<String> args) {
// 1.重写向构造：在一个构造函数中去调用另一个构造函数
Person p = Person.setupInto('jack', 20);
// 2.工厂构造
// Dart提供了factory关键字, 用于通过工厂去获取对象, 如果对象存在直接返回，否则创建
Person p1 = Person.map({'name': 'rose', 'age': 18});
Person p2 = Person.map({'name': 'jack', 'age': 22});
print(identical(p1, p2)); // true, 因为是直接获取对象
// 3.利用工厂构造来实现单例
Singleton s1 = Singleton();
Singleton s2 = Singleton();
print(identical(s1, s2));
}
class Person {
String name;
int age;
static var _cache;
Person(this.name, this.age) {
print("我被调用了");
this.name = name;
this.age = age;
}
Person.setupInto(String name, int age) : this(name, age);
// 工厂构造
factory Person.map(Map map) {
if (Person._cache == null) {
Person._cache = Person.setupInto(map['name'], map['age']);
print("创建对象");
}
return Person._cache;
}
}
class Singleton {
static final Singleton _singleton = Singleton.internal();
factory Singleton() {
print('Singleton 工厂构造被调用');
return _singleton;
}
Singleton.internal() {
print('internal 被调用了');
}
}
5.setter && getter
void main(List<String> args) {
// getter的定义方式 get+方法名
// setter的定义方式 set+方法名(参数)
// 注意：getter方法是没有( )的。返回值类型可以不用声明。
// setter方法有且只能接收一个参数
// 注意调用方式，是以属性修改的方式，不是以函数调用的方式。
Person p = Person();
p.name = 'jack'; // 这样是不会调用 setter和getter的
print(p.name);
// 调用 setter getter的正确姿势
p.setName = 'rose';
print(p.getName);
}
class Person {
var name;
// set方法
set setName(String name) {
print('设置');
this.name = name;
}
// get 方法
get getName {
print('获取');
return this.name;
}
}
6. 对象运算符
void main(List<String> args) {
// is 是父类或当前类
// is! 不是
// as 转换
// ?
// .. 级联运算
int data = 100;
print(data is num); // true
print(data is int); // true
num n = 100;
print(n is int); // true
print(n is Object); // true
print((n as int).runtimeType); // int
// print((n as double)); // 转换失败
var p;
p?.show(); // 如果 p 为 null, 不执行 show()方法，这和Swfit相同的
Person p2 = Person(name: 'jack', age: 20);
p2
..name = 'rose'
..age = 18
..show();
}
class Person {
String name = "";
int age = 0;
Person({this.name = "", this.age = 0});
void show() => print("$name, $age");
}
7. static关键字
void main(List<String> args) {
// static的用法与其它语言几乎是一样的
// 使用 static 关键字来实现类级别的变量和函数
// 静态方法不能访问非静态成员，非静态方法可以访问静态成员
// 这些和其它语言几乎是一样的
Person.printInfo();
Person.country = "美国";
Person p = Person();
p.show();
// p.country = "ABC"; // 不允许在界面，通过对象来访问静态成员
// p.printInfo(); // 同上
}
class Person {
String name = "";
static String country = "中国";
static printInfo() {
// print(name); // 错误，不能访问非静态成员
print(country);
}
void show() {
country = "abc"; // 在类内，非静态成员可以访问静态成员
print("$name, $country");
}
}
8.类的分离与私有属性
class Person {
String _name = "";
set setName(String name) {
_name = name;
}
get name => _name;
}
import './person.dart';
void main(List<String> args) {
// Dart 中没有 public private protected这些访问修饰符
// Dart中使用 _ (下划线) 把一个属性或者方法定义成私有
// 私有属性在同一文件，都是可以访问的
Student stu = Student();
stu._name = 'jack';
Person p = Person();
// p._name = 'jack'; // 不能访问
// 通过 getter和setter来访问
p.setName = "rose";
print(p.name);
}
class Student {
String _name = "";
}
网友评论