【2025】Java 从入门到实战：核心特性全解析（方法、类与对象、多态三大特性及关键字thissuper）附带代码案例

前言

        Java 作为一门纯面向对象编程语言，其核心思想围绕 "类与对象" 展开。本文将系统讲解 Java 面向对象编程的核心概念，包括类与对象、方法、方法重载与重写、封装、继承、多态以及 this 与 super 关键字的使用，帮助初学者快速掌握面向对象编程精髓。

一、类与对象

1.1 概念

• 类 (Class)：是对一类事物的抽象描述，定义了这类事物的属性和行为，是创建对象的模板。
• 对象 (Object)：是类的具体实例，拥有类定义的属性和行为。

例如："汽车" 是类，而你家的那辆红色宝马就是对象。

1.2 语法与示例

// 定义类
public class Car {// 属性(成员变量)String color;  // 颜色String brand;  // 品牌int speed;     // 速度// 行为(方法)// 加速public void accelerate() {speed += 10;System.out.println(brand + "正在加速，当前速度：" + speed + "km/h");}// 刹车public void brake() {speed = 0;System.out.println(brand + "已刹车，当前速度：" + speed + "km/h");}public static void main(String[] args) {// 创建对象Car bmw = new Car();// 给对象属性赋值bmw.color = "红色";bmw.brand = "宝马";bmw.speed = 0;// 调用对象方法bmw.accelerate();  // 宝马正在加速，当前速度：10km/hbmw.accelerate();  // 宝马正在加速，当前速度：20km/hbmw.brake();       // 宝马已刹车，当前速度：0km/h// 创建另一个对象Car benz = new Car();benz.color = "黑色";benz.brand = "奔驰";benz.speed = 0;benz.accelerate();  // 奔驰正在加速，当前速度：10km/h}
}

二、方法详解

2.1 方法的概念与结构

方法是类中定义的行为，用于实现特定功能。方法的基本结构：

修饰符 返回值类型 方法名(参数列表) {// 方法体return 返回值;  // void类型不需要return
}

2.2 方法的分类

• 无参无返回值
• 有参无返回值
• 无参有返回值
• 有参有返回值

示例：

public class MethodDemo {// 无参无返回值public void sayHello() {System.out.println("Hello World!");}// 有参无返回值public void printInfo(String name, int age) {System.out.println("姓名：" + name + "，年龄：" + age);}// 无参有返回值public int getRandomNumber() {return (int)(Math.random() * 100);}// 有参有返回值public int add(int a, int b) {return a + b;}public static void main(String[] args) {MethodDemo demo = new MethodDemo();demo.sayHello();demo.printInfo("张三", 20);System.out.println("随机数：" + demo.getRandomNumber());System.out.println("两数之和：" + demo.add(10, 20));}
}

三、方法重载 (Overload)

3.1 概念

方法重载指在同一个类中，允许存在多个同名方法，但这些方法的参数列表必须不同（参数个数不同或参数类型不同）。

3.2 特点

• 方法名必须相同
• 参数列表必须不同（个数、类型、顺序）
• 返回值类型可以不同
• 修饰符可以不同

3.3 示例

public class OverloadDemo {// 计算两个整数的和public int add(int a, int b) {return a + b;}// 计算三个整数的和（参数个数不同）public int add(int a, int b, int c) {return a + b + c;}// 计算两个小数的和（参数类型不同）public double add(double a, double b) {return a + b;}// 计算一个整数和一个小数的和（参数顺序不同）public double add(int a, double b) {return a + b;}public static void main(String[] args) {OverloadDemo demo = new OverloadDemo();System.out.println(demo.add(10, 20));        // 30System.out.println(demo.add(10, 20, 30));    // 60System.out.println(demo.add(10.5, 20.5));    // 31.0System.out.println(demo.add(10, 20.5));      // 30.5}
}

四、封装 (Encapsulation)

4.1 概念

封装是指将对象的属性和行为封装起来，只暴露必要的接口与外界交互，隐藏内部实现细节。

