一、函数与模块

1. 函数对比

Java 方法

在 Java 中，方法是类的一部分，必须定义在类内部。以下是一个简单的 Java 方法示例：

public class MethodExample {
    // 定义一个静态方法，用于计算两个整数的和
    public static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        int result = add(3, 5);
        System.out.println("两数之和为: " + result);
    }
}

在这个例子中，add 方法是一个静态方法，需要明确指定返回值类型（这里是 int）和参数类型（两个 int 类型的参数）。

Python 函数

Python 中的函数定义更加灵活，不需要定义在类中。示例如下：

# 定义一个函数，用于计算两个数的和
def add(a, b):
    return a + b

result = add(3, 5)
print(f"两数之和为: {result}")

Python 函数使用 def 关键字定义，不需要指定参数和返回值的类型，解释器会在运行时自动处理。

Python 函数的特殊参数特性

• 默认参数

def greet(name, message="Hello"):
    return f"{message}, {name}!"

print(greet("John"))
print(greet("Jane", "Hi"))

在 Python 中，可以为函数的参数设置默认值。如果调用函数时没有提供该参数的值，就会使用默认值。

• 可变参数

def sum_numbers(*numbers):
    total = 0
    for num in numbers:
        total += num
    return total

print(sum_numbers(1, 2, 3))
print(sum_numbers(1, 2, 3, 4, 5))

使用 * 可以定义可变参数，允许函数接受任意数量的参数，这些参数会被封装成一个元组。

2. 模块对比

Java 包

Java 使用包（package）来组织代码，将相关的类放在同一个包中。以下是一个简单的 Java 包示例：

// 在 com.example.math 包下定义一个 MathUtils 类
package com.example.math;

public class MathUtils {
    public static int multiply(int a, int b) {
        return a * b;
    }
}

在另一个类中使用这个包：

import com.example.math.MathUtils;

public class Main {
    public static void main(String[] args) {
        int result = MathUtils.multiply(3, 4);
        System.out.println("两数之积为: " + result);
    }
}

Java 的包需要在文件开头使用 package 关键字声明，使用时需要使用 import 语句导入。

Python 模块

Python 使用模块来组织代码，一个 .py 文件就是一个模块。以下是一个简单的 Python 模块示例：

# math_utils.py 文件
def multiply(a, b):
    return a * b

在另一个 Python 文件中使用这个模块：

import math_utils

result = math_utils.multiply(3, 4)
print(f"两数之积为: {result}")

Python 使用 import 语句导入模块，也可以使用 from...import... 语句导入模块中的特定函数或变量。

二、面向对象编程

1. 类的定义

Java 类

public class Person {
    // 成员变量
    private String name;
    private int age;

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

    // 成员方法
    public void introduce() {
        System.out.println("My name is " + name + ", and I'm " + age + " years old.");
    }

    public static void main(String[] args) {
        Person person = new Person("Alice", 25);
        person.introduce();
    }
}

在 Java 中，类的成员变量和方法需要明确指定访问修饰符（如 private、public 等），构造方法的名称必须与类名相同。

Python 类

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f"My name is {self.name}, and I'm {self.age} years old.")

person = Person("Alice", 25)
person.introduce()

Python 类使用 class 关键字定义，构造方法是 __init__ 方法，第一个参数通常是 self，表示实例本身。

2. 继承

Java 继承

// 父类
class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

// 子类
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
    }
}

Java 使用 extends 关键字实现继承，子类可以重写父类的方法，使用 @Override 注解来明确表示这是一个重写的方法。

Python 继承

# 父类
class Animal:
    def eat(self):
        print("Animal is eating.")

# 子类
class Dog(Animal):
    def eat(self):
        print("Dog is eating.")

dog = Dog()
dog.eat()

Python 同样通过在类名后面的括号中指定父类名来实现继承，子类可以直接重写父类的方法。

3. 多态

Java 多态

// 父类
class Shape {
    public void draw() {
        System.out.println("Drawing a shape.");
    }
}

// 子类
class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}

// 子类
class Square extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a square.");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Shape circle = new Circle();
        Shape square = new Square();

        circle.draw();
        square.draw();
    }
}

在 Java 中，通过父类引用指向子类对象实现多态，调用相同的方法会根据实际对象类型执行不同的实现。

Python 多态

# 父类
class Shape:
    def draw(self):
        print("Drawing a shape.")

# 子类
class Circle(Shape):
    def draw(self):
        print("Drawing a circle.")

# 子类
class Square(Shape):
    def draw(self):
        print("Drawing a square.")

def draw_shape(shape):
    shape.draw()

circle = Circle()
square = Square()

draw_shape(circle)
draw_shape(square)

Python 中多态的实现更加灵活，只要对象具有相同名称的方法，就可以在函数中进行调用，不依赖于继承关系。