【JAVA学习之路 | 基础篇】面相对象特征--封装性

1.我们为什么需要封装性

1. 随着我们系统越来越复杂，类会越来越多，那么类之间的访问边界必须把握好，面相对象开发原则遵循"高内聚，低耦合".
2. 高内聚、低耦合是软件工程中的概念，也是UNIX操作系统设计的经典原则.
3. "高内聚"，类的内部数据操作细节自己完成，不允许外部干涉.
4. "低耦合"，仅暴露少数方法给外部使用，尽量方便外部调用.
5. 通俗的说:把该隐藏的隐藏起来，该暴露的暴露出来，体现封装的设计思想.

2.如何实现类的封装

• 实现封装就是控制类或成员的可见性范围.这就需要依赖访问控制修饰符，也称为权限修饰符来控制.
• 我们可以使用四种权限修饰符来修饰类即类的内部成员，当这些成员被调用时，体现可见性的大小.
• 权限修饰符:public，protected，缺省，private.

修饰符        本类内部        本包内        其他包的子类        其他包的非子类
 
private         1               0               0                   0
 
 
缺省            1               1               0                    0
 
 
protected       1               1               1                   0
 
 
public          1               1               1                   1

3.权限的使用

• 类 : 外部类只能使用public，缺省.
• 类的内部成员 : 可以使用四种权限修饰符进行修饰.

4.封装性的体现

• 私有化类的属性(private)，提供公共的get/set方法.对此属性进行访问和更改.
• 将类中不需要对外暴露的方法设置为private.虽然外部不能通过对象.方法来访问私有方法，但可以定义一个public方法，在该公共方法内调用私有方法.

public class Employee {
    private String name;
    private String gender;
    private int age;
    private String tephone;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public String getGender() {
        return gender;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    public void setTephone(String tephone) {
        this.tephone = tephone;
    }
    public String gerInfo() {
        return name + "\t" + gender + "\t" + age + "\t" + tephone;
    }
}

5. 外部类为什么不能用protected修饰

原因 :

• Java中的外部类不能使用`protected`修饰符。这是因为`protected`修饰符允许同一个包内的类以及所有子类访问该成员，无论这些子类位于何处。然而，对于外部类而言，这样的访问控制级别没有实际意义，因为外部类本身就是作为公共接口的一部分或者包内共享的，而不应该受限于只有子类才能访问的规则。
• 此外，包之间没有继承关系，这意味着“子包”这一概念并不适用于对外部类的访问控制。因此，外部类只能使用`public`（公开访问，任何地方都能访问）或者默认访问修饰符（也就是不写任何访问修饰符，这时只有同一个包内的类可以访问）。如果你想控制外部类的访问权限，应该通过将类放在适当的包中并利用包的访问控制来实现。
• 相比之下，内部类则可以使用`private`、`protected`以及默认和`public`修饰符，因为它是在另一个类的上下文中定义的，这些访问修饰符能够有效地控制内部类的可见性。

protected拿来修饰内部类.

public class A{

    protected class B{

         //

}

}

类B可以被类A子类访问，以及在同一包下的其他类访问，如果其他包下的类(本包下的类无需继承类A)想要创建类B的实例，他们必须通过继承类A并在其中操作.