重载(Overloading)实现"同名多能"，集合框架(Collections)提供"动态容器"——二者共同构建Java灵活性的基石。
一、重载(Overloading)：同名方法的多元实现
1. 方法重载(Method Overloading)
-
核心规则：
- 方法名相同
- 参数列表不同（类型/数量/顺序）
- 返回类型不参与重载判定
// 有效重载示例 void log(int errorCode) { ... } void log(String message) { ... } // 参数类型不同 void log(int code, String detail) { ... } // 参数数量不同 void log(String header, int priority) { ..} // 参数顺序不同 // 无效重载：仅返回类型不同 int calculate() { ... } double calculate() { ... } // 编译错误！ -
实战案例：
class Adder { int add(int a, int b) { return a+b; } String add(String s1, String s2) { return s1+s2; } }# 输出示例 Calling first overloaded method... Result:3 Calling second overloaded method... Result:HelloWorld!
2. 构造器重载(Constructor Overloading)
-
核心价值：
- 提供多种对象初始化方式
- 默认构造器 + 参数化构造器组合
class MyClass { private int sum; // 默认构造器 public MyClass() { sum = 0; } // 参数化构造器 public MyClass(int a, int b) { sum = a + b; } }# 输出示例 Object created with first constructor... Sum=0. Object created with second constructor... Sum=3. -
设计原则：
- 通过
this()调用同类其他构造器 - 保持初始化逻辑一致性
- 通过
二、参数传递：值 vs 引用
1. 基本类型：值传递(Pass By Value)
-
核心机制：创建参数值的独立副本
-
示例现象：方法内修改不影响原始变量
void increment(int x) { x++; // 仅修改局部副本 } public static void main(String[] args) { int num = 5; increment(num); System.out.println(num); // 输出5（未改变） }# 输出日志 In main(),x=0 In IncPassByVal() -- Before increment,x=0 -- After increment,x=1 In main(),x=0 # 原始值不变
2. 对象类型：引用传递(Pass By Reference)
-
核心机制：传递对象内存地址的副本
-
关键特性：
- 方法内修改对象状态会影响原始对象
- 重新赋值引用不影响原始引用
void updateName(Student s) { s.name = "Alice"; // 修改实际对象 s = new Student(); // 仅影响局部引用 }# 输出示例 In Main, before increment n=10. In Increment, n=10. In Main, after increment n=11. # 对象状态被修改
三、集合框架：动态数据容器
1. ArrayList：动态数组
-
核心特性：
- 自动扩容/缩容
- 保持插入顺序
- O(1) 随机访问
ArrayList<String> list = new ArrayList<>(); list.add("Java"); // 添加元素 list.add(0, "Python"); // 指定位置插入 list.remove(1); // 移除索引1的元素# 输出示例 Accessing elements by their indices... First element:10 Second element:20 Iterating through each element... Element[0]:10 Element[1]:20 -
实战技巧：
- 用
list.ensureCapacity(100)预分配内存 - 使用
Collections.sort()进行排序
- 用
2. HashMap：键值对存储
-
核心机制：
- 基于哈希表的键值映射
- O(1) 时间复杂度查询
- 键唯一，值可重复
HashMap<Integer, String> days = new HashMap<>(); days.put(1, "Monday"); days.put(2, "Tuesday"); // 三种遍历方式 for (Integer key : days.keySet()) { ... } // 遍历键 for (String value : days.values()) { ... } // 遍历值 for (Map.Entry<Integer, String> entry : days.entrySet()) { // 遍历键值对 System.out.println(entry.getKey() + ":" + entry.getValue()); }# 交互式输出 Please enter your choice: 1. How many days are there in a week? 2. List the days of a week 3. Day of Week... 4. Exit My Choice:2 The days are... Day1:Monday Day2:Tuesday -
设计注意：
- 重写
equals()时必须重写hashCode() - 用
LinkedHashMap需保持插入顺序
- 重写
四、高频实战场景
1. 实现一个加法类，实现字符串相加、数字相加、颜色相加
Color 类实现
public class Color {
private final String color; // 封装颜色属性（私有不可变）
// 构造器：通过字符串初始化颜色
public Color(String color) {
this.color = color.toLowerCase(); // 统一转为小写
}
// 获取颜色值
public String getColor() {
return color;
}
// 核心方法：检测颜色类型（红/绿/蓝）
public boolean isRed() {
return color.equals("red");
}
public boolean isGreen() {
return color.equals("green");
}
public boolean isBlue() {
return color.equals("blue");
}
}
设计要点：
- 封装性：通过
private final确保颜色值不可篡改 - 标准化处理：构造器将输入转为小写避免大小写敏感问题
- 类型检测：
isRed()/isGreen()/isBlue()方法提供颜色判断能力
Adder 类实现
public class Adder {
// 原始方法：整数相加（保留原项目功能）
public int add(int a, int b) {
return a + b;
}
// 原始方法：字符串拼接（保留原项目功能）
public String add(String s1, String s2) {
return s1 + s2;
}
// ⭐ 新增重载方法：颜色混合（光学三原色原理）
public Color add(Color c1, Color c2) {
// 红 + 蓝 = 品红 (Magenta)
if ((c1.isRed() && c2.isBlue()) ||
(c1.isBlue() && c2.isRed())) {
return new Color("Magenta");
}
// 红 + 绿 = 黄 (Yellow)
else if ((c1.isRed() && c2.isGreen()) ||
(c1.isGreen() && c2.isRed())) {
return new Color("Yellow");
}
// 蓝 + 绿 = 青 (Cyan)
else if ((c1.isBlue() && c2.isGreen()) ||
(c1.isGreen() && c2.isBlue())) {
return new Color("Cyan");
}
// 其他组合返回黑色
return new Color("Black");
}
}
重载原理：
- 方法签名：
add(Color, Color)与原有add(int,int)和add(String,String)构成重载 - 光学混合规则：基于文档要求实现三原色组合逻辑
- 对称处理：
c1.isRed() && c2.isBlue()与c1.isBlue() && c2.isRed()视为等效组合
测试主程序
public class Main {
public static void main(String[] args) {
Adder adder = new Adder();
// 测试原始功能（整数相加）
System.out.println("1 + 2 = " + adder.add(1, 2));
// 测试原始功能（字符串拼接）
System.out.println("Hello + World = " +
adder.add("Hello", "World"));
// ⭐ 测试新功能（颜色混合）
Color red = new Color("RED");
Color green = new Color("Green");
Color blue = new Color("BLUE");
// 红+蓝 -> 品红
Color mix1 = adder.add(red, blue);
System.out.println("Red + Blue = " + mix1.getColor());
// 红+绿 -> 黄
Color mix2 = adder.add(red, green);
System.out.println("Red + Green = " + mix2.getColor());
// 蓝+绿 -> 青
Color mix3 = adder.add(blue, green);
System.out.println("Blue + Green = " + mix3.getColor());
// 无效组合 -> 黑
Color mix4 = adder.add(red, red);
System.out.println("Red + Red = " + mix4.getColor());
}
}
预期输出与原理验证
1 + 2 = 3
Hello + World = HelloWorld
Red + Blue = Magenta
Red + Green = Yellow
Blue + Green = Cyan
Red + Red = Black
关键技术总结
-
重载实现要点
// 三个add()构成重载 add(int, int) // 整数加法 add(String, String) // 字符串拼接 add(Color, Color) // 颜色混合（新增） -
颜色混合算法优化
// 对称检测逻辑（确保顺序无关） if ((c1.isRed() && c2.isBlue()) || (c1.isBlue() && c2.isRed())) { ... -
防御性编程
- 颜色值统一转为小写 (
toLowerCase()) - 未定义组合返回黑色 (
new Color("Black"))
- 颜色值统一转为小写 (
2. 实现IntList
import java.util.ArrayList;
import java.util.Arrays;
public class IntList {
// 核心数据结构：使用ArrayList存储整数
private ArrayList<Integer> list = new ArrayList<>();
// ================= 构造器重载 =================
/**
* 默认构造器（创建空列表）
*/
public IntList() {}
/**
* 参数化构造器（接收数组初始化）
* @param numbers 整数数组
*/
public IntList(int... numbers) {
for (int num : numbers) {
list.add(num);
}
}
// ================= 核心功能实现 =================
/**
* 打印列表内容
*/
public void print() {
// 空列表特殊处理
if (list.isEmpty()) {
System.out.println("[]");
return;
}
// 构建格式化输出
StringBuilder sb = new StringBuilder("[");
for (int i = 0; i < list.size(); i++) {
sb.append(list.get(i));
if (i < list.size() - 1) sb.append(", ");
}
sb.append("]");
System.out.println(sb);
}
/**
* 计算列表平均值
* @return 平均值（列表为空时返回0）
*/
public double average() {
if (list.isEmpty()) return 0.0;
int sum = 0;
for (int num : list) {
sum += num;
}
return (double) sum / list.size();
}
/**
* 从头部移除元素
*/
public void removeFromFront() {
if (!list.isEmpty()) {
list.remove(0);
}
}
/**
* 从尾部移除元素
*/
public void removeFromBack() {
if (!list.isEmpty()) {
list.remove(list.size() - 1);
}
}
// ================= 测试主程序 =================
public static void main(String[] args) {
// 测试1：使用数组初始化
System.out.println("=== Test 1: Array Initialization ===");
IntList list1 = new IntList(10, 20, 30, 40, 50);
System.out.print("List content: ");
list1.print();
System.out.printf("Average: %.2f\n", list1.average());
// 测试2：空列表处理
System.out.println("\n=== Test 2: Empty List ===");
IntList list2 = new IntList();
System.out.print("Empty list: ");
list2.print();
System.out.printf("Average (empty): %.2f\n", list2.average());
// 测试3：移除操作
System.out.println("\n=== Test 3: Removal Operations ===");
System.out.println("-- Original list --");
list1.print();
System.out.println("\n-- After removing from front --");
list1.removeFromFront();
list1.print();
System.out.println("\n-- After removing from back --");
list1.removeFromBack();
list1.print();
}
}
关键功能解析
1. 数据结构设计
private ArrayList<Integer> list = new ArrayList<>();
- 选择原因：使用
ArrayList作为底层存储，满足动态扩容需求 - 封装性：
private访问控制防止外部直接修改列表
2. 构造器重载
public IntList() {} // 默认构造器
public IntList(int... numbers) { ... } // 变长参数构造器
- 灵活性：支持空列表创建和数组初始化两种方式
- 变长参数：
int...语法允许传入任意数量整数
3. 平均值计算算法
public double average() {
if (list.isEmpty()) return 0.0;
int sum = 0;
for (int num : list) {
sum += num;
}
return (double) sum / list.size();
}
- 空列表处理：优先检查避免除零错误
- 精度控制：使用
(double)强制转换确保浮点运算 - 遍历优化：增强for循环提高可读性
4. 元素移除实现
public void removeFromFront() {
if (!list.isEmpty()) list.remove(0);
}
public void removeFromBack() {
if (!list.isEmpty()) list.remove(list.size() - 1);
}
- 安全防护：
isEmpty()检查防止空列表操作 - 高效操作：
- 头部移除：
remove(0)时间复杂度 O(n) - 尾部移除：
remove(size-1)时间复杂度 O(1)
- 头部移除：
5. 格式化输出
public void print() {
if (list.isEmpty()) {
System.out.println("[]");
return;
}
StringBuilder sb = new StringBuilder("[");
for (int i = 0; i < list.size(); i++) {
sb.append(list.get(i));
if (i < list.size() - 1) sb.append(", ");
}
sb.append("]");
System.out.println(sb);
}
- 空值处理：特殊输出空列表符号
[] - 性能优化：使用
StringBuilder避免字符串拼接开销 - 格式规范：输出符合 JSON 数组格式，增强可读性
预期输出与验证
=== Test 1: Array Initialization ===
List content: [10, 20, 30, 40, 50]
Average: 30.00
=== Test 2: Empty List ===
Empty list: []
Average (empty): 0.00
=== Test 3: Removal Operations ===
-- Original list --
[10, 20, 30, 40, 50]
-- After removing from front --
[20, 30, 40, 50]
-- After removing from back --
[20, 30, 40]
关键总结
-
重载三要素
- 方法名统一，参数差异化
- 构造器重载实现多样化初始化
- 返回类型不参与重载决策
-
参数传递本质
类型 传递方式 方法内修改影响 基本类型 值传递 不影响原始值 对象类型 引用传递 影响原始对象状态 -
集合选择矩阵
需求 推荐集合 优势 有序访问/索引查询 ArrayList动态数组+快速随机访问 键值查询/去重存储 HashMap哈希表实现O(1)查找
掌握重载与集合如同获得Java"瑞士军刀"——前者解决接口简洁性问题，后者攻克动态数据管理挑战。二者结合可构建出灵活高效的工业级应用。
扫一扫
7291
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
