[Java基础] 流程控制
[Java基础] 运算符
[Java基础] 基本数据类型
[Java基础] Java HashMap 的数据结构和底层原理
目录
什么是面向对象编程
优势
劣势
类与对象
类（Class）
对象（Object）
区别
实战案例
定义Book类
创建并使用Book对象
封装
封装的主要特点
封装的实战案例
定义 BankAccount 类
创建并使用 BankAccount 对象
代码解释
继承
继承的主要特点
继承的实战案例
定义 Animal 父类
定义 Dog 子类
定义 Cat 子类
创建并使用 Animal、Dog 和 Cat 对象
代码解释
多态
多态的主要特点
多态的实战案例
定义 Shape 父类
定义 Circle 子类
定义 Rectangle 子类
定义 Triangle 子类
创建并使用 Shape 对象
代码解释
什么是面向对象编程
面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它将数据（属性）和操作数据的方法（行为）封装在一起，形成一个称为“对象”的独立单元。面向对象编程的核心思想是模拟现实世界中的对象及其交互方式，使程序更直观、模块化和易于维护。面向对象编程主要又以下的一些特征。
- 类（Class）：定义对象的结构和行为
- 对象（Object）：表示现实世界中的实体或概念。
- 封装（Encapsulation）：保护数据不被外部直接访问，提高安全性和代码的可维护性。
- 继承（Inheritance）：促进代码重用和建立类的层次结构。
- 多态（Polymorphism）：增加代码的灵活性和扩展性。
优势
- 模块化：将程序分解成独立的模块，每个模块负责特定的功能，便于开发和维护。
- 重用性：通过继承和组合，可以重用现有的代码，减少重复劳动。
- 可扩展性：通过多态和接口，可以轻松地添加新的功能和行为，而不会影响现有代码。
- 易维护性：封装使得代码更加安全，减少了外部对内部实现的依赖，降低了维护成本。
劣势
- 过度设计：为了追求完美的面向对象设计，有时会导致过度设计，增加了系统的复杂性。例如，过多的类和接口可能会使代码难以理解和维护。
- 内存占用：对象的创建和销毁会消耗更多的内存。每个对象都需要分配内存来存储其属性和方法，这可能导致内存使用效率降低。
- 运行时开销：动态绑定（如多态）会引入额外的运行时开销，尤其是在性能敏感的应用中，这种开销可能是不可接受的。
- 框架依赖：许多面向对象的框架和库增加了代码的体积和复杂性，可能会影响性能和可维护性。
类与对象
在Java中，类（Class）和对象（Object）是面向对象编程（OOP）的基本概念。理解它们之间的区别对于掌握Java编程至关重要。
类（Class）
类是一个模板或蓝图，它定义了具有相似属性（变量）和行为（方法）的对象。类可以看作是一个抽象的概念，它描述了如何创建具体的实体（即对象）。类本身不是实际存在的东西，而是一个用来创建对象的模板。它具有以下的特点：
- 属性（Variables）：类中可以定义各种类型的变量，如整型、字符串等，用于存储对象的状态。
- 方法（Methods）：类中可以定义方法，用于实现对象的行为。
- 构造器（Constructors）：用于初始化新创建的对象成员变量。
- 访问修饰符（Access Modifiers）：如public, private, protected，用于控制类、方法和变量的可见性。
对象（Object）
对象是类的具体实例。当根据类创建一个对象时，这个对象就拥有了类所定义的所有属性和方法。每个对象都有自己的状态（属性值），但共享同一套行为（方法）。
区别
- 抽象与具体：类是抽象的，是对象的模板；对象是具体的，是类的实例。
- 存在形式：类存在于编译后的字节码文件中；对象在运行时存在于内存中。
- 作用：类用于定义对象的结构和行为；对象用于表示现实世界中的实体或概念。
实战案例
假设我们要开发一个简单的图书管理系统，其中需要处理图书的信息。我们可以先定义一个Book类，然后根据这个类创建不同的Book对象来表示具体的图书。
定义Book类
public class Book {// 属性private String title;private String author;private int yearPublished;// 构造函数public Book(String title, String author, int yearPublished) {this.title = title;this.author = author;this.yearPublished = yearPublished;}// 方法public void displayInfo() {System.out.println("书名: " + title);System.out.println("作者: " + author);System.out.println("出版年份: " + yearPublished);}
}创建并使用Book对象
public class Main {public static void main(String[] args) {// 创建Book对象Book book1 = new Book("平凡的世界", "路遥", 1986);Book book2 = new Book("活着", "余华", 1993);// 显示书籍信息book1.displayInfo();book2.displayInfo();}
}在这个例子中，Book类定义了所有图书共有的属性和行为，而book1和book2则是Book类的具体实例，它们各自代表了一本具体的书。
封装
封装（Encapsulation）是面向对象编程（OOP）的核心概念之一，它是指将数据（属性）和操作数据的方法（行为）绑定在一起，并隐藏对象的内部实现细节。封装的主要目的是保护数据不被外部直接访问，提高安全性和代码的可维护性。
封装的主要特点
- 数据隐藏：通过将属性设为私有（
private），防止外部直接访问和修改。 - 访问控制：通过提供公共的方法，让外部可以不感知内部的实现细节。
- 增强安全性：防止外部代码对内部数据的非法访问和修改。
- 提高可维护性：通过封装，可以在不改变外部调用的情况下修改内部实现。
封装的实战案例
假设我们要开发一个简单的银行账户管理系统，其中需要处理账户的基本信息，如账户号、余额等。我们可以使用封装来保护账户的敏感信息，并提供安全的访问和修改方法。
定义 BankAccount 类
public class BankAccount {// 私有属性private String accountNumber;private double balance;// 构造器public BankAccount(String accountNumber, double initialBalance) {this.accountNumber = accountNumber;this.balance = initialBalance;}// 提供安全的存款方法public void deposit(double amount) {if (amount > 0) {balance += amount;System.out.println("存入 " + amount + " 元，当前余额为 " + balance + " 元。");} else {System.out.println("存款金额必须大于0。");}}// 提供安全的取款方法public void withdraw(double amount) {if (amount > 0 && amount <= balance) {balance -= amount;System.out.println("取出 " + amount + " 元，当前余额为 " + balance + " 元。");} else {System.out.println("取款金额必须大于0且不超过当前余额。");}}// 提供显示账户信息的方法public void displayAccountInfo() {System.out.println("账户号: " + accountNumber);System.out.println("余额: " + balance + " 元");}
}创建并使用 BankAccount 对象
public class Main {public static void main(String[] args) {// 创建BankAccount对象BankAccount myAccount = new BankAccount("123456789", 1000.0);// 显示账户信息myAccount.displayAccountInfo();// 存款myAccount.deposit(500.0);// 取款myAccount.withdraw(200.0);// 再次显示账户信息myAccount.displayAccountInfo();// 尝试非法操作myAccount.withdraw(2000.0); // 取款金额超过余额myAccount.deposit(-100.0); // 存款金额小于0}
}代码解释
- 私有属性：
accountNumber和balance被设为私有，防止外部直接访问和修改。 - 构造器：
BankAccount类的构造器用于初始化账户号和初始余额。 - 存款方法：
deposit方法用于安全地存入金额，只允许存入正数。 - 取款方法：
withdraw方法用于安全地取出金额，只允许取出正数且不超过当前余额。 - 显示账户信息：
displayAccountInfo方法用于显示账户的基本信息。
继承
继承（Inheritance）是面向对象编程（OOP）中的一个重要概念，它允许一个类（子类）继承另一个类（父类）的属性和方法。通过继承，可以实现代码的重用，减少重复代码，同时建立类之间的层次结构。
继承的主要特点
- 代码重用：子类可以继承父类的属性和方法，减少重复代码。
- 层次结构：通过继承，可以建立类的层次结构，反映现实世界中的关系。
- 多态：继承是实现多态的基础，子类可以覆盖父类的方法，实现不同的行为。
继承的实战案例
假设我们要开发一个简单的动物管理系统，其中需要处理不同种类的动物。我们可以使用继承来建立动物类的层次结构，减少重复代码。
定义 Animal 父类
public class Animal {// 属性private String name;private int age;// 构造器public Animal(String name, int age) {this.name = name;this.age = age;}// 方法public void eat() {System.out.println(name + " 在吃东西。");}public void sleep() {System.out.println(name + " 在睡觉。");}// 抽象方法，子类需要实现public void makeSound() {System.out.println(name + " 发出声音。");}
}定义 Dog 子类
public class Dog extends Animal {// 新增属性private String breed;// 构造器public Dog(String name, int age, String breed) {// 调用父类的构造器super(name, age); this.breed = breed;}// 重写父类的方法（Java核心特性覆写）@Overridepublic void makeSound() {System.out.println(getName() + " 在汪汪叫。");}// 新增方法public void fetch() {System.out.println(getName() + " 去捡球。");}
}定义 Cat 子类
public class Cat extends Animal {// 新增属性private boolean isIndoor;// 构造器public Cat(String name, int age, boolean isIndoor) {super(name, age); // 调用父类的构造器this.isIndoor = isIndoor;}// 重写父类的方法（Java核心特性覆写）@Overridepublic void makeSound() {System.out.println(getName() + " 在喵喵叫。");}// 新增方法public void climbTree() {System.out.println(getName() + " 爬树。");}
}创建并使用 Animal、Dog 和 Cat 对象
public class Main {public static void main(String[] args) {// 创建Animal对象Animal myAnimal = new Animal("动物", 5);myAnimal.eat();myAnimal.sleep();myAnimal.makeSound();// 创建Dog对象Dog myDog = new Dog("狗狗", 3, "金毛");myDog.eat();myDog.sleep();myDog.makeSound();myDog.fetch();// 创建Cat对象Cat myCat = new Cat("猫咪", 2, true);myCat.eat();myCat.sleep();myCat.makeSound();myCat.climbTree();}
}代码解释
父类 Animal：定义了基本的属性（name 和 age）和方法（eat 和 sleep）。提供了一个抽象方法 makeSound，子类需要覆写实现这个方法。
子类 Dog：继承了 Animal 类，新增了一个属性 breed。覆写了 makeSound 方法，实现了狗的叫声。新增了一个方法 fetch，表示狗去捡球的行为。
子类 Cat：继承了 Animal 类，新增了一个属性 isIndoor。重写了 makeSound 方法，实现了猫的叫声。新增了一个方法 climbTree，表示猫爬树的行为。
主类 Main：创建了 Animal、Dog 和 Cat 对象，并调用了它们的方法，展示了继承和多态的特点。
多态
多态（Polymorphism）是面向对象编程（OOP）中的一个重要概念，它允许一个接口或基类引用指向不同的派生类对象，从而实现不同的行为。多态主要有两种形式：方法重载（Overloading）和方法重写（Overriding）。
多态的主要特点
- 代码灵活性：通过多态，可以使用基类的引用调用子类的方法，实现不同的行为，提高了代码的灵活性。
- 代码扩展性：可以轻松地添加新的子类，而不需要修改现有的代码，增强了代码的扩展性。
- 代码复用：通过多态，可以复用基类的代码，减少重复代码。
多态的实战案例
假设我们要开发一个简单的图形绘制系统，其中需要处理不同类型的图形（如圆形、矩形等）。我们可以使用多态来实现不同图形的绘制方法。
定义 Shape 父类
//abstract是Java的关键字，用于定义抽象类
public abstract class Shape {// 抽象方法，子类必须实现public abstract void draw();
}定义 Circle 子类
public class Circle extends Shape {private double radius;public Circle(double radius) {this.radius = radius;}@Overridepublic void draw() {System.out.println("绘制一个半径为 " + radius + " 的圆。");}
}定义 Rectangle 子类
public class Rectangle extends Shape {private double width;private double height;public Rectangle(double width, double height) {this.width = width;this.height = height;}@Overridepublic void draw() {System.out.println("绘制一个宽为 " + width + "，高为 " + height + " 的矩形。");}
}定义 Triangle 子类
public class Triangle extends Shape {private double base;private double height;public Triangle(double base, double height) {this.base = base;this.height = height;}@Overridepublic void draw() {System.out.println("绘制一个底为 " + base + "，高为 " + height + " 的三角形。");}
}创建并使用 Shape 对象
public class Main {public static void main(String[] args) {// 创建不同类型的Shape对象Shape circle = new Circle(5.0);Shape rectangle = new Rectangle(4.0, 6.0);Shape triangle = new Triangle(3.0, 4.0);// 使用多态调用draw方法drawShape(circle);drawShape(rectangle);drawShape(triangle);}// 通用的绘图方法，这里会调用传进来的不同子类的draw()方法，执行的是子类的行为public static void drawShape(Shape shape) {shape.draw();}//控制台输出/*绘制一个半径为 5.0 的圆。绘制一个宽为 4.0，高为 6.0 的矩形。绘制一个底为 3.0，高为 4.0 的三角形。*/
}代码解释
父类 Shape：定义了一个抽象方法 draw，子类必须实现这个方法。
子类 Circle：继承了 Shape 类，实现了 draw 方法，绘制一个圆。
子类 Rectangle：继承了 Shape 类，实现了 draw 方法，绘制一个矩形。
子类 Triangle：继承了 Shape 类，实现了 draw 方法，绘制一个三角形。
主类 Main：创建了 Circle、Rectangle 和 Triangle 对象，并将它们赋值给 Shape 类型的变量。通过 drawShape 方法调用 draw 方法，展示了多态的特点。