Java面向对象

让我们先记住这4个核心特性吧：
​​面向对象四大特性​​
封装（保险箱藏数据）
继承（父子关系传承）
多态（变形金刚变身）
抽象（模板化设计）

一、类和对象（重点基础）

1. 类 vs 对象

• 类​​ = 设计图（如：手机设计图）
• ​​对象​​ = 具体实物（如：你手里的iPhone16）

// 类定义
public class Phone {// 属性（成员变量）String brand; double price;// 方法（行为）void call(String number) {System.out.println("正在拨打：" + number);}
}// 创建对象
Phone myPhone = new Phone(); 
myPhone.brand = "华为";
myPhone.call("10086"); // 调用方法

二、封装（Encapsulation）

​​核心思想​​：把数据藏起来，通过安全通道访问

public class Student {// 用private隐藏数据（重点！）private String name;private int age;// 对外提供getter/setter（安全通道）public String getName() { return name; }public void setAge(int age) {if(age > 0 && age < 150) { // 数据校验this.age = age;} else {System.out.println("年龄无效！");}}
}// 使用
Student s = new Student();
s.setAge(20); // 正确
s.setAge(200); // 输出"年龄无效！"

三、继承（Inheritance）

​​核心思想​​：子类继承父类特征（代码复用）

// 父类
class Animal {void eat() {System.out.println("吃东西");}
}// 子类继承（extends关键字）
class Dog extends Animal {// 特有方法void bark() {System.out.println("汪汪叫");}
}// 使用
Dog myDog = new Dog();
myDog.eat();  // 继承自父类
myDog.bark(); // 自己的方法

​​关键点​​：

• Java是单继承（一个类只能有一个父类）
• 使用super访问父类成员（如：super.eat()）
• 方法重写（Override）：子类覆盖父类方法

四、多态（Polymorphism）

​​两种形式​​：

​​1.编译时多态​​（方法重载）

同名方法，参数不同

class Calculator {int add(int a, int b) { return a + b; }double add(double a, double b) { return a + b; } // 重载
}

2.​​运行时多态​​（重点！）

父类引用指向子类对象

Animal myPet = new Dog(); // 向上转型
myPet.eat(); // 实际调用Dog类的eat方法（如果重写了）// 向下转型（需强制转换）
if(myPet instanceof Dog) {Dog realDog = (Dog)myPet;realDog.bark();
}

五、抽象（Abstraction）

​​两种实现方式​​：

1.​​抽象类​​（abstract class）

abstract class Shape {// 抽象方法（没有实现）abstract double calculateArea();// 普通方法void printType() {System.out.println("这是一个形状");}
}

2.​​接口​​（interface，重点！）

interface USB {// 默认public abstract（可省略）void transferData(); // JDK8+可以有默认方法default void checkConnection() {System.out.println("检查USB连接");}
}class Mouse implements USB {@Overridepublic void transferData() {System.out.println("传输鼠标数据");}
}

3.抽象类 vs 接口​​（重点记忆！）

特性	抽象类	接口
实例化	❌ 不能实例化	❌ 不能实例化
方法实现	可以有具体方法	JDK8前只能有抽象方法
变量	可以有普通变量	默认public static final
继承	单继承	多实现（implements多个）
构造方法	✔️ 有构造方法	❌ 没有构造方法
设计理念	"is-a"关系	"has-a/can-do"能力

六、其他关键知识点

1.​​访问权限修饰符​​（重点记忆）

修饰符	类内部	同包	子类	其他包
private	✔️	❌	❌	❌
默认（不写）	✔️	✔️	❌	❌
protected	✔️	✔️	✔️	❌
public	✔️	✔️	✔️	✔️

2.​​this关键字​​：指向当前对象实例

3.static关键字​​：类级别的成员（如：Math.PI）

七、练习

1.学生信息管理​​（类与对象）

创建一个Student类，包含：

• 私有属性：学号(id)、姓名(name)、年龄(age)
• 公共的getter/setter方法（对年龄进行合法性校验，只允许0-120岁）
• 显示学生信息的方法display()
  创建一个测试类，实例化3个学生对象并显示信息
  ​​涉及知识点​​：封装、构造方法、访问控制

