在面向对象的程序设计中，我们需要一定程度的封装性以实现信息的隐藏。类的可访问性，是指当前类可被其他类的所访问的程度。这种形式的修饰符有两个，通过不同的可访问性修饰符可以体现程序的封装性。
类的可访问修饰符只能使用：
·public
·默认访问控制属性
这两种也适用于构造方法的修饰。
public修饰的类可被其他任意类所访问，而默认访问控制属性就是无修饰符，只能被当前包中的类所访问。也就是public修饰的类可展示给所有的类使用，而默认访问控制属性修饰的类只能展示给当前包中的类使用。
**public**
关键之public修饰的类具有最大的可被访问性，凡是用public修饰的类都可以被其他任何类所访问，无论是其他类实在当前包中还是别的地方，所以，public具有最好的公开性。
但是在使用public修饰符的时候，必须保证一个包中，也就是一个.java程序中，只能有一个public类，这个类作为整个.java文件对外的接口，实现文件内的封装。
示例1：
//首先生成一个包文件，其中包含一个类
package myPage;

public class Mypackage {
    public void sum(int i,int j)
    {
        System.out.println(i+j);
    }

}
编译通过，生成包myPage.里面保存Mypackage文件，然后创建新的应用程序，不在当前包中，看能不能使用包中的类创建对象。
package classTest;
import myPage.Mypackage;
public class PublicTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Mypackage mp = new Mypackage();
        mp.sum(2, 3);
    }

}
编译后，程序运行成功，可知该程序可调用当前包中的文件。
public修饰的类具有最好的可被访问属性，所以无论PublicTest类在什么地方，都可以使用Mypackage类。
需要注意的是，在调用该类的时候需要首先导入该类，才能使用（使用import语句定位并导入)。
**默认访问**
默认访问属性说明该类只能被同一个包中的类所访问，包外的类无法生成该类的对象。这样，就是类有了封装性能。
示例2：
//如果把示例1中的类Mypackage改为如下：
package myPage;

class Mypackage {
    public void sum(int i,int j)
    {
        System.out.println(i+j);
    }

}
在PublicTest类中的编译时无法通过的，会提示：“The type myPage.Mypackage is not visible”。因为Mypackage不是公共的，不能访问。
修改方法：一种是放在同一个包中，另一种就是在Mypackage类前面添加public关键字。
**成员的可访问性**
与类的可访问修饰符想死，类中的成员也有可访问性修饰符，这些修饰符说明了成员能否在其他类中使用。
类中成员的修饰符有4种：private、默认、protected、public。他们的限定强度依次减弱。
1.public
示例3：
public class test{
    public static void main(String [] args){
        myClass mc = new myClass();
        System.out.println(mc.i);
        mc.out();
    }
}
class myClass
{
    public int i =4;
    public void out()
    {
        System.out.println("four");
    }
}
程序顺利编译运行。
2.protected
被protected修饰的成员变量或者方法可以被同一个类、同一个包中的不同类以及不同包中的子类所访问。与public不同的是，protected修饰的成员不能被不同的包中的非子类访问，也就是说protected可以隐藏一部分信息，使之不可见不可用。
示例4:
//将示例3中的类改为如下：
class myClass
{
    protected int i =4;
    protected void out()
    {
        System.out.println("four");
    }
}
程序编译运行正常。
示例5：
//将示例1中的Mypackage改为如下：
class myClass
{
    protected int i =4;
    protected void out()
    {
        System.out.println("four");
    }
}
编译不能通过，提示：“The method sum(int, int) from the type Mypackage is not visible”。
原因就在于protected修饰的方法只可以被同一包中的类或者不同包中的子类访问。
3.默认
如果成员没有属性控制符，就是默认访问控制属性。默认访问控制属性的可访问性更加严格，只能被当前类或者同一个包中的其他类访问。
示例6：
//将示例1中的Mypackage类改为如下：
package myPage;


public class Mypackage {
    void sum(int i,int j)
    {
        System.out.println(i+j);
    }
}
编译提示：The method sum(int, int) from the type Mypackage is not visible。
程序中，sum()为默认属性，不能被其他包中的类访问和使用，变量mc.sum()无法找到，所以导致程序出现错误。
4.private
private修饰的成员只能在同一个类中被访问，在任何其他类中都不能被访问，这就保证了private具有最好的封装性能。
示例7：
public class example{
    public static void main(String [] args){
        test myTest = new test();
        myTest.show();
        myTest.out();//无法调用
    }
}
class test
{
    private void out()
    {
        System.out.println("private void out");
    }
    void show()
    {
        System.out.println("void show()");
    }
}
编译提示：“The method out() from the type test is not visible”。
因为out()为private类型，所以不能被其他类访问。