Java访问权限修饰符

共计 2994 个字符，预计需要花费 8 分钟才能阅读完成。

《Thinking in Java》第六章中6.2小节“Java访问权限修饰符”；

public：接口访问权限

public修饰的成员对任何人开放，所有人都可以访问；

package cn.peiluming.test1.test1_1;

/**
 * @author plm
 * @create 2021/2/21 23:38
 */
public class Cookie {
    public Cookie() {
        System.out.println("Constructor No Args.");
    }

    void demo() {
        System.out.println("demo.");
    }
}


package cn.peiluming.test1;

import cn.peiluming.test1.test1_1.Cookie;

/**
 * @author plm
 * @create 2021/2/21 23:43
 */
public class Dinner {
    public static void main(String[] args) {
        Cookie cookie = new Cookie();
        //! cookie.demo();  // 'demo()' is not public in 'cn.peiluming.test1.test1_1.Cookie'. Cannot be accessed from outside package
    }
}

/* 输出
Constructor No Args.
 */

Cookie对象的构造器是public且类也是public的，但是demo()只向test1包中的类提供访问权限，所以编译会提示如上报错。

默认包

// The Other class
class Pie {
    void demo() {
        System.out.println("Pie.demo()");
    }
}


/**
 * @author plm
 * @create 2021/2/21 23:57
 */
class Cake {
    public static void main(String[] args) {
        Pie pie = new Pie();
        pie.demo();
    }
}

/* 输出
Pie.demo()
 */

最初或许会以为这两个文件毫不相关，它们并不在包下面，而是在src下面，但是Cake却可以创建Pie对象并调用它的demo()方法！
通常会认为Pie和demo()享有包访问权限，应该是不可以被Cake所用的，它们确实拥有包访问权限，但这只是部分正确！
Cake可以访问的原因是因为它们同处于相同目录并且都没有给自己设定任何包名称，Java将这样的文件自动看作隶属于该目录的默认包中，于是它们就给所有其他文件提供了包访问权限！
注意：默认包这一块必须确保你的CLASSPATH之中要有”.”!

window:

linux:

private：私有无法访问

private修饰的成员，除了本类之外，其他任何类都无法访问这个成员！
通常情况，我们使用private将不必要的方法进行隔离，只对外开放我们想要开放的，比如：

/**
 * @author plm
 * @create 2021/2/22 0:52
 */
public class IceCream {
    public static void main(String[] args) {
        //! Sundae sundae = new Sundae(); // 'Sundae()' has private access in 'Sundae'
        Sundae instance1 = Sundae.getInstance();
        System.out.println(instance1);  // Sundae@16c0663d
        Sundae instance2 = Sundae.getInstance();
        System.out.println(instance2);  // Sundae@16c0663d

    }
}

class Sundae {
    private Sundae() {
    }

    private static final Sundae sundae;

    static {
        sundae = new Sundae();
    }

    static Sundae getInstance() {
        // 比如搞一个单例构造
        return sundae;
    }
}

如上，不能通过构造器创建Sundae对象，而必须通过调用getInstance()方式获取单例对象；

protected：继承访问权限

proceted处理的更多的是继承的概念，继承就可以对现有类进行一个扩展，基类创建者希望某个特定成员，只赋予派生类而不是所有类！

package cn.peiluming.test1.test1_1;

/**
 * @author plm
 * @create 2021/2/21 23:38
 */
public class Cookie {
    public Cookie() {
        System.out.println("Constructor No Args.");
    }

    void demo() {
        System.out.println("demo.");
    }

    protected void test() {
        System.out.println("test.");
    }
}


import cn.peiluming.test1.test1_1.Cookie;

/**
 * @author plm
 * @create 2021/2/22 1:07
 */
public class ChocolateChip extends Cookie {
    public ChocolateChip() {
        System.out.println("ChocolateChip Constructor No Args ");
    }

    public void chomp() {
        //! demo(); // 'demo()' is not public in 'cn.peiluming.test1.test1_1.Cookie'. Cannot be accessed from outside package
        test(); // protected修饰的就可以访问
    }

    public static void main(String[] args) {
        ChocolateChip chocolateChip = new ChocolateChip();
        chocolateChip.chomp();
    }
}

/* 输出
Constructor No Args.
ChocolateChip Constructor No Args 
test.
 */

当然protected也提供包访问权限，也就是说相同包内的其他类可以访问protected修饰的成员！

包访问权限

有人问了🤔：为什么没有写修饰符，那是因为这就是默认不写的情况（即：不加访问修饰词）；
目的就是为了整合同一个包下面相关的类，以是的它们之间能够轻松地相互作用。

package cn.peiluming.test1;

/**
 * @author plm
 * @create 2021/2/22 1:20
 */
class A {
    A() {
        System.out.println("A Constructor No Args.");
    }

    void demo() {
        System.out.println("A.demo()");
    }

}

package cn.peiluming.test1;

/**
 * @author plm
 * @create 2021/2/22 1:21
 */
class B {
    public static void main(String[] args) {
        A a = new A();
        a.demo();
    }
}

/*
A Constructor No Args.
A.demo()
 */

总结