4.2 实现方式

• 使用 private 修饰成员变量，限制直接访问
• 提供 public 修饰的 getter 和 setter 方法，用于访问和修改成员变量

4.3 示例

public class Student {// 私有属性，外部不能直接访问private String name;private int age;// 公共的getter和setter方法public String getName() {return name;}public void setName(String name) {// 可以在setter中添加验证逻辑if (name != null && name.length() > 0) {this.name = name;} else {System.out.println("姓名不能为空");}}public int getAge() {return age;}public void setAge(int age) {// 年龄必须在合理范围内if (age > 0 && age < 150) {this.age = age;} else {System.out.println("年龄必须在0-150之间");}}public void study() {System.out.println(name + "正在学习");}public static void main(String[] args) {Student student = new Student();student.setName("");  // 姓名不能为空student.setName("张三");student.setAge(200);  // 年龄必须在0-150之间student.setAge(20);System.out.println("姓名：" + student.getName() + "，年龄：" + student.getAge());student.study();  // 张三正在学习}
}

五、继承 (Inheritance)

5.1 概念

继承是指一个类（子类）可以继承另一个类（父类）的属性和方法，从而实现代码复用。Java 中使用 extends 关键字实现继承，且只支持单继承。

5.2 特点

• 子类拥有父类非 private 的属性和方法
• 子类可以扩展自己的属性和方法
• 子类可以重写父类的方法

5.3 示例

