一. 简介

详细内容参考：Java修饰符

本篇主要是对访问控制修饰符的讲解。

public，protected，default( 不使用修饰符，包访问权限 )，private

二. 在类中的使用

对于非内部类而言，类的访问权限修饰词仅有public和包访问权限两种

内部类可以是private或protected的

总结：

default包访问权限：包访问权限就是Java中的默认的权限，具有包访问权限的类成员只能被同一包中的类访问。

public ：被public修饰的类成员能被所有的类直接访问；

1. default

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//父类
package com.xl.study.day0417.xiushifu;

class MyClass {
    public void printfStr(){
        System.out.println("父类");
    }
}

//同一个包下的子类
package com.xl.study.day0417.xiushifu;

public class MyClass_Child_Package extends MyClass {
    @Override
    public void printfStr() {
        super.printfStr();

        System.out.println("子类（与父类在同一个包下）");
    }
}

//不是同一个包下
//无法访问

2. public

对所有的类都是可见的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
//父类
package com.xl.study.day0417.xiushifu;

public class MyClass {
    public void printfStr(){
        System.out.println("父类");
    }
}

//同一个包下的子类
package com.xl.study.day0417.xiushifu;

public class MyClass_Child_Package extends MyClass {
    @Override
    public void printfStr() {
        super.printfStr();

        System.out.println("子类（与父类在同一个包下）");
    }
}

//不是同一个包下的子类
package com.xl.study.day0417.xiushifu_test;

import com.xl.study.day0417.xiushifu.MyClass;

public class MyClass_Child_NoPackage extends MyClass {
    @Override
    public void printfStr() {
        super.printfStr();

        System.out.println("子类（与父类不在同一个包下）");
    }
}

3. protected

不可以修饰外部类，修饰内部类

4. private

不可以修饰外部类，修饰内部类

三. 在方法中的使用

总结：（基于方法所在类是public修饰）

public：所有类中都是可见的，可以被子类继承。

private：除了类本身其他类都是不可见的，不可以被子类继承，只有类内部才可以访问。

default：同一个包下的类是可见的，可以被同一个包下的类继承，不可以被不在同一个包下的类继承。

Protected：同一个包下的类以及子类里面是可见的，可以被同一个包或者不同包下的类继承。

1. public

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
//父类
package com.xl.study.day0417.xiushifu;

public class MyClass {
    public void printfStr(){
        System.out.println("父类");
    }
}

//同一个包下的子类
package com.xl.study.day0417.xiushifu;

public class MyClass_Child_Package extends MyClass {
    @Override
    public void printfStr() {
        super.printfStr();

        System.out.println("子类（与父类在同一个包下）");
    }
}

//不是同一个包下的子类
package com.xl.study.day0417.xiushifu_test;

import com.xl.study.day0417.xiushifu.MyClass;

public class MyClass_Child_NoPackage extends MyClass {
    @Override
    public void printfStr() {
        super.printfStr();

        System.out.println("子类（与父类不在同一个包下）");
    }
}

2. private

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//父类
package com.xl.study.day0417.xiushifu;

public class MyClass {
    private void printfStr(){
        System.out.println("父类");
    }
}

//同一个包下的子类
package com.xl.study.day0417.xiushifu;

public class MyClass_Child_Package extends MyClass {
   
}

//不是同一个包下的子类
package com.xl.study.day0417.xiushifu_test;

import com.xl.study.day0417.xiushifu.MyClass;

public class MyClass_Child_NoPackage extends MyClass {
    
}

3. default

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//父类
package com.xl.study.day0417.xiushifu;

public class MyClass {
    void printfStr(){
        System.out.println("父类");
    }
}

//同一个包下的子类
package com.xl.study.day0417.xiushifu;

public class MyClass_Child_Package extends MyClass {
    @Override
    void printfStr() {
        super.printfStr();

        System.out.println("子类（与父类在同一个包下）");
    }
}

//不是同一个包下的子类
package com.xl.study.day0417.xiushifu_test;

