Java 修饰符

  Java提供了许多种修饰符，主要分为两类：
    一：访问修饰符
    二：非访问修饰符

  Java中有四种访问控制修饰符，用来保护对于类、变量、方法以及构造方法的访问。
 private ： 在同一类里可见。可以修饰：变量，方法，内部类。
 default（什么也不写）： 在同一包里可见。可以修饰：类，接口，变量，方法。
 protected ：对同一包内的类和所有子类可见。可以修饰：变量，方法，内部类。
 public ：对所有的类可见。可以修饰：类，接口，变量，方法。

class A {
	
	private int a;
	int b;
	protected int c;
	public int d;
	//private 修饰构造方法
	private A() {
		super();
	}
	//默认的构造方法
	A(int a) {
		super();
		this.a = a;
	}
	//protected 修饰构造方法
	protected A(int a, int b) {
		super();
		this.a = a;
		this.b = b;
	}
	//public 修饰构造方法
	public A(int a, int b, int c, int d) {
		super();
		this.a = a;
		this.b = b;
		this.c = c;
		this.d = d;
	}
	//private 修饰方法
	private void method() {
	}
	//默认的方法
	void method2() {
	}
	//protected 修饰方法
	protected void method3() {
	}
	//public 修饰方法
	public void method4() {
	}
	//private 修饰内部类
	private class C{
		
	}
	//protected 修饰内部类
	protected class D{
		
	}
}
//public 修饰类
public class B {
}
//默认 修饰接口
interface C{
	
}

//public 修饰接口
public interface D {

}

  注意：一个.java文件中只能有一个public类，且和文件名相同。

  静态内容随着类的加载而加载，且只加载一次。

  属性、方法、代码块、内部类

  static关键字用来声明独立于对象的静态变量，无论类实例化多少个对象，静态变量只有一个（被所有实例化对象共享）。静态变量也被称为类变量。局部变量不能被声明为静态变量。
  所以当一个实例化对象改变静态变量时，所有实例化对象调用此静态变量的值是被修改过的。

  static关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。
对静态变量和静态方法可以直接使用类.静态变量和类.静态方法的方式来使用。

public class StaticUse {
	private static int m = 100;

	public StaticUse() {
		addM();

	}

	public static int getM() {
		return m;
	}

	public static void addM() {
		m++;
	}
	
	public static void main(String[] args) {	
		System.out.println("m = " + StaticUse.getM());
		new StaticUse();
		System.out.println("m = " + StaticUse.getM());
	}
}

运行结果

变量、方法、类
####  final变量
变量一旦被赋值后，不能够被重新赋值。
1.final修饰属性：赋值的位置：显式初始化、代码块中初始化、构造器中初始化
2.final修饰局部变量：
final 修饰符通常和 static 修饰符一起使用来创建类常量。

public class D{
	//显式初始化a
	final int a = 10;
	final int c;
	final int d;
	//代码块中初始化d
	{
		d = 50;
	}
	//下面是两个全局常量
	public static final  int CONSTANT = 20;
	static final String TITLE = "去扰嶟";
	
	//构造器中初始化c
	public D(){
		final int b = 30;
		c = 40;
		}
}

父类中的final方法可以被子类继承，不能被子类重写。

public class A{
	public final void method(){
	}
}

final类不能被继承。

public final class A{
}

方法、类

抽象类不能用来实例化对象。
抽象类中有构造方法，子类可在实例化时调用。

abstract class A{
	public abstract void a();//抽象方法
}

抽象方法只有方法的声明，没有方法体，方法的具体实现由子类重写。
抽象方法不能被声明为final和static。
有抽象方法的类一定是抽象类，抽象类可以不包含抽象方法。

public abstract class A{
	abstract void a();//抽象方法
}
class B extends A{
	//重写抽象方法
	@Override
	void a(){
		....
	}
}