2019-11-26 · 面向对象特征之一：封装和隐藏

一，我们设计程序追求“高内聚，低耦合”

高内聚：类的内部数据细节自己完成，不允许外部干涉。
低耦合：仅对外部暴露少量的方法用于使用。

就类似于洗衣机，我们是用户，只需要按一下开关和洗涤模式就可以使用了。不需要了解洗衣机的电机，原理等内部结构。

对于程序而言：隐藏对象内部的复杂性，只对外公开简单的接口，便于外界调用，从而提高系统的可扩展性，可维护性。这就是Java封装性的设计思想。

二，问题引入

当我们创建一个类后，可以通过“对象.属性”的方式，对对象的属性进行赋值，这里的赋值只会受到对象和属性的数据类型和存储范围的限制。但是在实际问题中，我们往往会有需要加入更多的制约条件。

例如：用户可能把legs（腿）设置成-1000

所以，这时候我们只能通过方法进行限制条件的添加。同时我们要避免用户继续使用“对象.属性”的方式对属性进行赋值。则需要把属性声明改为私有的（private）。
---> 此时，针对于属性就体现了封装性。

三，封装性的体现：

我们将类的属性xxx私有化（private）。同时，我们要提供公共的（public）方法来获取（getXxx）和设置（setXxx）属性的值。

public class TTest {
    public static void main(String[] args) {
        zoo z = new zoo();
        
        z.name = "哈士奇";
        z.age = 1;
        z.setLegs(4);
        System.out.println(z.name + "有" + z.getLegs() + "条腿");
    }
}

class zoo{
    
    String name;
    int age;
    
    //私有化
    //将属性legs定义为private，只能被zoo类内部访问
    private int legs;
    //对于属性的设置：腿的个数要先被设置
    public void setLegs(int l) {
        if(l>=0 && l%2==0) {
            legs = l;
        }else {
            //有问题就抛出个异常
            throw new RuntimeException("数据非法！");
        }
    }
    //对于属性的获取：
    public int getLegs() {
        return legs;
    }
}

扩展：
封装性的体现并不只有如上一个，设计模式中的单例设计模式，某些不对外暴露的私有的方法......都是封装性的体现。

四，封装性的体现，需要权限修饰符来配合

Java规定了四种权限：private，缺省，protected，public。
四种权限可以修饰类的内部结构：属性，方法，构造器和内部类。
修饰类只可以使用：缺省和public。

四种权限的测试：
首先定义一个 Order 类，测试在同一个类中是否可以使用。

/*
 *  * 四种权限的测试
 */
public class Order {
    
    
    private int orderPrivate;
    int orderDefault;//缺省
    public int orderPublic;
    
    
    private void methodPrivate() {
        orderPrivate = 1;
        orderDefault = 1;
        orderPublic  = 1;
    }
    void methodDefault() {
        orderPrivate = 1;
        orderDefault = 1;
        orderPublic  = 1;
    }
    public void methodPublic() {
        orderPrivate = 1;
        orderDefault = 1;
        orderPublic  = 1;
    }
}

都可以使用。
再定义一个 ordertest 用于测试出了 order 类之后的情况。

/*
 *  * 四种权限的测试
 */
public class OrderTest {
    public static void main(String[] args) {
        
        Order o = new Order();
        
        o.orderDefault = 1;
        o.orderPublic = 2;
        //出Order类之后，私有的结构就不可以调用了
//      o.orderPrivate = 3;//The field Order.orderPrivate is not visible
        
        
        
        o.methodDefault();
        o.methodPublic();
        //出Order类之后，私有的结构就不可以调用了
//      o.methodPrivate();//The method methodPrivate() from the type Order is not visible
    }
}

五，练习题

封装的练习题

Person类：

public class Person {
    int age;
    
    public void setAge(int a) {
        if(a>=0 && a<=130) {
            age = a;
        }else {
            throw new RuntimeException("数据非法！");
        }
    }
    
    public int getAge() {
        return age;
    }
}

PersonTest类：

public class PersonTest {
    public static void main(String[] args) {
        
        Person b = new Person();
        
        b.setAge(35);
        System.out.println("我今年" + b.getAge() + "岁啦！");
    }
}

六，总结

Java提供了四种权限修饰符来修饰类以及类的内部结构
体现了类和类的内部结构在被调用时的可见性大小。

2019-11-26 · 面向对象特征之一：封装和隐藏