基本数据类型
int a = 123
double b = 123
// 不可换行
String a = '23'
String b = "123"
// 可换行
String c = '''123456'''
String d = """123456"""
bool a = false
bool b = true
// 1.定义List 的方式 - 任意类型
var a = ["张三"，20，true]
// 2.定义List 的方式 - 指定类型
var b = <String>["张三"，"20"，"true"]
// 3.定义List 的方式 - 可变
var b = []
b.add("1234")
// 3.定义List 的方式 - 创建固定长度的集合,可修改元素的数据
var b = List.filled(2,"")
var b = List<String>.filled(2,"") // list里面必须是对应的类型
void main{
// 方式1
var person = {
"name": "张三"，
"age": 20,
"work": ["程序员"，"专家"]
}
// 方式2
var editor = new Map()
editor["name"] = "张三"
editor["age"] = "李四"
editor["work"] = ["程序员","专家"]
print(person["name"])
print(editor["name"])
if( person["name"] is String){
print(person["name"])
}
}
void main(){
Runes input = new Runes('\u2665','\u{1f60e}')
print(new String.fromCharCodes(input))
}
- Symbols
Symbos对象表示在Dart程序中声明的运算符或标识符
运算符
// 算术运算符
+
-
*
/
%
~ // 取整
// 关系运算符
==
!=
>
<
>=
<=
// 逻辑运算符
!
&&
||
// 赋值运算符
==
??=
// 备注：a??=b a为空则将b赋值给a，否则不赋值
// 复合运算符
+=
-=
*=
/=
%=
~=
条件运算符
if...else
switch...case
三元表达式
?? // a??10 a为空则将10赋值给a，否则不赋值
类型转换
Number==>>String 使用toString()
String ==>> Number int类型：int.parse() 、double类型：double.parse()
判断变量是否为空 String类型:a.isEmpty Int类型:a == 0
循环
for
while
do...while
continue
break
list常用的属性和方法
// 常用属性
length
reversed
isEmpty
isNotEmpty
// 常用方法
add
addAll // 拼接数组
indexOf
remove
removeAt // 删除 传入索引值
fillRange(start, end, value) // 修改
insert(index, value) // 指定位置插入
insertAll(index,list) // 指定位置插入List
toList() // 其他类型转换成List
join()
split()
forEach
map
where
any
every
set的方法
// 基本用法
var s = new Set()
s.add("111")
// 数组去重
List myList = [1,2,3,4,5,6,3,2,1]
s.addAll(myList )
print(s) // {1,2,3,4,5,6}
print(s.toList()) // [1,2,3,4,5,6]
map属性和方法
// 常用属性：
keys
values
isEmpty
isNotEmpty
// 常用方法：
remove(key)
addAll({...})
containsValue // 查看映射内的值 返回true/false
forEach
map
where
any // 返回true或者false,集合有满足条件返回true，否则返回false
every // 返回true或者false,集合全部满足条件返回true，否则返回false
方法定义
int printInfo(int x, int y){
print(x+y)
return x+y
}
// 可选参数，默认参数
String printInfo(String name，[String sex='男', int age=18]) {
if(age!=null){
return "姓名：$name----年龄：$age"
}else{
return "姓名：$name----年龄：保密"
}
}
// 命名参数
String printInfo(String name，{String sex='男',int age=18}) {
if(age!=null){
return "姓名：$name----年龄：$age"
}else{
return "姓名：$name----年龄：保密"
}
}
// 方法当作参数传递
fnOne(){
print('fn1')
}
fnTwo(fn){
fn()
}
var fnAnonymous = (){
pring('匿名方法')
}
void main(){
var a = 1;
var b = 2;
var c = printInfo(a,b);
var d = printInfo("张三",'男',18);
var e = printInfo("张三",sex:'男');
var f = fnAnonymous()
fnTwo(fnOne);
print(c);
print(d);
print(e);
print(f);
}
箭头函数
var a = ["张三"，20，true]
var list = a.map((value) => value*2)
var fnAnonymous = (){
pring('匿名方法')
}
((int n){
pring(n)
})(2)
闭包
// 不污染全局，常驻内存
fn(){
var a = 123;
return (){
a++;
print(a)
}
}
var b = fn()
b(); // 124
b(); //125
类
class Person{
String _name, address; // 单独抽离类成一个文件，才没没法使用私有属性，
static String sex = "男"; // 静态属性使用类名调用或者使用内部方法调用
int age;
// 构造函数
//Person(String _name, int age){
// this.name = name;
// this.age = age;
//}
// 默认构造函数(简写)
Person(this._name, this.age);
// 命名构造函数
Person.other(){
this.address= "衢州"
}
// 构造函数给默认值
otherInfo():age=18{
print("${this.age}")
}
// get
get inputInfo{
return this.age;
}
// set
set changeInfo(value){
this.age = value
}
// 静态方法（可以访问静态属性和调用静态方法，没法访问非静态属性，没法调用非静态方法）
static void showInfo(){
print("static")
}
// 方法
void getPersonInfo(){
print("$name------$age")
print("${this.name}----${this.age}")
print(sex) // 调用静态属性
showInfo() // 调用静态方法
}
// 方法
void setPersonInfo(int age){
this.age = age;
}
// 通过方法调用私有属性
String getName(){
return this._name;
}
// 私有方法
String _run(){
return this._name
}
// 通过共有方法调用私有方法
execRun(){
this._run();
}
}
对象操作符
? // 条件运算发
as // 类型转化 (p as Person).getName()
is // 类型判断 p is Person
.. // 级联操作
Person p = new Person("小小"，18)；
p..name = "小二"
..age =20
..getName()
类的继承
class Person{
String name;
num age;
Person(String name, int age);
void getPersonInfo(){
print("${this.name}----${this.age}");
}
void work(){
print("无");
}
}
class Programmer extends Person{
String sex;
// super既可以给父类构造函数传参也可以给父类命名构造函数传参
Programmer(String name, num age, String sex):super(name,age){
this.sex = sex;
}
run(){
print("${this.name}----${this.age}---${this.sex}");
super.work(); // 子类调用父类的方法
}
// 覆写父类的方法
@override // 可写可不写，建议写
void work(){
print("程序员");
}
}
抽象类
abstract class Animal{
eat(); // 抽象方法，字类必须实现这个方法;
info(){ // 普通方法
print("普通方法")
}
}
class Dog extends Animal{
@override
eat(){
return "bone";
}
}
接口
// 普通类和抽象类都能定义接口，抽象类定义接口可以规范实现他的类，普通类则无法规范。
// 建议使用抽象类来定义接口，来约束类的对属性和方法的实现
abstract class Db{
String url;
add( String data);
save( String data);
delete( String data);
}
class MySql implements Db{
@override
String uri;
MySql(this.uri);
@override
add(String data){
print("add");
print(data);
}
@override
save(String data){
print("save");
print(data);
}
@override
delete(String data){
print("delete");
print(data);
}
}
一个类实现多少接口
abstract class A{
String name;
printA();
}
abstract class B{
printB();
}
class C implements A,B{
@override
String name;
@override
printA(){
print("A");
}
@override
printA(){
print("A");
}
}
mixins
// mixins的类只能继承自Object, 不能继承其他类
// mixins的类不能有构造函数
// 一个类可以mixins多个mixins类
class A{
String name = ;
printA("A");
}
class B{
printB("B");
}
// class C extends D with A,B{}
class C with A,B{
}
void main(){
var c = new C();
print(c.name)
c.printA();
c.printB();
}
泛型
// 泛型 泛型方法 泛型类 泛型接口
// 泛型方法
T getData<T>(T value){
return value
}
void main(){
getDate<String> ("你好！")
}
class Mylist<T>{
List list = <T>[];
void add(T value){
this.list.add(value);
}
List getList(){
return list;
}
}
void main(){
Mylist mylist = new Mylist<String>();
mylist.add("小红")；
pirnt(mylist.getList());
}
abstract class Cache<T>{
getByKey(String key);
void setByKey(String key, T value);
}
class FileCache<T> implements Cache<T>{
@override
getByKey(String key){
return key
}
@override
void setByKey(String key, T value){
print("${key}----${value}")
}
}
class MemoryCache<T> implements Cache<T>{
@override
getByKey(String key){
return key
}
@override
void setByKey(String key, T value){
print("${key}----${value}")
}
}
void main(){
MemoryCache memoryCache = new MemoryCache<Map>()
memoryCache.setByKey("数据", {"name": "小小"，"age": 18})
}
库
// 自定义的库
import 'lib/xxx.dart';
// 系统内置库
import 'dart:math';
import 'dart:io';
import 'dart:convert';
// Pub包管理系统中的库
https:// pub.dev/packages
https:// pub.flutter-io.cn/packages
https:// pub.dartlang.org/flutter/
// 库重命名
import 'package:http/http.dart' as http
// 库部分引入
import "lib/xxx.dart" show getInfo(方法名); getInfo能使用，其他的方法不可用；
import "lib/xxx.dart" hide getInfo(方法名); getInfo不能使用，其他函数可以使用；
// 延时加载库
import "package:deferred/hello.dart" deferred as hello;
// 库分片
part 'link.dart'
//1.需要在自己项目根目录新建一个pubspec.yml
//2.在pubspec.yaml文件 软后配置名称、描述、依赖信息
//3.然后运行pub get 获取包下载到本地
//4.项目中引入库`import 'package:http/http.dart' as http` 文档
async
import 'dart:io'
import 'dart:conver';
void main() async{
var result = await getDataFromZhihuApi();
print(result);
}
getDataFromZhihuApi() async{
// 创建HttpClient 对象
var httpClient = new HttpClient()
// 创建Uri对象
var uri = new Uri.http("news-at.zhihu.com",'/api/3/stories/latest');
// 发起请求，等待请求
var request await httpClient.getUrl(uri);
// 关闭请求，等待响应
var response = await request.close();
// 解码响应的内容
return await response.transform(utf8.decoder).join();
}
其他
// ? 可空类型
// !类 型断言
String? getData(data){
if(data != null){
return " This is Data!";
}
return null
}
void printLength(String? str){
try{
print(str!.length) // 如果str为空抛出异常，如果不为空则正常打印str的长度。
}catch(e){
pinnt("str is null")
}
}
void main(){
int? a = 123
a = null
getData(a)
printLength(a)
}
class Person{
late String name;
late int age;
void setData(String name, int age){
this.name = name;
this.age = age;
}
}
String printInfo(String userName,{required int age, required String sex}){
return "姓名: $userName-----性别：$sex----年龄：$age"
}
// name可穿可不传
class Person{
String? name;
int age
Person({this.name,required this.age})
printInfo(){
print("$name ----$age")
}
}
