Flutter学习（三：方法、异常、类）

最新推荐文章于 2023-06-24 07:00:00 发布
最新推荐文章于 2023-06-24 07:00:00 发布
阅读量1.6k 收藏
点赞数
分类专栏： Flutter学习 文章标签： flutter
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/t576163422/article/details/103204035
版权

一：方法

Dart语言中定义方法的时候，如果不定义参数类型，可以传入任何类型。并且Dart中不支持方法重载。
例如：三种定义方法的方式

int fun(int i, int j) {
  return i + j;
}
//也可以不写参数类型，即为Object类型参数
fun( i, j) {
  return i + j;
}
//对于只有一个表达式的方法，可以选择使用简写语法来定义：
//在方法体后加入 =>表达式;（只能使用一个表达式）
fun(i, j) => i + j;

匿名方法

有返回值匿名方法
//调用fun方法,传入一个方法
String str = fun((String str) {
 //执行anonymityMethod方法,返回数据
  return str;
});

String fun(String anonymityMethod(String str)) {
  //调用anonymityMethod方法
  return anonymityMethod("调用匿名方法");
}
无返回值匿名方法
fun((String str) {
  print(str);
});
String fun(void anonymityMethod(String str)) {
  anonymityMethod("调用匿名方法");
}

一等方法对象

Dart语言是一门面向对象的语言，方法也是对象，类型为Function。

Function对象代码方法
void fun(String str1, String str2) {
 print("fun方法-------" + str1 + str2);
}
//方法也是对象，类型是Function
Function f = fun;//fun方法是Function类型对象
f("参数1", "参数2");//调用fun方法

在Dart中的方法也是对象，类型是属于Function类型的。那么如果方法的参数为方法呢？那该如何表示？

/**
 * fun1方法参数为Function类型，那么该如何调用fun1方法呢？
 */
void fun1(Function f) {
  f("参数");//❌运行报错，调用fun1时传入的匿名方法有两个参数，所以会参数异常
  f(1, "参数");//Function无法表示传递而来的这个方法参数有几个，所以无法编译时检查
}

Function f1 = fun1;
f1();//❌报错，参数fun1需要一个Function类型参数，所以参数异常
//调用fun1方法，传入一个匿名方法，有点像lamda表达式
f1((int i, String s) {
   return bool;        
});

在调用参数类型为Function的方法时，可以传入匿名方法，这样使用起来比较麻烦。而且Function无法表示方法的参数和返回值，所以编译时检查不出来，运行时才报错。这样使用起来不是很方便，那该如何解决这个问题呢？

typedef关键字
/**
 * typedef关键字：
 * 定义"DEF"方法类型，此时"DEF"其实就是一个含有int、String参数和String返回值的方法类
 * 型，DEF就可以表示方法的参数和返回值。如此就有了编译时检查。
 */
typedef String DEF(int i, String s);
String fun2(DEF def) {//如此就有编译时检查了
  return def(1, "参数");
}
//fun3方法表示的含义与fun2一致，只是fun2使用了typedef关键字，更加简洁
String fun3(String method(int i, String s)) {
  return method(1, "参数");
}
使用场景

在点击事件、接口回调等场景中使用

//定义click方法类型；
typedef void onClick();
class Button {
  //对外暴露设置点击事件方法，把点击后需要执行的方法传递进来
  void setOnClickListener(onClick onClickMethod) {
    onClickMethod();//调用方法
  }
}

默认值参数

可以在方法体中初始化参数默认值。如果该方法没有被传入值为null，则使用默认值

/**
 * 默认值参数，可以设置参数的默认值
 */
void fun({int i = 1, String str = "我是默认值"}) {
}
void fun([int i = 1, String str = "我是默认值"]) {
}

可选位置参数

使用“[]”包裹方法体。如果方法有多个参数，想给某个参数传值，那么该参数前的参数都要传值。只能按照顺序传值。

//调用fun方法
fun(1);
fun(1, "传递一个参数");
/**
 * 可选位置参数
 * 如果想给String str传值，那int i就必须传值
 */
