前端开发_6-Flutter-Dart学习2
@
前言
继续继续
一、方法
普通方法
返回类型 方法名称（参数1，参数2,...）{
方法体
return 返回值;
}
void printInfo(){
print('我是一个自定义方法');
}
int getNum(){
var myNum=123;
return myNum;
}
String printUserInfo(){
return 'this is str';
}
List getList(){
return ['111','2222','333'];
}
方法传参
int sumNum(int n){
var sum=0;
for(var i=1;i<=n;i++)
{ sum+=i; }
return sum;
}
var n1=sumNum(5);print(n1);
var n2=sumNum(100);print(n2);
//定义一个带可选参数的方法 ，最新的dart定义可选参数需要指定类型默认值
String printUserInfo(String username,[int age=0]){ //行参
if(age!=0){
return "姓名:$username---年龄:$age";
}
return "姓名:$username---年龄保密";
}
print(printUserInfo('张三',21)); //实参
print(printUserInfo('张三'));
//定义一个命名参数的方法，最新的dart定义命名参数需要指定类型默认值
String printUserInfo1(String username, {int age = 0, String sex = '男'}) {//行参
if (age != 0) {
return "姓名:$username---性别:$sex--年龄:$age";
}
return "姓名:$username---性别:$sex--年龄保密";
}
print(printUserInfo1('张三', age: 20, sex: '未知'));
//实现一个 把方法当做参数的方法
var fn=(){
print('我是一个匿名方法');
};
fn();
//方法
fn1() {
print('fn1');
}
//方法
fn2(fn) {
fn();
}
//调用fn2这个方法 把fn1这个方法当做参数传入
fn2(fn1);
箭头、匿名方法，闭包
//箭头函数
List list=['苹果','香蕉','西瓜'];
list.forEach((value){
print(value);
});
list.forEach((value)=>print(value));
//。。。。。。
List list=[4,1,2,3,4];
var newList=list.map((value){
if(value>2){
return value*2;
}
return value;
});
print(newList.toList());
var newList1=list.map((value)=>value>2?value*2:value);
print(newList1.toList());
//匿名方法
// var printNum=(){
// print(123);
// };
// printNum();
// var printNum=(int n){
// print(n+2);
// };
// printNum(12);
// 自执行方法
((int n){
print(n);
print('我是自执行方法');
})(12);
//通过方法的递归 求1-100的和
var sum=0;
fn(int n){
sum+=n;
if(n==0){
return;
}
fn(n-1);
}
fn(100); print(sum);
/*
闭包：
1、全局变量特点: 全局变量常驻内存、全局变量污染全局
2、局部变量的特点： 不常驻内存会被垃圾机制回收、不会污染全局
/* 想实现的功能：
1.常驻内存
2.不污染全局
产生了闭包,闭包可以解决这个问题.....
闭包: 函数嵌套函数, 内部函数会调用外部函数的变量或参数, 变量或参数不会被系统回收(不会释放内存)
闭包的写法： 函数嵌套函数，并return 里面的函数，这样就形成了闭包。
*/
*/
void main() {
//闭包
fn() {
var a = 123; /*不会污染全局 常驻内存*/
return () {
a++;
print(a);
};
}
var b = fn();
b();
b();
}
二、面向对象
面向对象编程(OOP)的三个基本特征是：封装、继承、多态
封装：封装是对象和类概念的主要特性。封装，把客观事物封装成抽象的类，并且把自己的部分属性和方法提供给其他对象调用, 而一部分属性和方法则隐藏。
继承：面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
多态：允许将子类类型的指针赋值给父类类型的指针, 同一个函数调用会有不同的执行效果 。
一个类通常由属性和方法组成。
Dart所有的东西都是对象，所有的对象都继承自Object类。
Dart是一门使用类和单继承的面向对象语言，所有的对象都是类的实例，并且所有的类都是Object的子类
1.初识
//最新版本的dart中需要初始化不可为null的实例字段，如果不初始化的话需要在属性前面加上late
class Person{
late String _name;//私有属性
late int age;
Person(this._name,this.age);//默认构造函数的简写
Person.now() {
print('我是命名构造函数');
}
Person.setInfo(String name, int age) {
this._name = name;
this.age = age;
}
void printInfo(){
print("${this._name}----${this.age}");
}
}
void main(){
Person p1=new Person('张三',20);
p1.printInfo();
Person p2=new Person('李四',25);
p2.printInfo();
Person p3= new Person.setInfo('王五', 30);
p3.printInfo();
}
//======
class Rect{
late num height;
late num width;
Rect(this.height,this.width);
get area{
return this.height*this.width;
}
set areaHeight(value){
this.height=value;
}
}
void main(){
Rect r=new Rect(10,4); // print("面积:${r.area()}");
r.areaHeight=6;
print(r.area);
}
2.静态方法，成员，继承，对象操作符
/*
Dart中的静态成员:
1、使用static 关键字来实现类级别的变量和函数
2、静态方法不能访问非静态成员，非静态方法可以访问静态成员
*/
class Person {
static String name = '张三';
int age=20;
static void show() {
print(name);
}
void printInfo(){ /*非静态方法可以访问静态成员以及非静态成员*/
// print(name); //访问静态属性
// print(this.age); //访问非静态属性
show(); //调用静态方法
}
static void printUserInfo(){//静态方法
print(name); //静态属性
show(); //静态方法
//print(this.age); //静态方法没法访问非静态的属性
// this.printInfo(); //静态方法没法访问非静态的方法
// printInfo();
}
}
//-------------------------------------------------------------
/*
Dart中的对象操作符:
? 条件运算符 （了解） https://dart.dev/tools/diagnostic-messages#invalid_null_aware_operator
as 类型转换
.. 级联操作 （连缀） (记住)
*/
class Person {
String name;
num age;
Person(this.name, this.age);
void printInfo() {
print("${this.name}---${this.age}");
}
}
main() {
// Person p;
// p?.printInfo(); //已被最新的dart废弃 了解
// Person p=new Person('张三', 20);
// p?.printInfo(); //已被最新的dart废弃 了解
// var p1;
// p1='';
// p1=new Person('张三1', 20);
// (p1 as Person).printInfo();
Person p1 = new Person('张三1', 20);
p1.printInfo();
p1
..name = "李四"
..age = 30
..printInfo();
}
//------------------------------------------------
//Dart中的类的继承：
// 1、子类使用extends关键词来继承父类
// 2、子类会继承父类里面可见的属性和方法 但是不会继承构造函数
// 3、子类能复写父类的方法 getter和setter
class Person {
String name;
num age;
Person(this.name, this.age);
Person.xxx(this.name, this.age);
void printInfo() {
print("${this.name}---${this.age}");
}
work(){
print("${this.name}在工作...");
}
}
class Web extends Person {
late String sex;
Web(String name, num age, String sex) : super.xxx(name, age) {
this.sex = sex;
}
run(){
print('run');
super.work(); //自类调用父类的方法
}
//覆写父类的方法
@override //可以写也可以不写 建议在覆写父类方法的时候加上 @override
void printInfo(){
print("姓名：${this.name}---年龄：${this.age}");
}
}
main() {
// Person p=new Person('李四',20);
// p.printInfo();
Web w = new Web('张三', 12, "男");
w.printInfo();w.run();
}
3.抽象类、多态
/*
Dart中抽象类: Dart抽象类主要用于定义标准，子类可以继承抽象类，也可以实现抽象类接口。
1、抽象类通过abstract 关键字来定义
2、Dart中的抽象方法不能用abstract声明，Dart中没有方法体的方法我们称为抽象方法。
3、如果子类继承抽象类必须得实现里面的抽象方法
4、如果把抽象类当做接口实现的话必须得实现抽象类里面定义的所有属性和方法。
5、抽象类不能被实例化，只有继承它的子类可以
extends抽象类 和 implements的区别：
1、如果要复用抽象类里面的方法，并且要用抽象方法约束自类的话我们就用extends继承抽象类
2、如果只是把抽象类当做标准的话我们就用implements实现抽象类
案例：定义一个Animal 类要求它的子类必须包含eat方法
*/
abstract class Animal{
eat(); //抽象方法
run(); //抽象方法
printInfo(){
print('我是一个抽象类里面的普通方法');
}
}
class Dog extends Animal{
@override
eat() {
print('小狗在吃骨头');
}
@override
run() {
// TODO: implement run
print('小狗在跑');
}
}
class Cat extends Animal{
@override
eat() {
// TODO: implement eat
print('小猫在吃老鼠');
}
@override
run() {
// TODO: implement run
print('小猫在跑');
}
}
main(){
Dog d=new Dog();
d.eat();
d.printInfo();
Cat c=new Cat();
c.eat();
c.printInfo();
// Animal a=new Animal(); //抽象类没法直接被实例化
Animal d=new Dog();
d.eat();
Animal c=new Cat();
c.eat();
}
//-----------
4.混入，接口
/*
Dart中一个类实现多个接口：
*/
abstract class A{
late String name;
printA();
}
abstract class B{
printB();
}
class C implements A,B{
@override
late String name;
@override
printA() {
print('printA');
}
@override
printB() {
// TODO: implement printB
return null;
}
}
void main(){
C c=new C();
c.printA();
}
//--------------------------------------------------------
/*
mixins的中文意思是混入，就是在类中混入其他功能。
在Dart中可以使用mixins实现类似多继承的功能
因为mixins使用的条件，随着Dart版本一直在变，这里讲的是Dart2.x中使用mixins的条件：
1、作为mixins的类只能继承自Object，不能继承其他类
2、作为mixins的类不能有构造函数
3、一个类可以mixins多个mixins类
4、mixins绝不是继承，也不是接口，而是一种全新的特性
*/
class Person{
String name;
num age;
Person(this.name,this.age);
printInfo(){
print('${this.name}----${this.age}');
}
void run(){
print("Person Run");
}
}
class A {
String info="this is A";
void printA(){
print("A");
}
void run(){
print("A Run");
}
}
class B {
void printB(){
print("B");
}
void run(){
print("B Run");
}
}
class C extends Person with B,A{
C(String name, num age) : super(name, age);
}
void main(){
var c=new C('张三',20);
c.printInfo();
// c.printB();
// print(c.info);
c.run();
print(c is C); //true
print(c is A); //true
print(c is B); //true
}
5.泛型
/*
通俗理解：泛型就是解决 类 接口 方法的复用性、以及对不特定数据类型的支持(类型校验)
*/
//不指定类型放弃了类型检查。我们现在想实现的是传入什么 返回什么。比如:传入number 类型必须返回number类型 传入 string类型必须返回string类型
// T getData<T>(T value){
// return value;
// }
getData<T>(T value){
return value;
}
void main(){
// print(getData(21));
// print(getData('xxx'));
// getData<String>('你好');
print(getData<int>(12));
}
//-----------------------------------------
/*
class MyList {
List list = <int>[];
void add(int value) {
this.list.add(value);
}
List getList() {
return list;
}
}
MyList l = new MyList();
l.add(1);
l.add(12);
l.add(5);
print(l.getList());
*/
class MyList<T> {
List list = <T>[];
void add(T value) {
this.list.add(value);
}
List getList() {
return list;
}
}
main() {
// MyList l1=new MyList();
// l1.add("张三");
// l1.add(12);
// l1.add(true);
// print(l1.getList());
// MyList l2 = new MyList<String>();
// l2.add("张三1");
// print(l2.getList());
MyList l3 = new MyList<int>();
l3.add(11);
l3.add(12);
l3.add("aaaa");
print(l3.getList());
}
三、库的使用
1、从下面网址找到要用的库
https://pub.dev/packages
https://pub.flutter-io.cn/packages
https://pub.dartlang.org/flutter/
2、import 'lib/Person2.dart' as lib;重命名
/*
Dart中的库主要有三种：
1、我们自定义的库
import 'lib/xxx.dart';
2、系统内置库
import 'dart:math';
import 'dart:io';
import 'dart:convert';
3、Pub包管理系统中的库
https://pub.dev/packages
https://pub.flutter-io.cn/packages
https://pub.dartlang.org/flutter/
1、需要在自己想项目根目录新建一个pubspec.yaml
2、在pubspec.yaml文件 然后配置名称 、描述、依赖等信息
3、然后运行 pub get 获取包下载到本地
4、项目中引入库 import 'package:http/http.dart' as http; 看文档使用
*/
/*
部分导入
如果只需要导入库的一部分，有两种模式：
模式一：只导入需要的部分，使用show关键字，如下例子所示：
import 'package:lib1/lib1.dart' show foo;
模式二：隐藏不需要的部分，使用hide关键字，如下例子所示：
import 'package:lib2/lib2.dart' hide foo;
*/
// import 'lib/myMath.dart' show getAge;
import 'lib/myMath.dart' hide getName;
void main(){
// getName();
getAge();
}
/*
async和await
这两个关键字的使用只需要记住两点：
只有async方法才能使用await关键字调用方法
如果调用别的async方法必须使用await关键字
async是让方法变成异步。
await是等待异步方法执行完成。
*/
void main() async {
var result = await testAsync();
print(result);
}
//异步方法
testAsync() async {
return 'Hello async';
}
/*
延迟加载
也称为懒加载，可以在需要的时候再进行加载。
懒加载的最大好处是可以减少APP的启动时间。
懒加载使用deferred as关键字来指定，如下例子所示：
import 'package:deferred/hello.dart' deferred as hello;
当需要使用的时候，需要使用loadLibrary()方法来加载：
greet() async {
await hello.loadLibrary();
hello.printGreeting();
}
*/
四、其他模块
1.空安全
/*
Null safety翻译成中文的意思是空安全。
null safety 可以帮助开发者避免一些日常开发中很难被发现的错误，并且额外的好处是可以改善性能。
Flutter2.2.0（2021年5月19日发布） 之后的版本都要求使用null safety。
? 可空类型
! 类型断言
late 关键字主要用于延迟初始化。（先声明不赋值）
required 主要用于允许根据需要标记任何命名参数（函数或类），使得它们不为空。因为可选参数中必须有个 required 参数或者该参数有个默认值。
*/
String? getData(apiUrl){
if(apiUrl!=null){
return "this is server data";
}
return null;
}
// ? 可空类型
// int? a=123; // int? 表示a是一个可空类型
// a=null;
// print(a);
// ! 类型断言
// String? str="this is str";
// str=null;
// print(str!.length);
//类型断言: 如果str不等于null 会打印str的长度，如果等于null会抛出异常
// printLength("str");
//printLength(null);
总结
语法基础大致就这些。
