Java学习—修饰符

java中有两种类型的修饰符：访问修饰符和非修饰符。
java中的访问修饰符指定数据成员，方法，构造函数或类的辅助功能(范围)。
一共有4种类型的java访问修饰符：

• private
• default
• protected
• public

有许多非访问修饰符，如：static, abstract, synchronized, native, volatile, transient等修饰符。这里，我们将只学习访问修饰符。

private

私有(private)访问修饰符只能在类中访问。
示例：
在这个例子中，我们创建了两个类:A和Simple。 类包含私有数据成员和私有方法。 我们从类外访问这些私有成员，所以会产生编译时错误。

class A {
    private int data = 40;

    private void msg() {
        System.out.println("Hello java");
    }
}

public class Simple {
    public static void main(String args[]) {
        A obj = new A();
        System.out.println(obj.data);// 私有变量，不可以从外部类中直接访问，因此有编译错误
        obj.msg();// 私有方法，不可以从外部类中直接访问，因此有编译错误
    }
}

如果将类的构造函数声明为私有，则不能从类外部创建该类的实例。 例如：

class A {
    private A() {
    }// private constructor

    void msg() {
        System.out.println("Hello java");
    }
}

public class Simple {
    public static void main(String args[]) {
        A obj = new A();// Compile Time Error
    }
}

注意：类不能是私有或保护，除非是嵌套类。

default

如果不使用任何修饰符，默认情况下将其视为default修饰符。default修饰符只能在包内访问。
示例：
在这个例子中，我们创建了两个包pack和mypack。从它的包外部访问A类，因为一个类不是public的，所以它不能从包外部访问。如下两个类：A.java 和 B.java 代码。

package pack;  
class A{  
    void msg(){System.out.println("Hello");}  
}

package mypack;

import pack.*;

class B {
    public static void main(String args[]) {
        A obj = new A();// Compile Time Error
        obj.msg();// Compile Time Error
    }
}

在上面的例子中，A类的范围和它的方法msg()是默认(default)的，所以它不能从包外部访问。

protected

protected访问修饰符可以在包中和包外部访问，但只能通过继承。protected访问修饰符可以应用于数据成员，方法和构造函数。 它不能应用于类。
示例：
在这个例子中，我们创建了两个包pack和mypack。 A类的包是public的，所以可以从外部访问包。 但是这个包的msg方法声明为protected，因此只能通过继承从类外面访问它。如下两个类：A.java 和 B.java 代码。

package pack;

public class A {
    protected void msg() {
        System.out.println("Hello");
    }
}

package mypack;

import pack.*;

class B extends A {
    public static void main(String args[]) {
        B obj = new B();
        obj.msg();
    }
}

public

公共(public)访问修饰符可随处访问。 它在所有其他修饰符中具有最广泛的范围。
示例：

package pack;

public class A {
    public void msg() {
        System.out.println("Hello");
    }
}

package mypack;

import pack.*;

class B {
    public static void main(String args[]) {
        A obj = new A();
        obj.msg();
    }
}

理解Java中的访问修饰符

如果你要覆盖任何方法，重写的方法(即在子类中声明)则不能声明得更严格。

class A {
    protected void msg() {
        System.out.println("Hello java");
    }
}

public class Simple extends A {
    void msg() {
        System.out.println("Hello java");
    }// C.T.Error

    public static void main(String args[]) {
        Simple obj = new Simple();
        obj.msg();
    }
}

默认(default)修饰符比受保护的修饰符更严格。 这就是为什么有编译时错误。