void fun([int i, String str]) {
}

可选命名参数

使用“{}”包裹方法体，可以根据参数名称进行传值。调用方法时，使用“:”进行分割参数名称和传入参数，以键值对方式传入参数。

//调用fun方法，给参数名为“str”的参数赋值
fun(str:"可选位置参数");
fun(i:3);
/**
 * 可选命名参数，使用参数名称给参数赋值
 */
void fun({int i, String str}) {
}
使用场景：可以不需要像Java一样，写很多重载方法，并有默认值。

二：异常

抛出异常

Dart 异常是非检查异常。 方法无需声明了他们所抛出的异常， 调用方法时也不要求你捕获任何异常。
Dart中提供了 Exception和Error类型， 以及一些子类型。你还可以定义自己的异常类型。
Dart中可以抛出任何非null对象为异常，不仅仅是实现了 Exception 或者Error 的对象。

/**
 * 抛出异常 
 */
String test() {
  //抛出Exception
  throw new Exception("抛出Exception");
  //抛出自定义对象
  throw new MyClass();
  //抛出String
  throw "抛出String";
  //抛出int
  throw 100;
  //抛出方法
  throw testMethod();
}

捕捉异常

Dart中捕获异常同样是使用catch语句，catch()方法可以带有一个或两个参数，第一个参数为抛出的异常对象， 第二个为堆栈信息 ( StackTrace 对象)。

on关键字：Dart中的catch无法指定异常类型，需要结合on来使用。
rethrow关键字：可以把捕获的异常给重新抛出
/**
 * catch不同类型的异常
 * catch的参数：exc、exd
 * 此时catch的参数无需设置类型，参数数量也可以是1个或者2个
 */
void main() {
  try {
    test();
  } catch(exc, exd) {//catch所有类型 异常
    print(exc);//抛出的异常对象
    print(exd);//StackTrace 调用栈信息
  } on Exception catch(exc, exd) {//catch指定类型 Exception
  } on String catch(exc) {//catch指定类型 String
  } on Function catch(exc) {//catch指定类型 方法
	rethrow;//捕获的异常重新抛出
  }
}

三：类

Dart的命名规范

源文件:lowercase_with_underscores 风格来命名库和文件名。例如：my_dart_file
类名:UpperCamelCase风格来命名类名。例如：MyClass
方法名:lowerCamelCase。例如：myCustomMethod
变量、常量:lowerCamelCase。例如：myCompanyName

Dart的中的访问修饰符_

Dart中只有两种访问范围，使用下划线开头是私有属性，相当于private，Dart中只有public或private。

修饰类：_类名；
修饰方法：_方法名；
修饰变量：_变量名；

举个栗子

//公共范围（public）
public String str;//Java中
String str;//Dart中
//私有范围（private）
private String str;//Java中
String _str;//Dart中

构造方法、可选参数构造方法、命名构造方法

Dart中简化了构造方法。并且由于Dart中不支持方法重载。所以构造方法也不可以重载，由此产生了命名构造方法；

class Person {
  String name;
  String _age;
  //构造方法
  Person(this.name, this._age);
  //可选参数构造方法
  Person({String name, String age}) {
     this.name = name;
     this._age = age;
  }
  //命名构造方法，相对于可选参数构造方法，表明的含义更加清晰
  Person.name(this.name);
  Person._age(this._age);
}

参数初始化列表

​ 在构造方法的方法体执行之前会先执行初始化列表

/**
 * 在构造方法的参数体之后，方法体之前，使用冒号分割。给本类变量赋值。
 */
Person.initFromBean(Person person):name = person.name, _age = person._age;
Person.initName(String name): name = name; 
Person.initAge(int age):_age = age {}

重定向构造方法

重定向构造方法是没有方法体的，在构造方法的参数体后，使用冒号调用其他构造方法。
使用场景：例如自定义View中，构造方法自己调用自己。

