Java的访问控制符

在Java里面又三种访问控制权限，分别是public  protected  privated意思分时是共有的，受保护的，以及私有的。这三种权限，下面我们来看看这三种权限的比较和区别.

首先来看看public该权限的限制是最广的，基本是最大的权限，任何人都可以访问。Protected是受保护的，介于共有和私有之间

Privated是私有的。只有本类可以访问和使用，其他的类是不容许使用的.下面来看看代码.

package ooJect;

/**
 * @author hackbase   Java的访问权限控制.首先我们来得出结论.
 * java的访问控制权限，一致困扰着我很多年，今天来深入的理解下访问控制权限的问题
 * java的访问控制权限又三个分别是public  protected,private还有一个默认的default
 * 一共四个访问控制权限。
 * privated---->default----protected----->public   访问权限依次从小到大.
 * 图中4个访问控制级别中的default并没有对应访问控制符，当不使用任何访问控制符来修饰类或类成员时，
 * 系统默认使用该访问控制级别。这4个访问控制级别的详细介绍如下。
 * <p>
 * 1.•private(当前类访问权限)：如果类里的一个成员（包括成员变量、方法和构造器等）
 * 使用private访问控制符来修饰，则这个成员只能在当前类的内部被访问。
 * 很显然，这个访问控制符用于修饰成员变量最合适，使用它来修饰成员变量就可以把成员变量隐藏在该类的内部
 * <p>
 * 2.•default(包（package）访问权限)：
 * 如果类里的一个成员（包括成员变量、方法和构造器等）
 * 或者一个外部类不使用任何访问控制修饰，就称它为包访问权限的，
 * default访问控制的成员或外部类可以被相同包下的其他类访问。
 * <p>
 * 3.•protected（子类访问权限）：
 * 如果一个成员（包括成员变量、方法和构造器等）
 * 使用protected访问控制符修饰，那么这个成员既可以被同一个包中的其他类访问，
 * 也可以被不同包中的子类访问。在通常情况下，
 * 如果使用protected来修饰一个方法，通常是希望其子类来重写这个方法
 * 4.
 * •public（公共访问权限）：这是一个最宽松的访问控制级别，
 * 如果一个成员（包括成员变量、方法和构造器等）或者一个外部类使用public访问控制符修饰，
 * 那么这个成员或外部类就可以被所有类访问，
 * 不管访问类和被访问类是否处于同一个包中，是否具有父子继承关系。
 * <p>
 * <p>
 * 来看看Java的访问权限控制说明
 * 1.public 在自己包自己类，自己包别的类，别的包，别的类同时又继承关系,别的包别的类没有继承关系都可以都可以访问
 * 用public修饰的成员属性，成员方法，以及构造方法.
 * 2.Protected自己包，自己累，自己包，别的类，别的包，别的类，但是iyou继承关系可以继承，但是不能访问成员变量或者成员方法
 * 3.default自己包自己类，自己包，别的类都可以访问，其他的都不能访问
 * 4.privated自己包自己类可以访问，别的一概不得访问。
 */
public class ProtectedProteryTest {
    public static void main(String[] args) {
        Father t1 = new Father("jack", 12, 25);
        System.out.println("输入人的信息为:");
        System.out.println("输入的年龄为:" + t1.age);
        System.out.println("输入的id数值为" + t1.id);
        System.out.println("输入的名字为:" + t1.name);

    }

    static class Father {
        private String name;
        private int age;
        private int id;

