Java基础四（封装）

面向对象的封装性：封装与隐藏

一、问题的引入

• 当创建一个类的对象后，可以通过“对象.属性“的方式进行赋值。
• 赋值操作要受到属性的数据类型和存储范围约束。在实际问题时，需要给属性赋值加入额外的
• 限制条件。这个条件就不能在属性声明是体现，只能通过方法进行限制条件的添加。同时，
• 需要用户避免用户“对象.属性“的方式进行赋值。则需要将属性声明为private，此时针对属性就体现了封装性。

二、封装性的体现

• 1.类的属性XX私有化（private），同时，提供公共的（public）方法获取（getXX）和设置(SetXX)
• 拓展：封装性的体现：1.如上，2.不对外暴露的私有方法，3.单例模式。。。

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

• 1.java规定的4种权限：（从小到大排列）：private、缺省（default）、protected、public
  • private: 类内部
  • 缺省：同一个包可以使用
  • protected：不同包的子类
  • public：同一个工程
• 2.四种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
• 3.具体的。四种权限可以用来修饰类的内部结构：属性、方法、构造器、内部类
    修饰类，只能使用：缺省、public

总结封装性：

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

public class AnimalTest {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.name = "大黄";
        a.eat();
        //a.age = 1;
        //private 不能调用
        //a.legs = 4;

        a.show();

        //a.legs = -4;
        //a.setLegs(-6);
        a.setLegs(6);
        a.setAge(5);
        //通过方法赋属性值
        a.show();

        System.out.println(a.name);
        System.out.println(a.getLegs());
        System.out.println(a.getAge());
    }
}

class Animal{
    String name;
    private int age;
    private int legs;
    //加限制条件，不能直接调用，需要通过方法
    //没有暴露属性

    //对属性的设置
    //'接口',隐藏属性
    public void setLegs(int l){
        if(l <= 9 && l % 2 ==0){
            legs = l;
        }else{
            legs = 0;
        }
    }

    //对属性的获取
    public int getLegs(){
        return legs;
    }

    public void setAge(int a){
        age = a;
    }

    public int getAge(){
        return age;
    }

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

同一个中的类

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

}

public class OrderTest {
    public static void main(String[] args) {
        Order order = new Order();

        order.orderDefault = 1;
        order.orderPublic = 2;
        //order.orderPrivate;
        //出了order类之后，私有的结构就可以调用

        order.methodDefault();
        order.methodPublic();
        //order.methodPravete();

    }
}

不同包中的类

public class OrderTest {
    public static void main(String[] args) {
        Order order = new Order();

        //order.orderDefault = 1;
        //出了order类所属的包之后，私有的结构、缺省声明的结构就不可以调用了
        order.orderPublic = 2;
        //order.orderPrivate;
        //出了order类之后，私有的结构就可以调用

        //order.methodDefault();
        //出了order类所属的包之后，私有的结构、缺省声明的结构就不可以调用了
        order.methodPublic();
        //order.methodPrivate();

    }
}