Dart学习——函数、类

x33g5p2x  于2022-06-27 转载在 其他  
字(5.5k)|赞(0)|评价(0)|浏览(546)

Dart

实现打印HelloWorld

  1. main(){
  2. print('HelloWrold');
  3. }

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

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

以上是简化版的main函数

完整版的main函数

  1. 函数的返回值类型 函数的名称(参数列表){
  2. 函数体
  3. }
  4. void main(List<String> args){
  5. print('Hello Flutter');
  6. print(args);
  7. }

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

Dart中变量的声明

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

  1. 明确的声明(指定类型)
    通过runtimeType属性获取数据类型
  1. // Dart是强类型的语言;变量有自己的类型
  2. void main(List<String> args) {
  3. String name = 'Mike';
  4. int age = 18;
  5. double height = 1.88;
  6. print("$name $age $height");
  7. //打印数据的类型
  8. print(name.runtimeType);
  9. //Mike 18 1.88
  10. //String
  11. }
  1. 类型推导
  1. void main(List<String> args) {
  2. var name = 'Mike';
  3. const message = 'HelloFlutter';//const定义常量,必须在定义时赋值
  4. final message //final定义常量,可以在运行时赋值
  5. //打印数据的类型
  6. print(name.runtimeType);
  7. //如果想修改数据类型,使用dynamic(动态的)
  8. //String
  9. }

Dart数据类型

1 数字类型 int double

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

字符串和数字之间的转化

  1. //字符串 -> 数字
  2. var one = int.parse('111');
  3. var two = double.pare('12.22');
  4. //数字 -> 字符串
  5. var num1 = 11;
  6. var num2 = 12.333;
  7. var num1Str = num1.toString();
  8. var num2Str = num2.toString();
  9. var num2StrD = num2.toStringAsFixed(2);//保留两位小数

2、布尔类型Boolen

注意:Dart中不能判断非0即真,或者非空即真

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

  1. //错误
  2. if(message){
  3. }

3 字符串类型

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

  1. void main(List<String> args) {
  2. var message1 = 'hello';
  3. var message2 = "hello";
  4. var message3 = '"
  5. hello
  6. "';//三引号可以换行
  7. }

字符串的拼接

  1. final name = 'why';
  2. final age = 18;
  3. print("name:$name age:$age")

4 集合类型

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

其中,List可以这样来定义:

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

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

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

Set用处之一就是去重

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

函数的参数

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

  1. 返回值类型 函数名称(参数列表){
  2. 执行代码
  3. }

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

必传参数

  1. void printInfo(String name){
  2. print(name);
  3. }

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

可选参数

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

位置可选参数

用[ ]将参数包括起来

  1. int sum(int num1, int num2, [dynamic num3]){
  2. print(num3);
  3. return num1 + num2;
  4. }

以上num3就是可选位置参数

命名可选参数

用{ }将参数包括起来

  1. int sum(int num1, int num2, {dynamic num3}){
  2. print(num3);
  3. return num1 + num2;
  4. }
  5. sum(num3: 50 , 10 ,20)

函数第一公民

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

  1. void foo(){
  2. print('name');
  3. }
  4. void fun(Function func){
  5. func();
  6. }
  7. void main(List<String> args) {
  8. fun(foo);
  9. }
  10. //name

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

  1. void foo(){
  2. print('name');
  3. }
  4. Function fun(Function func){
  5. return func;
  6. }
  7. void main(List<String> args) {
  8. Function bar = fun(foo);
  9. bar();
  10. }
  11. //name

运算符

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

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

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

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

  1. void main(List<String> args) {
  2. dynamic num = 'haha';
  3. dynamic message = 'xixi';
  4. num = message ?? 'hehe';
  5. print(num); // xixi
  6. }

  1. //定义类
  2. class Person{
  3. String? name;
  4. int? age;
  5. void getname(){
  6. print("它的名字是$name");
  7. }
  8. }
  9. void main(List<String> args) {
  10. final p = Person();
  11. p.name = 'haha';
  12. print(p.name);
  13. }

构造函数

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

  1. class Person{
  2. String? name;
  3. int? age;
  4. Person(String name , int age){
  5. this.name = name;
  6. this.age = age;
  7. }
  8. void getname(){
  9. print("它的名字是$name");
  10. }
  11. }
  12. void main(List<String> args) {
  13. final p =Person('张三',18);
  14. print(p.name);
  15. }

语法糖的写法:

  1. class Person{
  2. String? name;
  3. int? age;
  4. Person(this.name,this.age);
  5. void getname(){
  6. print("它的名字是$name");
  7. }
  8. }
  9. void main(List<String> args) {
  10. final p =Person('张三',18);
  11. print(p.name);
  12. }

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

  1. Person.formMap(Map<String,dynamic> map){
  2. this.name = map['name'];
  3. this.age = map[age];
  4. }
  1. class Person{
  2. String? name;
  3. int? age;
  4. Person(this.name,this.age);
  5. Person.formMap(Map<String,dynamic> map){
  6. this.name = map['name'];
  7. this.age = map[age];
  8. }
  9. void getname(){
  10. print("它的名字是$name");
  11. }
  12. }
  13. void main(List<String> args) {
  14. final p = Person('张三',18);
  15. print(p.name);
  16. Map<String,dynamic> p1 = {
  17. 'name':'李四',
  18. 'age': 18
  19. };
  20. final p2 = Person.formMap(p1);
  21. print('${p2.name}');
  22. }

类的继承

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

  1. class Animal{
  2. int? age;
  3. Animal(this.age);
  4. void eating(){
  5. print('再吃东西');
  6. }
  7. }
  8. class Person extends Animal{
  9. String? name;
  10. Person(this.name,int age):super(age);
  11. }
  12. void main(List<String> args) {
  13. final p = Person('张三',18);
  14. p.eating();
  15. }

抽象类

继承是多态使用的前提。

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

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

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

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

  1. //抽象类
  2. abstract class Shape{
  3. getArea();//抽象方法
  4. }
  5. class Circular extends Shape{
  6. dynamic r;
  7. Circular(this.r);
  8. @override
  9. double getArea(){
  10. return r * r * 3.14;
  11. }
  12. }
  13. class rectangle extends Shape{
  14. dynamic width;
  15. dynamic height;
  16. rectangle(this.width,this.height);
  17. @override
  18. dynamic getArea(){
  19. return width * height;
  20. }
  21. }
  22. void calcuAra(Shape s){
  23. print(s.getArea());
  24. }
  25. void main(List<String> args) {
  26. Circular c = Circular(5);
  27. calcuAra(c);
  28. rectangle r = rectangle(30, 20);
  29. calcuAra(r);
  30. }

mixin

  1. mixin Running{
  2. void running(){
  3. print('奔跑');
  4. }
  5. }
  6. mixin Swimer{
  7. void swimming(){
  8. print('游泳');
  9. }
  10. }
  11. class Person with Running,Swimer{
  12. }
  13. void main(List<String> args) {
  14. Person p = Person();
  15. p.swimming();
  16. }

泛型

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

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

List使用时的泛型写法:

  1. //创建List的方式
  2. var names1 = ['why','kobe','james'];
  3. print(names1.runtimeType);//List<Object>
  4. //限制类型
  5. var names2 = <String>['why','kobe','james',111];//最后一个报错
  6. List<String> names3 = ['why','kobe','james',111];//最后一个报错

Map使用时的泛型写法:

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

Location类的定义:泛型方式

  1. class Location<T>{
  2. T x;
  3. T y;
  4. }

相关文章