一、面向对象编程基础概念
1. 对象与类
对象是现实事物的抽象，通过属性和行为描述。例如，一个“学生”对象可以有“学号、姓名”等属性，以及“学习、提交作业”等行为。
类是对象的模板，定义对象的属性（成员变量）和行为（成员方法）。
示例代码：定义一个 Person 类
public class Person {
// 成员变量
String name;
int age;
// 成员方法
public void speak() {
System.out.println(name + "正在说话");
}
}2. 构造方法
构造方法用于初始化对象，其名称与类名相同，无返回值类型。不能被继承，可以被重载。
示例代码：带参数的构造方法
public class Person {
String name;
int age;
// 构造方法
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}二、封装
1. 概念
将属性私有化（private），通过公有方法（getter/setter）控制访问，确保数据安全。
2. 实现方式
示例代码：使用封装保护属性
public class Student {
private String id; // 私有属性
// public方法提供访问入口
public String getId() {
return id;
}
public void setId(String id) {
if (id != null && !id.isEmpty()) {
this.id = id;
}
}
}3. 优势
数据安全：避免非法值直接修改属性。
灵活性：在 setter中可添加校验逻辑。
三、继承
1. 概念
子类继承父类的属性和方法，并扩展自身功能。
示例代码：Student继承 Person
public class Student extends Person {
private String major;
public Student(String name, int age, String major) {
super(name, age); // 调用父类构造方法
this.major = major;
}
}
2. 方法重写（Override）
子类重写父类方法以实现特定行为。
示例代码：重写 speak()方法
public class Student extends Person {
@Override
public void speak() {
System.out.println("学生" + name + "正在回答问题");
}
}四、多态
1. 概念
同一方法在不同对象中有不同实现。
示例代码：父类引用指向子类对象
Person p1 = new Person("张三", 20);
Person p2 = new Student("李四", 18, "计算机科学");
p1.speak(); // 输出：张三正在说话
p2.speak(); // 输出：学生李四正在回答问题
五、抽象与接口
1. 抽象类
定义规范，子类必须实现抽象方法。
示例代码：抽象类 Shape
public abstract class Shape {
public abstract double calculateArea(); // 抽象方法
}
2. 接口
定义行为契约，支持多继承。
示例代码：接口 Drawable
public interface Drawable {
void draw(); // 默认 public abstract
}
class Circle implements Drawable {
@Override
public void draw() {
System.out.println("绘制圆形");
}
}
六、final 关键字
1. 修饰类
final修饰的类不可被继承，常用于设计不可变类。
final class ImmutableClass {
private final int value;
public ImmutableClass(int value) {
this.value = value;
}
public int getValue() {
return value;
}
}
// 编译错误：无法继承 final 类
// class SubClass extends ImmutableClass {}
2. 修饰方法
final方法不可被子类重写，确保方法逻辑不变。
class Parent {
public final void printMessage() {
System.out.println("这是父类的最终方法");
}
}
class Child extends Parent {
// 编译错误：无法重写 final 方法
// @Override
// public void printMessage() {}
}
3. 修饰变量
final变量为常量，赋值后不可修改。
public class Constants {
public static final double PI = 3.1415926;
public static void main(String[] args) {
// PI = 3.14; // 编译错误：常量不可修改
}
}七、Object 类
1. 核心地位
所有类的隐式父类，提供基础方法（如 toString()、equals()、hashCode()）。 2. 常用方法
示例代码：重写 toString() 和 equals()
class Student {
private String id;
private String name;
@Override
public String toString() {
return "学号：" + id + "，姓名：" + name;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
Student student = (Student) obj;
return id.equals(student.id) && name.equals(student.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name);
}
}八、内部类
内部类是定义在另一个类内部的类，可直接访问外部类的成员。根据定义位置和修饰符的不同，分为以下四类：
1. 成员内部类
特点：
- 作为外部类的成员，可直接访问外部类的所有成员（包括 private）。
- 必须先创建外部类对象，再创建内部类对象。
示例代码：
class Outer {
private int outerValue = 10;
// 成员内部类
class Inner {
void print() {
System.out.println("访问外部类属性：" + outerValue); // 直接访问外部类私有成员
}
}
}
// 使用方式
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(); // 通过外部类对象创建内部类对象
inner.print(); // 输出：访问外部类属性：102. 静态内部类
特点：
- 使用static修饰，属于外部类本身，无需依赖外部类对象。
- 只能直接访问外部类的静态成员。
示例代码：
class Outer {
private static int staticValue = 20;
private int instanceValue = 30;
// 静态内部类
static class StaticInner {
void print() {
System.out.println("访问外部类静态属性：" + staticValue);
// System.out.println(instanceValue); // 编译错误！不能访问外部类实例成员
}
}
}
// 使用方式
Outer.StaticInner staticInner = new Outer.StaticInner(); // 直接通过类名访问
staticInner.print(); // 输出：访问外部类静态属性：203. 局部内部类
特点：
- 定义在方法或代码块内部，作用域仅限于该方法或代码块。
- 若访问方法的局部变量，该变量必须是 final
示例代码：
class Outer {
public void method() {
final int localVar = 40; // 局部变量必须为 final 或等效 final
// 局部内部类（定义在方法内）
class LocalInner {
void print() {
System.out.println("访问局部变量：" + localVar);
// localVar = 50; // 编译错误！不可修改 final 变量
}
}
LocalInner inner = new LocalInner();
inner.print(); // 输出：访问局部变量：40
}
}
// 使用方式
Outer outer = new Outer();
outer.method();4. 匿名内部类
特点：
- 没有类名，直接通过 new 接口/父类() { ... } 方式定义。
- 常用于简化事件监听、线程实现等场景。
示例代码（实现接口）：
interface ClickListener {
void onClick();
}
public class Button {
public void addClickListener(ClickListener listener) {
listener.onClick();
}
public static void main(String[] args) {
Button button = new Button();
// 匿名内部类实现接口
button.addClickListener(new ClickListener() {
@Override
public void onClick() {
System.out.println("按钮被点击！");
}
});
}
}
示例代码（继承父类）：
abstract class Animal {
abstract void sound();
}
public class Test {
public static void main(String[] args) {
// 匿名内部类继承抽象类
Animal dog = new Animal() {
@Override
void sound() {
System.out.println("汪汪汪");
}
};
dog.sound(); // 输出：汪汪汪
}
}内部类的核心优势
1. 封装性：将仅在一个地方使用的类逻辑隐藏在外部类内部。
2. 直接访问外部类成员：简化对外部类私有属性的操作。
3. 多继承模拟：通过实现多个接口间接实现多继承（如匿名内部类）。
九、this 关键字
1. 指代当前对象
用于访问当前对象的成员变量或方法。
示例代码：
class Person {
private String name;
public void setName(String name) {
this.name = name; // this 区分成员变量与局部变量
}
}
2. 构造方法调用
在构造方法中调用其他构造方法。
示例代码：
class Student {
private String name;
private int age;
public Student() {
this("未知", 0); // 调用带参构造方法
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}总结
面向对象编程通过六大核心特性（封装、继承、多态、抽象、接口、内部类）和关键语法（final、this、Object类），构建了灵活、安全且可扩展的代码体系。
扫一扫
5041
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