        private Father(String name, int age, int id) {
            this.id = id;
            this.age = age;
            this.name = name;

        }
    }
}
/**
 * 访问的对象在同一个类里面，直接访问就可以了。
 * class A {
 * int a = 10;
 * <p>
 * void printA() {
 * System.out.println(a);
 * }
 * }
 * printA()要访问a，因为它们在同一个类，所以可以通过a直接访问。
 * 访问对象在不同类（假设访问对象在类B），
 * 此时可以通过声明、初始化B的一个对象，通过[对象名.成员变量/方法的名字]进行访问。
 * <p>
 * ps：这种情况仅限于成员方法访问成员变量/方法
 * class A {
 * void printB() {
 * B ob = new B();
 * System.out.println(ob.b);
 * }
 * }
 * <p>
 * class B {
 * int b = 10;
 * }
 * A中的printB()要访问B中的b，因为它们不在同一个类，
 * 所以可以在printB()中声明、初始化B的一个对象ob，通过ob.b进行访问。
 * <p>
 * 此外，当访问对象为静态变量/方法时，
 * 可以通过[访问对象所在类的类名.成员变量/方法的名字]进行访问。
 * <p>
 * class A {
 * static int a = 10;
 * <p>
 * int doubleA = A.a * 2;
 * <p>
 * void printB() {
 * System.out.println(B.b);
 * }
 * }
 * <p>
 * class B {
 * static int b = 10;
 * }
 * <p>
 * doubleA要访问a，由于a为静态变量，因此可以通过A.a进行访问。
 * <p>
 * A中的printB()要访问B中的b，由于b为静态变量，因此可以通过B.b进行访问。
 * <p>
 * <p>
 * 2.结论中提到了包，我们来看一下Java中包的定义和作用。
 * 包的作用
 * •1 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
 * •2 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，
 * 不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，
 * 应该加上包名加以区别。因此，包可以避免名字冲突。
 * •3 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
 * <p>
 * Java使用包（package）这种机制是为了防止命名冲突，访问控制，
 * 提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。
 * <p>
 * <p>
 * 3.结论中还提到了继承，我们来看一下Java中继承的定义。
 * class A extends B {
 * void printB() {
 * B ob = new B();
 * System.out.println(ob.b);
 * A ob2 = new A();
 * System.out.println(ob2.b);
 * }
 * }
 * <p>
 * class B {
 * int b = 10;
 * }
 * <p>
 * A继承B，因此A继承B的成员变量b。由于A在printB()中，
 * 声明、初始化B的一个对象ob后，可以通过ob.b访问b，
 * 则声明、初始化A的一个对象ob2后，可能通过ob2.b访问b。（可以访问则可以继承）。
 * <p>
 * 然而，在不同包里，子类继承父类时，
 * 子类只能访问父类的public型成员变量/方法，却能继承父类的protected和public型成员变量/方法
 * /* Stark.java
 * <p>
 * <p>
 * package winter.is.coming;
 * <p>
 * public class Stark {
 * private boolean ned;
 * boolean robb;
 * protected boolean sansa;
 * public boolean arya;
 * <p>
 * void howIsNed() {
 * System.out.println(ned);
 * }
 * }
 * <p>
 * class Snow {
 * void whoseBastard() {
 * Stark stark = new Stark();
 * // System.out.println(stark.ned); 不可访问
 * System.out.println(stark.robb);
 * }
 * }
 * <p>
 * <p>
 * <p>
 * import winter.is.coming.Stark;
 * <p>
 * public class Greyjoy extends Stark {
 * void betray() {
 * <p>
 * Stark stark = new Stark();
 * // System.out.println(stark.robb); 不可访问
 * // System.out.println(stark.sansa); 不可访问
 * <p>
 * Greyjoy greyjoy = new Greyjoy();
 * // System.out.println(greyjoy.robb); 不可访问
 * System.out.println(greyjoy.sansa);
 * <p>
 * }
 * }
 * <p>
 * <p>
 * <p>
 * import winter.is.coming.Stark;
 * <p>
 * public class Bolton {
 * void flay() {
 * Stark stark = new Stark();
 * System.out.println(stark.arya);
 * }
 * }
 * <p>
 * <p>
 * <p>
 * package winter.is.coming;
 * <p>
 * public class Stark {
 * private boolean ned;
 * boolean robb;
 * protected boolean sansa;
 * public boolean arya;
 * <p>
 * void howIsNed() {
 * System.out.println(ned);
 * }
 * }
 * <p>
 * class Snow {
 * void whoseBastard() {
 * Stark stark = new Stark();
 * // System.out.println(stark.ned); 不可访问
 * System.out.println(stark.robb);
 * }
 * }
 * <p>
 * <p>
 * <p>
 * import winter.is.coming.Stark;
 * <p>
 * public class Greyjoy extends Stark {
 * void betray() {
 * <p>
 * Stark stark = new Stark();
 * // System.out.println(stark.robb); 不可访问
 * // System.out.println(stark.sansa); 不可访问
 * <p>
 * Greyjoy greyjoy = new Greyjoy();
 * // System.out.println(greyjoy.robb); 不可访问
 * System.out.println(greyjoy.sansa);
 * <p>
 * }
 * }
 * <p>
 * <p>
 * <p>
 * import winter.is.coming.Stark;
 * <p>
 * public class Bolton {
 * void flay() {
 * Stark stark = new Stark();
 * System.out.println(stark.arya);
 * }
 * }
 * <p>
 * <p>
 * 得出重要的结论：
 * ① 自己包自己类 -- private可访问
 * ② 自己包别的类 -- default可访问
 * ③ 别的包别的类有继承关系 -- protected可继承，不可访问
 * ④ 别的包别的类无继承关系 -- public可访问
 */

/**


 package winter.is.coming;

 public class Stark {
 private boolean ned;
 boolean robb;
 protected boolean sansa;
 public boolean arya;

 void howIsNed() {
 System.out.println(ned);
 }
 }

 class Snow {
 void whoseBastard() {
 Stark stark = new Stark();
 // System.out.println(stark.ned); 不可访问
 System.out.println(stark.robb);
 }
 }



 import winter.is.coming.Stark;

 public class Greyjoy extends Stark {
 void betray() {

 Stark stark = new Stark();
 // System.out.println(stark.robb); 不可访问
 // System.out.println(stark.sansa); 不可访问

 Greyjoy greyjoy = new Greyjoy();
 // System.out.println(greyjoy.robb); 不可访问
 System.out.println(greyjoy.sansa);

 }
 }



 import winter.is.coming.Stark;

 public class Bolton {
 void flay() {
 Stark stark = new Stark();
 System.out.println(stark.arya);
 }
 }


 得出重要的结论：
 ① 自己包自己类 -- private可访问
 ② 自己包别的类 -- default可访问
 ③ 别的包别的类有继承关系 -- protected可继承，不可访问
 ④ 别的包别的类无继承关系 -- public可访问
 */

其实访问控制权限不是那么的重要，大家只需要记住结论姐可以了。大家也可以写下代码自己测试一下.这里我就不再写代码了。