由于想要写一款性能较好,但是又可以一套代码多个平台运行的客户端app,所以选择了flutter 就去看了官方文档,大体发现flutter使用的dart语言和java和js差不多,感觉就是缝合怪。
Dart 是一种面向对象的编程语言,语法上与 Java、JavaScript 等语言有一些相似之处,因此对于有 Java 基础的开发者,Dart 的语法应该相对容易理解。以下是 Dart 语言的语法介绍,特别对比了与 Java 的异同。
看完由遗忘很正常 ,必要时可以查看官方中文文档
1. 基本语法
1.1 变量声明
Dart 是强类型语言,但可以通过 var
来声明类型推断的变量。
- Dart:
java
int age = 30; // 明确类型
var name = 'John'; // 自动推断为 String
- Java:
java
int age = 30; // 明确类型
String name = "John"; // 明确类型
Dart 中 var
类似于 Java 的局部类型推断 var
(自 Java 10 引入)。
1.2 常量
Dart 中使用 const
和 final
来声明常量。const
是编译时常量,而 final
是运行时常量,赋值后不能修改。
- Dart:
java
const double pi = 3.14; // 编译时常量
final currentTime = DateTime.now(); // 运行时常量
- Java:
java
final double PI = 3.14; // Java 没有 const,但 final 可以限制变量不可修改
如果不显示定义 编译时会自动推断
var b="奥萨苏";
1.3 函数定义
Dart 中的函数定义与 Java 类似,但 Dart 的函数可以是顶级函数,不需要类的包装。
- Dart:
java
int add(int a, int b) {
return a + b;
}
// 简写方式(箭头函数)
int subtract(int a, int b) => a - b;
- Java:
java
public int add(int a, int b) {
return a + b;
}
Dart 的函数可以直接返回表达式,使用 =>
箭头函数表示法。
如果不显示定义返回值 则是dynamic类型
java
void main() {
int a=12 ;
print('你好世界');
print(a++);
String name ="jack";
print("开发者的名字是=$name"); //输出的时候的引用
// 双引号嵌套单引号
// 单引号嵌套双引号
print("他就是世界第一的'火影大王'");
print('他就是世界第一的"火影大王"');
var b="奥萨苏";
print(b);
add(1,2);
}
add (int a,int b){
return a+b;
}
2. 控制流
2.1 条件语句
Dart 的 if-else
语法与 Java 完全一致。
- Dart:
java
if (age > 18) {
print('Adult');
} else {
print('Minor');
}
- Java:
java
if (age > 18) {
System.out.println("Adult");
} else {
System.out.println("Minor");
}
2.2 循环
Dart 的循环控制结构与 Java 非常相似,for
、while
、do-while
循环的语法基本一致。
- Dart:
java
for (int i = 0; i < 5; i++) {
print(i);
}
int i = 0;
while (i < 5) {
print(i);
i++;
}
- Java:
java
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
int i = 0;
while (i < 5) {
System.out.println(i);
i++;
}
2.3 switch-case
Dart 的 switch-case
语法与 Java 类似,但 case
不需要 break
,也没有 fall-through
行为。
- Dart:
java
var grade = 'A';
switch (grade) {
case 'A':
print('Excellent');
break;
case 'B':
print('Good');
break;
default:
print('Unknown grade');
}
- Java:
java
char grade = 'A';
switch (grade) {
case 'A':
System.out.println("Excellent");
break;
case 'B':
System.out.println("Good");
break;
default:
System.out.println("Unknown grade");
}
3. 面向对象编程
3.1 类和对象
Dart 是面向对象语言,所有东西都是对象,类的定义方式与 Java 类似。
- Dart:
java
class Person {
String name;
int age;
// 构造函数
Person(this.name, this.age);
void greet() {
print('Hello, my name is $name');
}
}
void main() {
var person = Person('Alice', 30);
person.greet();
}
- Java:
java
class Person {
String name;
int age;
// 构造函数
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void greet() {
System.out.println("Hello, my name is " + name);
}
}
public static void main(String[] args) {
Person person = new Person("Alice", 30);
person.greet();
}
3.2 继承
Dart 支持单继承,使用 extends
关键字。
- Dart:
java
class Employee extends Person {
String jobTitle;
Employee(String name, int age, this.jobTitle) : super(name, age);
@override
void greet() {
print('Hello, I am $name, and I work as a $jobTitle');
}
}
- Java:
java
class Employee extends Person {
String jobTitle;
public Employee(String name, int age, String jobTitle) {
super(name, age);
this.jobTitle = jobTitle;
}
@Override
public void greet() {
System.out.println("Hello, I am " + name + ", and I work as a " + jobTitle);
}
}
3.3 接口和抽象类
Dart 没有显式的 interface
关键字,但所有类都可以作为接口被实现。使用 abstract
关键字定义抽象类。
- Dart:
java
abstract class Animal {
void sound(); // 抽象方法
}
//作为接口被实现
class Dog implements Animal{
@override
void sound() {
print('Woof');
}
}
//但是接口没有有办法在父类申明数值
abstract class Animal {
late String name;
Animal(this.name); // 抽象方法
void sound();
}
//使用implents 就会报错
class Dog extends Animal{
Dog(String name):super(name);
@override
void sound() {
print('Woof');
}
}
- Java:
java
abstract class Animal {
abstract void sound();
}
class Dog extends Animal {
@Override
void sound() {
System.out.println("Woof");
}
}
演示代码
这里dart 利用的是重写来实现继承和实现的逻辑
java
class Person {
String name;
int age;
// 构造函数
Person(this.name, this.age);
void greet() {
print('Hello, my name is $name');
}
}
void main() {
// 多态 父类对象 申明位子类对象
Person person = Employee('网名', 30,"日报记者");
person.greet();
Iservice service=ServiceImple("jack");
service.sayhello();
}
class Employee extends Person {
String jobTitle;
//调用父类的构造函数 和本类的构造函数
Employee(String name, int age, this.jobTitle) : super(name, age);
@override
void greet() {
print('Hello, I am $name, and I work as a $jobTitle');
}
}
abstract class Iservice {
late String name; // 抽象类中的变量
Iservice(this.name);
void sayhello(){
print("接口说你好");
}
int Add(int a, int b);
}
class ServiceImple extends Iservice {
ServiceImple(String name):super(name);
/**
* 实现父类空方法
*/
@override
int Add(int a, int b) {
return a + b; // 实现加法
}
/**
* 对父类重写 增强
*/
@override
void sayhello() {
super.sayhello();
print('Hello, my name is $name'); // 使用 name
}
}
4. 异步编程
4.1 异步函数
Dart 有内置的 async
和 await
关键字,用于处理异步编程,这与 JavaScript 中的异步编程类似。
-
Dart:
感觉跟js的很想
java
Future<void> fetchData() async {
var data = await fetchFromServer();
print(data);
}
Future<String> fetchFromServer() {
// 模拟从服务器获取数据 俩秒后返回数据
return Future.delayed(Duration(seconds: 2), () => 'Server data');
}
//冒泡排序
main() {
fetchData();
}
- Java 中没有
async
和await
,你可以通过CompletableFuture
或其他异步库实现异步操作:
java
import java.util.concurrent.CompletableFuture;
public class AsyncExample {
public static void main(String[] args) {
fetchData();
}
public static void fetchData() {
CompletableFuture.supplyAsync(() -> fetchFromServer())
.thenAccept(data -> System.out.println(data));
}
public static String fetchFromServer() {
try {
Thread.sleep(2000); // 模拟耗时操作
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Server data";
}
}
4.2 Stream
Dart 中的 Stream
类似于 Java 的 Stream
,但它更侧重于处理异步事件流。
- Dart:
java
Stream<int> countStream(int to) async* {
for (int i = 1; i <= to; i++) {
yield i;
}
}
void main() async {
await for (var value in countStream(5)) {
print(value); // 依次输出 1 到 5
}
}
- Java 中的
Stream
主要用于集合的函数式操作,而异步流处理可以使用RxJava
或Project Reactor
。
5. 其他重要特性
5.1 集合操作
Dart 中的集合与 Java 类似,包括 List
、Set
、Map
等。
api和java差不多
- Dart:
java
List<int> numbers = [1, 2, 3];
Map<String, int> ages = {'Alice': 30, 'Bob': 25};
numbers.forEach(print);
- Java:
java
List<Integer> numbers = Arrays.asList(1, 2, 3);
Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 30);
ages.put("Bob", 25);
numbers.forEach(System.out::println);
Dart 语言中的集合操作非常丰富,类似于 Java 的集合框架,但也有其独特之处。Dart 提供了常用的集合类型(如 List
、Set
和 Map
),并提供了大量的 API 来操作集合。以下是 Dart 集合操作和 API 的详解:
1. List(列表)
List
是 Dart 中的可变数组,类似于 Java 中的 ArrayList
。它可以存储有序的元素,并且允许重复元素。
创建列表
-
空列表:
var list = <int>[]; // 创建空的整数列表
-
带初始值的列表:
var list = [1, 2, 3, 4]; // 初始化列表
-
不可变列表:
var fixedList = List.unmodifiable([1, 2, 3]); // 创建不可修改的列表
常用 API
-
添加元素:
list.add(5); // 添加单个元素 list.addAll([6, 7]); // 添加多个元素
-
插入元素:
list.insert(0, 0); // 在索引 0 处插入 0 list.insertAll(1, [8, 9]); // 在索引 1 处插入多个元素
-
删除元素:
list.remove(1); // 删除第一个值为 1 的元素 list.removeAt(0); // 删除索引为 0 的元素 list.removeWhere((item) => item % 2 == 0); // 删除所有符合条件的元素
-
查找元素:
var containsTwo = list.contains(2); // 检查列表是否包含某个元素 var indexOfThree = list.indexOf(3); // 查找元素的位置
-
排序:
javalist.sort(); // 升序排序 list.sort((a, b) => b.compareTo(a)); // 降序排序
-
遍历:
javalist.forEach((item) => print(item)); // 遍历列表并打印每个元素
-
映射和过滤:
javavar squaredList = list.map((item) => item * item).toList(); // 对每个元素平方并返回新列表 var evenList = list.where((item) => item.isEven).toList(); // 筛选偶数
-
其他常用操作:
javalist.clear(); // 清空列表 var isEmpty = list.isEmpty; // 检查是否为空 var length = list.length; // 获取长度
2. Set(集合)
Set
是一个无序且元素唯一的集合,类似于 Java 的 HashSet
。
创建集合
-
空集合:
javavar set = <int>{}; // 创建空的整数集合
-
带初始值的集合:
javavar set = {1, 2, 3, 4}; // 初始化集合
常用 API
-
添加元素:
javaset.add(5); // 添加单个元素 set.addAll([6, 7]); // 添加多个元素
-
删除元素:
javaset.remove(1); // 删除元素 1 set.removeWhere((item) => item.isEven); // 删除符合条件的元素
-
集合操作:
javavar unionSet = set.union({5, 6}); // 并集 var intersectionSet = set.intersection({3, 4, 5}); // 交集 var differenceSet = set.difference({3, 4}); // 差集
-
遍历:
javaset.forEach((item) => print(item)); // 遍历集合
-
其他常用操作:
javavar containsThree = set.contains(3); // 检查集合是否包含某个元素 var isEmpty = set.isEmpty; // 检查是否为空 var length = set.length; // 获取长度
3. Map(映射)
Map
是键值对的集合,类似于 Java 的 HashMap
。键必须是唯一的,值可以重复。
创建映射
-
空映射:
javavar map = <String, int>{}; // 创建空的键值对映射
-
带初始值的映射:
javavar map = {'one': 1, 'two': 2}; // 初始化映射
常用 API
-
添加或更新键值对:
javamap['three'] = 3; // 添加新键值对 map.update('two', (value) => value + 2); // 更新键 'two' 的值
-
删除键值对:
javamap.remove('one'); // 删除键 'one' 对应的键值对
-
查找值:
javavar value = map['two']; // 根据键获取值 var containsKey = map.containsKey('two'); // 检查是否包含某个键 var containsValue = map.containsValue(2); // 检查是否包含某个值
-
遍历:
javamap.forEach((key, value) => print('$key: $value')); // 遍历映射
-
获取键或值的集合:
javavar keys = map.keys; // 获取所有键 var values = map.values; // 获取所有值
-
其他常用操作:
javavar isEmpty = map.isEmpty; // 检查是否为空 var length = map.length; // 获取长度
5.2 异常处理
Dart 的异常处理与 Java 类似,使用 try-catch
。
- Dart:
java
try {
var result = 10 ~/ 0; // 整数除法会抛出异常
} catch (e) {
print('Caught an exception: $e');
} finally {
print('This will always execute');
}
- Java:
java
try {
int result = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("Caught an exception: " + e);
} finally {
System.out.println("This will always execute");
}
5.3 空安全
Dart 支持空安全(null-safety),防止 null
引发错误,类似于 Java 的 Optional。
- Dart:
java
String? name; // 允许为 null
name = null;
print(name?.length); // 使用 ?. 操作符避免空指针异常
- Java:
java
Optional<String> name = Optional.ofNullable(null);
System.out.println(name.map(String::length).orElse(0));
枚举
dart 的枚举也和java类似
dart 需要强制编译时就申明构造函数不可变
java
enum HttpStatus {
ok(200, "响应成功"),
created(201, "创建成功"),
badRequest(400, "请求错误"),
unauthorized(401, "未授权"),
notFound(404, "未找到"),
internalServerError(500, "服务器内部错误");
final int code;
final String name;
//一申明即不可变
const HttpStatus(this.code, this.name);
}
java
java
public enum Test {
ok(200, "OK");
final int code;
final String message;
Test(int code, String message) {
this.code = code;
this.message = message;
}
}
补充
下面的内容都是用到啥 补充啥
初始化
构造函数后面跟 :代码块即可执行初始化 在构造函数之前执行
还有之前的构造函数调用父类方式本质也只是这种初始化的缩写
java
class Animal{
String name;
int age;
Animal(this.name,this.age);
}
class Person extends Animal{
String action;
Person(String name,int age,this.action):super(name,age){
print("构造函数被调用");
super.age=age;
super.name=name;
}
}
可变参数搭配可空操作
dart
void greet(String name, {String? greeting, String? farewell}) {
if (greeting != null) {
print('$greeting, $name!');
} else {
print('Hello, $name!');
}
if (farewell != null) {
print('$farewell, $name!');
}
}
void main() {
greet('Alice'); // 输出: Hello, Alice!
greet('Bob', greeting: 'Hi'); // 输出: Hi, Bob!
greet('Charlie', farewell: 'Goodbye'); // 输出: Hello, Charlie! Goodbye, Charlie!
greet('David', greeting: 'Hey', farewell: 'See you'); // 输出: Hey, David! See you, David!
}