浅谈为什么不用public修饰成员变量

海克斯科技勥

已于 2024-06-27 15:54:49 修改

阅读量825

点赞数 12

文章标签： java

于 2024-06-27 15:22:36 首次发布

本文链接：https://blog.csdn.net/weixin_41857176/article/details/140014201

版权

使用public修饰成员变量（也称为字段或属性）在Java中通常被认为是不好的做法，原因有以下几点：

破坏封装性：封装性是面向对象编程的四大基本特性之一，它要求隐藏对象的内部状态和实现细节，只对外提供必要的访问接口。使用public修饰成员变量会让类的内部状态直接暴露给外部，这样其他类就可以直接访问和修改这些状态，从而破坏了封装性。
增加耦合度：当类的成员变量被声明为public时，其他类可以直接访问和修改这些变量，这可能导致类之间的耦合度增加。高耦合度的代码难以维护和扩展，因为修改一个类可能会影响到其他多个类。
难以控制对成员变量的访问：使用public修饰成员变量意味着任何代码都可以直接读取或修改这些变量的值。这可能导致一些意外的副作用或错误，因为无法确保其他代码在访问或修改这些变量时是否遵循了正确的逻辑或规则。
缺乏灵活性：一旦成员变量被声明为public，就很难再更改其访问级别或添加额外的逻辑（如验证、计算等）。相反，如果成员变量是私有的，并提供了公共的get和set方法，那么就可以在这些方法中添加任何必要的逻辑，而不会影响到类的外部接口。
不符合Java的编码规范：Java的编码规范（如Java Bean规范）通常建议将类的成员变量声明为私有的，并提供公共的get和set方法来访问和修改这些变量的值。这样做可以使代码更加清晰、易于维护和扩展。

因此，为了避免上述问题，通常建议将类的成员变量声明为私有的，并提供公共的get和set方法（也称为访问器和修改器）来访问和修改这些变量的值。这样可以确保类的内部状态得到良好的封装和保护，同时提供足够的灵活性来添加额外的逻辑或更改访问级别。

这里主要讨论第一点破坏封装性：

当使用public修饰成员变量时，类的内部状态将直接暴露给外部，这意味着其他类可以直接访问和修改这些状态，这确实破坏了封装性。下面是一个简单的代码示例来说明这种情况：

public class Person {  
    // 使用public修饰的成员变量  
    public String name;  
    public int age;  
  
    // 构造方法  
    public Person(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
  
    // 其他方法...  
}  
  
public class Main {  
    public static void main(String[] args) {  
        // 创建一个Person对象  
        Person person = new Person("Alice", 30);  
  
        // 由于name和age是public的，可以直接访问和修改  
        System.out.println("Name before modification: " + person.name); // 输出：Name before modification: Alice  
        System.out.println("Age before modification: " + person.age); // 输出：Age before modification: 30  
  
        // 直接修改Person对象的内部状态  
        person.name = "Bob";  
        person.age = 40;  
  
        System.out.println("Name after modification: " + person.name); // 输出：Name after modification: Bob  
        System.out.println("Age after modification: " + person.age); // 输出：Age after modification: 40  
  
        // 外部类可以直接访问和修改Person的内部状态，这破坏了封装性  
    }  
}

在上面的示例中，Person类有两个public成员变量：name和age。在Main类的main方法中，我们创建了一个Person对象，并直接访问和修改了它的name和age字段。由于这些字段是public的，外部类Main可以毫无限制地访问和修改它们，这违反了封装性的原则。

为了遵循封装性的原则，我们应该将name和age字段声明为private，并提供公共的get和set方法来访问和修改它们：

public class Person {  
    // 使用private修饰的成员变量  
    private String name;  
    private int age;  
  
    // 构造方法  
    public Person(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
  
    // 公共的get方法  
    public String getName() {  
        return name;  
    }  
  
    // 公共的set方法  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    // 其他的get和set方法...  
    public int getAge() {  
        return age;  
    }  
  
    public void setAge(int age) {  
        this.age = age;  
    }  
  
    // 其他方法...  
}  
  
// Main类中的代码将使用get和set方法来访问和修改Person对象的属性

在修改后的Person类中，name和age字段被声明为private，并且提供了公共的get和set方法来访问和修改它们的值。这样，外部类只能通过这些方法来访问和修改Person对象的内部状态，从而维护了封装性。

但是这里可能会有疑问：外部类Main可以毫无限制地访问和修改它们，这违反了封装性的原则。那我使用get/set方法时不也是可以毫无限制地访问和修改它们吗？

这个观点是没问题的，但是这里的关键是get和set方法提供了一种可控的方式来访问和修改类的内部状态，而不是直接暴露字段。通过get和set方法，您可以添加额外的逻辑来验证输入、触发事件、计算值或执行其他任何您认为必要的操作。

让我们通过一个例子来更清楚地说明这一点：

假设我们有一个BankAccount类，它有一个balance字段，表示账户的余额。如果我们直接暴露这个字段为public，那么任何外部类都可以随意修改它，这可能会导致余额变为负数或者其他不合法的值。

public class BankAccount {  
    public double balance; // 直接暴露为public  
  
