美文网首页flutter探索
dart 数据类型

dart 数据类型

作者: Amy_yqh | 来源:发表于2019-06-17 21:53 被阅读0次

    一、变量和常量

    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);
  }
}

    相关文章

      网友评论

        本文标题：dart 数据类型

        本文链接：https://www.haomeiwen.com/subject/fodqfctx.html

        延伸阅读

        深度阅读

        • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

        栏目导航

        热点阅读

        flutter探索

        关于我们|服务条款|联系我们|dart 数据类型|投稿指南|网站地图|RSS订阅|排版工具|手机版

        提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

        Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

        备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

        本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

        所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！