类

面向对象编程(OOP)

介绍

• 把问题抽象成一个类,通过调用类成员的方式来解决问题
• 面向过程是将问题抽象成一个个的方法,通过调用方法来解决问题

特性

封装

• 通过访问修饰符将数据隐藏,外部不能直接访问,只能通过类提供的公共方法进行操作

继承

• 子类通过extends关键字继承父类的非私有方法和属性
• 子类可以重写父类的方法
• 子类对象可以作为父类的类型进行引用
• 高耦合,父类的修改可能会影响子类

多态

• 同一个方法或操作在不同对象上产生不同的结果

组成

成员变量

特点

1. 在类中,方法外定义
2. 存储在堆内存中,每个类实例都有自己的成员变量
3. 静态成员变量存储在方法区,属于类本身,所有类实例共享
4. 有默认值,数值类型默认为,布尔类型默认为false,引用类型默认为null

生命周期

• 随着对象的创建而创建,随着对象的销毁而结束
• 静态成员变量在类加载时创建,类卸载时结束

初始化

1. 默认初始化,初始化未显式赋值的成员变量
2. 显式初始化,初始化显式赋值的成员变量
3. 构造方法初始化,通过构造方法初始化成员变量

成员方法

特点

• 通过对象实例调用
• 静态方法可以通过类名调用,也可以通过对象实例调用

重载与重写

操作	Overload	Override
发生位置	同一类	子类
方法名	相同	相同
参数列表	可以不同	相同
访问修饰符	可以不同(无限制)	子类的访问修饰符必须大于等于父类方法的访问修饰符
返回值类型	可以不同	子类的返回值类型必须等于父类的返回值类型或是其子类

构造器

特点

1. 构造方法名必须与类名相同
2. 没有返回值类型
3. 在创建对象时自动调用
4. 可以重载
5. 用于初始化新创建的对象
6. 如果没有定义构造器,java会自动提供一个默认的无参构造器
7. 对象初始化时,子类默认会调用父类的无参构造器,如果父类没有无参构造器,则需要使用super方法显式调用

代码块

匿名代码块

1. 创建对象时执行
2. 常用于初始化类成员
3. 多个代码块,从上而下执行

静态代码块

1. 在类加载时执行,仅执行一次
2. 常用于初始化静态变量

局部代码块

1. 定义在方法内部或构造器内部
2. 用于限制及局部变量的作用域

同步代码块

1. 实现线程同步,确保同一时刻只有一个线程能访问该代码块

访问修饰符

访问修饰符	范围
private	当前类内部可见,其他类(子类,同包类)无法访问
默认	当前包所有类可见,不同包的类(包括子类)无法访问
protected	当前包与其他包的子类(继承)可见
public	所有位置都可见

this与super

• this用于调用当前类的变量或方法
• super用于调用父类的方法或父类的构造方法

final

修饰对象	说明
变量	final修饰变量表示其值不可修改且必须显式初始化
类	final修饰类表示该类为最终类,不能被继承
方法	final修饰方法表示该方法不能被重写

内部类

特点

• 在类中定义另一个类
• 可以访问外部类的私有成员
• 内部类可以是静态的

匿名内部类

特点

• 没有类名
• 没有构造器
• 可以访问外部类的成员
• 不能访问非final修饰的局部变量
• 主要用于快速实现接口或抽象类

组合

特点

• 一个类的成员变量是另一个类对象
• 低耦合,不依赖于父类的实现细节

组合与继承

特性	组合	继承
关系	包含(Dog包含Body)	是(Dog是Animal)
灵活性	可以动态的替换成员对象	编译时绑定

设计模式

创建型模式

• 对象创建的模式解耦

单例模式

特点

• Singleton
• 确保类只有一个实例,并提供全局访问点
• 适用于数据库连接池,日志管理类,配置类

实现

• 线程安全 + 双重检查锁
• 私有化构造器
• 设置一个外部访问的示例instance
• 设置访问instance的方法,通过锁保证任何线程访问该类都只有一个实例

示例

public class DBConnection{
    private static volatile DBConnection instance;
    private DBConnection(){}//私有化构造器

    public static DBConnection getInstance(){
        if(instance == null){
            synchronized(DBConnection.class){
                if(instance == null){
                    instance = new DbConnection();
                }
            }
        }
        return instance;
    }
}

工厂方法模式

特点

• Factory Method
• 将对象创建的逻辑延迟到子类,解决对象创建依赖的问题
• 适用于根据条件动态创建对象的场景

实现

• 创建接口与实现类
• 创建工厂类,编写方法根据参数判断要创建的实现类

示例

interface Vehicle{
    void start();
}

class Car implements Vehicle{
    @Override
    public void start(){
        System.out.println("car started");
    }
}

class Moto implements Vehicle{
    @Override
    public void moto(){
        System.out.println("moto started");
    }
}

class VehicleFactory{
    public Vehicle createVehicle(String type){
        return switch(type){
            case "car"-> new Car();
            case "moto" -> new Moto();
            default -> throw new IllegalArgumentException("Invalid type");
        }
    }
}

