初学移动端-第一篇

初学移动端-第一篇

flutter是一种基于dart语言的框架

一、dart环境搭建

dart官网
需选择相应的版本下载

如果在cmd命令行中报错识别不了choco ，那么首先需要用PowerShell进行安装Chocolatey

1.win+x打开PowerShell
2.执行代码

Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))

3.测试安装是否成功

choco -v

4.根据官网命令安装sdk

//安装sdk
choco install dart-sdk

//更新命令
choco upgrade dart-sdk

5.配置环境变量

//在系统环境变量path，中引入到dart到bin的文件目录，即可

6.测试
在命令行中输入dart --version测试一下是否引入成功

二、Flutter安装

Flutter安装包

//在系统环境变量path，中引入到Flutter到bin的文件目录，即可

三、dart初体验

在这里我使用的是vscode，需要下载前两个插件

运行代码

---

四、dart基础 一、dart介绍

Dart官方文档:

Dart是谷歌发布的一门开源的计算机编程语言，后来被Ecma (ECMA-408)认定为标准。它被用于web、服务器、移动应用和物联网等领域的开发。它是宽松开源许可证（修改的BSD证书）下的开源软件。 Dart是面向对象的、类定义的、单继承的语言。它的语法类似C语言，可以转译为Javascript，支持接口(interfaces)、混入(mixins)、抽象类(abstract classes)、具体化泛型(reified generics)、可选类型(optional typing)和sound type system。

二、dart铺垫知识点

//dart入口函数
main(){
}

//Dart的打印
print()

//Dart的注释
//这是单行注释

//Dart变量/常量的声明

		String  str = '124'
		int num = 1
		var str = '124'//自动识别数据类型
		
		String str1 = "可";//指定数据类型
		String str2 = "可";
		print("$str1$str2");//输出时候字符串拼接用$变量 $变量
			
		const num;//final可以先不用赋值，但是const声明时必须要赋值
		final age;//一旦赋值都不可以再被修改

//dart变量命名规则

三、dart编码规范

样式规范

1、类、枚举、类型定义，以及泛型，都需要使用大写字母开头的驼峰命名法
2、在使用元数据的时候也要使用驼峰命名法命名
3.命名库、包目录dart文件都是应该是小写加上下划线
4.将引用的库使用as转化名字也应该是小写加下划线
5.变量名、方法、参数名都应该采用小写开头的驼峰命名(常量命名使用大写)
6.花括号的用法也有一定的规范。只有一个if语句没有else的时候，并且在一行内能够很好的展现就可以不用花括号

//类规范命名
class Person{}
//类元数据
@JsonSerializable()
class AddressEntity extends Object{}
//命名库
library peg_parse.source_scanner;
//导入dart文件
import 'file_system.dart';
//引用
import 'file_system.dart' as systemjs;

赋值

//如果不为空想返回false
optionThing?.isEnableed)??false

集合

//如果要使用不可扩展的列表或者其他的一些自定义集合类型，那么务必使用构造函数
var points = [];
var address = Map();
//想要指定类型的时候，推荐如下写法
var points = List[];
var address = Map();
//不要使用.length的方法表示一个集合是否为空,使用isEmpty或者isNotEmpty
//避免使用带有方法字面量的Iterable.forEach()惯用方法使用循环
for(var person in people){}
//不要使用List.from()除非打算更改结果类型，有两种方法，一个是List.from()一个是Iterable.toList()
//使用where过滤集合
var objects = [1,"1"];
var int = object.whereType();
//变量例子
class Cricle{
  int r;
  final PI = 3.14;
  Cricle(this.r);
  get area => PI*this.r*this.r;
}
main() {
var p = new Cricle(3);
print(p.area);
}
//成员
class Container{
  var width;
  var height;
}
//构造方法
class Container{
  var width;
  var height;
  Container(this.width,this.height);
}
//尽量不要使用new来创建对象最新的Dart可以全部去掉代码中的new关键字
//不要使用过多的const修饰对象
const color = {
  Color(red,[255,0,0])
};
//try catch
try { 
} catch (e) {
}

四、数据类型

常用基本数据类型Number String Boolean List Map

Number包括两类int、double，两者都属于num类型的子类

