• Dart学习——函数、类

    Dart

    实现打印HelloWorld

    main(){
 print('HelloWrold');
}

    • 1
    • 2
    • 3

    在命令行输入dart 文件名.dart即可运行dart文件

    1. dart的入口是main函数
    2. 在dart中打印内容使用print

    以上是简化版的main函数

    完整版的main函数

    函数的返回值类型 函数的名称(参数列表){
  函数体
}

void main(List<String> args){
  print('Hello Flutter');
  print(args);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    在命令行输入dart 文件名.dart 参数即可将参数传入main函数

    Dart中变量的声明

    Dart通过var / const / final / dynamic 定义变量

    1. 明确的声明（指定类型）
      通过runtimeType属性获取数据类型
    // Dart是强类型的语言；变量有自己的类型

void main(List<String> args) {

  String name = 'Mike';
  int age = 18;
  double height = 1.88;
  print("$name $age $height");
  //打印数据的类型
  print(name.runtimeType);

//Mike 18 1.88
//String
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    1. 类型推导
    void main(List<String> args) {

  var name = 'Mike';
  const message = 'HelloFlutter';//const定义常量，必须在定义时赋值
  final message //final定义常量，可以在运行时赋值
  //打印数据的类型
print(name.runtimeType);
 //如果想修改数据类型，使用dynamic（动态的）
 
//String
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    Dart数据类型

    1 数字类型 int double

    //1、整数类型int
int age = 18;
int hetAge = 0x12;

    • 1
    • 2
    • 3

    字符串和数字之间的转化

    //字符串 -> 数字
var one = int.parse('111');
var two = double.pare('12.22');

//数字 -> 字符串

var num1 = 11;
var num2 = 12.333;
var num1Str = num1.toString();
var num2Str = num2.toString();
var num2StrD = num2.toStringAsFixed(2);//保留两位小数

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    2、布尔类型Boolen

    注意：Dart中不能判断非0即真，或者非空即真

    即不能使用if(非布尔类型)之类的代码

    //错误
if(message){

}

    • 1
    • 2
    • 3
    • 4

    3 字符串类型

    字符串定义方式。单、双、三引号都可以

    void main(List<String> args) {
  var message1 = 'hello';
  var message2 = "hello";
  var message3 = '"
  hello
	"';//三引号可以换行
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    字符串的拼接

    final name = 'why';
final age = 18;
print("name:$name age:$age")

    • 1
    • 2
    • 3

    4 集合类型

    Dart内置了三种集合类型：List / Set / Map

    其中，List可以这样来定义：

    void main(List<String> args){
	var letters = ['a','b','c','d'];
	// List<String> names = ["a","b"];
	print('$letters ${letters.runtimeType}')
}

//[a, b, c, d] List<String>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    其中，set可以这样定义：
    其实就是把[ ]换成{ }就好了。

    • Set和List 最大的两个不同就是：Set是无序的，并且元素是不重复的
    void main(List<String> args){
	Set<int> nums = {101,111,121,101};
	print('$nums ${nums.runtimeType}');
}

//{101, 111, 121} _CompactLinkedHashSet<int>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    Set用处之一就是去重

    void main(List<String> args){
	List<int> nums = [101,111,121,101];
	List<int> nums1 = List.from(Set.from(nums));
	print('$nums1 ${nums1.runtimeType}');


//[101, 111, 121] List<int>

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    函数的参数

    由上面可知函数的定义方式为

    返回值类型 函数名称（参数列表）{
  执行代码
}

    • 1
    • 2
    • 3

    Dart中函数的参数分为两种，必传参数、可选参数

    必传参数

    void printInfo(String name){
	print(name);
}

    • 1
    • 2
    • 3

    其中 name为必传参数，如果少传参数，就会报错。
    在这里插入图片描述

    可选参数

    可选参数分为两种：可选位置参数、可选命名参数

    位置可选参数

    用[ ]将参数包括起来

    int sum(int num1, int num2, [dynamic num3]){
  print(num3);
  return num1 + num2;
}

    • 1
    • 2
    • 3
    • 4

    以上num3就是可选位置参数

    命名可选参数

    用{ }将参数包括起来

    int sum(int num1, int num2, {dynamic num3}){
  print(num3);
  return num1 + num2;
}

sum(num3: 50 , 10 ,20)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    函数第一公民

    函数可以做参数传给一个函数：

    void foo(){
  print('name');
}

void fun(Function func){
  func();
}
void main(List<String> args) {
  fun(foo);
}


//name

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    函数也可以做为函数的返回值：

    void foo(){
  print('name');
}

Function fun(Function func){
  return func;
}
void main(List<String> args) {
 Function bar = fun(foo);
  bar();
}


//name

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    运算符

    void main(List<String> args) {
 int num = 3;
 print(num / 2);//除法运算 1.5
 print(num ~/2);//整除运算 1 
}

    • 1
    • 2
    • 3
    • 4
    • 5

    ??= 赋值运算
    当被赋值的数值已经有值时，采用原来的值，否则赋值新的值。类似 ||

    void main(List<String> args) {
 var num = 3;
 num ??= 4;
 print(num); //3
}

    • 1
    • 2
    • 3
    • 4
    • 5
    void main(List<String> args) {
 var num = null;
 num ??= 4;
 print(num); //4
}

    • 1
    • 2
    • 3
    • 4
    • 5

    条件运算符
    ??前面的有值，则赋值前面的值，否则赋值后面的值

    void main(List<String> args) {
 dynamic num = 'haha';
 dynamic message = 'xixi';
 num = message ?? 'hehe';
 print(num); // xixi
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    类

    //定义类
class Person{
  String? name;
  int? age;

  void getname(){
    print("它的名字是$name");
  }
}

void main(List<String> args) {
  final p = Person();
  p.name = 'haha';
  print(p.name);

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    构造函数

    每一个类之中都有一个默认的无参构造函数，希望在创建实例的同时，将属性传入类中，就需要自定义一个构造函数

    class Person{
  String? name;
  int? age;

  Person(String name , int age){
    this.name = name;
    this.age = age;
  }
  
  void getname(){
    print("它的名字是$name");
  }
}
void main(List<String> args) {
  final p =Person('张三',18);
  print(p.name);

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    语法糖的写法:

    class Person{
  String? name;
  int? age;

  Person(this.name,this.age);


  void getname(){
    print("它的名字是$name");
  }
}
void main(List<String> args) {
  final p =Person('张三',18);
  print(p.name);

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    如果想通过Map进行实例创建：可以通过 \

    Person.formMap(Map<String,dynamic> map){
    this.name = map['name'];
    this.age = map[age];
  }

    • 1
    • 2
    • 3
    • 4
    class Person{
  String? name;
  int? age;

  Person(this.name,this.age);

  Person.formMap(Map<String,dynamic> map){
    this.name = map['name'];
    this.age = map[age];
  }

  void getname(){
    print("它的名字是$name");
  }
}
void main(List<String> args) {
  final p = Person('张三',18);
  print(p.name);
  Map<String,dynamic> p1 = {
    'name':'李四',
    'age': 18
  };

  final p2 = Person.formMap(p1);

  print('${p2.name}');
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    类的继承

    Dart中使用extend关键字，子类中使用super来访问父类。

    class Animal{
  int? age;

  Animal(this.age);

  void eating(){
    print('再吃东西');
  }
}


class Person extends Animal{
  String? name;

  Person(this.name,int age):super(age);
}
void main(List<String> args) {
  final p = Person('张三',18);
  p.eating();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    抽象类

    继承是多态使用的前提。

    但是，父类本身可能并不需要对某些方法具体的实现，所以父类中定义的方法，我们可以定义为抽象方法。

    什么是抽象方法？在Dart中没有具体实现的方法，就是抽象方法

    • 抽象方法，必须存在与抽象类中
    • 抽象类是使用abstract声明的类

    下面对的代码中，Shape类就是一个抽象类，其中包含一个抽象方法。

    
//抽象类
abstract class Shape{
  getArea();//抽象方法
}

class Circular extends Shape{
  dynamic r;

  Circular(this.r);

  @override
  double getArea(){
    return r * r * 3.14;
  }

}

class rectangle extends Shape{
  dynamic width;
  dynamic height;

  rectangle(this.width,this.height);

  @override
  dynamic getArea(){
    return width * height;
  }

}

void calcuAra(Shape s){
  print(s.getArea());
}

void main(List<String> args) {
 Circular c = Circular(5);
  calcuAra(c);
  rectangle r = rectangle(30, 20);
  calcuAra(r);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    mixin

    mixin Running{
  void running(){
    print('奔跑');
  }
}

mixin Swimer{
  void swimming(){
    print('游泳');
  }
}

class Person with Running,Swimer{

}

void main(List<String> args) {
  Person p = Person();
  p.swimming();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    泛型

    泛型：就是一种不确定的数据类型。
    比如：List<E>E就是泛型。 这种不确定的数据类型需要在使用这个类的时候才能够确定出来。
    泛型可以省略，如果省略，默认泛型是Object类型。
    泛型的好处：

    1. 省略了强转的代码。
    2. 可以把运行时的问题提前到编译时期。

    List使用时的泛型写法：

    //创建List的方式
var names1 = ['why','kobe','james'];
print(names1.runtimeType);//List<Object>

//限制类型
var names2 = <String>['why','kobe','james',111];//最后一个报错
List<String> names3 = ['why','kobe','james',111];//最后一个报错

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    Map使用时的泛型写法：

    Map<String,dynamic> info2 = {'name':'张三','age':18};
var info3 = <String,dynamic>{'name':'张三','age':18};

    • 1
    • 2

    Location类的定义：泛型方式

    class Location<T>{
  T x;
  T y;
}

    • 1
    • 2
    • 3
    • 4
  • 相关阅读:
    小程序真题合集
    《机械设计基础》题库
    深入理解hbase（三）Hbase中的BucketCache
    推荐系统的下一步？阿里时空聚合GNN，效果吊打LightGCN！
    我的C#基础
    Linux第一个小程序——进度条
    神经网络模型如何使用的,神经网络模型是干嘛的
    Prometheus监控之SNMP Exporter介绍和数据展现
    Rust开发——Vec向量
    在 Wed 中应用 MyBatis（同时使用MVC架构模式，以及ThreadLocal 事务控制）
  • 原文地址：https://blog.csdn.net/xiaotangyu7dong/article/details/125435952