Eralng 学习笔记第九天, 随手记-复习

1,Erlang的模式匹配和 java的多态 和方法重载

Erlang 中的模式匹配和 Java 中的某些编程方式有相似之处,但它们通常更接近于 Java 中的多态(polymorphism)和方法重载(method overloading)这样的概念。

  1. 多态(Polymorphism):在 Erlang 中,函数的模式匹配允许根据不同的参数模式调用不同的函数实现,这与多态的思想相似。不同的模式匹配代表了不同的行为,这使得代码更加灵活和易于扩展。而在 Java 中,多态通过子类继承和方法重写来实现,允许同一个方法在不同的子类中有不同的实现。

  2. 方法重载(Method Overloading):在 Erlang 中,你可以定义多个名称相同但参数不同的函数,根据参数的不同模式匹配到不同的函数实现,这与方法重载的概念相似。而在 Java 中,方法重载允许在同一个类中定义多个方法,它们具有相同的名称但不同的参数列表。

虽然 Erlang 中的模式匹配与 Java 中的多态和方法重载有一些相似之处,但它们的实现方式和语法结构仍然有很大的不同。在 Erlang 中,模式匹配是一种更加直观和强大的特性,可用于函数定义、消息处理等方面,而在 Java 中,多态和方法重载通常用于实现更加面向对象的编程模型。

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

当你试图将 Erlang 的模式匹配与 Java 的某些编程方式进行比较时,以下是一些例子,可能会帮助你更好地理解 Erlang 的模式匹配:

多态(Polymorphism):

在 Erlang 中,你可以定义多个具有相同名称但参数不同的函数,根据参数的不同模式匹配到不同的函数实现。这与 Java 中的方法重写和多态的概念相似。

% Erlang 中的模式匹配
area({circle, Radius}) ->
math:pi() * Radius * Radius;
area({rectangle, Width, Height}) ->
Width * Height.

在这个例子中,area/1 函数根据不同的参数模式(圆形或矩形)计算面积。

方法重载(Method Overloading):

在 Erlang 中,你可以定义多个具有相同名称但参数不同的函数,根据参数的不同模式匹配到不同的函数实现。这与 Java 中的方法重载的概念相似。

% Erlang 中的模式匹配
calculate(Summand1, Summand2) ->
Summand1 + Summand2;
calculate(Summand1, Summand2, Summand3) ->
Summand1 + Summand2 + Summand3.

在这个例子中,calculate/2 函数和 calculate/3 函数根据参数的不同数量模式匹配到不同的函数实现。

这些例子展示了 Erlang 中模式匹配的灵活性和强大性,它使得代码更加清晰、简洁,并且更容易理解和维护。通过这些比较,你可以更好地理解 Erlang 的语法和编程模型,并且将你在 Java 中的编程经验应用到 Erlang 的开发中。

 

2. Erlang 的消息传递机制与 Java 的消息队列:

在 Erlang 中,进程之间通过消息传递进行通信,这与 Java 中使用消息队列进行通信的概念相似。Erlang 的消息传递机制具有高度并发和分布式特性,与 Java 中的消息队列可以实现类似的功能。

erlang   :

% Erlang 中的消息传递
Pid ! {message, Data}.

java :

// Java 中的消息队列
queue.add(message);

3. Erlang 的并发模型与 Java 的线程:

Erlang 中的进程是轻量级的并发实体,每个进程都有自己的独立执行流程。这与 Java 中的线程模型有些相似,虽然 Erlang 进程更加轻量级和高度并发。

 

% Erlang 中的进程创建
Pid = spawn(Module, Function, Args).

 

// Java 中的线程创建
Thread thread = new Thread(new Runnable() {
public void run() {
// 逻辑代码
}
});
thread.start();

4. 模式匹配和异常处理:

在 Erlang 中,模式匹配常常用于处理不同类型的消息或数据,这与 Java 中的异常处理有些相似。在 Java 中,你可以使用不同的 catch 分支来处理不同类型的异常。

 

% Erlang 中的模式匹配
handle_message({ok, Data}) ->
process_data(Data);
handle_message({error, Reason}) ->
log_error(Reason).

 

// Java 中的异常处理
try {
// 可能会抛出异常的代码
} catch (IOException e) {
// 处理 IOException 异常
} catch (SQLException e) {
// 处理 SQLException 异常
}

 

