Java 修饰符：探索 Java 语言中的访问控制和继承机制

什么是修饰符？

Java 语言中，修饰符用于控制类、方法、变量和构造函数的访问和继承权限。Java 中有四种访问控制修饰符，它们分别是：

    public
    protected
    default
    private

除此之外，Java 还有两种非访问控制修饰符，分别是：

    static
    final

那么这些修饰符到底有什么作用呢？接下来我们将一一探究。

public 修饰符

public 修饰符是最常见的访问控制修饰符，它可以让类、方法、变量和构造函数对所有类可见，无论是在同一个包还是在不同的包中。

例如，我们可以在一个名为 MyPackage 的包中定义以下类：

    package MyPackage;

    public class MyClass {
        public String name = "Java";
        public void printName() {
            System.out.println("名称：" + name);
        }
    }

然后在另一个名为 TestPackage 的包中使用这个类：

    package TestPackage;
    import MyPackage.MyClass;

    public class Test {
        public static void main(String[] args) {
            MyClass myObj = new MyClass();
            myObj.name = "Java 修饰符";
            myObj.printName();
        }
    }

在这个例子中，MyClass 中的 name 和 printName() 方法都被声明为 public，所以它们可以在 Test 类中被访问。

protected 修饰符

protected 修饰符可以让类、方法和变量对同一个包中的其他类以及该类的子类可见。

例如，我们可以在一个名为 Animal 的类中定义以下方法：

    public class Animal {
        protected void animalSound() {
            System.out.println("动物发出叫声");
        }
    }

然后在一个名为 Cat 的子类中使用这个方法：

    public class Cat extends Animal {
        public static void main(String[] args) {
            Cat myCat = new Cat();
            myCat.animalSound();
        }
    }

在这个例子中，我们可以在 Cat 类中访问 Animal 类中的 protected 方法 animalSound()，因为 Cat 是 Animal 的子类。

default 修饰符

default 修饰符也称为 package-private，它可以使类、方法和变量对同一个包中的其他类可见，但对于不在同一个包中的类是不可见的。

例如，我们可以在一个名为 MyPackage 的包中定义以下类：

    package MyPackage;

    class MyClass {
        public String name = "Java";
        void printName() {
            System.out.println("名称：" + name);
        }
    }

然后在同一个包中的另一个类中使用这个类：

    package MyPackage;

    class Test {
        public static void main(String[] args) {
            MyClass myObj = new MyClass();
            myObj.name = "Java 修饰符";
            myObj.printName();
        }
    }

在这个例子中，MyClass 中的 name 和 printName() 方法都没有被声明为 public 或 protected，所以它们只能在同一个包中的其他类中被访问。

private 修饰符

private 修饰符可以使类、方法和变量对该类的其他方法可见，但对于不在同一个类中的方法是不可见的。

例如，我们可以在一个名为 Person 的类中定义以下变量：

    public class Person {
        private String name;

        public void setName(String newName) {
            name = newName;
        }

        public String getName() {
            return name;
        }
    }

在这个例子中，name 变量被声明为 private，这意味着只有 Person 类中的其他方法可以访问它。如果我们尝试在 Person 类外部访问 name 变量，编译器会报错。

static 和 final 修饰符

static 和 final 修饰符不属于访问控制修饰符，它们分别用于创建静态变量和常量。

static 修饰符用于创建类变量，也称为静态变量。这些变量属于类，而不是属于特定的实例。因此，它们可以被类中所有的对象或方法使用。

例如，我们可以在一个名为 MyClass 的类中定义以下静态变量：

    public class MyClass {
        static String myClassVar = "Java";
        public String myObjVar = "修饰符";

        public static void main(String[] args) {
            MyClass myObj = new MyClass();
            System.out.println(myObj.myObjVar);
            System.out.println(MyClass.myClassVar);
        }
    }

在这个例子中，myClassVar 变量被声明为 static，所以它可以被 MyClass 类中的任何方法使用。

final 修饰符用于创建常量，也称为不可变变量。一旦给常量赋值，它就不能被更改了。

例如，我们可以在一个名为 MyClass 的类中定义以下常量：

    public class MyClass {
        final String myVar = "Java 修饰符";

        public static void main(String[] args) {
            MyClass myObj = new MyClass();
            System.out.println(myObj.myVar);
        }
    }

在这个例子中，myVar 变量被声明为 final，所以它的值不能被更改。

结论

修饰符在 Java 语言中起着非常重要的作用，它们可以帮助我们控制类、方法、变量和构造函数的访问和继承权限。了解这些修饰符的作用可以让我们更好地理解 Java 语言中的访问控制和继承机制。

希望这篇文章对你有所帮助，如果你有任何问题或建议，请在评论区留言。谢谢！