Dart学习——函数、类

Dart

实现打印HelloWorld

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

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

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

以上是简化版的main函数

完整版的main函数

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

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

在命令行输入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
}

2. 类型推导

void main(List<String> args) {
    

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

Dart数据类型

1 数字类型 int double

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

字符串和数字之间的转化

//字符串 -> 数字
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);//保留两位小数

2、布尔类型Boolen

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

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

//错误
if(message){
    

}

3 字符串类型

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

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

字符串的拼接

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

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>

其中，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>

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>

}

函数的参数

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

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

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

必传参数

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

其中 name为必传参数，如果少传参数，就会报错。

可选参数

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

位置可选参数

用[ ]将参数包括起来

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

以上num3就是可选位置参数

命名可选参数

用{ }将参数包括起来

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

sum(num3: 50 , 10 ,20)

函数第一公民

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

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

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


//name

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

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

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


//name

运算符

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

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

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

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

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

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

类

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

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

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

}

构造函数

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

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

}

语法糖的写法:

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

}

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

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

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

类的继承

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

抽象类

继承是多态使用的前提。

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

什么是抽象方法？在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);
}

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

泛型

泛型：就是一种不确定的数据类型。
比如：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];//最后一个报错

Map使用时的泛型写法：

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

Location类的定义：泛型方式

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