dart特性
代码居多可复制自行运行学习。
1、方法
///方法定义
///返回类型 方法名(参数1,参数2,...){
/// 方法体...
/// return 返回值
///}
void main(List<String> args) {
String person= getPerson("huangxiaoguo", 25);
print(person);//name=huangxiaoguo,age=25
}
String getPerson(String name,int age){
return "name=$name,age=$age";
}
///方法特性
///方法也是对象,并且有具体的类型Function
///返回值类型、参数类型都可省略
///箭头语法:=> expr 是{return expr;}缩写。只适用于一个表达式
///方法都有返回值。如果没有指定,默认return null 最后一句执行
void main(List<String> args) {
printPerson("张三", 18);
print(printPerson("张三", 18));
String person = getPerson("huangxiaoguo", 25);
print(person);
}
printPerson(name, age) {
print("name=$name,age=$age");
}
getPerson(name, age) => "name=$name,age=$age";
//name=张三,age=18
//name=张三,age=18
//null
//name=huangxiaoguo,age=25
///可选参数
///可选命名参数:{param1,param2,…}
///可选位置参数:[param1,param2,…]
///如果存在具体参数,可选参数声明,必须在参数后面
void main(List<String> args) {
printPerson("张三");
printPerson("张三", age: 28);
printPerson("张三", age: 28, gender: "huang");
printPerson("张三", gender: "huang", age: 28);
print("---------------------------------------------");
printPerson2("张三");
printPerson2("张三", 28);
printPerson2("张三", 28, "huang");
}
// 可选命名参数(常用)
printPerson(String name, {int age, String gender}) {
print("name=$name,age=$age,gender=$gender");
}
// 可选位置参数
printPerson2(String name, [int age, String gender]) {
print("name=$name,age=$age,gender=$gender");
}
//name=张三,age=null,gender=null
//name=张三,age=28,gender=null
//name=张三,age=28,gender=huang
//name=张三,age=28,gender=huang
//---------------------------------------------
// name=张三,age=null,gender=null
//name=张三,age=28,gender=null
//name=张三,age=28,gender=huang
/// 默认参数值
///使用 = 在可选参数值指定默认值
///默认值只能是编译时常量
void main(List<String> args) {
printPerson("张三");
printPerson("张三", age: 28);
printPerson("张三", age: 28, gender: "huang");
printPerson("张三", gender: "huang", age: 28);
}
// 可选命名参数(常用)
printPerson(String name, {int age=66, String gender="Name"}) {
print("name=$name,age=$age,gender=$gender");
}
//name=张三,age=66,gender=Name
//name=张三,age=28,gender=Name
//name=张三,age=28,gender=huang
//name=张三,age=28,gender=huang
/// 方法对象
///方法可作为对象赋值给其他变量
///方法可作为参数传递给其他方法
void main(List<String> args) {
var func = printHello;
Function func1 = printHello;
func();
func1();
var list = [1, 2, 3, 4];
list.forEach(print);
var list2 = ['h', 'e', 'l', 'l', 'o'];
print(listTimes(list2, times));
}
void printHello() {
print("Hello");
}
List listTimes(List list, String times(str)) {
for (var i = 0; i < list.length; i++) {
list[i] = times(list[i]);
}
return list;
}
String times(str) {
return str * 3;
}
//Hello
//Hello
//1
//2
//3
//4
//[hhh, eee, lll, lll, ooo]
///匿名方法
///(参数1,参数2,....){
/// 方法体...
/// return 返回值
/// }
/// 可赋值给变量,通过变量进行调用
///可在其他方法中直接调用或传递给其他方法
///
void main(List<String> args) {
var func = () {
print("Hello");
};
func();
var func1 = (str) {
print("Hello-------$str");
};
func1("huangxiaoguo");
// 通过()进行调用,不推荐使用
(() {
print("通过()进行调用,不推荐使用");
})();
//匿名方法传参
var list2 = ['h', 'e', 'l', 'l', 'o'];
print(listTimes(list2, (str) {
return str * 3;
}));
}
List listTimes(List list, String times(str)) {
for (var i = 0; i < list.length; i++) {
list[i] = times(list[i]);
}
return list;
}
//Hello
//Hello-------huangxiaoguo
//通过()进行调用,不推荐使用
//[hhh, eee, lll, lll, ooo]
///闭包
///闭包是一个方法(对象)
///闭包定义在其他方法内部
///闭包能够访问外部方法内的局部变量,并持有其状态
void main(List<String> args) {
var func = a();
for (var i = 0; i < 5; i++) {
func();
}
print("-------------------------");
var func1 = b();
for (var i = 0; i < 5; i++) {
func1();
}
}
a() {
int count = 0;
printCount() {
print(count++);
}
return printCount;
}
b() {
int count = 10;
return () {
print(--count);
};
}
//0
//1
//2
//3
//4
//-------------------------
//9
//8
//7
//6
//5
2、类
///类
///属性默认会get set
///使用 final 属性只有get
///属性和方法通过.访问
///方法不能被重载
void main (){
var person = new Person();
person.name;
person.work();
}
class Person{
String name;
int age;
final address;
void work(){
print(name+age);
}
}
///计算属性
void main (){
var rect = new Rectangle();
rect.width = 20;
rect.height = 20;
print(rect.area);
rect.area = 200;
print(rect.width);
}
class Rectangle{
num width,height;
num get area => width * height;
set area(value){
width = value / 20;
}
}
///构造方法
/// 构造方法不能重载
class Person{
String name;
int age;
final String gen;
//默认
Person(){}
Person(String name , int age){
this.name = name;
this.age = age;
}
//final 可以在构造方法中初始化
Person(this.name , this.age, this.gen){
}
///多构造方法写法
Person.withName(this.name){
}
}
///常量构造方法
///使用const声明构造方法,所以变量都是final
///const 声明可以省略
/// const person = const Person("aa",12);
/// const person = Person("aa",12);
class Person{
final String name;
final int age;
const Person(this.name , this.age);
void work(){
print(name+age);
}
}
///工厂构造方法
///可以返回对象
class Node {
String name;
int age;
factory Node(String name) {
return Node._a(name, 1);
}
Node._a(this.name,this.age); // 私有构造方法
}
///静态 static 和java 一样
void main(){
Page.scrollDown();
}
class Page{
static int currentPage = 1;
//方法是静态 里面成员也必须是静态
static void scrollDown(){
currentPage = 1;
print("scrollDown...$currentPage");
}
//方法不是静态,可以访问静态成员
void scrollUp(){
currentPage++;
print("scrollUp...$currentPage");
}
}
///对象操作符
void main(){
Person person;
person?.work();// ?. 如果person是空不继续执行
//as 如果person是Person类型的话 as 可以转换
var person;
person = "";
person = new Person();
(person as Person).work();
//is 是否是Person对象
if(person is Person){
person.work();
}
//..级联操作符
var person = new Person();
person..name = "tome"
..age = 18
..work();
}
class Person{
String name;
int age;
void work(){
print("work...")
}
}
3、面向对象编程
///继承
/**
* 使用关键字extends继承
* 子类继承可见的属性和方法,不会继承构造方法
* 子类能复写父类方法、getter和setter
* 单继承,多态性
*/
/**
* 继承中的构造方法
* 子类的构造方法默认会调用父类的无名无参构造方法
* 如果父类没有无名无参构造方法,这需要显示调用父类构造方法
* 在构造方法参数后使用:显示调用父类构造方法
*/
void main(){
var student = new Student();
student.age = 18;
student.name = "Tome";
Person person = new Student();
}
class Student extends Person{
void study(){
print("Student ...");
}
}
class Person{
var age;
var name;
void run(){
print("Person ...");
}
}
///抽象类
/**
* 抽象类使用abstract表示,不能直接被实例化
* 抽象方法不用abstract修饰,无实现
* 抽象类可以没有抽象方法
*/
///接口
/**
* 类和接口是统一的,类就是接口
* 每个类都隐式的定义了一个包含所以实例成员的接口
* 如果复用已有的类的实现,使用继承(extends)
* 如果只是使用已有类的外在行为,使用接口(implements)
*/
///Mixins
/**
* Mixins类似于多继承,是多类继承中重用一个类代码的方式
* 做完Mixin的类不能有显示声明构造方法
* 作为Mixin的类只能继承Object
* 使用关键字with连接一个或者对个mixin
*/
class A{
void a(){
print("a()")
}
}
class B{
void a(){
print("a()")
}
}
class C{
void a(){
print("a()")
}
}
class D extends A with B,C{
}
//两个表达式一样
class Car = D with A;
class Car extends D with A{
}