import com.xl.study.day0417.xiushifu.MyClass;

public class MyClass_Child_NoPackage extends MyClass {
    
}

4. protected

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
//父类
package com.xl.study.day0417.xiushifu;

public class MyClass implements Cloneable {
    protected void printfStr(){
        System.out.println("父类");
    }

    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        try {
            myClass.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

//同一个包下的子类
package com.xl.study.day0417.xiushifu;

public class MyClass_Child_Package extends MyClass {
    @Override
    protected void printfStr() {
        super.printfStr();
    }
}

class Test{
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.printfStr();

        MyClass_Child_Package myClass_child_package = new MyClass_Child_Package();
        myClass_child_package.printfStr();
      
        //不可访问clone()
    }
}

//不同包下的子类
package com.xl.study.day0417.xiushifu_test;

import com.xl.study.day0417.xiushifu.MyClass;
import com.xl.study.day0417.xiushifu.MyClass_Child_Package;

public class MyClass_Child_NoPackage extends MyClass {
    @Override
    protected void printfStr() {
        super.printfStr();
    }
}

class Text{
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        MyClass_Child_Package myClass_child_package = new MyClass_Child_Package();

        MyClass_Child_NoPackage myClass_child_noPackage = new MyClass_Child_NoPackage();
        myClass_child_noPackage.printfStr();
      
        //不可访问clone()
    }
}

clone()方法是定义在Object里面的protected方法，根据我们的说法，它的可见性只能是java.lang包以及它的子类。

而这里我们的MyClass，MyClass_Child_Package，MyClass_Child_NoPackage都是其子类，所以可以在里面调用

clone()方法。Test，Text类不在其中，故无法访问。

那么按理来说，MyClass的printfStr()的可见性应该是com.xl.study.day0417.xiushifu包和MyClass_Child_Package，MyClass_Child_NoPackage类。为什么在Text类里面MyClass_Child_NoPackage实例可以访问printfStr()方法呢？那是因为我们重写了printfStr()方法，导致我们可以访问，我们这个时候访问的不是MyClass的printfStr()方法了。

同一个包下的类以及子类是可见的，子类需要分类说明。如果是同一个包下的子类，那就和同一个包下的类是一样的。不同包下的子类是可见的是针对当前子类可以访问父类用protected修饰的方法而不是说这里面的父类对象可以访问其protected修饰的方法。

四. 在变量中使用

总结：（基于方法所在类是public修饰）

public：所有类中都是可见的。

private：除了类本身其他类都是不可见的。

default：同一个包下的类是可见的。

Protected：同一个包下的类以及子类是可见的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
//父类
package com.xl.study.day0417.xiushifu;

public class MyClass implements Cloneable {
    protected int xl_test = 0;

    protected void printfStr(){
        System.out.println("父类");
    }

    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        try {
            myClass.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

//同一个包下的子类
package com.xl.study.day0417.xiushifu;

public class MyClass_Child_Package extends MyClass {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.xl_test = 1;
        myClass.printfStr();
    }
}

//不同包下的子类
class Test{
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.xl_test = 1;
        myClass.printfStr();

        MyClass_Child_Package myClass_child_package = new MyClass_Child_Package();
        myClass_child_package.printfStr();
    }
}

package com.xl.study.day0417.xiushifu_test;

import com.xl.study.day0417.xiushifu.MyClass;
import com.xl.study.day0417.xiushifu.MyClass_Child_Package;

public class MyClass_Child_NoPackage extends MyClass {

    public static void main(String[] args) {
        MyClass_Child_NoPackage myClass_child_noPackage = new MyClass_Child_NoPackage();
        myClass_child_noPackage.printfStr();
        myClass_child_noPackage.xl_test = 1;
    }
}

class Text{
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        MyClass_Child_Package myClass_child_package = new MyClass_Child_Package();

        MyClass_Child_NoPackage myClass_child_noPackage = new MyClass_Child_NoPackage();
    }
}