【java篇】【05修饰符】

修饰符分类

1. 访问修饰符
2. 非访问修饰符

用来定义类、方法或者变量

访问控制修饰符

用来保护对类、变量、方法、和构造方法访问

default ：同包类可见
private ：同一个类中可见
public ：对所有类可见
protected:对同一包中所有子类可见

默认访问权限修饰符default

default修饰声明变量或者方法，对同一包内的所有类都是可见的；接口里的 变量 都隐式声明为 public static final，默认访问权限为public。不适用任何访问权限关键字修饰。

私有访问权限修饰符 private

1、private是最严格的访问级别，被private声明的方法、变量、和构造方法只能被属性类访问，且类和接口不能声明为private。

2、声明为私有访问类型的变量只能通过公共的getter方法来被外部访问。

3、private访问修饰符主要用来隐藏类的实现细节和保护类的数据。

共有访问权限修饰符public

使用public修饰的或者说声明的类、方法、构造方法和接口能够被其它类访问。如果相互访问的public类分布在不同的包中，需要导入相应的包；类的继承性，类的所有public修饰的方法和变量都能被继承。

受保护的访问权限修饰符 protected

1、被声明为 protected 的变量、方法、构造器能被同包中的任意其它类访问，也能被其它的不同包中的类访问。

2、protected 不能修饰类和接口（接口的成员变量和成员方法也不能使用protected修饰）；方法和成员变量能够声明为protected；

3、子类能访问protected修饰符声明的方法和变量，这样可以保护不相关的类访问这些方法和变量。

访问控制和继承

方法继承遵循以下规则：

父类中声明为public的方法在子类中必须使用public修饰。
父类中声明为protected的方法在子类中要么声明为protected要么为public，不能声明为private。
父类中默认修饰符声明的方法，能够在子类中声明为private。
父类中声明为private的方法，不能被继承。

非访问修饰符

• static 修饰符：用来创建类方法和类变量
• final 修饰符 ：用来修饰类、方法和变量，其修饰的类不能被继承，修饰的方法不能被继承和重新定义，修饰的变量为常量，不能被修改。
• abstract 修饰符 ：用来创建抽象类和抽象方法
• synchronized 和 volatile 修饰符 ：主要用于线程的编程。

static修饰符

• 静态变量：static关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被成为类变量。局部变量能被声明为static变量。
• 静态方法：static关键字用来声明独立与对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据。然后计算这些数据。

对类变量和方法的访问可直接使用：classname.variablename 和 classname.methodname的方式。

/* 创建一个实例计算器类 */
public class InstanceCounter {
	
	private static int numInstances = 0;//初始实例个数为0
	
	protected static int getCount() {
		return numInstances;
	}
	
	private static void addInstance() {
		numInstances++;
	}
	
	InstanceCounter(){
		InstanceCounter.addInstance();
	}
	public static void main(String[] args) {
		System.out.println("Starting with "+ InstanceCounter.getCount()+" instances");
		
		for(int i = 0;i < 100;i++) {
			new InstanceCounter();
		}
		
		System.out.println("Created "+ InstanceCounter.getCount()+" instances");

	}

}

final 变量

final变量能被显示地初始化并且只能初始化一次。被声明为final的对象的引用不能指向不同的对象，但是final对象里的数据可以被改变。也就是说final对象的引用不能改变，但里面的值可以改变。

final方法

类中的final方法可以被子类继承，但不能被子类修改。作用：防止方法的数据被修改

final类

final类不能被继承

abstract修饰符

抽象类

抽象类不能用来实例化对象；一个类不能同时被 abstract 和final 修饰；如果一个类包含抽象方法，那么这个类要声明为抽象类。

抽象类可以包含抽象方法和非抽象方法。

abstract class Demo{
    private String d_name;
    
    public abstract void absFun();//抽象方法
    
    public abstract void method(){
        
    }
}

抽象方法

• 抽象方法是一种没有任何实现的方法，该方法的具体实现由子类提供。抽象方法不能被声明成final和strict。
• 任何继承抽象类的子类必须实现父类的所有抽象类，除非该子类也是抽象类。
• 如果一个类包含抽象方法，那么这个类要声明为抽象类。

public abstract class SuperClass{
    abstract void method();//抽象方法
}

class SubClass extends SuperClass{
    //实现抽象方法的具体
    void method(){
        ...
    }
}

synchronized 修饰符

synchronized 关键字声明的方法同一时间只能被一个线程访问，synchronized修饰符可以应用于四个访问修饰符。

public synchronized void method(){
    ...
}

transient 修饰符

• 序列化对象包含被 transient 修饰符的实例变量时，Java虚拟机跳过该特定变量
• 该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型

public transient int limit = 20; // will not persist 
public int b;//will persist

volatile 修饰符

volatile修饰的成员变量在每次被线程访问时，都强迫从 共享 内存中重读 该成员变量的值；当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。一个volatile对象引用可能是 null。

public class MyRunnable implements Runnable
{
    private volatile boolean active;
    public void run()
    {
        active = true;
        while (active) // line 1
        {
            // 代码
        }
    }
    public void stop()
    {
        active = false; // line 2
    }
}

在一个线程中调用run()方法，在另一个线程中调用stop()方法。如果line 1中的active位于缓冲区的值被使用，那么当把line 2中的active设置成false时，循环也不会停止。