dart 数据类型
2019-06-17 本文已影响0人
Amy_yqh
一、变量和常量
1.变量 var
dart语言的变量定义与JavaScript定义变量一样的，使用var 关键字。变量没有赋值，默认值为null。
void main(){
var name = 'amy';
print(name)
}
1.常量 const final
使用const ,final定义常量时，必须要初始化，否则会报错。定义完之后，不能再重新赋值。
void main(){
const name = 'amy';
print(name)
final age = 18;
print(age)
}
二、数值型
数值型有int（整型），double（浮点型），dart的数值型的方式和属性与javascript差不多，不过，dart的数值型多了一个‘~/’，相除求整的运算符
1.运算符
+，-，*，/，%，~/
void main(){
int a = 10;
double b = 12.3;
print(a+b);
print(a-b);
print(a*b);
print(a/b);
print(a~/b); // 除求整
print(a%b);
print(0.0/0.0); //nan
}
2.方法和属性
void main(){
int a = 10;
double b = 12.3;
print(a.isEven);
print(a.isFinite);
print(a.isInfinite);
print(a.isNaN);
print(a.isOdd);
print(a.abs());
print(a.ceil());
}
三.字符串
1.字符串定义
字符串定义可以使用单引号，双引号，三引号来定义
void main(){
var str = 'hello dart';
var str1 = """hello
world""";
var str2 = 'hello \n amy';
var str3 = r'hello \n amy';
print(str);
print(str1);
print(str2);
print(str3);
}
注意：
1.三引号定义用于多行字符串的显示，连换行和空格也会打印出来；
2.字符串使用普通方式定义，且中间有转译符，会识别转义符；
3.字符串定义前面加‘r’会把字符串的内容原本输出
2.字符串的运算符
+,* ,==,[]
void main(){
String str = 'hello dart';
print(str+'hahha');
print(str*5); // 遍历5次连接起来
print(str[0]);
}
3.字符串插值表达式
+,* ,==,[]
void main(){
var a =1;
var b =2;
print('a+b = ${a+b}'); // 字符串占位符
print('a = $a');
}
如果有表达式，使用大括号括起来，如果只是一个变量，就直接写$,
4.字符串的属性和方法
void main(){
String str = 'hello dart';
print(str.trim());
print(str.padLeft(20,'a'));// 在字符串的左边补指定字符串（默认为空格）
print(str.length);
print(str.isEmpty);
}
属性，方法有很多，可以到官网或源码看看，这里就不一一列举了。
5.布尔型
布尔型就两种，false和true
void main(){
bool isFalse = false;
bool isTrue = true;
print(isFalse);
print(isTrue);
}
6.List型（Array）
1.List的定义
void main(){
var list = [1,2,3,'22'];
var list1 = const [4,5,6];
var list2 = new List();
}
使用const定义的list，不可修改
2.LIST的方法属性
属性：主要有[],length等
方法：add(),insert(),remove(),clear()等
方法太多了，不想写了
7.Map型
8.dynamic型
与JavaScript不同的地方
1.算术运算符??
void main(){
var aa;
var bb = 'js';
print(aa??bb);
}
如果aa没有值，值就为bb，如果aa有值，结果就为aa
2.switch--case 的continue 跳转标签
void main(){
var aa = 'dart';
switch(aa){
D:
case 'dart':
print('dart');
break;
case 'js':
print('js');
continue D;
case 'python':
print('python');
break;
}
}
打印出来:
js
dart
8.函数
（1）可选参数为对象
void main(List argc){
print(printPeople('amy',age:18));
print(printPeople('amy',age:18));
}
printPeople(String name,{int age,String genger}){
return 'I am $name,$age,$genger';
}
函数的可选参数为对象时，如果函数调用使用可选参数，必选填写参数名
（2）可选参数为数组
printPeople1(String name,[int age,String genger]){
return 'I am $name,$age,$genger';
}
void main(List argc){
print(printPeople1('amy'));
print(printPeople1('amy',16,'女'));
}
可选参数为数组时，调用函数使用可选函数，直接写入对应下标的值就可以。
（3）可选参数设置默认值
printPeople2(String name,{int age = 30,String genger = 'male'}){
return 'I am $name,$age,$genger';
}
void main(List argc){
print(printPeople2('amy'));
print(printPeople2('amy',genger:'famale'));
}
重新赋值会把默认值覆盖，没有赋值就为默认数据。
9.类
void main(List argc){
var person = new Person();
person.name='amy';
person.age=18;
print(person.name);
person.say();
}
class Person{
String name;
int age;
final String father = 'bab'; // final 定义的变量没有setter方法，只能getter
void say(){
print('hi,我可以说话');
}
// void say(int age){ // 方法不能重载
// print('hi,我可以说话');
// }
}
（1）类的声明使用class
（2）类的创建使用new ,new 可省
（3）类中定义的实例变量都有getter和setter属性，但是final声明的变量只有getter.，没有setter.
(4) 方法不能重构
10 .类的计算属性
void main(){
var rect = new Rectangle();
rect.width=10;
rect.height=20;
print(rect.getRect());
print(rect.area);
rect.area = 200;
print(rect.width);
}
class Rectangle{
num width,height;
num getRect(){
return width*height;
}
num get area=> width*height;
set area(value){
width = value/2;
}
}
计算属性首先声明类型 ，然后一个get/set 再定义计算属性的名称，ok，看上面代码
11.构造函数
1.默认构造函数
定义类对象的时候，如果不写构造函数，默认会有一个构造函数
void main(){
print('hello world');
var people = new People();
people.name='amy';
people.age=18;
print(people.name);
}
class People {
String name;
int age;
People(){}
final String gender = '男';
}
2.重写构造函数
void main(){
print('hello world');
var people = new People('amy',18);
print(people.name);
}
class People {
String name;
int age;
final String gender = '男';
People(String name,int age){
this.name = name;
this.age = age;
}
}
3.构造函数的语法糖
void main(){
print('hello world');
var people = new People('amy',18);
print(people.name);
}
class People {
String name;
int age;
final String gender = '男';
People(this.name,this.age);
}
4.具名构造函数（重构）
void main(){
print('hello world');
var people = new People('amy',18);
new People.withName('ye');
var age = new People.withAge(18);
print(people.name);
print(age.age);
}
class People {
String name;
int age;
final String gender = '男';
People(this.name,this.age);
People.withName(this.name);
People.withAge(this.age);
}
12.常量构造函数
void main(){
var people = [new] [const] People('amy',18);
print(people.age);
}
class People {
final String name;
final int age;
const People(this.name,this.age);
}
常量构造函数：
（1）类的定义必须使用final；
（2）类的构造函数使用const 声明；
（3）new 类对象时const可以省略
13.工厂构造函数
void main(){
var people = new People('amy',18);
print(people.name);
}
class People {
String name;
int age;
factory People(String name,int age){
if(name!=null){
return People._withName(name);
}else{
return People._withAge(age);
}
}
People._withName(this.name);
People._withAge(this.age);
}
普通的构造函数是不能有返回值的，但是使用factor来定义的工厂构造函数是可以有返回值；
14.初始化列表
void main(){
var people = new People('amy',18);
Map map = {'name':'胖金妹','age':1,'gender':'女'};
var pp = new People.withMap(map);
print(pp.name);
print(people.name);
}
class People {
String name;
int age;
String gender = 'nv';
People(this.name,this.age);
People.withMap(Map map):name = map['name'],age=map['age']{
this.gender = map['gender'];
}
}
15.静态成员
void main(){
var people = new People();
People.scrollDown();
people.scrollUp();
}
class People {
// 类中的常量必须使用static定义
static const int maxPage = 10;
// 静态变量，
static int currentPage = 0;
// 静态方法，实例不能直接调用，使用类调用
static void scrollDown(){
currentPage ++;
print('scrolldown');
}
void scrollUp(){
currentPage--;
print('scrollUp');
}
}
（1）定义类中的静态变量和静态方法，使用static关键字
（2）静态成员不能访问非静态成员，非静态成员可以访问静态成员
（3）类中的常量需要使用static const 声明
16 对象操作符
1、.?条件成员访问
void main(){
People people = new People();
people?.work(); // 条件成员访问
}
class People {
String name;
int age;
void work(){
print('work');
}
}
当不确定返回对象是否为空时，使用条件成员访问来判断
2、.as类型的转换
void main(){
var people;
people ='';
people = new People();
(people as People).work(); // 类型的转换
}
class People {
String name;
int age;
void work(){
print('work');
}
}
3、?,?!判断符
void main(){
var people;
people ='';
people = new People();
if(people is People){
print('true');
people.work();
}
if(people is! People){
print('false');
}
}
class People {
String name;
int age;
void work(){
print('work');
}
}
使用?判断左边的实例是否是右边的类型。
4、..级联运算符
void main(){
var people = new People();
people..name='amy'..age=18;
print(people.name);
}
class People {
String name;
int age;
void work(){
print('work');
}
}
17call方法的使用
void main(){
var people = new People();
people..name='amy'..age=18;
print(people.name);
people(); //对象作为方法来使用
}
class People {
String name;
int age;
void call(){
print('name:$name,age:$age');
}
}
call 方法定义，可以使实例对象作为一个方法来使用
void main(){
var people = new People();
people..name='amy'..age=18;
print(people.name);
people('tom',1); //对象作为方法来使用
}
class People {
String name;
int age;
void call(String name,int age){
print('name:$name,age:$age');
}
}
如果call方法声明了形参，调用实例对象时，也要传入对应的参数
18.类的继承
// people.dart
void main(){
var people = new People();
}
class People {
String name;
int age;
String _address;
bool get isAdult=> age>18;
void run (){
print('people run');
}
}
// student.dart
import 'people.dart';
void main() {
var student = new Student();
student.study();
student.name='amy';
student.age=12;
// student._address = 'ddd';// 不能继承父类的私有属性
print(student.isAdult);
student.run();
}
class Student extends People{
void study(){
print('student study');
}
void run(){ // 重写父类的方法
print('student run');
}
@override // 重写父类的计算属性
// TODO: implement isAdult
bool get isAdult => this.age>16;
}
dart的继承与其他语言的差不多，
（1）使用extends关键字实现继承
（2）子类可以继承父类的可见属性和方法
（3）子类可以重写父类的方法，getter，setter方法。
19.继承中的构造方法
1.子类的构造方法会调用父类的无名无参的构造方法
void main(){
var stu = new Student();
}
class People {
String name;
int age;
People(){
print('People');
}
void run (){
print('people run');
}
}
class Student extends People{
void study(){
print('student study');
}
}
//编译结果：People
子类的构造方法调用父类的无名有参的构造方法
void main(){
var stu = new Student('amy');
print(stu.name);
}
class People {
String name;
int age;
People(this.name);
}
class Student extends People{
Student(String name) : super(name);
void study(){
print('student study');
}
}
2.子类的构造方法调用父类有参有名的构造方法
void main(){
var stu = new Student(16);
print(stu.age);
}
class People {
String name;
int age;
People(this.name);
People.withAge(this.age);
}
class Student extends People{
Student(int age) : super.withAge(age); // 初始化列表
void study(){
print('student study');
}
}
如果父类的构造方法中不仅有无名构造方法，也有具有构造方法，在子类实现继承的时候，可以通过选择
20.抽象类
void main(){
var stu = new Student();
stu.run();
}
abstract class People {
void run(){}
}
class Student extends People{
void run(){
print('重写抽象类的方法');
}
}
（1）抽象类通过abstract 关键字来创建
（2）抽象类不能通过new表达式实现实例化；
（3）通过子类继承抽象类来实现抽象类的方法和属性；
（4）抽象类的方法前面不需要abstract修饰，抽象类的方法可以为空；
21.接口
void main(){
var stu = new Student();
stu.run();
}
abstract class People {
void run(){}
}
class Student implements People{
void run(){
print('重写抽象类的方法');
}
}
（1）接口会重新类的所有属性和方法，可以是任意的类
22.Mixins 实现多继承
void main(){
var d = new D();
d.a();
d.b();
d.c();
d.d();
}
class A{
void a(){
print('A --a');
}
}
class B{
void b(){
print('B--b');
}
}
class C{
void c(){
print('C--c');
}
}
// mixins 实现类似多继承的效果
class D extends A with B,C{
void d(){
print('d--d');
}
}
void main(){
var d = new D();
d.a(); // B--a
}
class A{
void a(){
print('A --a');
}
}
class B{
void a(){
print('B --a');
}
void b(){
print('B--b');
}
}
class C{
void a(){
print('C --a');
}
void b(){
print('C--b');
}
void c(){
print('C--c');
}
}
// mixins 实现类似多继承的效果
class D extends A with C,B{
void d(){
print('D--d');
}
}
如果多个类中有相同的方法，调用的是最后一个类方法
注意：
（1）Mixins类似于多继承，是在多继承中重用一个类代码的方法‘
（2）作为Mixins的类不能有显性声明构造方法
（3）作为Mixins的类只能继承自Object
（4）使用关键字with连接一个或多个Mixins
综合的案例：
void main(){
var car = new Car();
var bus = new Bus();
car.work();
bus.work();
}
abstract class Engine{
void work();
}
class OilEngine implements Engine{
void work(){
print('烧油引擎');
}
}
class ElectricEngine implements Engine{
void work(){
print('烧电引擎');
}
}
class Tyre{
String name;
void run(){
print('跑起来啦');
}
}
class Car = Tyre with ElectricEngine;
class Bus = Tyre with OilEngine;
// 不同的写法
[class Car extends Tyre with OilEngine{}]
23.dart的枚举
void main(){
var currentSeason = Season.autumn;
switch(currentSeason){
case Season.spring:
print('1-3月');
break;
case Season.summer:
print('4-6月');
break;
case Season.autumn:
print('7-9月');
break;
case Season.winter:
print('10-12月');
break;
}
}
enum Season{
spring,
summer,
autumn,
winter
}
（1）index从0开始，依次累加
（2）不能指定原始值
（3）不能添加方法
24.泛型
dart中类型是可选的，可使用泛型限定类型
void main(){
var list = new List<int>();
list.add(1);
print(list);
}
类的泛型
void main(){
var utilsInt = new Units<int>();
utilsInt.put(1);
var utilsStr = new Units<String>();
utilsStr.put('amy');
}
class Units<T>{
T element;
void put(T element){
this.element = element;
}
}
方法的泛型
void main(){
var units = new Units();
units.put<int>(2);
}
class Units{
void put<T>(T element){
print(element);
}
}