//调用
View view = View.context(10);
class View {
  int context;
  int attr;
  int style;
  //重定向调用，命名构造方法View.attr
  View.context(int context):this.attr(context, 666);
  //重定向调用，构造方法View
  View.attr(int context, int attr):this(context, attr, 234);
  //构造方法
  View(this.context, this.attr, this.style);
}

常量构造方法

使用const关键字修饰构造方法，并且所有全局变量声明为final。
使用const关键字来创建对象，当你创建时传入的参数一样，无论你创建几个对象，它们其实都是同一个对象。

class Demo {
  final int width;
  final int height;
  /**
   * 常量构造方法
   */
  const Demo(this.width, this.height);
}
void main() {
  //使用new来创建，常量构造方法的对象和普通对象没有区别
  Demo demo1 = new Demo(1, 1);
  Demo demo2 = new Demo(1, 1);
  print(demo1 == demo2);//false
  print(demo1.hashCode == demo2.hashCode);//false
  /**
   * 使用const来创建对象，传递的参数一样，对象必须有常量构造方法
   * 代表它们是同一个编译期常量对象。
   */
  Demo demo3 = const Demo(1, 1);
  Demo demo4 = const Demo(1, 1);
  print(demo3 == demo4);//true
  print(demo3.hashCode == demo4.hashCode);//true
}

工厂构造方法

使用factory关键词修饰的构造方法时，这个构造方法必须返回，类的实例或者子类的实例。但是可以不创建新的实例。
例如：工厂构造函数可能从缓存中获取一个实例并返回，或者返回一个子类型的实例。（工厂构造函数无法访问 this）

/**
 * static和factory修饰构造方法产生的效果差不多。
 * 但是他们的本质是不一样的，factory修饰属于构造方法，必须返回类或子类的实例对象，
 * 而static修饰则是方法，如果不指明返回值是可以不返回实例对象的。
 */
class Parent {
  //构造方法
  Parent();
  /**
   * 工厂构造方法
   * 使用factory关键字修饰一个命名构造方法
   * 返回一个子类实例
   */
  factory Parent.getChild() {
    return new Child();
  }
  /**
   * 静态方法
   * 返回一个子类实例
   */
  static Child getChild1() {
    return new Child();
  }
}
工厂构造方法写单例
//调用
SingleInstance instance = SingleInstance.getInstance();
/**
 * Dart单例
 */
class SingleInstance{
  static SingleInstance _instance;
  /**
   * 命名构造方法 + 私有化
   */
  SingleInstance._newInstance();
  /**
   * 工厂构造方法 + 命名构造放，返回对象单例
   */
  factory SingleInstance.getInstance() {
    if(_instance == null) {
      //调用 私有命名构造方法 创建对象
      _instance = new SingleInstance._newInstance();
    }
    //返回单例实例
    return _instance;
  }
  String getString() {
    return "我是返回值";
  }
}

get、set方法

实例对象的非私有属性变量(非final、非私有)，都会有一个隐式的get\set方法，无需写get\set方法。

View view = new View();
view.height = 1000;//set赋值
int height = view.height;//get获取

class View {
  //实例对象的非私有属性变量,会有一个隐式的get\set方法,无需写get\set方法
  int place;
  int _width;
  int _height;

  int get width => _width;
  set width(int value) {
    _width = value;
  }
  int get height => _height;
  set height(int value) => _height = value;
}

运算符重载

使用operator关键字，可以把已有操作符进行重新定义，可重载的运算符有：
在这里插入图片描述

/**
 * 使用重新定义的>操作符，来比较view1和view2两个对象，传入的参数面积大小。返回bool类型
 */
bool b = view1 > view2;

class View {
  int _width;
  int _height;
  
  int get width => _width;
  set width(int value) {
    _width = value;
  }
  int get height => _height;
  set height(int value) => _height = value;
  //重新定义 >操作符，比较两个View的面积
  bool operator>(View otherView) {
    bool b =  height * width > otherView.height * otherView.width;
    return b;
  }
}

抽象类

使用 abstract 修饰符定义一个抽象类。抽象类中允许出现无方法体的方法