抽象工厂模式

特点

• Abstract Factory
• 创建相关或依赖的对象家族,无需指定具体类
• 适用于跨平台UI组件库,不同的主题系统

实现

• 创建接口与实现类
• 实现类返回对应的类

示例

interface GUIFactory{
    Button createButton();
}

class WinFactory implements GUIFactory{
    @Override
    public Button createButton(){
        return new WinButton();
    }
}

class MacFactory implements GUIFactory{
    @Override
    public Button createButton(){
        return new MacButton();
    }
}

工厂方法与抽象工厂

• 工厂方法针对一个产品等级结构(如车)
• 抽象工厂针对多个产品登记结构(如车 + 轮胎 + 引擎)

结构型模式

• 类与对象的组合结构优化

适配器模式

特点

• Adapter
• 让不兼容的接口协同工作

实现

• 创建一个新接口
• 创建类适配器,继承老接口,实现新接口,并使用新接口的实现方法调用老接口方法
• 适用于整合第三方库,兼容旧系统代码

示例

class LegacyPrinter{//旧接口
    void printDocument(){
        System.out.println("print");
    }
}

interface ModernPrinter{//新接口
    void print();
}

class PrinterAdapter extends LegacyPrinter implements ModernPrint{//类适配器
    @Override
    public void print(){
        super.printDocument();
    }
}

装饰者模式

特点

• Decorator
• 动态的为对象添加额外职责,比继承更灵活
• 适用于IO流,动态功能扩展

实现

• 创建装饰者基类,实现接口
• 装饰者基类,有接口的成员变量与赋值接口的构造方法
• 继承装饰者基类,调用基类构造方法,并对基类的成员变量进行扩展操作

示例

interface Coffee{
    double getCost();
    String getDescription();
}

class Simple impelents Coffee{
    @Override 
    public double getCost(){
        reutrn 2.0'
    }

    @Override
    public String getDescription(){
        return "simple";
    }
}

abstract class CoffeeDecorator{
    protected Coffee decoratedCoffee;
    public CoffeeDecorator(Coffee coffee){
        this.decoratedCoffee = coffee;
    }
}

class MlikDecorator extends CoffeeDecorator{
    public MlikDecorator(Coffee coffee){
        super(coffee);
    }

    @Override 
    public double getCost(){
        return decoratedCoffee.getCost() + 1.0;
    }

    @Override
    public String getDescription(){
        return decoratedCoffee.getDescription() + ",Milk";
    }
}

组合模式

特点

• Composite
• 将对象组合成树形结构,层次分明
• 适用于文件系统,菜单树,组织架构

实现

• 创建根接口,表示整个结构的整体组合
• 创建根接口实现类,进行各种操作

示例

interface FileSystemComponent{
    void display();
}

class File implements FileSystemComponent{
    private String name;
    public File(String name){
        this.name = name;
    }
    @Override
    public void display(){
        System.out.println("File: " + name);
    }
}

class Directory implements FileSystemComponent{
    private String name;
    private List<FileSystemComponent> children = ne ArrayList<>();
    public Directory(String name){
        this.name = name;
    }
    public void add(FileSystemComponent comp){
        children.add(comp);
    }
    @Override
    public void display(){
        for(FileSystemCmponent comp : children){
            comp.display();
        }
    }
}

行为型模式

• 对象间的交互与职责分配

观察者模式

特点

• Observer
• 定义对象间的一对多依赖,当一个对象状态改变时,所有依赖他的对象都会自动更新
• 适用于事件驱动系统,消息订阅

实现

• 创建观察接口
• 创建观察接口实现类
• 创建一对多观察类的类

示例

interface Observer{
    void update(String news);
}

class NewChannel implements Observer{
    @Override
    public void update(String news){
        System.out.println("channel" + news);
    }
}

class NewsAgency{
    private List<Observer> observers = new ArrayList<>();
    public void addObserver(Observer observer){
        observers.add(observer);
    }
    public void notifyObservers(String news){
        for(Observe o : observers) o.update(news);
    }
}

策略模式

特点

• 定义一系列算法,使其可以相互替换,且算法的变化独立于他的客户端
• 支付方式选择,排序算法切换

实现

• 创建策略接口
• 创建一系列策略实现类
• 创建客户端类,添加能够动态定义算法的方法

示例

interface PaymentStrategy{
    void pay(double amount);
}

class CreditCardPayment implements PaymentStrategy{
    @Override
    public void pay(double amount){
        System.out.println("CreditCard Pay: " + amount);
    }
}

class AlipayPayment implements PaymentStrategy{
    @Override
    public void pay(double amount){
        System.out.println("Alipay Pay: " + amount);
    }
}

class ShoppingCart{
    private PaymentStrategy strategy;
    public void setPaymentStrategy(PaymentStrategy p){
        this.strategy = p;
    }
    public void checkout (double amount){
        strategy.pay(aomunt);
    }
}