Java-面向对象-封装、接口

目录

封装介绍

封装的优点

实现封装的步骤

接口介绍

接口的声明语法

接口的特点

接口的实现

接口的多重实现

接口继承

接口与抽象类的区别

实例演示

---

封装介绍

封装(Encapsulation)是面向对象编程(OOP)的三大特性之一(另外两个是继承和多态)。它就像给你的代码穿上了一件"智能外套"，既能保护内部数据，又能提供简洁的交互方式。

想象你有一个存钱罐：

• 不封装：罐子完全敞开，任何人都可以随意拿取或放入钱币

• 封装后：罐子有一个投币口(方法)和显示窗口(方法)，但钱币不能被直接触碰

这就是封装的核心思想：隐藏对象的内部细节，仅暴露必要的操作接口。

封装的优点

• 良好的封装能够减少耦合。
• 类内部的结构可以自由修改。（内部变更不影响外部）
• 可以对成员变量进行更精确的控制。
• 隐藏信息，实现细节。

实现封装的步骤

• 修改属性的可见性来限制对属性的访问（一般限制为private）

public class BankAccount {
    private double balance;  // 私有变量，外部无法直接访问
    
    // 公共方法作为访问接口
    public double getBalance() {
        return balance;
    }
    
    public void deposit(double amount) {
        if(amount > 0) {
            balance += amount;
        }
    }
}

将类中的balance变量设置成了私有，外部无妨访问，从而实现了对信息的隐藏。

• 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问

public void setBalance(double amount) {
    if(amount >= 0) {  // 添加验证逻辑
        this.balance = amount;
    }
}

通过setter方法，getter方法来实现对私有变量的访问。

/* 文件名: EncapTest.java */
public class EncapTest{
 
   private String name;
   private String idNum;
   private int age;
 
   public int getAge(){
      return age;
   }
 
   public String getName(){
      return name;
   }
 
   public String getIdNum(){
      return idNum;
   }
 
   public void setAge( int newAge){
      age = newAge;
   }
 
   public void setName(String newName){
      name = newName;
   }
 
   public void setIdNum( String newId){
      idNum = newId;
   }
}

所以要访问任何私有变量的类都要通过这些setter、getter方法：

/* F文件名 : RunEncap.java */
public class RunEncap{
   public static void main(String args[]){
      EncapTest encap = new EncapTest();
      encap.setName("James");
      encap.setAge(20);
      encap.setIdNum("12343ms");
 
      System.out.print("Name : " + encap.getName()+ 
                             " Age : "+ encap.getAge());
    }
}

接口介绍

• 接口(Interface)是Java编程语言中一个非常重要的概念，它是抽象方法的集合，用于定义行为规范。
• 接口是一种完全抽象的类，它只包含抽象方法和常量(在Java 8之前)。接口定义了一组方法签名(没有实现)，任何实现该接口的类都必须提供这些方法的具体实现。

接口的声明语法

[访问修饰符] interface 接口名 [extends 父接口1, 父接口2...] {
    // 常量声明
    // 方法签名
}
//接口是允许多继承的

实例：

public interface Animal {
    void eat();
    void sleep();
}

接口的特点

• 完全抽象：接口只能包含抽象方法（Java8可以使用 default 关键字修饰的非抽象方法）

• 多继承：一个类可以实现多个接口，但只能继承一个类

• 隐式公开：接口中的方法默认是public abstract的

• 隐式静态常量：接口中的变量默认是public static final的

• 不能实例化：不能直接创建接口的实例

• 注意：接口不是要被类继承，而是要被类实现

接口的实现

类使用implements关键字实现接口，必须实现接口中所有的抽象方法(除非是抽象类)。

public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
    
    @Override
    public void sleep() {
        System.out.println("Dog is sleeping");
    }
}

接口的多重实现

public class Smartphone implements Camera, Phone, Computer {
    // 实现所有接口的方法
}

类是不允许多继承的，接口是允许的！！!

接口继承

接口与类的相似点，两者都可以继承：

public interface Shape {
    void draw();
}

public interface ColoredShape extends Shape {
    void setColor(String color);
}

接口与抽象类的区别

实例演示

// 定义接口
public interface Logger {
    void log(String message);
    default void logError(String error) {
        log("ERROR: " + error);
    }
}

// 实现接口
public class FileLogger implements Logger {
    @Override
    public void log(String message) {
        // 写入文件的实现
        System.out.println("Log to file: " + message);
    }
}

public class DatabaseLogger implements Logger {
    @Override
    public void log(String message) {
        // 写入数据库的实现
        System.out.println("Log to database: " + message);
    }
}

// 使用接口
public class Application {
    private Logger logger;
    
    public Application(Logger logger) {
        this.logger = logger;
    }
    
    public void process() {
        logger.log("Application started");
        // ...
        logger.logError("Something went wrong");
    }
    
    public static void main(String[] args) {
        Application app = new Application(new FileLogger());
        app.process();
        
        Application dbApp = new Application(new DatabaseLogger());
        dbApp.process();
    }
}