java中dart类详细讲解

超、凢脫俗 2022-10-29 07:51 242阅读 0赞

dart 是一个面向对象的语言;面向对象有

继承  
封装  
多态  
dart的所有东西都是对象，所有的对象都是继承与object类

一个类通常是由属性和方法组成的

在dart中如果你要自定义一个类的话，将这个类放在main函数外面

类名使用大驼峰方法名使用小驼峰

1.定义这个类的属性和方法  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
//定义一个类的属性和方法  
class Person \{  
String name = '张三';  
int age = 19;  
void getInfo() \{  
// print('我叫$name,今年$age');第一种  
//推荐使用这样的写，通过this去访问  
print("$\{this.name\}====$\{this.age\}");  
\}  
\}  
  
//使用类中的属性和方法  
void main() \{  
// 调用Perso这个类 首先需要实例化这个类  
// Person p = new Person(); // 等价 var p=new Person  
var p = new Person();  
print(p.age);  
p.getInfo();  
\}  
2 .改变类中的属性和方法  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
class Person \{  
String name = '张三';  
int age = 19;  
void getInfo() \{  
//推荐使用这样的写法  
print("$\{this.name\}====$\{this.age\}");  
\}  
//限制类型，更改类中的属性和方法  
SetUserinfo(int age) \{  
this.age = age;  
\}  
\}  
  
void main() \{  
// 调用Perso这个类 首先需要实例化这个类  
Person p = new Person(); // 等价 var p=new Person  
print(p.age);//19  
p.getInfo();//张三====19  
p.SetUserinfo(100);  
p.getInfo();//张三====100  
\}  
3.默认构造函数  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
class Person \{  
//这是一个默认构造函数  
Person() \{  
print('默认构造函数里面的内容，该方法在实例化的时候会自动出发哈');  
\}  
\}  
  
void main() \{  
// 实例化的时候，会自动触发默认构造函数  
Person p = new Person(); // 等价 var p=new Person  
\}  
4. 动态传递，类多次实例化，打印不同的值  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
class Person \{  
String name;  
int age;  
Person(String name, int age) \{  
this.name = name;  
this.age = age;  
\}  
void getuserInfo() \{  
print(this.name);  
print(this.age);  
\}  
\}  
  
void main() \{  
// 实例化的时候，会自动触发  
Person p = new Person('张三', 10); // 等价 var p=new Person  
p.getuserInfo();  
  
//这个类可以实例化多次的哈  
Person v = new Person('张三1', 100); // 等价 var p=new Person  
v.getuserInfo();  
\}  
5.默认构造函数简写  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
class Person \{  
String name;  
int age;  
  
// Person(String name, int age) \{  
// this.name = name;  
// this.age = age;  
// \}  
//上面注释的代码等价于 Person(this.name, this.age);  
Person(this.name, this.age);  
void getuserInfo() \{  
print(this.name);  
print(this.age);  
\}  
\}  
6.命名构造函数,命名构造函数是可以写多个的；但是默认构造函数只能写一个  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
class Person \{  
//我是默认的构造函数  
Person() \{  
print('我是默认的构造函数');  
\}  
// 命名构造函数  
Person.mynow() \{  
print('我是命名构造函数');  
\}  
\}  
  
void main() \{  
// 实例化的时候，会默认构造自动触发  
Person p = new Person(); // 等价 var p=new Person  
Person v = new Person.mynow(); // 触发命名构造函数  
\}  
7.类抽离出去，单独放一个文件夹中  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
在项目的根目录创建一个文件夹 lib  
在lib文件夹中创建一个文件 xxx.dart内容如下  
  
class Person \{  
//我是默认的构造函数  
Person() \{  
print('我是默认的构造函数');  
\}  
// 命名构造函数  
Person.mynow() \{  
print('我是命名构造函数');  
\}  
\}  
  
  
在需要的某个文件中引入  
import 'lib/xxx.dart';  
void main() \{  
// 实例化的时候，会默认构造自动触发  
Person p = new Person(); // 等价 var p=new Person  
Person v = new Person.mynow(); // 触发命名构造函数  
\}  
8.dart修饰符  
dart和其他面向对象的语言不一样。没有向public private 这样的访问修饰符

但是我们可以使用\_把一个属性或者方法定义成私有的，(就是在变量或者方法的前面添加\_;并且要单独把他抽离出去变成一个文件 放在lib目录下，这样外面就不能够访问了);

但是个人觉得这种没有实质的意义 如果要访问这个私有的方法，那么在类种添加一个共有的方法；去访问这个私有的方法；访问在return回去； 就可以访问这个私有的方法了 私有方法，只有在当前类中访问哈 在lib目录下的animal.dart文件；

内容如下

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
class Animal \{  
String \_name = 'dog';//这是私有的方法，只当前这个类可以访问；其他类是不能够访问的哈~；  
// 如果非要访问这个类，可以通过共有方法来访问  
  
// 通过公共方法来访问这个类；间接访问  
getName()\{  
print(this.\_name);  
\}  
  
int age = 19;  
void getInfo() \{  
//推荐使用这样的写法  
print("$\{this.\_name\}====$\{this.age\}");  
\}  
  
//限制类型，更改类中的属性和方法  
SetUserinfo(int age) \{  
this.age = age;  
\}  
\}  
9. 计算矩形的面积将他改为get方法  
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  
class Rect \{  
num width;  
num height;  
Rect(this.width, this.height);  
getUserINfo() \{  
return (this.width \* this.height);  
\}  
\}  
  
void main() \{  
// 实例化的时候，会默认构造自动触发  
Rect p = new Rect(10, 4); // 等价 var p=new Person  
print(p.getUserINfo());  
\}  
  
将上面的代码改为get方法  
  
class Rect \{  
num width;  
num height;  
Rect(this.width, this.height);  
// getUserINfo() \{  
// return (this.width \* this.height);  
// \}  
  
// 将上面的代码该为get  
get getUserINfo \{  
return (this.width \* this.height);  
\}  
\}  
  
void main() \{  
// 实例化的时候，会默认构造自动触发  
Rect p = new Rect(10, 4);  
// print(p.getUserINfo());  
// 将上面的代码改为get方法的调用  
print(p.getUserINfo);//调用的时候直接通过访问属性的方式访问方法  
\}  
10.dart 中的set 方法  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
class Rect \{  
num width;  
num height;  
Rect(this.width, this.height);  
// 设置值的时候。我们使用了set方法  
set areaHeight(value) \{  
this.height = value;  
\}  
get area \{  
return this.height;  
\}  
\}  
void main() \{  
// 实例化的时候，会默认构造自动触发  
Rect p = new Rect(10, 4);  
p.areaHeight = 6; //当一个类的内部使用了set方法的时候。我们直接使用赋值；  
print(p.area); //内部使用了get 我们这直接通过属性获取值  
\}  
11.在实例化之前，给类内部初始化数值  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
class Rect \{  
num width;  
num height;  
// 在实例化之前，给类内部初始化数值  
Rect()  
: height = 2,  
width = 10 \{\}  
get area \{  
return this.height \* this.width;  
\}  
\}  
  
void main() \{  
// 实例化的时候，会默认构造自动触发  
Rect p = new Rect();  
print(p.area); //内部使用了get 我们这直接通过属性获取值  
\}  
到此这篇关于dart类详细讲解的文章就介绍到这了