Java四种访问权限实例分析

在Java中，有四种访问权限修饰符，包括public、protected、default和private。对于不同的访问权限，它们所允许的访问范围也不同，下面我们来详细讲解一下。

1. public

public是最宽松的访问权限，使用public修饰的类、变量和方法可以被任何其他类所访问，包括在不同包中的类。

示例1：

package com.example.a;
public class A {
    public int num1 = 1;
    protected int num2 = 2;
    int num3 = 3;
    private int num4 = 4;
}

在示例1中，我们在包com.example.a中定义了一个类A，并对其四个成员变量分别使用了public、protected、default和private修饰符。其中，num1是public修饰的，可以在其他包的任何类中访问到；num2是protected修饰的，可以在A类及其子类以及在同一个包中的其他类中访问到；num3是default修饰的，可以在同一个包中的其他类中访问到；num4是private修饰的，只能在A类中访问到。

示例2：

package com.example.b;
import com.example.a.A;
public class B {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.num1); // 可以访问到
        System.out.println(a.num2); // 编译报错
        System.out.println(a.num3); // 编译报错
        System.out.println(a.num4); // 编译报错
    }
}

在示例2中，我们在包com.example.b中定义了一个类B，并引入了包com.example.a中的类A。在B类的main方法中，我们创建了一个A类的对象a，通过对象a可以访问到A类中的num1成员变量，因为它是public修饰的。但是，对于其他三个成员变量，由于它们的访问权限小于public，我们无法在B类中访问到，会编译报错。

2. protected

protected修饰的成员变量和方法可以被该类本身、该类的子类和同一个包的其他类所访问。

示例3：

package com.example.a;
public class A {
    protected void test() {
        System.out.println("protected method");
    }
}

在示例3中，我们在包com.example.a中定义了一个类A，并对其test()方法使用protected修饰符。这意味着，test()方法可以被A类本身、A类的子类和同一个包中的其他类所访问到。

示例4：

package com.example.a;
public class B extends A {
    public static void main(String[] args) {
        B b = new B();
        b.test(); // 可以访问到
    }
}

在示例4中，我们定义了一个类B，继承了A类，并在B类的main方法中创建了一个B类的对象b。由于B类是A类的子类，所以它可以访问到A类中被protected修饰的test()方法。

3. default

default是不写访问权限修饰符时的默认访问权限，它允许同一个包中的其他类访问。

示例5：

package com.example.a;
class C {
    void test() {
        System.out.println("default method");
    }
}

在示例5中，我们在包com.example.a中定义了一个类C，并对其test()方法没有使用任何访问权限修饰符。这意味着，test()方法的访问权限是default，也就是可以被同一个包中的其他类所访问到。

示例6：

package com.example.b;
import com.example.a.C;
public class D {
    public static void main(String[] args) {
        C c = new C();
        c.test(); // 可以访问到
    }
}

在示例6中，我们在包com.example.b中定义了一个类D，并引入了包com.example.a中的类C。在D类的main方法中，我们创建了一个C类的对象c，通过对象c可以访问到C类中的test()方法，因为它们在同一个包中。

4. private

private是访问权限最小的修饰符，使用private修饰的成员变量和方法只能被该类本身所访问，其他类无法访问。

示例7：

package com.example.a;
public class A {
    private void test() {
        System.out.println("private method");
    }
}

在示例7中，我们在包com.example.a中定义了一个类A，并对其test()方法使用private修饰符。这意味着，test()方法只能被A类本身所访问。

示例8：

package com.example.b;
import com.example.a.A;
public class B {
    public static void main(String[] args) {
        A a = new A();
        a.test(); // 编译报错
    }
}

在示例8中，我们在包com.example.b中定义了一个类B，并引入了包com.example.a中的类A。在B类的main方法中，我们创建了一个A类的对象a，但是无法访问到A类中被private修饰的test()方法，会编译报错。