Dart学习——函数、类
Dart
实现打印HelloWorld
main(){
print('HelloWrold');
}在命令行输入dart 文件名.dart即可运行dart文件
- dart的入口是main函数
- 在dart中打印内容使用print
以上是简化版的main函数
完整版的main函数
函数的返回值类型 函数的名称(参数列表){
函数体
}
void main(List<String> args){
print('Hello Flutter');
print(args);
}在命令行输入dart 文件名.dart 参数即可将参数传入main函数
Dart中变量的声明
Dart通过var / const / final / dynamic 定义变量
- 明确的声明（指定类型）
通过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
}- 类型推导
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类型。
泛型的好处：
- 省略了强转的代码。
- 可以把运行时的问题提前到编译时期。
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;
}版权说明 : 本文为转载文章, 版权归原作者所有 版权申明
原文链接 : https://blog.csdn.net/xiaotangyu7dong/article/details/125435952
内容来源于网络，如有侵权，请联系作者删除！