int 
double //可以是整型也可以是浮点型
//数值和字符型可以相互转化
var valueDouble = int.parse('10');//double.parse('10.10')
var valueDouble = 10.toString();
var valueDouble = 10.10.toStringAsFixed(2);//保留两位小数

String类型

//字符串的表示方法
var a = "a";
var a1 = ```大块文本1```;
//转义字符/t,如果把转义字符变成普通字符需要添加前缀r
var r = r"n";
//字符串相接用+
//字符串插值用$(expression)

Boolean类型

//值必须为true或者false
bool   //true或false

List类型

//定义一个List
var list = [1,2];//可以改变容量arry.length = 0;改变长度为0
//常量list
var list = const[1,2];
//扩展运算符...
var list = [1,2];
var list2 = [1,2,...list];

Set类型

//去重类Set
var list = new Set();//可以对集合去重，结果是对象的形式
list.add('apple');
list.toList();//转化为List类型
//添加元素
list.add("value");
list.addAll(["苹果","葡萄"]);//追加一个数组
print(list);
//获取索引值
list.indexOf('苹果');//返回索引值，查找不到返回负一
//删除元素
list.remove('葡萄');//按照元素值删除
list.removeAt(2);//按照对应的索引值，数组下标
//修改元素
list.fillRange(1, 1,'荔枝');//开始位置和结束位置都修改为该值,(数值相同不变)
//指定位置插入元素
list.insert(2, "火龙果");
list.insertAll(2, ['圣女果','菠萝蜜']);

Map类型映射了一个关联key和value

//Map集合
var person = {
    "manager":"张三",
    "staff":"赵六"
};
person.keys.toList();//获取他的键并且转化为集合
person.values.toList();//获取他的值并且转化为集合
person.remove("staff");
person.addAll({
  "salesman":"王五"
});
person.containsValue("王五");
person.containsKey("salesman");

var arr = ["1"];//指定类型
var arry = [1,2];//可以改变容量arry.length = 0;改变长度为0
arry.add(2);
var arr = List.filled(2,"");//创建固定长度的集合
var arr = List.filled(2,"");
//定义Maps方法
var person = {
"name": "可可"，
"age":18
};//定义maps集合的形式跟json数据一样需要将属性名用双引号引用起来
print(preson['age'])//调用用中括号的形式
var p = new Map();
p["name"] = "可可";
//is关键词判断

五、运算符

常用算术运算符

//+、-、*、~/、%
a++;//先赋值后运算
++a;//先运算后赋值，先加一后赋值
a~/b//取整

常用关系运算符

//==、!=、>、<、>=、<= 

常用类型测试 *** 作符

//as、is、is!

赋值运算符

//=、??=
int b=20;
b??=10;
//如果b没有初始值那么就把10赋值给b
var a;
var b = a ?? 20;
print(b);//20因为a一开始没有默认值

逻辑运算符

//!、||、&&

位运算符

//&、|、^、~、<<、>>

条件表达式

condition?expr1:expr2
expr1??expr2

级联运算符

//..

六、流控制语句

if和elsefor循环while和do whilebreak和continueswitch和caseassert断言try-catch和throw

main() {
  List list = [
    {"title": "111"},
    {"title": "222"},
    {"title": "333"}
  ];
  for(int i = 0; i < list.length; i++){
    print(list[i]['title']);
  }
}
main() {
  List list = [
    {
      "title": "111",
      "news": [
        {
          "homenews": "央视新闻1",
        },
        {"homenews": "外媒新闻1"}
      ]
    },
    {
      "title": "222",
      "news": [
        {
          "homenews": "央视新闻2",
        },
        {"homenews": "外媒新闻2"}
      ]
    },
    {
      "title": "333",
      "news": [
        {
          "homenews": "央视新闻3",
        },
        {"homenews": "外媒新闻3"}
      ]
    }
  ];

  for (int i = 0; i < list.length; i++) {
    for(int j = 0; j < list[i]['news'].length; j++){
      print(list[i]['news'][j]['homenews']);
    }
  }
}

求1-100的和

  //求1-100的和
  var i = 1;
  var sum = 0;
 while(i <= 100){
   sum +=i;
   i++;

 }
 print(sum);

//forEach只能传入一个值
List list = ["苹果","橘子","香蕉"];
list.forEach((item){
print(item);//????
});

