Java进阶——面向对象编程

欢乐狗 · 2025-3-5 17:32:01

本篇文章，将深入探讨 Java 面向对象编程的关键知识点，并用一些例子展示这些概念的现实工作开辟中的应用。

一、三大特性

1. 封装

封装是指隐藏对象的内部细节，通过 private 关键字控制对对象属性的访问，并提供 public 的 getter/setter 方法来实现对属性的安全访问和修改。

public class User {
private String password;
public void setPassword(String input) {
if (isValidPassword(input)) {
this.password = encrypt(input);
}
}
private boolean isValidPassword(String input) {
// 密码验证逻辑
return input.length() >= 6;
}
private String encrypt(String input) {
// 加密逻辑
return "encrypted_" + input;
}
}

复制代码

getter/setter里面可以做一些简朴的逻辑
2. 继承

Java 中的继承通过 extends 关键字实现，一个类只能继承一个父类。子类可以重写父类的方法，通过 @Override 注解显式声明。

// 父类
class Animal {
public void sound() {
System.out.println("sound");
}
}
// 子类
class Dog extends Animal {
@Override
public void sound() {
System.out.println("barks");
}
}
public class Main {
public static void main(String[] args) {
Animal animal = new Dog();
animal.sound();
}
}

复制代码

3. 多态

多态分为编译时多态和运行时多态。编译时多态通过方法重载实现，运行时多态通过父类引用指向子类对象实现。

// 方法重载
class Calculator {
public int add(int a, int b) {
return a + b;
}
public double add(double a, double b) {
return a + b;
}
}
// 运行时多态
class Animal {
public void sound() {
System.out.println("sound");
}
}
class Dog extends Animal {
@Override
public void sound() {
System.out.println("barks");
}
}
public class Main {
public static void main(String[] args) {
Animal animal = new Dog();
animal.sound();
}
}

复制代码

二、类与对象

1. 对象创建

利用 new 关键字触发构造方法调用，对象内存分配在堆中，引用变量存储在栈中。

class Person {
String name;
public Person(String name) {
this.name = name;
}
}
public class Main {
public static void main(String[] args) {
Person person = new Person("John");
System.out.println(person.name);
}
}

复制代码

2. 构造方法

构造方法与类同名，无返回类型，可以重载多个构造器。默认构造器在类未定义任何构造器时自动生成。

class Car {
private String brand;
// 默认构造器
public Car() {
this.brand = "Unknown";
}
// 带参数的构造器
public Car(String brand) {
this.brand = brand;
}
public String getBrand() {
return brand;
}
}
public class Main {
public static void main(String[] args) {
Car car1 = new Car();
Car car2 = new Car("Toyota");
System.out.println(car1.getBrand());
System.out.println(car2.getBrand());
}
}

复制代码

3. 静态成员

static 修饰的属性和方法属于类级别，通过类名直接访问。静态方法不能访问非静态成员（无 this 上下文）。

class MathUtils {
public static final double PI = 3.14159;
public static double circleArea(double radius) {
return PI * radius * radius;
}
}
public class Main {
public static void main(String[] args) {
double area = MathUtils.circleArea(5);
System.out.println(area);
}
}

复制代码

三、访问控制修饰符

Java 提供了四种访问控制修饰符：private、默认、protected 和 public。
修饰符类内部同包子类其他包private✔✘✘✘默认✔✔✘✘protected✔✔✔✘public✔✔✔✔

四、方法相关

1. 方法签名

方法签名由方法名 + 参数列表构成（返回类型和异常不属于签名）。
2. final 关键字

final 可以修饰类（不可继承）、方法（不可重写）、变量（常量）。

final class FinalClass {
// final 方法
public final void finalMethod() {
System.out.println("Final method");
}
}
public class Main {
public static void main(String[] args) {
final int MAX_VALUE = 100;
// MAX_VALUE = 200; // 编译错误，final 变量不可修改
}
}

复制代码

3. 可变参数

public class Main {
public void printItems(String... items) {
for (String item : items) {
System.out.println(item);
}
}
public static void main(String[] args) {
Main main = new Main();
main.printItems("1", "2", "3");
}
}

复制代码

五、对象生命周期

对象的生命周期包括创建、利用和销毁三个阶段。对象由 new 关键字实例化，利用引用利用对象，最后由垃圾回收器自动回收无引用对象。

六、高级特性

1. 接口和抽象类

特性接口抽象类实现方式implementsextends方法实现Java 8+ 支持默认方法可包含详细方法成员变量默认 public static final无限制多继承支持多接口继承单继承 2. 内部类

Java 中有四种内部类：成员内部类、静态内部类、局部内部类和匿名内部类。

// 成员内部类
class OuterClass {
private int outerField;
class InnerClass {
public void accessOuterField() {
System.out.println(outerField);
}
}
}
// 静态内部类
class OuterClass2 {
private static int staticOuterField;
static class StaticInnerClass {
public void accessStaticOuterField() {
System.out.println(staticOuterField);
}
}
}
// 局部内部类
class OuterClass3 {
public void outerMethod() {
final int localVariable = 10;
class LocalInnerClass {
public void accessLocalVariable() {
System.out.println(localVariable);
}
}
LocalInnerClass inner = new LocalInnerClass();
inner.accessLocalVariable();
}
}
// 匿名内部类
class Main {
public static void main(String[] args) {
Runnable task = new Runnable() {
@Override
public void run() {
System.out.println("Task running");
}
};
new Thread(task).start();
}
}

复制代码

3. 枚举类

利用 enum 关键字定义枚举类，自动继承 java.lang.Enum。

public enum OrderStatus {
PENDING("待处理"), PAID("已支付");
private String desc;
OrderStatus(String desc) { this.desc = desc; }
public String getDesc() {
return desc;
}
}
public class Main {
public static void main(String[] args) {
OrderStatus status = OrderStatus.PENDING;
System.out.println(status.getDesc());
}
}

复制代码

七、对象关系

1. 组合

组合是一种强关联关系，团体与部分的生命周期同等。

class Engine {
public void start() {
System.out.println("Engine started");
}
}
class Car {
private Engine engine = new Engine();
public void startCar() {
engine.start();
}
}
public class Main {
public static void main(String[] args) {
Car car = new Car();
car.startCar();
}
}

复制代码

2. 聚合

聚合是一种弱关联关系，团体与部分可以独立存在。

class Student {
private String name;
public Student(String name) {
this.name = name;
}
}
class Classroom {
private List<Student> students;
public Classroom(List<Student> students) {
this.students = students;
}
}
public class Main {
public static void main(String[] args) {
Student student1 = new Student("Alice");
Student student2 = new Student("Bob");
List<Student> students = List.of(student1, student2);
Classroom classroom = new Classroom(students);
}
}

复制代码

总结

面向对象编程的焦点在于明白类与对象的关系。

← 上一篇 Java进阶——Stream流以及常用方法详解

记得点赞、关注、收藏哦！

下一篇 Java进阶——注解一文全懂 →

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

		自动登录	找回密码
密码			立即注册

Java进阶——面向对象编程

0 个回复

快速回复

楼主热帖

标签云

浏览过的版块