/**
 * abstract 声明抽象类
 */
abstract class Person{
  String name;
  void play();//抽象方法，不需要在方法前声明abstract，可以没有方法体
  void sleep() {}//也可以有正常的方法
  Person(this.name);//父类构造方法
}
//extends 继承抽象类
class Child1 extends Person {
  Child1(String name) : super(name);//子类构造
  @override
  void play() {//实现抽象方法
  }
}
class Child2 extends Person {
  Child2(String name) : super(name);//子类构造
  @override
  void play() {//实现抽象方法
  }
  @override
  void sleep() {//重写父类方法
    super.sleep();//使用super调用父类sleep方法
  }
}

接口

Dart中没有interface关键字。在Dart的类中，都隐式的定义了一个包含所有实例成员的接口。
使用implements关键字，可以实现这个类的所有实例成员。不能实现抽象类
（Dart中的类，即可以是类，也可以是接口。分不清了🤣🤣🤣🤣）

class Listener{
  static String name;
  String _age;

  static Function onLongClick() {//静态方法
  }
  void onClick(){//普通方法
  }
}
/**
 * 使用implements实现接口
 */
class MyInterface implements Listener {
  @override
  void onClick() {//实现普通方法
  }
  @override
  String _age;
}

接口与继承的区别

1、单继承，多实现。
2、继承可以有选择的重写父类方法并且可以使用super，实现强制重新定义接口所有成员。

可调用的类

如果Dart 类实现了call()方法，在对象实例后加括号，可以直接调用到call()方法。如果没有实现call方法则会报错。

CallDemo myCall = new CallDemo();
String str = myCall("我是字符串");//myCall对象后加括号，调用call方法；

class CallDemo {
  String str;
  String call(String str) {
    this.str = str;
    return this.str;
  }
}

混合mixins

Mixins 是一种在多类继承中，重用一个类代码的方法。
使用with关键字，后面跟着需要混入的类。要注意的是，被混入的类不能有构造方法。
混入与继承是兼容的，可以同时使用extends和with关键字。同时也可以使用super关键字，来调用被混入的方法和继承的方法。
混入方法时，如果存在重复的方法。
1、优先调用自身的方法
2、如果自身没有对应方法，就从with最右边开始查找。

C c = new C();
c.a();//c类中混入了A类，所以可以调用a方法
c.b();//c类中混入了B类，所以可以调用b方法
c.c();//调用自身的c方法
class A {
  void a() {//被混入的方法a
    print("a~~~~~~~");
  }
}
class B {
  void b() {//被混入的方法b
    print("b~~~~~~~");
  }
}
abstract class D {//抽象方法
  void d() {
  }
  //void e();//也可以混入抽象方法，这里为了记录super关键字，就不演示了
}
/**
 * 继承D类
 * 混入B、A类
 */
class C extends D with B, A{
  @override
  void d() {//重写父类D的d方法
    super.d();//调用父类D的d方法
  }
  void c() {
    super.a();//调用被混入的方法a
    print("c~~~~~~~");
  }
}

总结：
mixins弥补了接口和继承的不足，继承只能单继承，而接口无法复用实现，mixins却可以多混入并且能利用到混入类的具体实现。

