类
- 文件名一般以小写加下划线加小写的方式
- 类名一般用大写字母开头
- dart没有像java一样的private之类的关键词来限制类或者变量，但是可以加下划线代表私有
- 构造方法不需要方法体
- dart不允许方法重载，如果需要有多个不同参数的构造方法，可以使用命名构造方法的方式，取一个别名的构造方法，实现像java里构造方法的重载
- dart的构造方法允许可变参数，但是使用命名构造方法可以更直观表示方法作用和特性
- 参数初始化列表 初始化你类当中的属性 可以不写方法体
//包括类的定义 如果使用 _开头 意味着这个类是private
class Point{
//使用 _ 开始命名的变量 就是Java的 private
int _x;
int y;
//构造方法不需要方法体
Point(this._x,this.y);
//dart的构造方法允许可变参数，但是使用命名构造方法可以更直观表示方法作用和特性
// Point({int x,int y}){
//
// }
// 命名构造方法 命名更加直观的表示这个构造方法的作用与特性
Point.Cool(int y){
this. y = y;
print("我好帅啊!");
}
Point.X(this._x);
//参数初始化列表 初始化你类当中的属性 可以不写方法体
Point.fromMap(Map map):_x=map['x'],y=map['y'];
}
重定向构造方法
class View{
View(int context,int attr);
//重定向构造方法
View.a(int context):this(context,0);
//Java写法
// View(int context){
// this(context,0);
// }
}
常量构造方法
- 使用 new 来创建 常量构造方法的 对象 就和普通的对象没有区别
- 使用const 来创建多个对象，传递参数一样 表示 这几个对象是同一个 编译期常量 对象 （必须定义常量构造函数
- 工厂构造方法
- 有了私有的命名构造方法就不能再new默认的构造方法
- 同一个文件下可以调用私有命名构造方法，不同文件下才不能调用这个私有构造方法
class ImmutabelPoint{
final int x;
final int y;
// 常量构造方法
const ImmutabelPoint(this.x,this.y);
}
class Manager{
int i;
static Manager _instance;
// 工厂构造方法 必须返回一个 实例对象
factory Manager.getInstance(){
if(_instance == null){
_instance = new Manager._newInstance();
}
return _instance;
}
// static Manager get2(){
// return new Manager();
// }
//私有的 private的 有了这个私有的构造方法就不能再new Manager()了
//同一个文件下可以调用这个_newInstance，不同文件下才不能调用这个私有构造方法
Manager._newInstance();
}
void main(){
//使用 new 来创建 常量构造方法的 对象 就和普通的对象没有区别
//使用const 来创建多个对象，传递参数一样 表示 这几个对象是同一个 编译期常量 对象 （必须定义常量构造函数）
var p1 = const ImmutabelPoint(1,1);
var p2 = const ImmutabelPoint(1,1);
print(p1.hashCode == p2.hashCode);
print(p1 == p2);
/**
* 工厂构造方法
*/
new Manager.getInstance();
}
set get方法
- 类中每一个实例属性 变量都会有一个隐式的 get，非final 还有 set
- 类中非私有的变量本身就有隐式非final的get和set方法，dart又不支持重载，所以就不能再自定义这个变量的set和get方法了。可以给私有变量自定义
- 运算符重载
- 抽象类，跟java类似。区别是抽象类的抽象函数可以不写abstract关键词
- 接口，dart中每个类都可以看成是一个接口
- 可调用的类，可以直接调用类中的call函数
class Point{
//每一个实例属性 变量都会有一个隐式的 get，非final 还有 set
int _x;
int _y;
//x 是方法名
//这里可以写方法体，可以用=>写表达式，也可以写三元运算
int get x => _x;
set x(int x) => _x = x;
//运算符重载， 定义+ 操作的行为
Point operator +(Point othre){
var point = new Point();
point._x = _x + othre.x;
return point;
}
String operator -(int x){
return "hahahaha";
}
}
class Test{
void ass(){}
void fff(){}
void call(int ){
}
}
void main(){
// var point = new Point();
// // get
// print(point.xxxxx);
// // set
// point.bbbbbbb = 10;
var p1 = Point();
var p2 = Point();
p1.x = 10;
p2.x = 20;
var p3= p1 + p2;
p3 = p1 + p2 + p3;
print(p3.x);
//灵活......
String str = p3 - 1;
print(str);
//可调用的类
Test test = Test();
//调用的是Test中的call函数
test(1);
}
混合mixins
- 被mixin(混入)的类不能有构造函数
- 混合后有名称相同的函数时，自身是第一优先级，如果自身没有对应的方法，就从with最右边开始查找方法
- 内部可以用super关键词调用父类的函数
//被mixin(混入)的类不能有构造函数
class A {
void a(){
print("A 的a方法!");
}
}
class B{
void b(){
print("b方法");
}
void a(){
print("B 的a方法!");
}
}
// 满足了我们的多继承的需求
class C with B,A{
void c(){
}
// 重写了 混入类的a方法
void a(){
}
}
//C 就是A B的混合类
//class C = Object with A, B;
void main(){
//1、自身是第一优先级
//2、如果自身没有对应的方法，就从with最右边开始查找方法
var c = new C();
c.a();
}
