Java基础语法40-封装和隐藏

Java基础语法40-封装和隐藏

一、问题的引入

当我们创建一个类的对象以后，我们可以通过“对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如: setLegs()方法）同时我们需要避免用户使用“对象.属性"的方式进行赋值。则需要将属性声明为私有（private）。此时针对于属性就体现了封装性。

二、封装性的体现

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

public class AnimalTest {
    public static void main(String[] args) {
        Animal a = new Animal();
        
        a.show();
    }
}

class Animal {
    private String name;
    private int age;
    private int legs;

    //对属性的获取
    public int getLegs(){
        return legs;
    }
    //对属性的设置
    public void setLegs(int l) {
        if (l >= 0 && l % 2 == 0) {
            legs = l;
        } else {
            legs = 0;
        }
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void eat() {
        System.out.println("动物进食");
    }

    public void show() {
        System.out.println("name = " + name + ", age = " + age + ", legs = " + legs);
    }


}

封装性的体现的拓展：

① 如上

② 不对外暴露的私有的方法

③ 单例模式…

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

1. java规定的四种权限（从小到大排列）：private、缺省、protected、public

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	Yes
(缺省)	Yes	Yes
protected	Yes	Yes	Yes
public	Yes	Yes	Yes	Yes

2. 4种权限修饰符可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
3. 具体的，4种权限都可以修饰类的内部结构：属性、方法、构造器、内部类。修饰类的话，只能用：public、缺省

四、4种权限修饰符的测试

package com.demo;

public class Order {

    private int orderPrivate;
    int orderDefault;
    public int orderPublic;

    private void methodPrivate(){
        orderPrivate = 1;
        orderDefault =2;
        orderPublic = 3;
    }

    void methodDefault(){
        orderPrivate = 1;
        orderDefault =2;
        orderPublic = 3;
    }

    public void methodPublic(){
        orderPrivate = 1;
        orderDefault =2;
        orderPublic = 3;
    }
}

package com.demo;

public class OrderTest {
    public static void main(String[] args) {
        Order order = new Order();
        order.orderPublic = 1;
        order.orderDefault = 1;
        //出了order类以后，私有的结构就不能访问了
//      order.orderPrivate = 1;//orderPrivate 在 com.demo.Order 中是 private 访问控制

        order.methodDefault();
        order.methodPublic();
//      order.methodPrivate();//'methodPrivate()' has private access in 'com.demo.Order'
    }
}

package com.demo1;

import com.demo.Order;

public class OrderTest {
    public static void main(String[] args) {
        Order order = new Order();
        order.orderPublic = 1;
        order.orderDefault = 1;
        //出了order类以后，私有的结构就不能访问了
//      order.orderPrivate = 1;//orderPrivate 在 com.demo.Order 中是 private 访问控制

        order.methodDefault();
        order.methodPublic();
//      order.methodPrivate();//'methodPrivate()' has private access in 'com.demo.Order'

    }
}

五、总结

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