Python和Java语法风格直观对比：从变量定义到面向对象

# 基础声明：直接赋值建立绑定
counter = 10
total_price = 99.5
username = "Alice"
is_active = True

# 动态重绑定：随时指向不同类型对象
counter = "Ten"  # 合法，原整数对象失去引用

# 类型注解（仅辅助IDE与静态检查，无运行时强制）
age: int = 25
age = "Twenty-five"  # 运行时不会抛出异常

// 基础声明：显式声明存储槽位类型
int counter = 10;
double totalPrice = 99.5;
String username = "Alice";
boolean isActive = true;

// 槽位类型固定，类型不匹配编译直接报错
// counter = "Ten"; // 编译错误: 不兼容的类型

// Java 10+ 局部变量类型推导（仍然是静态强类型）
var age = 25; // 编译期推导为 int
// age = "Twenty-five"; // 编译期同样报错

scores = [85, 92, 78, 64]

# 条件分支：冒号后强制缩进4空格
for score in scores:
    if score >= 90:
        grade = "A"
    elif score >= 80:
        grade = "B"
    else:
        grade = "C"
    print(f"分数: {score}, 等级: {grade}")

# 作用域提醒：在Python中，for/if循环体内声明的
# 变量 grade 在循环结束后依然在当前函数作用域可用！

int[] scores = {85, 92, 78, 64};

// 条件分支与增强 for 循环
for (int score : scores) {
    String grade;
    if (score >= 90) {
        grade = "A";
    } else if (score >= 80) {
        grade = "B";
    } else {
        grade = "C";
    }
    System.out.println("分数: " + score + ", 等级: " + grade);
}

// grade 变量超出 for 大括号作用域后立即销毁
// System.out.println(grade); // 编译错误: 找不到符号

# 顶层独立函数，支持默认参数与可变参数
def build_profile(name, role="Developer", *skills, **meta):
    return {
        "name": name,
        "role": role,
        "skills": list(skills),
        "extra": meta
    }

# 灵活调用方式：位置、默认值与关键字参数混用
info = build_profile(
    "Bob",
    "Architect",
    "Python", "Docker",
    level=5, remote=True
)
print(info["skills"]) # 输出: ['Python', 'Docker']

import java.util.*;

public class ProfileBuilder {
    // 必须寄宿在类中；不支持默认参数，依靠重载实现
    public static Map<String, Object> buildProfile(String name) {
        return buildProfile(name, "Developer");
    }

    public static Map<String, Object> buildProfile(String name, String role, String... skills) {
        Map<String, Object> profile = new HashMap<>();
        profile.put("name", name);
        profile.put("role", role);
        profile.put("skills", Arrays.asList(skills));
        return profile;
    }
}
// 必须通过类名或实例静态方法进行明确类型调用

class Employee:
    # 类属性（所有实例共享）
    company = "TechCorp"

    def __init__(self, name: str, salary: float):
        self.name = name           # 公开属性
        self._dept = "R&D"         # 受保护属性（惯例约定）
        self.__salary = salary     # 私有属性（名称改写）

    # 实例方法必须显式接收入参 self
    def get_details(self) -> str:
        return f"{self.name} ({self.company}): {self.__salary}"

    # Pythonic 的属性封装器
    @property
    def salary(self) -> float:
        return self.__salary

public class Employee {
    // 类静态属性
    public static final String COMPANY = "TechCorp";

    // 实例字段必须先声明类型并限制访问权限
    private String name;
    protected String dept = "R&D";
    private double salary;

    // 构造器与类同名，无返回值
    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getDetails() {
        return this.name + " (" + COMPANY + "): " + this.salary;
    }

    // 必须显式编写 Getter/Setter 或使用 Lombok
    public double getSalary() {
        return this.salary;
    }
}