java基础之类的特殊成员

很多时候我们都会用到java中的特殊成员，常用的有final abstract static，下面我们分别来介绍这些修饰符的意义和作用。

• final关键字
  1 final修饰符修饰的成员属性当其被赋值之后，那么其值就不能够再更改，当子类继承抽象的父类时，父类中的抽象方法其实就是一个子类方法的模板，让子类的方法得以扩展，但是在使用了final关键字后，子类要对抽象方法进行重写就必须按照一定的顺序，而这一点也是它的很重要的一点，那就是可以在使用中面向修改关闭，从而达到精确控制子类的目的。

//这是父类HammerModel
public abstract class HammerModel {
	protected abstract void start ();
	protected abstract void stop();
	protected abstract void alarm();
	protected abstract void engineBoom();
	//final关键字的作用是：面向修改关闭。
	//下面的写法就是固定子类的行为，按照一定的模板进行方法的重写，
	即当要新建一个子类扩展方法的时候，
	用了final关键字将不能修改这些顺序,从而实现对子类精确控制的目的
	public final void run() {
		this.start();
		this.alarm();
		this.engineBoom();
		this.stop();
	}
}

public  class HammerH1Model extends HammerModel{
	//这是对父类的抽象方法的重写，从而达到扩展子类的目的，但是均是按照父类中抽象方法的顺序，实现精确控制子类的目的。
	@Override
	protected void start() {
		System.out.println("H1悍马启动");
	}

	@Override
	protected void stop() {
		// TODO Auto-generated method stub
		System.out.println("H1悍马停止");
	}

	@Override
	protected void alarm() {
		// TODO Auto-generated method stub
		System.out.println("H1悍马鸣笛");
	}

	@Override
	protected void engineBoom() {
		// TODO Auto-generated method stub
		System.out.println("H1悍马轰引擎");	
	}
}

• abstract修饰符
  abstract修饰的成员方法的表示的方法是不能够有实体内容的，即不能够被实现。同时被abstract修饰的类叫做抽象类，它有如下的这些特点。

• 特点一：抽象类不能够被实例化，即不能够直接创建子类。

• 特点二：抽象类里可以有抽象方法，也可以有非抽象方法。

• 特点三：一个类中有抽象方法，其必须是抽象类。

• 特点四：final和abstract不能同时修饰一个类。

抽象类的意义：抽象类的存在，就是为其所导出的类提供一个通用的模板，然后其子类在继承抽象类后实现对模板中的方法进行重写，达到对子类方法的扩展，从而实现具体的行为。但是抽象类在派生子类的时候还是有着一定的限制，那就是子类要继承抽象父类，必须将父类中全部的抽象方法进行重写，如果没有全部进行重写，那么子类就必须添上abstract变成抽象类。这一点在写代码的时候要注意。下面就是它的使用示例。

public abstract class AbstractClassExample {

    protected int x;
    private int y;

    public abstract void func1();

    public void func2() {
        System.out.println("func2");
    }
}

public class AbstractExtendClassExample extends AbstractClassExample {
    @Override
    public void func1() {
        System.out.println("func1");
    }
}

• static修饰符
  static修饰的成员属性和方法可以直接通过类名来访问，同时又称其为类变量和类方法，它是属于所有实例变量的，可以被类的实例所共享的静态变量。举个例子来说明就是一个学校的学生学号不同，但是他们都有一个共同的学校名称，学校的名称就是一个公共的变量，每一个学生都可以访问，这个公共变量就是类变量。

public class A {

    private int x;         // 实例变量
    private static int y;  // 静态变量

    public static void main(String[] args) {
        // int x = A.x;  // Non-static field 'x' cannot be referenced from a static context
        A a = new A();
        int x = a.x;
        int y = A.y;
    }
}

Static 注意事项：

1. 静态方法的实现在类加载的时候就已经实现了，不依赖任何的实例，所以必须要有方法体，那么这个方法不能是抽象方法

//这里会报错 This method requires a body instead of a semicolon
  private static void fun() ;

2. 只能访问静态的方法和静态变量，同时静态方法不能使用this和super关键字

public class A {

    private static int x;
    private int y;

    public static void func1(){
        int a = x;
        // int b = y;  // Non-static field 'y' cannot be referenced from a static context
        // int b = this.y;     // 'A.this' cannot be referenced from a static context
    }
}

3.非静态内部类的实例的实现依赖外部类，但是静态内部类就不需要

public class OuterClass {

    class InnerClass {
    }

    static class StaticInnerClass {
    }

    public static void main(String[] args) {
        // InnerClass innerClass = new InnerClass(); // 'OuterClass.this' cannot be referenced from a static context
        OuterClass outerClass = new OuterClass();
        InnerClass innerClass = outerClass.new InnerClass();
        StaticInnerClass staticInnerClass = new StaticInnerClass();
    }
}