一、函数
1、自定义方法
//main入口方法
void main() {
//调用方法
printInfo();
//自定义的方法也可以定义在main方法内部
int getNum() {
return 1;
}
print(getNum());
}
//自定义方法 void指没有返回值
void printInfo() {
print("自定义方法");
}
2、位置可选参数方法
将参数放到[ ]中来标记参数是可选的:
【】中的格式在新版本中为 :类型+?+名字(在老版本中没有?)
void main() {
String str = say("张三", "哈哈", "hehe");
print(str);
String str1 = say("张三", "哈哈");
print(str1);
}
String say(String from, String msg, [String? device]) {
var result = '$from says $msg';
if (device != null) {
result = '$result with a $device';
}
return result;
}
3、命名可选参数方法
定义函数时,使用{parm1,param2,…} 来指定命名参数,如:
void fun1( {bool? flag1, bool? flag2} ){
...
}
调用函数时,使用指定命名参数 paramName : value 。如:
fun1(flag1 : true, flag2 : false);
例子:
void main() {
fun1(flag1: true, flag2: false);
}
void fun1({bool? flag1, bool? flag2}) {
if (flag1 != null && flag1) {
print("aaa");
}
if (flag2 != null && !flag2) {
print("bbb");
}
}
使用required表示参数时必须性质的命名参数
4、默认值参数
在定义以上2和3方法时,可以使用 = 来定义可选参数的默认值。默认值只能是编译时常量。如果没有提供默认值,则默认值为null
void main() {
String str = say("张三", "哈哈", "hehe");
print(str);
String str1 = say("张三", "哈哈");
print(str1);
}
String say(String from, String msg, [String device = 'oo']) {
var result = '$from says $msg';
result = '$result with a $device';
return result;
}
void main() {
fun1();
}
void fun1({bool? flag1, bool flag2 = true}) {
if (flag2) {
print("bbb");
}
}
5、把方法当作参数的方法
void main() {
fun1(fun2);
}
fun1(fn) {
fn();
}
fun2() {
print("aaaa");
}
6、箭头函数
void main() {
List l1 = ['az', 'ss'];
//箭头函数后只允许有一行代码,简化代码
l1.forEach((element) => {print(element)});
l1.forEach((element) =>print(element));
}
7、自执行方法
void main() {
//自执行方法 ((形参){})(实参)
((int n) {
print(n);
print(123);
})(12);
}
8、闭包
闭包:
1、全局变量特点:全局变量常驻内存,全局变量污染全局
2、局部变量特点:不常驻内存,会被垃圾机制回收,不会污染全局
想实现的功能:
1、常驻内存
2、不污染全局
产生了闭包,闭包可以解决这个问题
闭包:函数嵌套函数,内部函数会调用外部函数的变量或参数,变量或参数不会被系统回收
闭包的写法:函数嵌套函数,并return里面的函数,这样就形成了闭包
void main() {
fn() {
var a = 123;
return () {
print(a);
};
}
var b = fn();
b();
}
二、面向对象
面向对象编程(OOP)的三个基本特征是:封装、继承、多态
dart所有的东西都是对象,所有的对象都继承自Object类
dart是一门使用类和单继承的面向对象语言,所有的对象都是类的实例,
并且所有的类都是Object的子类
一个类通常由属性和方法组成
三、类
1、声明、实例化
void main() {
//实例化类
Person person = new Person();
person.getInfo();
print(person.name);
}
//声明类
class Person {
String name = 'zs';
int age = 23;
void getInfo() {
print("${this.age}----${this.name}");
}
}
2、默认构造函数
void main() {
Person person = new Person("zs", 12);
person.getInfo();
print(person.name);
}
class Person {
String? name;
int? age;
//默认构造函数 可简写为Person(this.name,this.age);
Person(String name, int age) {
this.name = name;
this.age = age;
}
void getInfo() {
print("${this.age}----${this.name}");
}
}
3、命名构造函数
void main() {
Person p = new Person.now("ls");
print(p.name);
}
class Person {
String? name;
int? age;
//命名构造函数,可以有多个
Person.now(String name) {
this.name = name;
}
void getInfo() {
print("${this.age}----${this.name}");
}
}
4、提取类、导入类
5、私有方法、属性
dart和java不同,dart中没有 public private这些访问修饰符
但是可以使用“_”把一个属性或者方法定义成私有,私有若要起作用,需要将类像上面(4)一样提取出来
Person.dart
class Person {
String? _name; //私有属性
int? age;
Person(this._name, this.age);
String? getName() {
return this._name;
}
//私有方法
void _run() {
print("私有方法");
}
void execRun() {
this._run();
}
}
Index.dart
import 'Person.dart';
void main() {
Person p = new Person("ls", 12);
print(p.getName());
p.execRun();
}
6、setter、getter
Rect.dart
class Rect {
num height;
num width;
Rect(this.height, this.width);
//普通方法,和下面的getter效果一样
num area1() {
return this.height * this.width;
}
//定义getter方法,getter方法没有()
get area {
return this.height * this.width;
}
//定义setter方法
set areaHeight(value) {
this.height = value;
}
}
Index.dart
import 'Person.dart';
import 'Rect.dart';
void main() {
Rect rect = new Rect(1, 3);
//使用getter
print("使用getter方法:");
print("面积是:${rect.area}");
//使用setter方法==================这里和java不同
rect.areaHeight = 2;
//使用普通方法
print("使用普通方法:");
print(rect.area1());
}
四、静态
Dart中的静态成员:
1、使用static 关键字来实现类级别的变量和函数
2、静态方法不能访问非静态成员,非静态方法可以访问静态成员
void main() {
Person.name; //调用静态属性
Person.show(); //调用静态方法
Person person = new Person();
person.printInfo(); //调用非静态方法
}
class Person {
static String name = "张三"; //静态属性
int age = 20; //非静态属性
//静态方法
static void show() {
print(name);//静态方法可以访问静态属性,不可以访问非静态属性和方法
}
//非静态方法,可以访问静态成员以及非静态成员
void printInfo() {
print(name); //访问静态属性
print(this.age); //访问非静态属性
show(); //调用静态方法
}
}
五、对象操作符
1、is(类型判断)
void main() {
Person person = new Person();
if (person is Person) { //类型判断
print("true");
}
person.printInfo();
}
class Person {
String name = "张三";
int age = 20;
void printInfo() {
print(this.age);
}
}
2、as(类型转换)
void main() {
Person person = new Person();
(person as Person).printInfo(); //强制类型转换
}
class Person {
String name = "张三";
int age = 20;
void printInfo() {
print(this.age);
}
}
3、. . (级联操作(连缀))
void main() {
Person person = new Person();
// person.name = "ls";
// person.age = 30;
// person.printInfo();
//以上代码可以通过以下代码的方式编写
person
..name = "ls"
..age = 30
..printInfo();
}
class Person {
String name = "张三";
int age = 20;
void printInfo() {
print("${this.name}---${this.age}");
}
}
六、继承
Dart中的类的继承:
1、子类使用extends关键词来继承父类
2、子类会继承父类里面可见的属性和方法,但是不会继承构造函数
3、子类能复写父类的方法 getter和setter
void main() {
Web w = new Web();
print(w.age);
w.printInfo();
}
class Person {
String name = "张三";
int age = 20;
void printInfo() {
print("${this.name}---${this.age}");
}
}
//继承
class Web extends Person {
}
1、super关键字
void main() {
Web w = new Web("zs", 23);
print(w.age);
w.printInfo();
}
class Person {
String? name;
int? age;
Person(this.name, this.age);
void printInfo() {
print("${this.name}---${this.age}");
}
}
class Web extends Person {
Web(String? name, int? age) : super(name, age);
}
2、@overried
void main() {
Web w = new Web("zs", 23);
print(w.age);
w.printInfo();
}
class Person {
String? name;
int? age;
Person(this.name, this.age);
void printInfo() {
print("${this.name}---${this.age}");
}
}
class Web extends Person {
Web(String? name, int? age) : super(name, age);
@override
void printInfo() {
print("重写父类方法----${this.name}---${this.age}");
}
}
七、抽象类
Dart中抽象类:Dart抽象类主要用于定义标准,子类可以继承抽象类,也可以实现抽象类接口
1、抽象类通过abstract 关键字来定义
2、Dart中的抽象方法不能用abstract声明,Dart中没有方法提的方法称为抽象方法
3、如果子类继承抽象类必须得实现里面的抽象方法
4、如果把抽象类当作接口实现的话必须得实现抽象类里面定义的所有属性和方法
5、抽象类不能被实例化,只有继承它的子类可以
extends抽象类 和 implements 的区别:
1、如果要服用抽象类里面的方法,并且要用抽象方法约束子类的话就用extends继承抽象类
2、如果只是把抽象类当作标准的话我们就用implents实现抽象类
void main() {
Dog d = new Dog();
d.eat();
d.run();
}
abstract class Animal {
eat(); //抽象方法
run(); //抽象方法
printInfo() {
print("抽象类中的---普通方法");
}
}
class Dog extends Animal {
@override
eat() {
print("dog---eat");
}
@override
run() {
print("dog---run");
}
}
八、多态
Dart中的多态:
允许将子类类型的指针赋值给父类类型的指针,同一个函数调用会有不同的执行效果
子类的实例赋值给父类的引用
多态就是父类定义一个方法不去实现,让继承它的子类去实现,每个子类有不同的实现
九、接口
和java一样,dart也有接口,但是和java还是有区别的:
1、dart的接口没有interface 关键字定义接口,而是普通类或抽象类都可以作为接口被实现
同样使用implements关键字进行实现
2、如果实现的类是普通类,会将普通类中的属性和方法全部需要复写一遍
3、因为抽象类可以定义抽象方法,普通类不可以,所以建议使用抽象类定义接口
abstract class Animal {
eat(); //抽象方法
run(); //抽象方法
printInfo() {
print("抽象类中的---普通方法");
}
}
class Person {
String? name;
void run() {
print("run");
}
}
//多实现
class A implements Person , Animal{
@override
String? name;
@override
void run() {
// TODO: implement run
}
@override
eat() {
// TODO: implement eat
throw UnimplementedError();
}
@override
printInfo() {
// TODO: implement printInfo
throw UnimplementedError();
}
}
class Dog implements Animal {
@override
eat() {
// TODO: implement eat
throw UnimplementedError();
}
@override
printInfo() {
// TODO: implement printInfo
throw UnimplementedError();
}
@override
run() {
// TODO: implement run
throw UnimplementedError();
}
}
十、mixin混入
mixin的中文意思是混入,就是在类中混入其他功能
在Dart中可以使用mixin实现类似多继承的功能
使用mixin的条件:
1、作为mixin的类只能继承自Object,不能继承其他类
2、作为mixin的类不能有构造函数
3、一个类可以mixin多个mixin类
4、mixin绝不是继承,也不是接口,而是一种全新的特性
void main() {
C c = new C();
c.printA();
c.printB();
}
class A {
void printA() {
print("A");
}
}
class B {
void printB() {
print("B");
}
}
class C with A, B {}