/*
创建一个Student类，包含：
- 私有属性：学号(id)、姓名(name)、年龄(age)
- 公共的getter/setter方法（对年龄进行合法性校验，只允许0-120岁）
- 显示学生信息的方法display()
创建一个测试类，实例化3个学生对象并显示信息*/
public class Student {private Integer id;private String name;private Integer age;public Student(){}public Student(Integer id, String name, Integer age) {this.id = id;this.name = name;this.age = age;}public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {if(age >= 0 && age <= 120) {this.age = age;}else{System.out.println("请输入合法年龄");}}public String display() {return "Student{" +"id=" + id +", name='" + name + '\'' +", age=" + age +'}';}}

public class TestStudent {@Testpublic void test1() {Student s1 = new Student(001,"Holly",18);Student s2 = new Student(002,"Alice",25);Student s3 = new Student(003,"Bob",90);s3.setAge(150);System.out.println(s1.display());System.out.println(s2.display());System.out.println(s3.display());}
}

2.汽车租赁系统​​（继承与多态）

父类：Vehicle（交通工具）
属性：brand（品牌）, rentalPrice（日租金）
方法：calculateRent(int days) 计算租金子类：Car（轿车）
新增属性：seats（座位数）
重写计算租金方法：5座以下按原价，5座及以上每天加50元子类：Truck（卡车）
新增属性：load（载重量）
重写计算租金方法：载重超过5吨，租金每天上浮30%

创建测试类，演示多态的使用（父类引用指向子类对象）

​​涉及知识点​​：继承、方法重写、多态

