面向对象的三大特性之一——封装（含访问修饰符）

封装是面向对象的第一个重要特征，在前面的笔记中已经有所体现。

在看书学习的过程中发现封装和访问修饰符存在密切的联系，所以顺带对访问修饰符做一个大体的总结。

一、封装的两种实现方式。

  1.通过包实现封装性

package ClassNotes;

    class Person
    {
        .....
    }

包的导入：

import ClassNotes.HelloSwing;//导入
class Person
{
    int age；    
}
public class T01
{
    public static void main(String[] args)
    {
        Person p = new Person();
        P.age=12;
        HelloSwing frame=new HelloSwing();//调用
    }
}

2.通过访问权限实现封装。

class Person
{
    private int age;
    
}
public class T01
{
    public static void main(String[] args)
    {
        Person p = new Person();
        p.age=12;//错误的，无法给属性赋值
    }
}

(1).通过运用private修饰类、成员变量、成员方法来控制访问权限，从而达到封装的目的。

如何解决上面例子的问题呢？下面给出程序：

class Person
{
    private int age;
    public int getAge() 
    {
        return age;
    }

    public void setAge(int age) 
    {
        this.age = age;
    }
    public void print()
    {
        System.out.println("我今年："+age+"岁。");
    }
}
public class T01
{
    public static void main(String[] args)
    {
        Person p = new Person();
        p.setAge(12);
        p.print();
    }
}

(2).很明显，当一个属性被private修饰，使用对象是无法直接调用它的，所以通过创建getter/setter方法来间接为属性赋值，达到封装的目的。有时候我们也在getter/setter方法中加入属性的控制语句，对所赋值的合理性进行判断。

方法一：控制setter()方法

class Person
{
    private int age;
    public int getAge() 
    {
        return age;
    }

    public void setAge(int age) 
    {
        if(age>0&&age<100)
12         {
13             this.age=age;
14             this.print1();
15         }   
16         else
17         {
18             this.age=age;
19             this.print2();
20         }
    }
    public void print1()
    {
        System.out.println("我今年："+age+"岁。");
    }
    public void print2()
    {
        System.out.println("您输入的年龄"+age+"岁不符合常理，请重新输入！");
    }
}
public class T01
{
    public static void main(String[] args)
    {
        Person p = new Person();
        p.setAge(180);
    }
}

方法二：控制print()方法

class Person
{
    private int age;
    public int getAge() 
    {
        return age;
    }

    public void setAge(int age) 
    {
        this.age=age;
    }
    public void print()
    {
        if(age>0&&age<150)
16             System.out.println("我今年："+age+"岁。");
17         else
18             System.out.println("您输入的年龄"+age+"岁不符合常理，请重新输入！");
    }
}
public class T01
{
    public static void main(String[] args)
    {
        Person p = new Person();
        p.setAge(18);
        p.print();
    }
}

当p.setAge(18);     输出：我今年：18岁。

当p.setAge(180);   输出：您输入的年龄180岁不符合常理，请重新输入！

上面的两种方法虽说都达到了目的，但总感觉并没有真正控制赋值范围，后期如果想通了再来修改答案。

(3).**注意：上述是用private封装属性，如果用private封装方法，又该怎么调用该方法呢?

看下面的解决方法：

class Person
{
    private void print()
    {
        System.out.println("我今年是"+age+"岁。");
    }
 7     public int getAge() 
    {
        return age;
        print();//在类的方法中调用私有方法
    }
    public void setAge(int age) 
    {
        this.age=age;
    }
}

可以看出，访问修饰符private是对类外而言的，而在同一个类中，所有的类成员属性和方法都是互相可见的，也就是说它们能相互访问。

(4).如果我们不想让初始化后的属性值被外界修改时，可以使用构造方法配合私有化setter方法来实现终极封装。

class Person
{
    private int age;
    public Person(int age)
    {
        setAge(age);
    }
    public int getAge() 
    {
        return age;
    }
    private void setAge(int age) 
    {
        if(age>0&&age<100)
        {
            this.age=age;
            this.print1();
        }   
        else
        {
            this.age=age;
            this.print2();
        }
    }
    public void print1()
    {
        System.out.println("我今年："+age+"岁。");
    }
    public void print2()
    {
        System.out.println("您输入的年龄"+age+"岁不符合常理，请重新输入！");
    }
}
public class T01
{
    public static void main(String[] args)
    {
        Person p = new Person(20);
    }
}

因为构造方法只能在实例化对象时调用一次，所以实现了属性值的终极封装。 

二、访问修饰符。

常用的访问修饰符有private、protected、public和缺省。

下面的图片适当解释了它们各自的访问权限：

关于访问修饰符，不再详细叙述，以后遇到深层次问题再来讨论。