Dart 方法与类
2021-07-20 本文已影响0人
wuchao226
方法
int add(int i,int j) {
return i + j;
}
//也可以选择忽略类型(不推荐)
add( i, j) {
return i + j;
}
//对于只有一个表达式的方法，可以选择使用缩写语法来定义：
add(i, j) => i + j;
//在箭头 (=>) 和分号 (;) 之间只能使用一个 表达式
一等方法对象
Dart 是一个真正的面向对象语言，方法也是对象并且具有一种类型 `Function`。 这意味着，方法可以赋值给变量，也可以当做其他方法的参数。可以把方法当做参数调用另外一个方法
var list = [1,2,3];
//将 print 方法 作为参数传递给forEach
list.forEach(print);
//可以将方法赋值给一个变量 类型为Funcation
var p = print;
list.forEach(p);
在Java中如果需要能够通知调用者或者其他地方方法执行过程的各种情况，可能需要指定一个接口，比如 View 的 onClickListener。而在 Dart 中，我们可以直接指定一个回调方法给调用的方法，由调用的方法在合适的时机执行这个回调。
void setListener(Function listener){
listener("Success");
}
//或者
void setListener(void listener(String result)){
listener("Success");
}
//两种方式，第一种调用者根本不确定 回调函数的返回值、参数是些什么
//第二中则需要写这么一大段 太麻烦了。
//第三种：类型定义 将返回值为voide，参数为一个String的方法定义为一个类型。
typedef void Listener(String result)；
void setListener(Listener listener){
listener("Success");
}
方法可以有两种类型的参数：必需的和可选的。 必需的参数需要在参数列表前面， 后面再定义可选参数。
可选命名参数
把方法的参数放到 `{}` 中就变成可选 命名参数
int add({int i, int j}) {
if(i == null || j == null){
return 0;
}
return i + j;
}
调用方法的时候，可以使用这种形式 paramName: value 来指定命名参数。例如：
//无必须参数
add()
//选择传递参数
add(i:1)
//位置无关
add(i:1, j:2)
add(j:1, i:2)
可选位置参数
把方法的参数放到 `[]` 中就变成可选 位置参数，传值时按照参数位置顺序传递
int add([int i, int j]) {
if(i == null || j == null){
return 0;
}
return i + j;
}
// 1赋值给i
add(1);
// 按照顺序赋值
add(1,2);
默认参数值
在定义方法的时候，可选参数可以使用 `=` 来定义可选参数的默认值。
int add([int i = 1, int j = 2]) => i + j;
int add({int i = 1, int j = 2}) => i + j;
匿名方法
没有名字的方法，称之为匿名方法，也可以称之为 lambda 或者 closure 闭包。匿名方法的声明为：
([Type] param1, …) {
codeBlock;
};
如：
var list = ['apples', 'oranges', 'grapes', 'bananas', 'plums'];
list.forEach((i) {
print(list[i]);
});
示例
function_learn.dart
//构造方法
//实例方法
//setters 和 getters
//静态方法
//抽象方法
//私有方法
//匿名方法
//泛型方法
class TestFunction {
FunctionLearn functionLearn = FunctionLearn();
void start() {
functionLearn._learn();
functionLearn.anonymousFunction();
}
}
class FunctionLearn {
///方法构成
///返回值类型 + 方法名 + 参数
///其中：返回值类型可缺省，也可为void或具体的类型
///方法名：匿名方法不需要方法名，下文会提到
///参数：参数类型和参数名，参数类型可缺省（另外，参数又分可选参数和参数默认值，可参考面向对象一节中构造方法部分的讲解）
int sum(int val1, int val2) {
return val1 + val2;
}
///私有方法：
///通过_开头命名的方法
///作用域是当前文件
_learn() {
print('FunctionLearn');
}
/// 匿名方法：
/// 大部分方法都带有名字，例如 main() 或者 print();
/// 在Dart中你有可以创建没有名字的方法，称之为 匿名方法，有时候也被称为 lambda 或者 closure 闭包；
/// 你可以把匿名方法赋值给一个变量， 然后你可以使用这个方法，比如添加到集合或者从集合中删除；
/// 匿名方法和命名方法看起来类似— 在括号之间可以定义一些参数，参数使用逗号 分割，也可以是可选参数；
/// 后面大括号中的代码为函数体：
/// ([[Type] param1[, …]]) {
/// codeBlock;
/// };
anonymousFunction() {
var list = ['私有方法', '匿名方法'];
//下面的代码定义了一个参数为i （该参数没有指定类型）的匿名函数
//list 中的每个元素都会调用这个函数来 打印出来，同时来计算了每个元素在 list 中的索引位置
list.forEach((i) {
print(list.indexOf(i).toString() + ': ' + i);
});
}
}
类
Dart 是一个面向对象编程语言。 每个对象都是一个类的实例，所有的类都继承于 `Object`。
//每个实例变量都会自动生成一个 getter 方法（隐含的）。 非final 实例变量还会自动生成一个 setter 方法。
class Point {
num x;
num y;
}
构造函数
由于把构造函数参数赋值给实例变量的场景太常见了， Dart 提供了一个语法糖来简化这个操作：
class Point {
num x;
num y;
Point(this.x, this.y);
}
命名构造函数
Dart 并不支持构造函数的重载，而采用了命名构造函数为一个类实现多个构造函数：
class Point {
num x;
num y;
Point(this.x, this.y);
Point(this.y);///错误，不允许重载
//命名构造函数
Point.y(this.y) {
x = 0;
}
}
//使用
var p = Point.y(0);
初始化列表
在构造函数函数体执行之前会首先执行初始化列表，非常适合用来设置 final 变量的值。
class Point {
num x;
num y;
Point(this.x, this.y);
//命名构造函数
Point.y(this.y) {
x = 0;
}
Point.fromMap(Map map)
: x = map['x'], // : 和c++一样，初始化列表
y = map['y'];
Point.x(int i)
: x = i,
y = 0;
}
重定向构造函数
有时候一个构造函数会调动类中的其他构造函数(在Java中就是 `this(...)`)。 一个重定向构造函数是没有代码的，在构造函数声明后，使用 冒号调用其他构造函数。
class Point {
num x;
num y;
Point(this.x, this.y);
Point.xy(int x,int y):this(x,y); ///调用上面的构造函数
}
常量构造函数
如果你的类提供一个状态不变的对象，你可以把这些对象 定义为编译时常量。要实现这个功能，需要定义一个 `const` 构造函数， 并且声明所有类的变量为 `final`。
class ImmutablePoint {
final num x;
final num y;
//常量构造函数
const ImmutablePoint(this.x, this.y);
}
void main(){
//编译器常量
var p1 = const ImmutablePoint(0,0);
var p2 = const ImmutablePoint(0,0);
print(p1 == p2); // true
}
工厂构造函数
当实现一个使用` factory` 关键词修饰的构造函数时，这个构造函数不必创建类的新实例。例如，一个工厂构造函数 可能从缓存中获取一个实例并返回，或者 返回一个子类型的实例。（工厂构造函数无法访问 `this`）
class Logger {
final String name;
//从缓存获取对象
static final Map _cache = {};
//工厂构造函数，无法使用this变量
factory Logger(String name) {
if (_cache.containsKey(name)) {
//工厂构造函数需要返回 Logger 实例对象
return _cache[name];
} else {
final logger = Logger._internal(name);
_cache[name] = logger;
return logger;
}
}
//以 _ 开头的函数、变量无法在库外使用
Logger._internal(this.name);
}
借助工厂构造函数能够实现单例:
//使用工厂构造实现单例
class Manager {
static Manager _instance;
//和static是一样的, 区别是factory毕竟是构造函数，需要返回一个实例，而static是静态方法。
factory Manager.getInstance() {
if (_instance == null) {
_instance = new Manager._internal();
}
return _instance;
}
// static Manager getInstance() {
// if (_instance == null) {
// _instance = new Manager._internal();
// }
// return _instance;
// }
Manager._internal();
}
Getters 和 Setters
Dart中每个实例变量都隐含的具有一个 getter， 如果变量不是 final 的则还有一个 setter。可以通过实现 getter 和 setter 来创建新的属性， 使用 `get` 和 `set` 关键字定义 getter 和 setter：
class Rect {
num left;
num top;
num width;
num height;
Rect(this.left, this.top, this.width, this.height);
//使用 get定义了一个 right 属性
num get right => left + width;
set right(num value) => left = value - width;
}
void main() {
var rect = Rect(0, 0, 10, 10);
print(rect.right); //10
rect.right = 15;
print(rect.left); //5
}
需要注意的是，在get与set中使用自身会导致Stack Overflow
可覆写的操作符
把已经定义的、有一定功能的操作符进行重新定义。可以重新定义的操作符有：
| < | + | | | [] |
| ---- | ---- | ---- | ----- |
| > | / | ^ | []= |
| <= | ~/ | & | ~ |
| >= | * | << | == |
| – | % | >> | |
比如：List就重写了 `[]`。
class Point {
int x;
int y;
//返回值 参数随你定义
Point operator +(Point point) {
return Point(x + point.x, y + point.y);
}
Point(this.x, this.y);
}
var p1 = Point(1, 1);
var p2 = p1 + Point(2, 2);
print(p2.x); ///3
print(p2.y); ///3
抽象类
使用 `abstract` 修饰符定义一个抽象类。抽象类中允许出现无方法体的方法
abstract class Parent {
String name;
void printName(); //抽象方法，不需要在方法前声明 abstract
}
抽象类不能被实例化，除非定义工厂方法并返回子类。
abstract class Parent {
String name;
//默认构造方法
Parent(this.name);
//工厂方法返回Child实例
factory Parent.test(String name){
return new Child(name);
}
void printName();
}
// extends 继承抽象类
class Child extends Parent{
Child(String name) : super(name);
@override
void printName() {
print(name);
}
}
void main() {
var p = Parent.test("Lance");
print(p.runtimeType); //输出实际类型 Child
p.printName();
}
接口
与Java不同，Dart中没有`interface`关键字，**Dart中每个类都隐式的定义了一个包含所有实例成员的接口**， 并且这个类实现了这个接口。如果你想 创建类 A 来支持 类 B 的 方法，而不想继承 B 的实现， 则类 A 应该实现 B 的接口。
class Listener{
void onComplete(){}
void onFailure(){}
}
class MyListsner implements Listener{
MyListsner(){
}
@override
void onComplete() {
}
@override
void onFailure() {
}
}
与继承的区别在于：
1、单继承，多实现。
2、继承可以有选择的重写父类方法并且可以使用super，实现强制重新定义接口所有成员。
可调用的类
如果 Dart 类实现了 `call()` 函数则 可以当做方法来调用。
class Closure {
call(String a, String b) => '$a $b!';
}
main() {
var c = new Closure();
var out = c("Hello","Dart");
print(out);
}
混合mixins
Mixins 是一种在多类继承中重用 一个类代码的方法。它的基本形式如下：
//被mixin(混入)的类不能有构造函数
class A {
void a(){}
}
class B{
void b(){}
}
class C with A,B{
void c(){}
}
with后面跟着需要混入的类，被mixin(混入)的类不能有构造函数。现在的 C拥有了三个方法（a、b与c）。假设A与B 存在相同的方法，以最右侧的混入类为主，比如：
class A {
String getMessage() => 'A';
}
class B {
String getMessage() => 'B';
}
//
class AB with A, B {}
class BA with B, A {}
void printMessage(obj) => print(obj.getMessage());
void main() {
printMessage(AB()); //输出 B
printMessage(BA()); //输出 A
}
继承与mixins是兼容的
class A {
String getMessage() => 'A';
}
class B {
String getMessage() => 'B';
}
class P{
String getMessage() => 'P';
}
class AB extends P with A, B {}
class BA extends P with B, A {}
//可以简写成：
//class AB = P with A, B;
//class BA = P with B, A;
void printMessage(obj) => print(obj.getMessage());
void main() {
printMessage(AB()); //输出 B
printMessage(BA()); //输出 A
}
mixins弥补了接口和继承的不足，继承只能单继承，而接口无法复用实现，mixins却可以多混入并且能利用到混入类的具体实现：
abstract class Swimming{
void swimming(){
print("游泳");
}
}
abstract class Jump{
void jump(){
print("跳跃");
}
}
//只能单继承，如果需要Jump，只能以implements的形式
class Lance extends Swimming implements Jump{
//实现接口
void jump(){
print("跳跃");
}
}
//但是实际上，我们经常不需要重新实现Jump方法，复用Jump所实现的jump方法就可以了
//这时使用混合能够更加方便
class Lance1 with Swimming, Jump {}
示例
void _oopLearn() {
//创建Student的对象
Student stu1 = Student('清华', 'Jack', 18);
stu1.school = '985';
print(stu1.toString());
Student stu2 = Student('北大', 'Tom', 16, city: '上海', country: '中国');
print(stu2.toString());
Student.doPrint('_oopLearn');
StudyFlutter sf = StudyFlutter();
sf.study();
Logger log1 = Logger();
Logger log2 = Logger();
print(log1 == log2);
}
oop_learn.dart
///面向对象（OOP）
class Student extends Person {
//定义类的变量
String _school; //通过下划线来标识私有字段（变量）
String city;
String country;
String name;
static Student instance;
///构造方法：
///通this.school初始化自有参数
///name,age交给父类进行初始化
///city为可选参数
///country设有默认参数
Student(this._school, String name, int age,
{this.city, this.country = 'China'})
//初始化列表：除了调用父类构造器，在子类构造器方法体之前，你也可以初始化实例变量，不同的初始化变量之间用逗号分隔开
: name = '$country.$city',
//如果父类没有默认构造方法（无参构造方法），则需要在初始化列表中调用父类构造方法进行初始化
super(name, age) {
//构造方法体不是必须的
print('构造方法体不是必须的');
}
//命名构造方法：[类名+.+方法名]
//使用命名构造方法为类实现多个构造方法
Student.cover(Student stu) : super(stu.name, stu.age) {
print('命名构造方法');
}
//命名工厂构造方法：factory [类名+.+方法名]
//它可以有返回值，而且不需要将类的final变量作为参数，是提供一种灵活获取类对象的方式。
factory Student.stu(Student stu) {
return Student(stu._school, stu.name, stu.age,
city: stu.city, country: stu.country);
}
@override
String toString() {
return 'name:$name school:${this._school},city:$city,country:$country ${super.toString()}';
}
//可以为私有字段设置getter来让外界获取到私有字段
String get school => _school;
//可以为私有字段设置setter来控制外界对私有字段的修改
set school(String value) {
_school = value;
}
//静态方法
static doPrint(String str) {
print('doPrint:$str');
}
///科普小知识：实例方法，对象的实例方法可以访问到实例变量与this，如上述代码中的toString
}
///定一个Dart类，所有类都继承自Object
class Person {
String name;
int age;
Person(this.name, this.age);
///重写父类方法
@override
String toString() {
return 'name:$name, age:$age';
}
}
///工厂构造方法演示
class Logger {
static Logger _cache;
// 工厂构造方法：
// 不仅仅是构造方法，更是一种模式
// 有时候为了返回一个之前已经创建的缓存对象，原始的构造方法已经不能满足要求
// 那么可以使用工厂模式来定义构造方法
factory Logger() {
if (_cache == null) {
_cache = Logger._internal();
}
return _cache;
}
Logger._internal();
void log(String msg) {
print(msg);
}
}
///继承抽象类要实现它的抽象方法，否则也需要将自己定义成抽象类
class StudyFlutter extends Study {
@override
void study() {
print('Learning Flutter');
}
}
///使用 abstract 修饰符来定义一个抽象类，该类不能被实例化。抽象类在定义接口的时候非常有用，实际上抽象中也包含一些实现
abstract class Study {
void study();
}
///为类添加特征：mixins
///mixins 是在多个类层次结构中重用代码的一种方式
///要使用 mixins ，在 with 关键字后面跟一个或多个 mixin 的名字(用逗号分开)，并且with要用在extends关键字之后
///mixins的特征：实现 mixin ，就创建一个继承 Object 类的子类(不能继承其他类)，不声明任何构造方法，不调用 super
///猜猜上面的类中哪个是mixin？
class Test extends Person with Study {
Test(String name, int age) : super(name, age);
@override
void study() {
// TODO: implement study
}
}