switch(today){
case 'Monday':
print("today is monday");}

//assert,语句来中断正常执行的流程，当assert判断为false时发生中断，assert的判断为true便继续执行下面的语句
assert(text != null);

七、函数

函数的概念

Dart是一个面向对象的语言，函数属于Function对象。函数可以像参数一样
传递给其它函数，这样便于做回调函数。

int max(int a,int b){
	return a >= b?a:b;
}
//箭头函数=>语法简写函数相当于{return expr;}的简写
int max(int a,int b)=>a>b?a:b;
//箭头函数代码只能写一行
main(){
List list = ["苹果","香蕉","西瓜"];
list.forEach((value)=>print(value));
}

可选参数

Dart语言中可选参数分为以下两种：
命名参数:使用大括号{}括起来的参数
位置参数:使用中括号[]括起来的参数

//位置参数
void printInfor(String name,[String from = "中国"]){}
printInfor("华夏儿女","中国");

命名参数

指定格式命名的参数叫做命名参数

//命名参数通常是是一种可选参数，如果用户想要强制传入这个参数可以使用required注解来声明这个参数
setInfor(String name,int age,{required int id,required String address})=>"${id}  ${address}";
main() {
print(setInfor("张三",21,id:2022,address:"北京"));
}

main函数

//跟java一样是一个程序的入口函数

匿名函数

//跟js一样没有名字的函数但是具备函数的功能，可以称作为闭包
//匿名方法
main(){
var ff = (){
  print(1);
};
ff();
}
//自执行方法
main(){
((){
  print("object");
})();
}
main(){
List list = ["苹果","香蕉","西瓜"];
list.forEach((value)=>print(value));
}

八、面向对象基础

面向对象的叙述

面向对象是相对面向过程的一种编程语言，具备和基础混入的继承，每一个对象都是一个实例，所有的类都派生来自Object

