dart语言基础知识

时间  2020-07-14
标签 dart 语言 基础 知识 繁體版
原文   原文链接

1、Dart入口方法介绍Dart打印Dart注释 Dart变量 常量 命名规则
main(){
print('hello world');
}
function set:void(){
}
dart是个强大的脚本类语言，能够不预先定义变量类型，自动会i类型变量
dart 中定义变量能够经过var关键字能够经过类型来申明变量
Dart 常量： final 和 const修饰符
const值不变 一开始就得赋值
final 能够开始不赋值 只能赋一次 ; 而final不只有const的编译时常量的特性，最重要的它是运行时常量，而且final是惰性初始化，即在运行时第一次使用前才初始化
永远不改量的量，请使用final或const修饰它，而不是使用var或其余变量类型。
final name = 'Bob'; // Without a type annotation
final String nickname = 'Bobby';编程

const bar = 1000000; // Unit of pressure (dynes/cm2)
const double atm = 1.01325 * bar; // Standard atmosphere

Dart的命名规则：数组

一、变量名称必须由数字、字母、下划线和美圆符($)组成。

      2.注意：标识符开头不能是数字

      3.标识符不能是保留字和关键字。   

      4.变量的名字是区分大小写的如: age和Age是不一样的变量。在实际的运用中,也建议,不要用一个         单词大小写区分两个变量。

      五、标识符(变量名称)必定要见名思意 ：变量名称建议用名词，方法名称建议用动词

Dart数据类型
Numbers（数值）:
int
double
Strings（字符串）
String
Booleans(布尔)
bool
List（数组）
在Dart中，数组是列表对象，因此大多数人只是称它们为列表
Maps（字典）
一般来讲，Map 是一个键值对相关的对象。 键和值能够是任何类型的对象。每一个 键 只出现一次， 而一个值则能够出现屡次闭包

String str1='你好';ide

String str2='Dart';函数

print("$str1 $str2");
2、算数运行符
一、Dart运算符：
算术运算符this

      • / ~/ (取整) %（取余）
        关系运算符
        == ！= > < >= <=
        逻辑运算符
        ! && ||
        赋值运算符
        基础赋值运算符 = ??=
        复合赋值运算符 += -= *= /= %= ~/=
        条件表达式
        if else switch case
        三目运算符
        ??运算符：
        二、类型转换
        一、Number与String类型之间的转换
        二、其余类型转换成Booleans类型

    print(a+b); //加
    print(a-b); //减
    print(a*b); //乘
    print(a/b); //除
    print(a%b); //其他
    print(a~/b); //取整指针

3、常量和变量
一、List 和数组
List里面经常使用的属性和方法：code

经常使用属性：
    length          长度
    reversed        翻转
    isEmpty         是否为空
    isNotEmpty      是否不为空
经常使用方法：  
    add         增长
    addAll      拼接数组
    indexOf     查找  传入具体值
    remove      删除  传入具体值
    removeAt    删除  传入索引值
    fillRange   修改   
    insert(index,value);            指定位置插入    
    insertAll(index,list)           指定位置插入List
    toList()    其余类型转换成List  
    join()      List转换成字符串
    split()     字符串转化成List
    forEach   
    map
    where
    any
    every

二、Set集合
//Set 对象

//用它最主要的功能就是去除数组重复内容继承

//Set是没有顺序且不能重复的集合，因此不能经过索引去获取值
三、Map
映射(Maps)是无序的键值对：

经常使用属性：
    keys            获取全部的key值
    values          获取全部的value值
    isEmpty         是否为空
    isNotEmpty      是否不为空
经常使用方法:
    remove(key)     删除指定key的数据
    addAll({...})   合并映射  给映射内增长属性
    containsValue   查看映射内的值  返回true/false
    forEach   
    map
    where
    any
    every

3、函数
*
内置方法/函数：
print();
自定义方法：
自定义方法的基本格式：

返回类型  方法名称（参数1，参数2,...）{
    方法体
    return 返回值;
  }

*/
//调用方法传参

