Java-面向对象-封装、接口-优快云博客

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();
    }
}