    // ... 其他方法 ...  
}

但是，如果我们使用private来修饰balance字段，并提供getBalance和setBalance方法，我们就可以在setBalance方法中添加逻辑来确保余额不会变为负数：

public class BankAccount {  
    private double balance; // 封装为private  
  
    public double getBalance() {  
        return balance;  
    }  
  
    public void setBalance(double newBalance) {  
        if (newBalance >= 0) { // 添加逻辑确保余额不会为负数  
            balance = newBalance;  
        } else {  
            System.out.println("Error: Cannot set balance to a negative value.");  
        }  
    }  
  
    // ... 其他方法 ...  
}

在上面的例子中，虽然外部类仍然可以通过setBalance方法来“访问和修改”balance字段，但实际上它们是通过一个受控的接口来操作的。这个接口允许我们在修改值之前执行额外的逻辑，从而确保数据的完整性和合法性。

因此，虽然使用get和set方法时外部类仍然可以“访问和修改”类的内部状态，但这种访问和修改是受到控制的，并且可以通过添加额外的逻辑来限制或改变这种访问和修改的方式。这就是封装性的关键所在：它允许我们隐藏类的内部实现细节，并提供一个公共的、受控的接口来与外部世界进行交互。

那么问题又来了，我不需要添加额外的逻辑来验证输入、触发事件、计算值或执行其他操作，那是不是就可以定义成public？答案是否定的！

原因如下：

未来扩展性：即使您现在不需要添加任何逻辑，但未来的需求可能会改变。如果成员变量是private的，并且您已经提供了get和set方法，那么在未来需要添加逻辑时，您只需要修改这些方法即可，而不需要修改所有直接访问这些变量的代码。
封装性：封装性是面向对象编程的一个基本原则。它允许您隐藏对象的内部状态和实现细节，只提供必要的接口与外部进行交互。将成员变量定义为private并通过get和set方法提供访问和修改接口，可以更好地维护封装性。
代码清晰度：通过get和set方法，您可以清晰地表达成员变量的访问和修改意图。这有助于其他开发人员更好地理解您的代码，并知道如何正确地使用它。
可维护性：如果成员变量是public的，那么任何类都可以直接访问和修改它。这可能导致难以追踪的副作用和错误。通过将成员变量设置为private，您可以限制对它们的访问和修改，从而提高代码的可维护性。
遵循最佳实践：将成员变量定义为private并提供get和set方法是Java编程中的常见最佳实践。遵循这些最佳实践可以使您的代码更加健壮、可维护和易于理解。

因此，即使您当前不需要添加额外的逻辑，也建议将成员变量定义为private，并提供相应的get和set方法。这样可以使您的代码更加健壮、可扩展和易于维护。

最后，我们可以再加强下对封装概念的理解：

封装性（Encapsulation）是面向对象编程的三大基本特性之一（另外两个是继承和多态）。封装性强调将对象的属性（也称为字段或成员变量）和行为（方法或函数）结合成一个独立的、可操作的软件单元，即对象。封装隐藏了对象的内部状态和实现细节，仅对外提供公共的接口供其他对象访问和操作。

封装的好处包括：

数据隐藏：封装允许程序员隐藏对象的内部实现细节，只对外暴露必要的接口。这可以保护数据不被随意修改，从而减少了程序出错的可能性。
模块化和重用：通过封装，可以将复杂的系统划分为多个独立的模块（即类）。这些模块可以单独开发、测试和维护，从而实现代码的模块化和重用。
简化接口：封装可以隐藏不必要的复杂性，只向外界提供简洁、明确的接口。这使得其他开发者更容易理解和使用该类，降低了学习成本。
安全性：封装可以防止用户直接访问和修改类的内部状态，从而提高了程序的安全性。通过访问修饰符（如public、protected、private）可以控制对类成员的访问权限。
易于维护和修改：由于封装隐藏了内部实现细节，当需要修改类的内部实现时，只需要确保公共接口保持不变，就可以在不影响其他代码的情况下进行修改。