class Vehicle {protected String brand;protected double rentalPrice;//日租金public Vehicle(String brand, double rentalPrice) {this.brand = brand;this.rentalPrice = rentalPrice;}//计算租金（默认按天计算）public double calculateRent(int days){return rentalPrice * days;}
}
//子类：轿车
class Car extends Vehicle {private int seats;//座位数public Car(String brand, double rentalPrice, int seats) {super(brand, rentalPrice);this.seats = seats;}// 重写租金计算方法：5座以下按原价，5座及以上每天加50元@Overridepublic double calculateRent(int days){if(this.seats < 5) {return super.calculateRent(days);}else{return (rentalPrice + 50) * days;}}
}
//子类：卡车
class Truck extends Vehicle {private double load;//载重量（吨）public Truck(String brand, double rentalPrice, double load) {super(brand, rentalPrice);this.load = load;}// 重写租金计算方法：载重超过5吨，租金每天上浮30%@Overridepublic double calculateRent(int days){if(load > 5){return rentalPrice * 1.3 * days;}else{return super.calculateRent(days);}}
}
//测试类
public class VehicleRentalSystem{public static void main(String[] args) {// 创建不同类型的交通工具（多态：父类引用指向子类对象）Vehicle car1 = new Car("沃尔沃",300,5);Vehicle car2 = new Car("大众高尔夫",200,4);Vehicle truck1 = new Truck("东风",800,6.5);Vehicle truck2 = new Truck("福田",600,4.5);//存储在数组中便于遍历Vehicle[] vehicles = {car1, car2, truck1, truck2};int rentalDays = 3;//显示租赁信息for(Vehicle vehicle : vehicles){System.out.println("品牌：" + vehicle.brand);System.out.println("租期：" + rentalDays + "天");System.out.println("每日租金：" + vehicle.rentalPrice);System.out.println("总租金：" + vehicle.calculateRent(rentalDays) + "元");System.out.println("------------------");}}
}

​​3. 图形计算​​（接口与抽象类）

// 定义接口
interface Shape {double calculateArea(); // 计算面积double calculatePerimeter(); // 计算周长
}// 实现类
class Circle implements Shape { /* 实现方法 */ }
class Rectangle implements Shape { /* 实现方法 */ }

创建工厂类，根据输入类型（“circle"或"rectangle”）返回对应图形对象

​​涉及知识点​​：接口、工厂模式

public interface Shape {double calculateArea();//计算面积double calculatePerimeter();//计算周长
}

public class Circle implements Shape {private double radius;public Circle(double radius) {this.radius = radius;}@Overridepublic double calculateArea() {return Math.PI * radius * radius;}@Overridepublic double calculatePerimeter() {return 2 * Math.PI * radius;}
}

public class Rectangle implements Shape {private double length;private double width;public Rectangle(double length, double width) {this.length = length;this.width = width;}@Overridepublic double calculateArea() {return length * width;}@Overridepublic double calculatePerimeter() {return 2 * (length + width);}
}

public class ShapeFactory {public static Shape getShape(String type,double...params){if("circle".equalsIgnoreCase(type)){if(params.length == 1){return new Circle(params[0]);}}else if("rectangle".equalsIgnoreCase(type)){if(params.length == 2){return new Rectangle(params[0],params[1]);}}return null;}
}

public class TestShapeFactory {public static void main(String[] args) {Shape circle = ShapeFactory.getShape("Circle",5);if(circle != null){System.out.println("圆的面积：" + circle.calculateArea());System.out.println("圆的周长：" + circle.calculatePerimeter());}Shape rectangle = ShapeFactory.getShape("Rectangle",5,6);if (rectangle != null) {System.out.println("矩形的面积：" + rectangle.calculateArea());System.out.println("矩形的周长：" + rectangle.calculatePerimeter());}}
}

​​4. 简单图书馆系统​​（综合应用）

类结构：
- Book类（属性：书名、作者、是否借出）
- Library类（包含Book集合）方法：添加书籍、借阅书籍、归还书籍、显示所有书籍
- User类（属性：用户名，借阅列表）

要求：

• 使用ArrayList存储图书
• 实现基本的借阅/归还逻辑
• 处理异常情况（如重复借阅等）
  ​​涉及知识点​​：集合使用、类关系设计、异常处理

//测试类
public class LibrarySystem {public static void main(String[] args) {//创建图书馆和用户Library library = new Library();User user = new User("holly");//添加书籍library.addBook(new Book("Java编程思想","Bruce Eckel"));library.addBook(new Book("Effective Java", "Joshua Bloch"));library.addBook(new Book("Python数据分析", "Wes McKinney"));//显示所有书籍library.displayBooks();//借阅书籍library.borrowBook("Java编程思想", user);library.borrowBook("Java编程思想", user); // 重复借阅测试library.borrowBook("Effective Java", user);//显示用户借阅列表user.displayBorrowedBooks();//归还书籍library.returnBook("Java编程思想", user);library.returnBook("Java编程思想", user); // 重复归还测试//再次显示用户借阅列表和图书馆藏书user.displayBorrowedBooks();library.displayBooks();}
}
class Book{private String title;private String author;private boolean isBorrowed;public Book(String title, String author) {this.title = title;this.author = author;this.isBorrowed = false;}public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}public String getAuthor() {return author;}public void setAuthor(String author) {this.author = author;}public boolean isBorrowed() {return isBorrowed;}public void setBorrowed(boolean borrowed) {isBorrowed = borrowed;}@Overridepublic String toString() {return "《" + title + "》- " + author +(isBorrowed ? "[已借出]" : "[可借阅]");}
}
//图书馆类
class Library{ArrayList<Book> books;public Library() {this.books = new ArrayList<>();}//添加书籍public void addBook(Book book){books.add(book);System.out.println("已添加书籍：" + book.getTitle());}// 借阅书籍public boolean borrowBook(String title,User user){for(Book book : books){if(book.getTitle().equals(title)){if(book.isBorrowed()){System.out.println("借阅失败：《" + title + "》已被借出");return false;}if(user.hasBook(title)){System.out.println("借阅失败：您已经借阅《" + title + "》");return false;}book.setBorrowed(true);user.borrowBook(book);System.out.println("借阅成功：《" + title + "》");return true;}}System.out.println("借阅失败：未找到《" + title + "》");return false;}// 归还书籍public boolean returnBook(String title,User user){for(Book book : books){if(book.getTitle().equals(title)){if(!book.isBorrowed()){System.out.println("归还失败：《" + title + "》未被借出");return false;}if(!user.hasBook(title)){System.out.println("归还失败：您未借阅《" + title + "》");return false;}book.setBorrowed(false);user.returnBook(title);System.out.println("归还成功：《" + title + "》");return true;}}System.out.println("归还失败：未找到《" + title + "》");return false;}// 显示所有书籍public void displayBooks(){System.out.println("\n图书馆藏书列表:");if(books.isEmpty()){System.out.println("暂无藏书");}else{for(Book book : books){System.out.println(book);}}System.out.println("-------------");}
}
//用户类
class User{private String username;private List<Book> borrowedBooks;public User(String username) {this.username = username;this.borrowedBooks = new ArrayList<>();}//借阅书籍public void borrowBook(Book book){borrowedBooks.add(book);}//归还书籍public void returnBook(String title){borrowedBooks.removeIf(book -> book.getTitle().equals(title));}//检查是否已经借阅某本书public boolean hasBook(String title){return borrowedBooks.stream().anyMatch(book -> book.getTitle().equals(title));}//显示借阅列表public void displayBorrowedBooks(){System.out.println("\n" + username + " 的借阅列表：");if(borrowedBooks.isEmpty()){System.out.println("暂无借阅书籍");}else{for(Book book : borrowedBooks){System.out.println("《" + book.getTitle() + "》-" + book.getAuthor());}}System.out.println("-----------");}
}

​​5. 电商购物车系统​​（进阶挑战）

需求：
1. 商品类（Product）包含名称、价格、库存
2. 购物车类（ShoppingCart）管理商品集合
3. 实现功能：- 添加商品（库存不足时提示）- 移除商品- 计算总价- 显示购物车明细
4. 定义折扣策略接口（DiscountStrategy）：- 普通用户：无折扣- VIP用户：9折- 促销活动：满100减20

​​涉及知识点​​：接口设计、策略模式、集合操作

//测试类
public class ShoppingCarSystem {public static void main(String[] args) {//创建商品Product laptop  = new Product("笔记本电脑",5999,3);Product mouse = new Product("无线鼠标", 99, 10);Product keyboard = new Product("机械键盘", 299, 5);//创建购物车ShoppingCart cart = new ShoppingCart();cart.addProduct(laptop,1);cart.addProduct(mouse, 2);cart.addProduct(keyboard, 1);cart.addProduct(laptop, 3); // 测试库存不足//显示购物车（普通用户）cart.displayItems();//切换VIP用户策略cart.setDiscountStrategy(new VIPUserStrategy());System.out.println("\n切换为VIP用户折扣...");cart.displayItems();// 切换为促销活动策略cart.setDiscountStrategy(new PromotionStrategy());System.out.println("\n切换为促销活动折扣...");cart.displayItems();//移除商品cart.removeProduct(mouse,1);cart.displayItems();}
}
//商品类
class Product{private String name;//名称private double price;//价格private int stock;//库存public Product(String name, double price, int stock) {this.name = name;this.price = price;this.stock = stock;}public String getName() {return name;}public double getPrice() {return price;}public int getStock() {return stock;}//减少库存public boolean reduceStock(int quantity){if(stock >= quantity){stock -= quantity;return true;}return false;}//增加库存public void increaseStock(int quantity){stock += quantity;}@Overridepublic String toString() {return name + " - ￥" + price + "(库存：" + stock + ")";}
}
//折扣策略接口
interface DiscountStrategy{double applyDiscount(double total);
}
//普通用户策略（无折扣）
class NormalUserStrategy implements DiscountStrategy{@Overridepublic double applyDiscount(double total) {return total;}
}
//VIP用户策略（9折）
class VIPUserStrategy implements DiscountStrategy{@Overridepublic double applyDiscount(double total) {return total * 0.9;}
}
//促销活动策略（满100-20）
class PromotionStrategy implements DiscountStrategy{@Overridepublic double applyDiscount(double total) {return total >= 100 ? total - Math.floor(total / 100) * 20 : total;}
}
//购物车类
class ShoppingCart{private Map<Product,Integer> items;private DiscountStrategy discountStrategy;public ShoppingCart() {this.items = new HashMap<>();this.discountStrategy = new NormalUserStrategy();//默认为普通用户策略}//设置折扣策略public void setDiscountStrategy(DiscountStrategy strategy) {this.discountStrategy = strategy;}/*** 添加商品* @param product 要加入购物车的商品* @param quantity 要加入购物车的商品数量*/public void addProduct(Product product, int quantity){if(product.getStock() < quantity){System.out.println("添加失败：" + product.getName() + " 库存不足（库存: " + product.getStock() + ")");return;}if(items.containsKey(product)){items.put(product,items.get(product) + quantity);}else{items.put(product,quantity);}product.reduceStock(quantity);System.out.println("已添加 " + quantity + " 件 " + product.getName() + " 到购物车");}//移除商品public void removeProduct(Product product, int quantity){if(!items.containsKey(product)){System.out.println("移除失败：购物车中没有 " + product.getName());return;}int currentQuantity = items.get(product);if(quantity >= currentQuantity){items.remove(product);product.increaseStock(quantity);System.out.println("已从购物车移除所有 " + product.getName());}else{items.put(product,currentQuantity - quantity);product.increaseStock(quantity);System.out.println("已从购物车移除 " + quantity + " 件 " + product.getName());}}//计算总价（未打折public double calculateTotal(){double total = 0;for(Map.Entry<Product,Integer> entry : items.entrySet()){total += entry.getKey().getPrice() * entry.getValue();}return total;}//计算折扣后的价格public double calculateDiscountedTotal(){return discountStrategy.applyDiscount(calculateTotal());}//显示购物车明细public void displayItems(){System.out.println("\n购物车明细：");if(items.isEmpty()){System.out.println("购物车为空");}else{for(Map.Entry<Product,Integer> entry : items.entrySet()){Product product = entry.getKey();int quantity = entry.getValue();double subtotal = product.getPrice() * quantity;System.out.printf("%s x %d = ¥%.2f\n", product.getName(), quantity, subtotal);}System.out.println("-------------------");System.out.printf("原价总计: ¥%.2f\n", calculateTotal());System.out.printf("折扣后价格: ¥%.2f\n", calculateDiscountedTotal());}}
}

已添加 1 件 笔记本电脑 到购物车
已添加 2 件 无线鼠标 到购物车
已添加 1 件 机械键盘 到购物车
添加失败：笔记本电脑 库存不足（库存: 2)购物车明细：
无线鼠标 x 2 = ¥198.00
机械键盘 x 1 = ¥299.00
笔记本电脑 x 1 = ¥5999.00
-------------------
原价总计: ¥6496.00
折扣后价格: ¥6496.00切换为VIP用户折扣...购物车明细：
无线鼠标 x 2 = ¥198.00
机械键盘 x 1 = ¥299.00
笔记本电脑 x 1 = ¥5999.00
-------------------
原价总计: ¥6496.00
折扣后价格: ¥5846.40切换为促销活动折扣...购物车明细：
无线鼠标 x 2 = ¥198.00
机械键盘 x 1 = ¥299.00
笔记本电脑 x 1 = ¥5999.00
-------------------
原价总计: ¥6496.00
折扣后价格: ¥5216.00
已从购物车移除 1 件 无线鼠标购物车明细：
无线鼠标 x 1 = ¥99.00
机械键盘 x 1 = ¥299.00
笔记本电脑 x 1 = ¥5999.00
-------------------
原价总计: ¥6397.00
折扣后价格: ¥5137.00

6. 日志记录器​​（设计模式应用）

// 定义接口
interface Logger {void log(String message);
}// 实现类
class ConsoleLogger implements Logger { /* 输出到控制台 */ }
class FileLogger implements Logger { /* 写入文件（模拟）*/ }// 使用工厂模式创建Logger对象
class LoggerFactory {public static Logger getLogger(String type) { /* ... */ }
}

​​涉及知识点​​：工厂模式、接口设计

public class LoggerSystem {public static void main(String[] args) {//获取控制台日志记录器Logger consoleLogger = LoggerFactory.getLogger("console");consoleLogger.log("系统启动成功");//获取文件日志记录器Logger fileLogger = LoggerFactory.getLogger("file");fileLogger.log("用户登录");// 测试不支持的类型try {Logger invalidLogger = LoggerFactory.getLogger("database");} catch (IllegalArgumentException e) {System.out.println(e.getMessage());}}
}
//定义接口
interface Logger {void log(String message);
}//实现类（ 控制台日志记录器实现）
class ConsoleLogger implements Logger {/* 输出到控制台 */@Overridepublic void log(String message) {System.out.println("[控制台日志] " + message);}
}
//文件日志记录器实现（模拟写入文件）
class FileLogger implements Logger {/* 写入文件（模拟）*/@Overridepublic void log(String message) {System.out.println("[文件日志] 已记录: " + message);}
}//使用工厂模式创建Logger对象
//日志记录器工厂类
class LoggerFactory {public static Logger getLogger(String type) {if("console".equals(type)) {return new ConsoleLogger();}else if("file".equals(type)) {return new FileLogger();}throw new IllegalArgumentException("不支持的日志记录器类型：" + type);}
}

[控制台日志] 系统启动成功
[文件日志] 已记录: 用户登录
不支持的日志记录器类型：database

这些练习覆盖了企业级开发中最常用的OOP场景，让我们建立起扎实的面向对象思维吧！

📌重点记忆口诀

面向对象四特性，封装继承多态抽
类像图纸对象物，new关键字来生成
私有属性公开方，数据安全封装强
子承父业用继承，方法重写显特色
父类引用子对象，多态灵活变化多
抽象接口定规范，具体实现靠子类