main() {

//一、定义一个方法 求1到这个数的全部数的和 60 1+2+3+。。。+60

/*
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);

*/

//二、定义一个方法而后打印用户信息

// String printUserInfo(String username,int age){  //行参
//     return "姓名:$username---年龄:$age";
// }

// print(printUserInfo('张三',20)); //实参

//三、定义一个带可选参数的方法

// String printUserInfo(String username,[int age]){  //行参

//   if(age!=null){
//     return "姓名:$username---年龄:$age";
//   }
//   return "姓名:$username---年龄保密";

// }

// // print(printUserInfo('张三',21)); //实参

// print(printUserInfo('张三'))

//四、定义一个带默认参数的方法
// String printUserInfo(String username,[String sex='男',int age]){ //行参
// if(age!=null){
// return "姓名:$username---性别:$sex--年龄:$age";
// }
// return "姓名:$username---性别:$sex--年龄保密";
// }
// print(printUserInfo('张三'));
// print(printUserInfo('小李','女'));
// print(printUserInfo('小李','女',30));
//五、定义一个命名参数的方法
// String printUserInfo(String username,{int age,String sex='男'}){ //行参
// if(age!=null){
// return "姓名:$username---性别:$sex--年龄:$age";
// }
// return "姓名:$username---性别:$sex--年龄保密";

// }

// print(printUserInfo('张三',age:20,sex:'未知'));
//六、实现一个 把方法当作参数的方法
// var fn=(){
// print('我是一个匿名方法');
// };
// fn();

//方法
fn1(){
print('fn1');
}
//方法
fn2(fn){

fn();

}
//调用fn2这个方法 把fn1这个方法当作参数传入
fn2(fn1);
使用forEach打印下面List里面的数据*/

// List list=['苹果','香蕉','西瓜'];

// list.forEach((value){
//   print(value);
// });
// list.forEach((value)=>print(value));
// list.forEach((value)=>{
//   print(value)
// });

/需求：修改下面List里面的数据，让数组中大于2的值乘以2/
List list=[4,1,2,3,4];
// var newList=list.map((value){
// if(value>2){
// return value2;
// }
// return value;
// });
// print(newList.toList());
// var newList=list.map((value)=>value>2?value2:value);
// print(newList.toList());

/
需求： 一、定义一个方法isEvenNumber来判断一个数是不是偶数
二、定义一个方法打印1-n之内的全部偶数
/
//定义一个方法isEvenNumber来判断一个数是不是偶数
bool isEvenNumber(int n){
if(n%2==0){
return true;
}
return false;
}
printNum(int n){
for(var i=1;i<=n;i++){
if(isEvenNumber(i)){
print(i);
}
}
}
printNum(10);
}
void main(){
// print(getNum(12));
//匿名方法

// var printNum=(){
// print(123);
// };
// printNum();
// var printNum=(int n){
// print(n+2);
// };
// printNum(12);
//自执行方法
// ((int n){
// print(n);
// print('我是自执行方法');
// })(12);
//方法的递归
// var sum=1;
// fn(n){
// sum=n;
// if(n==1){
// return ;
// }
// fn(n-1)
// }
// fn(5);
// print(sum);
//经过方法的递归 求1-100的和
var sum=0;
fn(int n){
sum+=n;
if(n==0){
return;
}
fn(n-1);
}
fn(100);
print(sum);
}
/
闭包：

一、全局变量特色:    全局变量常驻内存、全局变量污染全局
二、局部变量的特色：  不常驻内存会被垃圾机制回收、不会污染全局

/* 想实现的功能：

1.常驻内存        
    2.不污染全局   

      产生了闭包,闭包能够解决这个问题.....  

      闭包: 函数嵌套函数, 内部函数会调用外部函数的变量或参数, 变量或参数不会被系统回收(不会释放内存)

        闭包的写法： 函数嵌套函数，并return 里面的函数，这样就造成了闭包。

*/

*/

/全局变量/
var a=123;
void main(){
// print(a);

// fn(){
//   a++;
//   print(a);
// }
// fn();
// fn();
// fn();

//局部变量
// printInfo(){
// var myNum=123;
// myNum++;
// print(myNum);
// }
// printInfo();

// printInfo();
// printInfo();

//闭包

fn(){
    var a=123;  /*不会污染全局   常驻内存*/
    return(){           
      a++;          
      print(a);
    };        
  }     
  var b=fn();   
  b();
  b();
  b();

}
01 Dart面向对象的介绍 以及Data内置对象
/*

面向对象编程(OOP)的三个基本特征是：封装、继承、多态 

封装：封装是对象和类概念的主要特性。封装，把客观事物封装成抽象的类，而且把本身的部分属性和方法提供给其余对象调用, 而一部分属性和方法则隐藏。

  继承：面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可使用现有类的功能，并在无需从新编写原来的类的状况下对这些功能进行扩展。

  多态：容许将子类类型的指针赋值给父类类型的指针, 同一个函数调用会有不一样的执行效果 。

Dart全部的东西都是对象，全部的对象都继承自Object类。

Dart是一门使用类和单继承的面向对象语言，全部的对象都是类的实例，而且全部的类都是Object的子类

一个类一般由属性和方法组成。

*/