// 父类：动物
class Animal {String name;public void eat() {System.out.println(name + "在吃东西");}public void sleep() {System.out.println(name + "在睡觉");}
}// 子类：狗（继承自动物）
class Dog extends Animal {// 子类扩展自己的方法public void bark() {System.out.println(name + "在汪汪叫");}
}// 子类：猫（继承自动物）
class Cat extends Animal {// 子类扩展自己的方法public void meow() {System.out.println(name + "在喵喵叫");}
}public class InheritanceDemo {public static void main(String[] args) {Dog dog = new Dog();dog.name = "旺财";dog.eat();   // 继承自父类的方法dog.sleep(); // 继承自父类的方法dog.bark();  // 子类自己的方法Cat cat = new Cat();cat.name = "咪咪";cat.eat();   // 继承自父类的方法cat.sleep(); // 继承自父类的方法cat.meow();  // 子类自己的方法}
}

六、方法重写 (Override)

6.1 概念

方法重写指子类可以重写父类的方法，以实现子类特有的功能。

6.2 规则

• 方法名、参数列表必须与父类完全相同
• 返回值类型必须与父类相同或为其子类型
• 访问修饰符不能严于父类
• 不能抛出比父类更多或更广泛的异常

6.3 示例

// 父类
class Shape {public void draw() {System.out.println("绘制图形");}
}// 子类：圆形
class Circle extends Shape {// 重写父类的draw方法@Override  // 注解，检查是否正确重写public void draw() {System.out.println("绘制圆形");}
}// 子类：矩形
class Rectangle extends Shape {// 重写父类的draw方法@Overridepublic void draw() {System.out.println("绘制矩形");}
}public class OverrideDemo {public static void main(String[] args) {Shape shape1 = new Circle();Shape shape2 = new Rectangle();shape1.draw();  // 绘制圆形shape2.draw();  // 绘制矩形}
}

6.4 重载与重写的区别

区别点	方法重载 (Overload)	方法重写 (Override)
定义	同一个类中，方法名相同，参数列表不同	子类中，方法名、参数列表与父类相同
返回值	可以不同	必须相同或为其子类型
访问修饰符	可以不同	不能严于父类
多态性	不体现多态	体现多态
关联	编译时多态	运行时多态

七、多态 (Polymorphism)

7.1 概念

多态是指同一操作作用于不同对象，可以产生不同的执行结果。多态的实现需要满足三个条件：

1. 存在继承关系
2. 子类重写父类方法
3. 父类引用指向子类对象

7.2 示例

// 父类：交通工具
class Vehicle {public void run() {System.out.println("交通工具在行驶");}
}// 子类：汽车
class Car extends Vehicle {@Overridepublic void run() {System.out.println("汽车在公路上行驶");}
}// 子类：飞机
class Plane extends Vehicle {@Overridepublic void run() {System.out.println("飞机在天空中飞行");}
}// 子类：轮船
class Ship extends Vehicle {@Overridepublic void run() {System.out.println("轮船在海上航行");}
}public class PolymorphismDemo {// 测试方法，接收父类类型参数public static void testRun(Vehicle vehicle) {vehicle.run();}public static void main(String[] args) {// 父类引用指向子类对象Vehicle car = new Car();Vehicle plane = new Plane();Vehicle ship = new Ship();testRun(car);   // 汽车在公路上行驶testRun(plane); // 飞机在天空中飞行testRun(ship);  // 轮船在海上航行}
}

八、this 与 super 关键字

8.1 this 关键字

this 代表当前对象的引用，主要用途：

• 区分成员变量和局部变量
• 调用当前类的其他构造方法
• 返回当前对象

示例：

public class ThisDemo {private String name;private int age;// 无参构造public ThisDemo() {this("张三", 18);  // 调用有参构造}// 有参构造public ThisDemo(String name, int age) {this.name = name;  // 区分成员变量和局部变量this.age = age;}public void printInfo() {System.out.println("姓名：" + this.name + "，年龄：" + this.age);}public ThisDemo getThis() {return this;  // 返回当前对象}public static void main(String[] args) {ThisDemo demo1 = new ThisDemo();demo1.printInfo();  // 姓名：张三，年龄：18ThisDemo demo2 = new ThisDemo("李四", 20);demo2.printInfo();  // 姓名：李四，年龄：20System.out.println(demo2 == demo2.getThis());  // true}
}

8.2 super 关键字

super 代表父类对象的引用，主要用途：

• 访问父类的成员变量
• 调用父类的方法
• 调用父类的构造方法

示例：

// 父类
class Person {protected String name;protected int age;public Person(String name, int age) {this.name = name;this.age = age;}public void sayHello() {System.out.println("大家好，我是" + name);}
}// 子类
class Student extends Person {private String school;public Student(String name, int age, String school) {super(name, age);  // 调用父类构造方法this.school = school;}@Overridepublic void sayHello() {super.sayHello();  // 调用父类的sayHello方法System.out.println("我在" + school + "上学");}public void printParentInfo() {System.out.println("父类中的姓名：" + super.name);  // 访问父类的成员变量System.out.println("父类中的年龄：" + super.age);}
}public class SuperDemo {public static void main(String[] args) {Student student = new Student("张三", 20, "北京大学");student.sayHello();/*输出：大家好，我是张三我在北京大学上学*/student.printParentInfo();/*输出：父类中的姓名：张三父类中的年龄：20*/}
}

8.3 this 与 super 的区别

区别点	this	super
概念	指向当前对象	指向父类对象
访问属性	访问当前类的属性	访问父类的属性
调用方法	调用当前类的方法	调用父类的方法
调用构造	调用当前类的其他构造	调用父类的构造
使用位置	可以在构造方法和普通方法中使用	可以在构造方法和普通方法中使用
与构造方法	必须放在构造方法的第一行（如果使用）	必须放在构造方法的第一行，且与 this 不能同时使用

总结

本文详细介绍了 Java 面向对象编程的核心概念，包括：

• 类与对象：类是模板，对象是实例
• 方法：类的行为，有多种形式
• 方法重载：同类中同名不同参的方法
• 封装：隐藏实现细节，提供接口
• 继承：子类继承父类，实现代码复用
• 方法重写：子类重写父类方法，实现多态
• 多态：同一操作作用于不同对象产生不同结果
• this 与 super：分别指向当前对象和父类对象

        掌握这些概念是学好 Java 面向对象编程的基础，建议通过大量练习加深理解，灵活运用这些特性编写高效、易维护的 Java 程序。