//面向对象的基本特征：封装、继承、多态、抽象
//Dart语言类有几部分构成:类名、成员变量、成员方法、构造方法
//类声明格式如下
[abstract] class className [extends superClassName] [implements interfaceName] [with className1,className2...]{//类体}
class className{
[static][const][final] type name;//成员变量
String run(){
	return "人类会跑步";//成员方法
}
}
//方法的使用
void getName(){
print("name");
}
String getID(){
print("getID");
}
int age(){
print("age");
}
main(){
getName();
}
//获取方法的值
int age(){
  return 18;
}
main(){
var value = age();
print(value);
}
//方法传入参数
int setAge(int age){
  return age;
}
main(){
print(setAge(19));
}
//
int setAge(int age,[int id]){
  if(id != null){
    print("age:$age id:$id");
  }else
    return age;
}
main(){
setAge(19,2022);
}
//静态变量(类变量)不需要实例化就能访问的变量用static修饰
//非静态方法必须实例化之后进行访问，用this访问静态属性
//静态方法不能 *** 作示例，因此不能访问this
//静态方法里面不能访问非静态属性和方法
//非静态属性和方法可以直接调用静态属性的方法
//类，main外面,首字母大写
class Person{
  String name = "可可";
  int age = 18;
  void getName(){
    print(this.name);
  }
}
main(){
var p1 = new Person();
p1.getName();
}
//
//类，main外面,首字母大写
class Person{
  String name = "可可";
  void getName(){
    print(this.name);
  }
  void setName(String name){
    this.name = name;
  }
}
main(){
var p1 = new Person();
p1.setName("coco");
p1.getName();
}
//实例化的时候处触发默认构造函数
class Person{
  String name = "可可";
  void getName(){
    print(this.name);
  }
  void setName(String name){
    this.name = name;
  }
  Person(){
    print("这是默认构造函数！");
  }
}
main(){
var p1 = new Person();
}
//通过默认构造方法传值
class Person{
  String name;
  void getName(){
    print(this.name);
  }
  void setName(String name){
    this.name = name;
  }
  Person(String this.name){
  }
}
main(){
var p1 = new Person("coco");
p1.getName();
}
//命名构造函数
//类，main外面,首字母大写
class Person{
  String name;
  void getName(){
    print(this.name);
  }
  void setName(String name){
    this.name = name;
  }
  Person(String this.name){
  }
  Person.now(){
    print("这个是命名构造函数");
  }
}
main(){
new Person.now();
}

List list = ["香蕉","苹果"];
print(list.length);
print(list.reversed);
print(list.isEmpty);
print(list.isNotEmpty);


//集合和字符串类型转化
List list = ["香蕉","苹果"];
var str = list.join(',');//集合类型转化为字符串
var value = str.split(',');//字符串转化为集合类型
print(value);

//直接修改集合中的值
List list = [1,2,3];
var list_1 = list.map((value){
  return value*2;
});
print(list_1.toList());

//条件判断，满足条件的返回
List list = [1,2,3];
var list_1 = list.where((value){
  return value>2;
});
print(list_1.toList());

//只要有一个满足条件就返回true
List list = [1,2,3];
var list_1 = list.any((value){//只要有一个满足条件就返回true
  return value>2;
});
print(list_1);

//只要有一个不满足条件就返回false
List list = [1,2,3];
var list_1 = list.every((value){
  return value>2;
});
print(list_1);

//forEach获取值
main(){
List list = ["苹果","香蕉","西瓜"];
list.forEach((value)=>{
  print(value)
});
}


//递归
main(){
 var sum = 1;
 computedNum(int n){
   sum *= n;
   if(n == 1){
     return sum;
   }
   computedNum(n-1);
 }
 computedNum(5);
 print(sum);
}


//闭包，变量常驻内存不污染全局
main(){
ff(){
  var n = 123;
  return(){
    n++;
    print(n);
  };
}
var b = ff();
b();
}

九、对象

对象是面向对象程序设计的核心，所谓对象就是在真是世界中的尸体，对象与实体是一一对应的，也就是说现实生活中么一个实体就是一个对象，它是一种具体的概念。类的实例化可以生成对象，实例的方法就是对象的方法，实例的变量就是对象属性。对象有如下特点：
对象具有属性和行为
对象具有变化的状态
对象具有唯一性
对象都是某个类的实例

创建对象

//声明对象即要创建一样类型的对象
Person name;//Person是一个类

实例化

//实例化即为对象分配内存空间，然后调用构造方法初始化对象
Person p = Person();//最新的Dart不需要使用new关键字进行实例化对象,p在初始化时为空最好加一个条件判断p != null;

对象成员

//应一个点来引用实例变量或者实例方法

构造方法

//构造方法是类的一种特殊方法，用来初始化类的一个新的对象，在创建对象之后自动调用，如果构造方法，会提供一个无参数的构造方法
class Person{
String name;
	Person(String name){
	this.name = name;//this指向当前引用实例
};}
//语法糖，简化构造方法
class Person{
String name;
	Person(this.name);
}

命名构造方法

//Dart不支持构造方法重载，无法像java语言一样使用不同的个参数来实现构造方法
class Person{
String name;
	Person(this.name);
	Person.run(){
	print("这是命名构造方法");
	}
}

调用父类的非默认非默认构造方法

//总结执行顺序如下
//初始化列表->父类无参数、构造方法->子类无参构造方法

//dart加私有加下划线_name
import 'bin/Person.dart';
main(){
Person p = new Person("");
p.exeturn();
}
//只能通过类里面的方法调用私有方法
class Person{
  String name;
  int age = 18;
  void getName(){
    print(this.name);
  }
  void setName(String name){
    this.name = name;
  }
  Person(String this.name){
  }
  Person.now(){
    print("这个是命名构造函数");
  }
  _getAge(){
    print(this.age);
  }
  void exeturn(){
      this._getAge();
  }
}
//get计算属性
class Rect{
  int height;
  int width;
  Rect(this.width,this.height);
  get area{
    return this.width*this.height;
  }
}
import 'bin/computedArea.dart';
main(){
var p = new Rect(10,10);
print(p.area);
}
//set计算属性
import 'bin/computedArea.dart';
main(){
var p = new Rect(10,10);
p.widthFn = 6;
print(p.area);
}
//实例化之前初始化列表
class Rect{
  int height;
  int width;
  Rect():height=10,width=10;
  get area{//get计算属性
    return this.width*this.height;
  }
  set widthFn(value){
    this.width = value;
  }
}

class Teacher{
  var name;
  var age;
  var id;
  Teacher(name,age);
  void printResult(){
    print("${this.name} ${this.age}");
  }
}
main(){
var p = new Teacher("张三",12);
p..name="赵六"
 ..age=12
 ..printResult();
}

//构造函数
class Teacher {
  var name;
  var age;
  var id;
  Teacher(this.name, this.age);
  void printResult() {
    print("${this.name} ${this.age}");
  }
}

class Web extends Teacher {
  String idName;
  Web(name, age,this.idName) : super(name, age){
    this.idName = idName;
  }//ctrl+shift+
  @override
   void printResult() {//复写方法,首先调用子类的方法
    print("姓名${this.name} 年龄${this.age}");
  }
}

main() {
  var p = new Web("张二",20,"2010");
  p.printResult();
}
//在子类中调用父类的构造方法用super
class Teacher {
  var name;
  var age;
  var id;
  Teacher(this.name, this.age);
  void printResult() {
    print("${this.name} ${this.age}");
  }
  void call(){
    print("object");
  }
}

class Web extends Teacher {
  run(){
    super.call();
  }
  String idName;
  Web(name, age,this.idName) : super(name, age){
    this.idName = idName;
  }//ctrl+shift+
  @override
   void printResult() {//复写方法,首先调用子类的方法
    print("姓名${this.name} 年龄${this.age}");
  }
}
main() {
  var p = new Web("张二",20,"2010");
  p.printResult();
  p.run();
}
//抽象类不能被实例化
abstract class Animal{
    run(){
      print("object");
    }
}
class cat extends Animal{
  @override
  run() {
      print("这个是cat方法");
  }
}
main() {
  var p = new cat();
  p.run();
}
//子类的实例调用父类的引用
abstract class Animal{
    run(){
      print("object");
    }
}
class cat extends Animal{
  @override
  run() {
      print("这个是cat方法");
  }
}
main() {
  Animal p = new cat();
  p.run();//只能调用父类中已经存在的方法
}
//implements 接口就是定义一些标准
abstract class DB{
  String url;
  add(var data);
  remove();
  del();
}
class mysql implements DB{
  @override
  String url;
  @override
  add(data) {
   print("这是mysql的add方法"+data);
  }
  @override
  del() {
    return null;
  }
  @override
  remove() {
    return null;
  }
}
main() {
var p = new mysql();
p.add("数据");
}
//可以继承多个接口

class Person{
  String name;
  Person(this.name);
  get setName{
    print(this.name);
  }
}
class A{
  String age;
}
class B{
  String id;
}
class C extends Person with B,A{
  C(String name) : super(name);
}
main() {
//所有类都是继承Object中的方法
}
//如果有相同的方法，后面类覆盖前面的类。A，B就是C的超类
class Person {
  String name;
  Person(this.name);
  get setName {
    print(this.name);
  }
  printFn() {
    print("Person");
  }
}
class A {
  String age;
  printFn() {
    print("A");
  }
}

class B {
  String id;
  printFn() {
    print("B");
  }
}
class C extends Person with A, B {
  C(String name) : super(name);
}
main() {
  var p = new C("张三");
  p.printFn();
}
//泛型在方法中的使用
getData(T data){
  return data;
}
class Demo{
  List list = [];
  void add(T value){
    this.list.add(value);
  }
  void getList(){
    print(this.list);
  }
}
main() {
Demo p = new Demo();
p.add("张三");
p.add(12);
p.getList();
}

//接口泛型指定
abstract class Cache {
  getByKey(String key) {}
  setByKey(String key, T value) {}
}
class FileCache implements Cache {
  getByKey(String key) {}
  setByKey(key, T value) {}
}
class MemoryCache implements Cache {
  @override
  getByKey(String key) {
    return null;
  }
  @override
  setByKey(String key, T value) {
   print("${value}");
  }
}
main() {
  MemoryCache p = new MemoryCache

class A{
  String name;
  int age;
  A(this.name,{required this.age});
}
main() {
var p = new A("name", age: 123);

}
//late
class Cricle{
  late int r;
  final PI = 3.14;
  Cricle(int r){
    this.r = r;
  }
  get area => PI*this.r*this.r;
}

main() {

}