void main(){ 

List list=new List();
list.isEmpty;
list.add('香蕉');
list.add('香蕉1');
Map m=new Map();
m["username"]="张三";
m.addAll({"age":20});
m.isEmpty;
Object a=123;
Object v=true;
print(a);
print(v);

}
02 Dart中建立义类使用类
/*

Dart是一门使用类和单继承的面向对象语言，全部的对象都是类的实例，而且全部的类都是Object的子类

*/

class Person{
String name="张三";
int age=23;
void getInfo(){
// print("$name----$age");
print("${this.name}----${this.age}");
}
void setInfo(int age){
this.age=age;
}

}
void main(){
//实例化
// var p1=new Person();
// print(p1.name);
// p1.getInfo();
Person p1=new Person();
// print(p1.name);
p1.setInfo(28);
p1.getInfo();
}
03 Dart中自定义类的默认构造函数

// class Person{
// String name='张三';
// int age=20;
// //默认构造函数
// Person(){
// print('这是构造函数里面的内容 这个方法在实例化的时候触发');
// }
// void printInfo(){
// print("${this.name}----${this.age}");
// }
// }

//张三 李四 王五

// class Person{
// String name;
// int age;
// //默认构造函数
// Person(String name,int age){
// this.name=name;
// this.age=age;
// }
// void printInfo(){
// print("${this.name}----${this.age}");
// }
// }
class Person{
String name;
int age;
//默认构造函数的简写
Person(this.name,this.age);
void printInfo(){
print("${this.name}----${this.age}");
}
}
void main(){
Person p1=new Person('张三',20);
p1.printInfo();
Person p2=new Person('李四',25);
p2.printInfo();

}
04 Dart中自定义类的命名构造函数
/
dart里面构造函数能够写多个
/
class Person{
String name;
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(){
// var d=new DateTime.now(); //实例化DateTime调用它的命名构造函数
// print(d);
//Person p1=new Person('张三', 20); //默认实例化类的时候调用的是 默认构造函数
//Person p1=new Person.now(); //命名构造函数
Person p1=new Person.setInfo('李四',30);
p1.printInfo();

}
05 Dart中把类单独抽离成一个模块
import 'lib/Person.dart';
void main(){
Person p1=new Person.setInfo('李四1',30);
p1.printInfo();
}
06 Dart中的私有方法 和私有属性
/
Dart和其余面向对象语言不同，Data中没有 public private protected这些访问修饰符合
可是咱们可使用_把一个属性或者方法定义成私有。
/
import 'lib/Animal.dart';
void main(){
Animal a=new Animal('小狗', 3);
print(a.getName());
a.execRun(); //间接的调用私有方法
}
07 类中的getter和setter修饰符的用法

// class Rect{
// int height;
// int width;

// getArea(){
// return this.height*this.width;
// }
// }
// class Rect{
// num height;
// num width;

// Rect(this.height,this.width);
// area(){
// return this.heightthis.width;
// }
// }
// void main(){
// Rect r=new Rect(10,4);
// print("面积:${r.area()}");
// }
// class Rect{
// num height;
// num width;
// Rect(this.height,this.width);
// get area{
// return this.heightthis.width;
// }
// }
// void main(){
// Rect r=new Rect(10,2);
// print("面积:${r.area}"); //注意调用直接经过访问属性的方式访问area
// }
class Rect{
num height;
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);
}
08 类中的初始化列表
// Dart中咱们也能够在构造函数体运行以前初始化实例变量

class Rect{
int height;
int width;
Rect():height=2,width=10{
print("${this.height}---${this.width}");
}
getArea(){
return this.height*this.width;
}
}
void main(){
Rect r=new Rect();
print(r.getArea());
}

4、01Dart 类中的静态成员 静态方法
/*
一、Dart中的静态成员:

一、使用static 关键字来实现类级别的变量和函数

二、静态方法不能访问非静态成员，非静态方法能够访问静态成员

*/
// class Person {
// static String name = '张三';
// static void show() {
// print(name);
// }
// }

// main(){
// print(Person.name);
// Person.show();
// }
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();

}

}
main(){
// print(Person.name);
// Person.show();
// Person p=new Person();
// p.printInfo();
Person.printUserInfo();
}
二、02Dart 中的对象操做符
/*
Dart中的对象操做符:

?     条件运算符 （了解）
as    类型转换
is     类型判断
..      级联操做 （连缀）  (记住)

*/

