个人学习用
不严谨
学习的话请看别的博客
使用类的成员
void main() {
/**
* Dart 是支持基于 mixin 继承机制的面向对象语言,所有对象都是一个类的实例,而所有的类都继承自 Object 类。基于 mixin 的继承 意味着每个除 Object 类之外的类都只有一个超类,
* Extension 方法是一种在不更改类或创建子类的情况下向类添加功能的方式。
*
* 使用(.)来访问对象的实例变量或方法
* 使用?.代替 . 可以避免左边的表达式为null而导致的问题
*
*/
print(MyClazz.a); //调用静态变量
MyClazz clazz = new MyClazz();
clazz.b;
clazz.showText();
}
class MyClazz {
static int a = 1;
int b = 2;
void showText() {
print('$a$b');
}
}
使用构造函数
void main() {
/**
* 使用构造函数
* 命名方式:
* 类名 或者 类名.标识符 的形式
*
*
*/
var p1 = Paint(1, 2);
var p2 = Paint.fromJson({"x": 1, "y": 2});
var p3 = Paint.fromJson({"a": 1, "b": 2});
p1.showText(); // 1 2
p2.showText(); // 1 2
p3.showText(); //null null ,因为传值时候 键值对不正确,键名字错误,方法键是 xy ,我使用的是 ab
}
class Paint {
int x;
int y;
Paint(this.x, this.y);
Paint.fromJson(Map<String, int> jsonMap) {
this.x = jsonMap["x"];
this.y = jsonMap["y"];
}
void showText(){
print(x);
print(y);
}
}
常量构造函数
void main() {
/**
*常量构造函数
* 使用常量构造函数创建对象时,参数一样情况下,创建的对象是一个
*
*/
//使用时候要用 const来定义 构造函数
var p1 = const Porint(1, 2);
var p2 = const Porint(1, 2);
var p3 = Porint(1, 2);
print(p1 == p2); //true
print(p1 == p3); //false
print(p2 == p3); //false
}
// 常量构造函数:final定义属性,const定义构造方法
class Porint {
final int a; //final定义属性
final int b;
const Porint(this.a, this.b); //const定义构造方法
void showText() {
print('$a$b');
}
}
获取对象的类型
void main() {
/**
* 获取对象类型
* 使用 对象名.runtimeType来获取运行时对象的类型
*
*/
var p1 = Point(1, 2);
var p2 = Point.fromJson({'x': 3, 'y': 4});
var p3;
print(p1.runtimeType);//Point
print(p2.runtimeType);//Point
print(p3.runtimeType);//Null
}
class Point {
int a;
int b;
Point(this.a, this.b);
Point.fromJson(Map<String, int> jsonMap) {
this.a = jsonMap['x'];
this.b = jsonMap['y'];
}
}
实例变量
void main() {
/**
* 实例变量
* 所有实例变量均会隐式地声明一个 Getter 方法,非 final 类型的实例变量还会隐式地声明一个 Setter 方法。
*
*/
}
class Potin {
int x; //声明实例变量 x 并初始化为 null。
int y; //声明实例变量 y 并初始化为 null。
int z = 0; // 声明实例变量 z 并初始化为 0。
//所有实例变量均会隐式地声明一个 Getter 方法,
// 非 final 类型的实例变量还会隐式地声明一个 Setter 方法。
}
构造函数
void main() {
/**
* 构造函数
*/
}
class Point {
int x;
int y;
// Point(this.x, this.y); //构造方法语法糖
//默认构造函数
Point(int x, int y) {
this.x = x;
this.y = y;
}
//命名构造函数
Point.mingming(int i, int j) {
this.x = i;
this.y = j;
}
}
方法
void main() {
/**
* 方法
*/
}
class Point {
int x, y;
Point(this.x, this.y);
int getNum(Point other) {
return this.x + this.y + other.x + other.y;
}
int get getTop => x + y; //get方法
set setTop(int i) => i - x;//set方法
}
抽象方法
void main() {
/**
* 抽象方法
* 实例方法.Getter方法以及Setter方法都可以是抽象方法
* 定义一个接口方法而不去做具体的实现让实现他的类去实现该方法
* 抽象方法只能存在于抽象类中
*
*/
}
//被abs修饰了,是抽象类
abstract class Father {
void show(); //没有{} 所以是抽象方法
}
class Son extends Father {
/**
* 重写抽象类中的抽象方法
*/
@override
void show() {
print("你好,我是被重写的方法");
}
}
抽象类
void main(){
/**
* 抽象类
* 1.被abstract修饰的类 为 抽象类,抽象类无法被实例化
* 2.抽象类常用于声明接口方法,有时也会有具体的实现方法
* 3.如果想让抽象类可被实例化,可以为抽象类定义 工厂构造函数
* 4.有抽象方法的类一定是抽象类,抽象类里不一定有抽象方法
*
*/
}
abstract class Point{
void show();
}
隐式接口
void main() {
/**
* 每一个类都隐式的定义了一个接口并且实现了该接口
* 这个接口包含: 所有这个类的实例成员 以及这个类所实现的其它接口
* 如果创建类A支持调用B类的API,但是又不想竭诚B类,则可以实现B类的接口
*
* 如果想要实现多个接口,则可以再 class Point implements Comparable, Location {...}
*/
String getHi(Person person) => person.getString("张三");
print(getHi(Person("李四"))); //你好,张三,我是李四
print(getHi(Son())); //你好张三
}
class Person {
final _name;
Person(this._name);
String getString(who) => '你好,$who,我是$_name';
}
class Son implements Person {
get _name => '我是默认的名字';
@override
String getString(String who) {
return '你好$who';
}
}
扩展一个类
void main() {
/**
* 使用 extend继承来 扩展一个类
*
*/
var s = Son(3);
s.show(); //章金来
s.showMore(); //章金来 //我今年3岁了
}
class Father {
String xing;
String ming;
Father(this.xing, this.ming);
void show() {
print('$xing$ming');
}
}
class Son extends Father {
int age;
Son(this.age) : super('章', '金来');
/**
* 重写的show方法
*/
@override
void show() {
super.show();
}
void showMore() {
super.show();
print('我今年$age岁了');
}
}
重写操作符
void main() {
/**
* 重写操作符: 通过operator方法可以重写 原来的操作符,达到自定义的效果
* 优先级: 混合运算时候 返回值要匹配,并且优先级不变
*/
var c1 = CaoZuo(1, 2);
var c2 = CaoZuo(3, 4);
print((c1 + c2).x); //4
print((c1 + c2).y); //-2
print((c1 - c2).x); //4
print((c1 - c2).y); //8
}
class CaoZuo {
int x, y;
CaoZuo(this.x, this.y);
//重写 + 操作符
CaoZuo operator +(CaoZuo other) => CaoZuo(this.x + other.x, this.y - other.y);
//重写 - 操作符
CaoZuo operator -(CaoZuo other) {
CaoZuo caoZuo = new CaoZuo(this.x, this.y);
caoZuo.x = caoZuo.x + other.x;
caoZuo.y = caoZuo.y * other.y;
return caoZuo;
}
}
Extension扩展
void main() {
/**
* Extension 方法 ,扩展,增加的意思
* 在Dart2.7中引入,为现有的库中添加功能的方法
* 在 IDE 中使用代码完成功能时,它建议将 Extension 方法与常规方法一起使用
* 不能对 dynamic使用这样的方法
*
*
*冲突:
如果扩展成员与接口或其他扩展成员发生冲突,则有几个选项。
1.更改导入冲突扩展的方式,使用show或hide公开或者隐藏API :
import 'string_apis_2.dart' hide NumberParsing2;
2.另一个选项是显式地应用扩展
NumberToString('111').parseInt()
3.如果两个扩展名相同,则可能需要使用前缀导入
import 'string_apis.dart';
import 'string_apis_3.dart' as rad; // 使用了前缀 as red ,前缀名是 red
print(NumberParsing('42').parseInt());
print(rad.NumberParsing('42').parseInt()); //前缀的调用方式
*/
print('42'.parseInt());
print(NumberToString('111').parseInt()); //显示调用
dynamic d = '123';
var v = '123';
//dynamic定义的数据 会报错
//dynamic定义的数据 会报错
// print(d.parseInt());//NoSuchMethodError: Class 'String' has no instance method 'parseInt'.
print(v.parseInt()); // 不会报错,因为变量v被推断为类型String:
}
/**
* 使用这个方式把parseInt方法,添加到String中
*/
extension NumberToString on String {
int parseInt() {
return int.parse(this);
}
double parseDouble() {
return double.parse(this);
}
}
枚举类型
enum Color { red, green, blue }
//enum 不能再方法内部定义,会报错
void main() {
/**
* 枚举类型 Enumerated types
* 也称为 enumerations 或 enums,用于定义一些固定数量的常量值
* 每一个枚举值都有一个名为 index 成员变量的 Getter 方法
*/
print(Color.red.index); //0
print(Color.green.index); //1
print(Color.blue.index); //2
//使用枚举的 values方法 获取到 所有枚举的 值的列表
List<Color> list = Color.values;
print(list);
//可以用在switch语句中
switch (Color.red) {
case Color.red:
break;
case Color.green:
break;
case Color.blue:
break;
}
//枚举的限制:
//不能成为子类,
//不能实现枚举
//不能显式的实例化一个枚举类
//不能 mixin
}
Mixin模式
void main() {
/**
* Mixin 混合模式
* 使用 with 关键字,可以实现多类似于多继承
*/
TestSon son = TestSon();
son.show();
}
//只能 子类实现
class TestSon extends Test with Music {
show();
}
class Test {}
//定义一个Mixin类,
//1.使用mixin关键字,不能使用class
//2.使用on 关键字,后面跟上 可以 mixin的类,只有继承了Test类的子类才可以使用 whth Music
mixin Music on Test {
//3.不能定义构造方法
int x, y, z;
void show() {
print('$x$y$z');
}
}
静态变量和静态方法
void main() {
/**
* 静态变量 和 静态方法
*
* 静态变量在首次使用的时候被初始化
* 静态方法不能使用实例来调用,因为静态加入内存比较早,实例比较晚
* 静态只能访问静态
*/
}
class Point {
static int i = 1;
static void show(){
print(i);
}
}