java中有两种类型的修饰符：访问修饰符和非修饰符。
java中的访问修饰符指定数据成员，方法，构造函数或类的辅助功能(范围)。
一共有4种类型的java访问修饰符：
privatedefaultprotectedpublic有许多非访问修饰符，如：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 代码。
//save by a.java
package pack;
class a{
void msg(){system.out.println("hello");}
}
b.java 代码的代码如下 -
//save by b.java
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 代码。
//save by a.java
package pack;
public class a {
protected void msg() {
system.out.println("hello");
}
}
b.java 代码如下 -
//save by b.java
package mypack;
import pack.*;
class b extends a {
public static void main(string args[]) {
b obj = new b();
obj.msg();
}
}
执行上面代码，得到如下结果 -
hello
公共(public)访问修饰符可随处访问。 它在所有其他修饰符中具有最广泛的范围。
public访问修饰符示例
如下两个类：a.java 和 b.java 代码。
a.java 的代码
//save by a.java
package pack;
public class a {
public void msg() {
system.out.println("hello");
}
}
b.java 的代码
//save by b.java
package mypack;
import pack.*;
class b {
public static void main(string args[]) {
a obj = new a();
obj.msg();
}
}
执行上面的代码，得到以下结果 -
hello
让我们通过下面的一个简单的表来理解访问修饰符。
| 访问修饰符 | 在类内 | 在包内 | 外部包只通过子类 | 外部包 |
|---|---|---|---|---|
| private | y | n | n | n |
| default | y | y | n | n |
| protected | y | y | y | n |
| public | y | y | y | y |
如果你要覆盖任何方法，重写的方法(即在子类中声明)则不能声明得更严格。
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)修饰符比受保护的修饰符更严格。 这就是为什么有编译时错误。