多喝水少吃肉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Flutter学习笔记11：Dart异常
haoyuegongzi的博客
06-06 672
异常表示一些未知的错误情况。 如果异常没有被捕获， 则异常会抛出， 导致抛出异常的代码终止执行。 Dart 代码可以抛出和捕获异常。 和 Java 有所不同， Dart 中的所有异常是非检查异常。 方法不会声明它们抛出的异常， 也不要求捕获任何异常。 Dart 提供了 Exception 和 Error 类型， 以及一些子类型。 当然也可以定义自己的异常类型。 但是，此外 Dart 程序可以抛出任何非 null 对象， 不仅限 Exception 和 Error 对象。 高质量的生产环境代码通常会实现 Er
Flutter | 异常处理
345丶
01-20 773
本文示例代码 在了解 Flutter 异常捕获之前需要先了解一下 Dart 的异常处理以及 Dart 的单线程模型，只有知道了代码的执行流程，我们才能只要该在什么地方去捕获异常 Dart 中的异常 Dart 可以抛出和捕获异常，如果没有被捕获，则会抛出，最终导致程序终止运行 和 Java 不同，Dart 中的所有异常时非检查异常，方法不会声明它们抛出的异常，也不要求捕获任何异常 Dart 提供了 Exception 和 Error 类型，以及一些子类型。也可以自定义异常类型。此外，Dart 程序可以抛出任.
Flutter之异常处理
可可的博客
03-23 3196
Flutter之异常处理 一、前言： flutter的异常处理与java非常相似。与java不同的是Dart不检测是否是声明的，也就是说方法或者函数不需要声明要抛出哪些异常 二、抛出异常的三种方式 void textException(){ throw Exception("方式一"); } //不建议 void textException(){ throw ("方式二"); } void textException()=>throw ("方式三"); 三、异常捕获格式 try{ //逻辑代码块
Flutter 常见异常分析
Gaga246的博客
04-17 889
Flutter 官方 bug （已经修复）StateError以上四种异常是我们在编写代码初期经常遇到的问题，通过对以上四种异常的分析，我们可以得到一些经验总结，在后续的开发中，我们可以根据这些总结，进行改进，以便更好的解决问题。需要更多Flutter学习资料，或者与 Android相关的资料都可以扫码免费领取！Flutter技术解析与实战》目录第一章 混合工程​ ● Flutter工程体系​ ● 混合工程改造实战。
Flutter Dart函数(方法)异常
最新发布
帅次的博客
06-24 775
Dart 是一个真正的面向对象语言，方法也是对象并且具有一种 类型 Function。 这意味着，方法可以赋值给变量，也可以当做其他方法的参数。
flutter学习四：使用自定义字体
01-08
对比图如下：左图是默认的，右图是自定义的（具体是什么字体我也不清楚，百度随便下载.ttf文件的） ...三.使用 import 'package:flutter/cupertino.dart'; import 'package:flutter/material.dart'; class HomeScreen
flutter_bugly：腾讯Bugly flutter应用更新统计及异常上报插件，支持Android，iOS
02-19
支持Android / iOS运营统计，原生异常上报，flutter异常上报，应用更新 一，约会 //因为大部分主流插件都已升级androidx，所以pub库升级androidx //版本更新弹窗问题见下面说明 //androidx dependencies : flutter...
flutter_picker:Flutter Picker插件
05-11
flutter_picker Flutter插件选择器。 包括NumberPicker，DateTimePicker，ArrayPicker和默认链接选择器。 提供灵活的参数以满足各种需求。 同时，您可以通过自定义适配器扩展更多功能。 支持平台 安卓 的iOS 如何...
Flutter学习笔记：有状态组件和组件间通信
01-08
Flutter有状态组件的定义方法 Flutter子组件和父组件之间的通信过程 动态组件生成的方法 关于定义回调函数类型上碰到的写法问题 实现效果： 1. Flutter有状态组件的定义 创建一个类(有状态组件)，该类用于继承...
flutter_study:个人flutter学习
03-29
flutter_study个人flutter学习
flutter-Dart学习之方法
gary101818的博客
07-27 184
目录一、方法的定义变量和作用域二、方法传参，默认参数、可选参数、命名参数 一、方法的定义变量和作用域 内置方法： 如，print()； 自定义方法定义的格式 返回类型 方法名称（参数1，参数2,…）{ 方法体 return 返回值; } 注意：当该方法没有返回值时，可以不写 newFriend(String friend,int age){ //无返回值 print("i have a friend his name is $friend and he is $age"); } 二、方法传参，默认
Flutter 之 Dart 基础 ----- 函数
Tracy1024的博客
05-19 356
前言 上一篇我们了解到Dart的变量声明方式和区别以及一些常见操作，也都比较的基础。我们今天再来讲一讲。 在Dart语言中，函数（方法）相当于一个对象。定义函数的方法，也跟Java非常类似， 不过也有一些区别。比如返回类型跟参数类型可以省略，不过我自己还是比较建议显示去指定类型。毕竟 代码可读性和调试会方便点。看一下代码，两个函数的效果是一样的。 main() { String s1 = printStr("李雷"); print('s1:'+s1); } String printStr
Flutter系列之Dart函数、类与运算符
l1624085379的专栏
08-19 740
编程语言虽然千差万别，但归根结底，设计思想无非是表示信息与处理信息 在Flutter系列之Dart语言概述中已经介绍了Dart如何表示信息，本篇将介绍Dart是如何处理信息的 作为一门真正面向对象的编程语言，Dart将处理信息的过程抽象为了对象，而函数、类与运算符则是抽象中最重要的手段 函数 函数是一段用来独立完成某个功能的代码片段，而Dart中所有类型都是对象类型，函数也不例外，即函数也是对象，...
【Flutter 1-11】Flutter手把手教程Dart语言——类、类的的成员变量和方法、类的构造函数
弗拉德的技术博客
12-04 1009
作者 | 弗拉德 来源 | 弗拉德（公众号：fulade_me) 类 Dart是一种面向对象的语言，所有对象都是一个类的实例，而所有的类都继承自Object类。每个除了Object类之外的类都只有一个超类，一个类的代码可以在其它多个类继承中重复使用。 类的实例变量 下面是声明实例变量的示例： class Point { double x; // 声明 double 变量 x 并初始化为 null。 double y; // 声明 double 变量 y 并初始化为 null double z =
Flutter - 类与方法的调用
solitary__的博客
05-15 4275
Flutter中所有的State是由 祖先 -> 父 -> 子 传递，一般不支持反向传递。 第一种：普通调用 所有方法都写在父组件中，正常调用 第二种：VoidCallback 在子类中使用VoidCallback定义一个方法，在父组件中直接使用父组件中的方法 例： void main() { runApp(App()); } class App extends StatelessWidget { @override Widget build(BuildContext contex
Flutter入门——必知必会之Dart基础语法之类、继承、方法、泛型、库小结（二）
最美不过，心中有梦，身旁有你！
01-07 1304
Dart中内置数据类型、类型转换、变量定义、控制语句、操作符的基本语法，这一篇接着小结方法、类、继承、泛型、库的相关知识。
【Flutter】Dart的类方法和对象操作符
俊而不逊的博客
10-22 789
1. 写在前面 在上篇文章中介绍了Dart中的工厂构造&单例对象&初始化列表，那么现在就继续来学习 Dart的类方法和对象操作符。 【Flutter】苹果Mac电脑配置flutter开发环境 【Flutter】 Android Studio 安装第三方模拟器—网易MuMu 【Flutter】项目运行报错Failed to find Build Tools revision 29.0.2 【Flutter】flutter doctor 报错Android license status unk
Flutter学习-dart(10): 操作符重载(与c++极为相似)
csr_warrior的博客
11-30 2077
1. 什么是运算符重载 运算符重载（英语：operator overloading）是多态的一种; 运算符重载通常只是一种语法糖，这种语法对语言的功能没有影响，但是更方便程序员使用。让程序更加简洁，有更高的可读性 2. 使用场景 当比较两个对象的大小时 假设此时有两个商品, 需要比较大小, 规则是按照价格进行比较;当不使用操作符重载时, 写出的代码可能是这样: if(good1.price < p2.price) { //小于 } 有了操作符重载之后: bool opera
Flutter入门——必知必会之Dart基础语法之重载操作符、消息循环和异步小结（三）
最美不过，心中有梦，身旁有你！
02-07 767
Dart基础语法之重载操作符、消息循环和异步小结
flutter boxShadow:
05-24
boxShadow 是Flutter中的一个属性，用于在容器周围创建阴影效果。它需要一个List类型的值，其中每个BoxShadow对象代表一个阴影。 例如，下面的代码将为一个具有深灰色背景的Container创建一个阴影效果： ```dart ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值