5. 模式匹配和选择语句(Switch Statements):

在 Erlang 中,case 表达式常常用于模式匹配,根据不同的模式选择执行不同的代码块,这与 Java 中的 switch 语句有些相似。

 

% Erlang 中的 case 表达式
case X of
  1 -> do_something();
  2 -> do_something_else();
  _ -> handle_default_case()
end.

 

// Java 中的 switch 语句
switch (x) {
  case 1:
    doSomething();
    break;
  case 2:
    doSomethingElse();
      break;
  default:
    handleDefaultCase();
}

6. 记录(Records)与 Java 的类(Classes):

在 Erlang 中,记录是一种轻量级的数据结构,用于组织和管理相关的数据字段。这与 Java 中的类具有一定的相似之处,它们都可以用于封装数据和行为。

 

% Erlang 中的记录
-record(person, {name, age}).

% 创建记录实例
Person = #person{name="Alice", age=30}.

在这个例子中,定义了一个名为 person 的记录类型,并创建了一个名为 Person 的记录实例。

 

// Java 中的类
public class Person {
  private String name;
  private int age;

  // 构造方法
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }

  // getter 和 setter 方法
  // ...
}

7. 宏(Macros)与 Java 的预处理器(Preprocessor):

在 Erlang 中,宏是一种在编译时执行代码转换的机制,它允许在代码中定义和使用自定义的代码片段。这与 Java 中的预处理器(如 #define)具有一定的相似之处,它们都用于在代码中进行代码替换和宏展开。

 

% Erlang 中的宏
-define(PI, 3.14159).

% 使用宏
CircleArea = ?PI * Radius * Radius.

 

在这个例子中,定义了一个名为 PI 的宏,并在代码中使用它来计算圆的面积。Java 中也有类似的预处理器功能,但通常更少见,并且在编译时执行。

// Java 中的预处理器
public class Constants {
  public static final double PI = 3.14159;
}

// 使用预处理器
double circleArea = Constants.PI * radius * radius;

8. 无类型变量(Untyped Variables)与 Java 的泛型(Generics):

在 Erlang 中,变量是无类型的,可以绑定到任何类型的值。这与 Java 中的泛型有些相似,泛型允许在编写代码时指定类型参数,以增加代码的类型安全性和灵活性。

 

在Erlang中,无类型变量属于Atom类型。Atoms是Erlang中的原子,它们是不可变的符号常量,通常用于表示标识符或者字面量。

Atoms以小写字母开头,可以包含字母、数字、下划线和@符号。在Erlang中,变量名必须以大写字母开头,因此无类型变量并不是Atoms类型,它们是Erlang中的变量。

 

% Erlang 中的无类型变量
X = 10,
Y = "hello",
Z = {1, 2, 3}.

 

在这个例子中,X 可以绑定到整数,Y 可以绑定到字符串,Z 可以绑定到元组。

// Java 中的泛型
List<Integer> numbers = new ArrayList<>();
numbers.add(10);
List<String> strings = new ArrayList<>();
strings.add("hello");

9. 匿名函数(Anonymous Functions)与 Java 的 Lambda 表达式:

在 Erlang 中,你可以定义匿名函数并将其传递给其他函数,这与 Java 中的 Lambda 表达式有些相似。Lambda 表达式允许你轻松地在代码中传递函数,并且具有简洁的语法。

% Erlang 中的匿名函数
Double = fun(X) -> 2 * X end,
Result = Double(10).

 

在这个例子中,定义了一个匿名函数 Double,它将参数加倍。

// Java 中的 Lambda 表达式
Function<Integer, Integer> doubleFunction = x -> 2 * x;
Integer result = doubleFunction.apply(10);

 

10. 模块化与包管理 

在 Erlang 中,模块是代码的基本组织单位,而在 Java 中,包(Package)是代码的基本组织单位。Erlang 使用模块来组织代码,并使用应用(Application)来管理模块和依赖关系。

% Erlang 中的模块定义
-module(math).
-export([add/2, subtract/2]).

add(A, B) ->
  A + B.

subtract(A, B) ->
  A - B.

 

 

// Java 中的包定义
package com.example.math;

public class MathOperations {

  public int add(int a, int b) {
    return a + b;
}

  public int subtract(int a, int b) {
    return a - b;
  }
}

 

posted @ 2024-02-06 17:30  d-w  阅读(22)  评论(0编辑  收藏  举报