Java访问修饰符

   本文对java中的修饰符问题做个简单梳理，java中的修饰符包括成员的修饰符、类和接口的修饰符，内部类与外部类的修饰符，以下对上述三个方面分别说明。

   1.成员的访问控制修饰符

权限修饰符	当前类	其它包子类	同包	其它包
public	√	√/*	√/*	√
protected	√	√/*	√/*	×
default	√	×	√/*	×
private	√	×	×	×

   public修饰的成员可以在当前类、子类、同包、其他包中被访问。private修饰的类属性和方法仅在当前类有效，子类重写父类的private修饰的方法是没有意义的，相当于定义一个新方法。以后只要是编写方法，99%的情况下都使用public进行定义。default对于同一个包中的其他类相当于公开（public），它不仅能在设置了该权限的类中访问，也可以在同一包中的类或子类中访问，对于不是同一个包中的其他类相当于私有（private）。protected除了具有default的访问权限外，还可以在不同包中所继承的子类访问，对子类相当于公开，对不是同一包中的没有父子关系的类相当于私有。要想更深入地理解这些访问权限，一方面需要明白各自的作用域，另一方面更是要弄清楚各自所体现出来的编程思想，比方说，private表现的封装思想，public表现的面向接口编程的思想等。<!--EndFragment-->

   关于default和protected区别的测试代码

 

package test1;
public class Car {
	String color;
	protected int wheels;
}
package test1;
public class Pickup extends Car {
	String color = "silver";
	protected int wheels = 4;
	void print(){
		System.out.println(super.color);
		System.out.println(super.wheels);
	}
}
package test1;
public class TestDemo {
	public static void main(String[] args) {
		Pickup p = new Pickup();
		System.out.println(p.color);
		System.out.println(p.wheels);
		p.print();
	}
}
package test2;
import test1.Car;
public class Pickup extends Car {
	void print(){
		System.out.println(super.color);//The field Car.color is not visible
		System.out.println(super.wheels);
	}
}
package test2;

import test1.Pickup;

public class Truck {
 
	Pickup p = new Pickup();
 
	void print(){
  
		System.out.println(p.color);//The field Pickup.color is not visible
  
		System.out.println(p.wheels);//The field Pickup.wheels is not visible
 
	}
}

 

   2.类和接口的修饰符

 

   成员访问控制修饰符中的public和default还可以修饰类，在同一个java文件里，公有类有且仅有一个，并且该文件命名为类名.java。

修饰符	成员方法	成员属性	类	接口	外部类	内部类
public	√	√	√	√	√
protected	√	√			×	√
default	√	√	√	√	√
private	√	√			×	√
abstract	√		√	√
static	√	√	×			√
final	√	√	√

 

 

   abstract和final修饰符只能二选一。

 

   3.内部类与外部类的修饰符

 

<!--EndFragment-->

 

 

 

class Outer { //  定义了外部类
	private String title = "HELLO WORLD" ;
	public void fun() {
		new Inner().print() ;
	}
	class Inner { //  定义内部类
	public void print() {
		System.out.println(title) ;
	}
	}
}
public class TestDemo {
	public static void main(String args[]) {
		Outer out = new Outer() ;
		out.fun() ;
	}
}

   外部类也可以直接操作内部类中的私有属性。

 

 

 

 

class Outer { //  定义了外部类
	private String title = "HELLO WORLD" ;
	class Inner { //  定义内部类
		private String msg = " 你好" ;  //  私有属性
		public void print() {
			System.out.println(Outer.this.title) ;
		}
	}
	public void fun() {
		Inner in = new Inner() ;
		System.out.println(in.msg) ;//  这是直接访问私有属性
	}
}
public class TestDemo {
	public static void main(String args[]) {
		Outer out = new Outer() ;
		out.fun() ;
	}
}

 

   对于内部类而言，也可以使用static关键字进行定义，使用了static定义的内部类严格来讲就变为了一个外部类。

 

 

 

class Outer { //  定义了外部类
private static String info = "Hello " ;
	static class Inner {
		public void print() {
			System.out.println("Hello World .") ;
                   System.out.println(info) ;
		}
	}
}
public class TestDemo {
	public static void main(String args[]) {
		Outer.Inner in = new Outer.Inner() ;
		in.print() ;
	}
} 

<!--EndFragment-->

   同时需要注意的是，如果此时要想通过内部类访问外部类中的属性，则外部类中的属性一定要使用static定义。

 

   除了普通类可以定义内部类之外，也可以在抽象类或接口的内部定义内部类、内部抽象类、内部接口等等。特别说明的是：如果在定义内部接口的时候使用了static，那么就表示定义的是外部接口。

 

interface A {
	static interface B {
		public void printB() ;
	}
}
class X implements A.B {
	public void printB() {}
}

 

   匿名内部类

 

interface A{
	public void fun() ;
}
public class TestDemo{
	public static void main(String args[]) {
		A a = new A(){
			public void fun(){
				System.out.println("Hello World .");
			}
		};//匿名内部类，前面的部分可以认为是父类的引用，后面直接重写父类方法。
		a.fun();
	}
}

修饰符	功能
transient	告诉编译器，在类对象序列化的时候，此变量不需要持久保存。
volatile	指出可能有多个线程修改此变量，要求编译器优化以保证对此变量的修改能够被正确的处理。
native	用该修饰符定义的方法在类中没有实现。
synchronized	同步方法，多线程的支持。
scrictpf	当对一个类或接口使用strictfp关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。严格约束意味着所有表达式的结果都必须是IEEE754算法对操作数预期的结果，以单精度和双精度格式表示。

 

 

 

<!--EndFragment-->