Java 包和访问权限操作

下面是Java包和访问权限操作的完整攻略：

1. Java 包

Java包是为了更好地组织类而创建的一种包含关系，类似于文件夹。它可以将具有相同功能的类组织在一起，方便类的查找、使用和维护。

1.1 包定义

包定义使用关键字 package，定义格式如下：

package 包名;

其中，包名由多个单词组成，中间使用.间隔，如：

package com.example.demo;

1.2 包导入

如果我们想要在某个Java文件中使用其他包的类，就需要使用包导入语句来导入该包。Java提供了两种导入方式，分别是单类导入和通配符导入。

1.2.1 单类导入

单类导入即导入某个具体的类，使用以下格式：

import 包名.类名;

例如：

import java.util.Date;

1.2.2 通配符导入

通配符导入即导入某个包下的所有类，使用以下格式：

import 包名.*;

例如：

import java.util.*;

1.3 包访问控制

Java向我们提供了访问控制修饰符，用于控制包、类、方法和变量的访问权限。访问控制修饰符有四种，分别是public、protected、default和private：

• public：任何类都可以访问该成员。
• protected：只有同包或者子类可以访问该成员。
• default：只有同包可以访问该成员，当我们没有明确指定访问修饰符时，默认为default。
• private：只有该类内部可以访问该成员。

示例如下：

package com.example.demo;

public class Demo {


    //public 成员变量可以被其他类访问
    public int a;

    //protected 成员变量只能在本包内使用，其他包的子类也能访问
    protected int b;

    //default 成员变量只能在本包内使用
    int c;

    //private 成员变量只能在类的内部使用
    private int d;

    public void method1() {
        //访问修饰符为public的成员可以在任何地方被访问
    }

    protected void method2() {
        //访问修饰符为protected的成员只能在本包内使用，其他包的子类也能访问
    }

    void method3() {
        //访问修饰符为default的成员只能在本包内使用
    }

    private void method4() {
        //访问修饰符为private的成员只能在类的内部使用
    }

}

2. 访问权限操作

在Java中，我们可以通过反射机制来进行访问权限的操作，包括获取、设置、检查访问权限。

2.1 获取访问权限信息

Java反射机制提供了一些方法来获取成员的访问修饰符信息，如：

//获取成员变量的访问修饰符
public int getModifiers()

//获取方法的访问修饰符
public int getModifiers()

其中，返回值表示访问修饰符的二进制表示，我们可以通过Java权限修饰符对照表来判断具体的修饰符类型。

