【Java功能体】Java中的修饰符详解

访问修饰符

共四种：default、private、public、protected
作用： 使用访问控制符来保护对类、变量、方法和构造方法的访问。

四种类别：
 default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
 private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
 public: 对所有类可见。使用对象：类、接口、变量、方法
 protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

default

使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。
 接口里的变量都隐式声明为 public static final；
 而接口里的方法默认情况下访问权限为 public。

//default修饰普通类
public class Main {
	String version = "1.5.1"; //等价于: public String version = "1.5.1";
	boolean processOrder() { //等价于: public boolean processOrder() {}
	   return true;
	}
	
	public static void main(String[] args) {
		
	}
}

private

功能： private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。
特性：

• 被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。
• 声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。

protected

protected 需要从以下两个点来分析说明：

1. 子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
2. 子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。

protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。

子类能访问 protected 修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。

非访问修饰符

共两种：static和final

static

Static的种类
特性：static修饰类方法和类变量。强调永远存在。
1. 静态变量：

1. 属于类，不属于对象，也被称为类变量。

2. 局部变量不能被声明为 static 变量。

3. 调用方式①可以使用对象访问：“对象.属性名”。

4. 调用方式②可以使用类名访问：“类名.属性名”（推荐使用！）。

2. 静态方法：

1. 属于类，与具体对象没有关系。
2. 静态方法不能使用类的非静态变量，因为每一个非静态变量是属于每一个对象的(每一个对象的数据是不同的)。
3. 因为不属于对象，故而没有this和super。
4. 静态方法从参数列表得到数据，然后计算这些数据。

3. static 修饰代码块

static {
    代码块;
}

备注：静态代码块执行优先级最高，它在类加载的时候就已经执行了。且只执行一次，通常用来加载：视频、图片等

static变量的调用

class People {
	static int number; //静态变量
	
	private String name;
	private int age;
	public People() {
		this.name = "A";
		this.age=10;
	}
}

public class Main {
	public static void main(String[] args) {
		People pa = new People();
		
		People.number = 100; //通过类调用static变量，推荐使用
		People.number += 1; 
		System.out.println("number: "+People.number);
		
		pa.number += 1; //通过对象调用static变量
		System.out.println("number: "+pa.number);
	}
}

static方法

class People {
	static int number; //静态变量
	
	private String name;
	private int age;
	public People() {
		this.name = "A";
		this.age=10;
	}
	
	public static void AboutThisClass() {
		System.out.println("This is a static method!");
		System.out.println("number: "+number);
		System.out.println("People.number: "+People.number);
		//this.number  没有this、super
		//name += 1  静态方法不能调用非静态变量
	}
}

public class Main {
	public static void main(String[] args) {
		People pa = new People();
		
		People.AboutThisClass();//以类的方式来调用静态方法，推荐使用
		pa.AboutThisClass(); //以对象的方式来调用静态方法，IDE给出警告，不推荐使用
	}
}

/*
 输出：
This is a static method!
number: 0
People.number: 0
This is a static method!
number: 0
People.number: 0
*/

static代码块

class People {
	static {
		System.out.println("这是static代码块！"); //只有在本程序、本类的首个对象创建时才会调用
	}
	
	private String name;
	private int age;
	public People() {
		this.name = "a";
		this.age = 10;
	}
	
	public void show() {
		System.out.println("name:"+this.name+" ,age:"+this.age);
	}
}

public class Main {
	public static void main(String[] args) {
		People pa = new People();
		pa.show();
		
		People pb = new People();
		pb.show();
	}
}

/*
 输出：
这是static代码块！
name:a ,age:10
name:a ,age:10
*/

static的特点

1. 被所有的对象所共享
2. 可以使用类名调用
3. 静态的加载优先于对象
4. 随着类的加载而加载
5. 凡是static修饰过的变量或者方法都属于类，不属于对象！

static方法与非static方法对比

静态方法：

可以调用静态的成员变量
可以调用静态的成员方法
不可以调用非静态成员变量
不可以调用非静态成员方法
静态方法只能调用静态的成员

非静态方法：

可以调用静态的成员变量
可以调用静态的成员方法
可以调用非静态的成员变量
可以调用非静态的成员方法

final

final修饰类、方法和变量。强调永远不变。

• final 修饰的类不能够被继承；这是因为继承后要被重写，而父类已经永不可变，故禁止继承；
• final 修饰成员方法，该方法不能被重写；
• final 修饰成员变量，此时变量不再是变量而是常量

//Javafinal修饰的类、方法、变量
final class FinalClass {
	private int x;
}
//报错，final类禁止被继承
//class NewClass extends FinalClass {
//	
//}

class People {
	private final String sexy = "man";

	//name = "woman";禁止修改final变量
	
	public final void PrintName() { //final方法
		System.out.println("sexy:"+this.sexy);
	}
}
class Student extends People {
//final方法禁止重写
//	public void PrintName() {
//		
//	}
}

public class Main {
	public static void main(String[] args) {
		People pa = new People();
		pa.PrintName();
	}
}
/*
 输出：
sexy:man
*/

  此外，还有abstract、synchronized、transient、volatile修饰符，这里不进行详细阐述。具体放到实际的使用环境再了解和学习它，例如学习抽象类时自然会了解到abstract