class Person {
String name;
num age;
Person(this.name,this.age);
void printInfo() {
print("${this.name}---${this.age}");
}

}

main(){

// Person p;
// p?.printInfo();
// Person p=new Person('张三', 20);
// p?.printInfo();
// Person p=new Person('张三', 20);
// if(p is Person){
// p.name="李四";
// }
// p.printInfo();
// print(p is Object);
// var p1;
// p1=''“
// p1=new Person('张三1', 20);
// // p1.printInfo();
// (p1 as Person).printInfo();
// Person p1=new Person('张三1', 20);
// p1.printInfo();
// p1.name='张三222';
// p1.age=40;
// p1.printInfo();
Person p1=new Person('张三1', 20);
p1.printInfo();
p1..name="李四"
..age=30
..printInfo();

}
三、03Dart 类的继承-简单继承
/*
面向对象的三大特性：封装 、继承、多态
Dart中的类的继承：
一、子类使用extends关键词来继承父类
二、子类会继承父类里面可见的属性和方法 可是不会继承构造函数
三、子类能复写父类的方法 getter和setter

*/
class Person {
String name='张三';
num age=20;
void printInfo() {
print("${this.name}---${this.age}");
}
}
class Web extends Person{

}
main(){
Web w=new Web();
print(w.name);
w.printInfo();
}
四、04Dart 类的继承 super关键词的使用 实例化自类给父类构造函数传参
五、
/*
面向对象的三大特性：封装 、继承、多态
Dart中的类的继承：
一、子类使用extends关键词来继承父类
二、子类会继承父类里面可见的属性和方法 可是不会继承构造函数
三、子类能复写父类的方法 getter和setter

/
class Person {
String name;
num age;
Person(this.name,this.age);
void printInfo() {
print("${this.name}---${this.age}");
}
}
class Web extends Person{
String sex;
Web(String name, num age,String sex) : super(name, age){
this.sex=sex;
}
run(){
print("${this.name}---${this.age}--${this.sex}");
}
}
main(){
// Person p=new Person('李四',20);
// p.printInfo();
// Person p1=new Person('张三',20);
// p1.printInfo();
Web w=new Web('张三', 12,"男");
w.printInfo();
w.run();
}
六、06Dart 类的继承 实例化自类给命名构造函数传参
/
面向对象的三大特性：封装 、继承、多态
Dart中的类的继承：
一、子类使用extends关键词来继承父类
二、子类会继承父类里面可见的属性和方法 可是不会继承构造函数
三、子类能复写父类的方法 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}");
}
}
class Web extends Person{
String sex;
Web(String name, num age,String sex) : super.xxx(name, age){
this.sex=sex;
}
run(){
print("${this.name}---${this.age}--${this.sex}");
}
}
main(){
// Person p=new Person('李四',20);
// p.printInfo();
// Person p1=new Person('张三',20);
// p1.printInfo();
Web w=new Web('张三', 12,"男");
w.printInfo();
w.run();
}
七、07Dart 类的继承 覆写父类的方法
/
面向对象的三大特性：封装 、继承、多态
Dart中的类的继承：
一、子类使用extends关键词来继承父类
二、子类会继承父类里面可见的属性和方法 可是不会继承构造函数
三、子类能复写父类的方法 getter和setter
/
class Person {
String name;
num age;
Person(this.name,this.age);
void printInfo() {
print("${this.name}---${this.age}");
}
work(){
print("${this.name}在工做...");
}
}
class Web extends Person{
Web(String name, num age) : super(name, age);
run(){
print('run');
}
//覆写父类的方法
@override //能够写也能够不写 建议在覆写父类方法的时候加上 @override
void printInfo(){
print("姓名：${this.name}---年龄：${this.age}"); br/>}@overridework(){print("${this.name}的工做是写代码");}}main(){ Web w=new Web('李四',20);w.printInfo();w.work();}八、 Dart 自类里面调用父类的方法/面向对象的三大特性：封装 、继承、多态Dart中的类的继承： 一、子类使用extends关键词来继承父类二、子类会继承父类里面可见的属性和方法 可是不会继承构造函数三、子类能复写父类的方法 getter和setter*class Person {String name;num age; Person(this.name,this.age);void printInfo() {print("${this.name}---${this.age}"); }work(){print("${this.name}在工做...");}

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程