示例代码如下所示：

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class AccessTester {

    public static void main(String[] args) {
        Demo demo = new Demo();

        Class<?> clz = demo.getClass();

        //获取 public 成员变量的访问修饰符
        Field aField = null;
        try {
            aField = clz.getDeclaredField("a");
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        System.out.println("public 成员变量的访问修饰符为：" + aField.getModifiers());

        //获取 protected 成员变量的访问修饰符
        Field bField = null;
        try {
            bField = clz.getDeclaredField("b");
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        System.out.println("protected 成员变量的访问修饰符为：" + bField.getModifiers());

        //获取 default 成员变量的访问修饰符
        Field cField = null;
        try {
            cField = clz.getDeclaredField("c");
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        System.out.println("default 成员变量的访问修饰符为：" + cField.getModifiers());

        //获取 private 成员变量的访问修饰符
        Field dField = null;
        try {
            dField = clz.getDeclaredField("d");
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        System.out.println("private 成员变量的访问修饰符为：" + dField.getModifiers());

        //获取 public 方法的访问修饰符
        Method method1 = null;
        try {
            method1 = clz.getDeclaredMethod("method1");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        System.out.println("public 方法的访问修饰符为：" + method1.getModifiers());

        //获取 protected 方法的访问修饰符
        Method method2 = null;
        try {
            method2 = clz.getDeclaredMethod("method2");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        System.out.println("protected 方法的访问修饰符为：" + method2.getModifiers());

        //获取 default 方法的访问修饰符
        Method method3 = null;
        try {
            method3 = clz.getDeclaredMethod("method3");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        System.out.println("default 方法的访问修饰符为：" + method3.getModifiers());

        //获取 private 方法的访问修饰符
        Method method4 = null;
        try {
            method4 = clz.getDeclaredMethod("method4");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        System.out.println("private 方法的访问修饰符为：" + method4.getModifiers());
    }
}

输出结果：

public 成员变量的访问修饰符为：1
protected 成员变量的访问修饰符为：4
default 成员变量的访问修饰符为：0
private 成员变量的访问修饰符为：2
public 方法的访问修饰符为：1
protected 方法的访问修饰符为：4
default 方法的访问修饰符为：0
private 方法的访问修饰符为：2

2.2 设置访问权限

通过反射机制，我们还可以设置成员的访问修饰符。下面是一个示例，该示例改变了类的成员变量的访问修饰符。

import java.lang.reflect.Field;

public class AccessTester {

    public static void main(String[] args) {
        Demo demo = new Demo();

        Class<?> clz = demo.getClass();

        //获取 private 成员变量的访问修饰符
        Field dField = null;
        try {
            dField = clz.getDeclaredField("d");
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }

        dField.setAccessible(true); //设置 private 成员变量可以被访问

        try {
            int value = (int) dField.get(demo); //获取 private 成员变量的值
            System.out.println("获取原始值为：" + value);

            dField.set(demo, 100); //设置 private 成员变量的值

            int newValue = (int) dField.get(demo); //获取设置后的值
            System.out.println("设置后的值为：" + newValue);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

    }
}

输出结果：

获取原始值为：0
设置后的值为：100

2.3 检查访问权限

除了获取和设置访问权限外，我们还可以使用反射机制来检查成员的访问权限。示例如下：

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class AccessTester {

    public static void main(String[] args) {
        Demo demo = new Demo();

        Class<?> clz = demo.getClass();

        //判断 public 成员变量是否可以访问
        Field aField = null;
        try {
            aField = clz.getDeclaredField("a");
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        System.out.println("public 成员变量是否可以访问：" + aField.isAccessible());

        //判断 protected 成员变量是否可以访问
        Field bField = null;
        try {
            bField = clz.getDeclaredField("b");
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        System.out.println("protected 成员变量是否可以访问：" + bField.isAccessible());

        //判断 default 成员变量是否可以访问
        Field cField = null;
        try {
            cField = clz.getDeclaredField("c");
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        System.out.println("default 成员变量是否可以访问：" + cField.isAccessible());

        //判断 private 成员变量是否可以访问
        Field dField = null;
        try {
            dField = clz.getDeclaredField("d");
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        System.out.println("private 成员变量是否可以访问：" + dField.isAccessible());

        //判断 public 方法是否可以访问
        Method method1 = null;
        try {
            method1 = clz.getDeclaredMethod("method1");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        System.out.println("public 方法是否可以访问：" + method1.isAccessible());

        //判断 protected 方法是否可以访问
        Method method2 = null;
        try {
            method2 = clz.getDeclaredMethod("method2");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        System.out.println("protected 方法是否可以访问：" + method2.isAccessible());

        //判断 default 方法是否可以访问
        Method method3 = null;
        try {
            method3 = clz.getDeclaredMethod("method3");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        System.out.println("default 方法是否可以访问：" + method3.isAccessible());

        //判断 private 方法是否可以访问
        Method method4 = null;
        try {
            method4 = clz.getDeclaredMethod("method4");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        System.out.println("private 方法是否可以访问：" + method4.isAccessible());
    }
}

输出结果：

public 成员变量是否可以访问：true
protected 成员变量是否可以访问：true
default 成员变量是否可以访问：false
private 成员变量是否可以访问：false
public 方法是否可以访问：true
protected 方法是否可以访问：true
default 方法是否可以访问：false
private 方法是否可以访问：false

至此，Java包和访问权限操作的攻略讲解完毕。