Java常见关键字final、static、super、abstract、this

用此blog记录我学习的过程，文中若有不恰当的地方，还望友情指出互相学习。

---

Java有超过50多个关键字，这篇文章主要讲解一些常见的几个关键字，有兴趣的同学还可以点此查看更多关键字，下面进入正题：

final

final关键字主要有三种用法：修饰类、修饰方法、修饰成员变量

• 修饰类

  • 如果一个类被final修饰，则这个类不能被继承，例如：

  final class A {
  }
  

  下面的代码则无法编译：

  class B extends A {    //编译错误
  }
  

• 修饰方法

  • 当final关键字修饰在方法上时，这表明此方法不能被重写，例如：

  class A {
  	final void method(){}
  }
  

  下面的代码则无法编译

  class B extends A{
  	void method(){}          //编译错误
  }
  

• 修饰成员变量

  • 对于基本类型 final使其数值不变
  • 对于引用类型 final使其引用不变

  final String message = "hello";
  message = "world";  //cannot assign value to final variable 'message'
  

注意：一个类不能同时被final和abstract修饰。因为被final修饰的类不能被继承；而被abstract修饰的类本身没有实现，必须通过子类来实现，也就是说要被继承

---

static

static关键字主要有三种用法：静态内部类、静态变量、静态方法、静态导包

• 静态内部类与非静态内部类
  • 非静态内部类依赖于外部类的实例，也就是说要先创建外部类的实例，才能用这个实例去创建非静态内部类，而静态内部类不需要
  • 静态内部类可以声明静态成员变量和方法，而非静态内部类不行
  • 非静态内部类可以随意访问外部类的成员变量和方法（静态+非静态），而静态内部类只能访问外部类的静态成员变量和方法

public class OuterClass {

    public String name;
    public static Integer number;

    /**
     * 非静态内部类
     */
    public class InnerClass{
        //static Integer age; //非静态内部类不可以声明静态方法或变量
        Integer age;

        public void method() {
            System.out.println(name);  //非静态内部类可以随意访问外部类的成员变量和方法
        }
    }

    /**
     * 静态内部类
     */
    public static class StaticInnerClass{
        static Integer age;    //静态内部类可以声明静态成员变量和方法
        public void method(){
            System.out.println(number);   //静态内部类可以访问外部类的静态成员变量和方法，但不能访问外部类的非静态的成员变量和方法
        }
    }

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        InnerClass innerClass = outerClass.new InnerClass();
        StaticInnerClass staticInnerClass = new StaticInnerClass();
    }
}

• 静态方法与静态成员变量
  • 静态方法与静态变量可以通过类名去访问

public class A  {

    static String phone;

    static void staticMethod(){
    }

    void NonStaticMethod(){
    }

    public static void main(String[] args) {
        A.phone = "123456";
        A.staticMethod();
        
        A a = new A();
        a.NonStaticMethod();
    }
}

• 静态导包
  格式为：import static 这两个关键字连用可以指定导入某个类中的指定静态资源，并且不需要使用类名调用类中静态成员，可以直接使用类中静态成员变量和成员方法

---

super

当派生类和基类具有相同的成员变量和方法时，在这种情况下，可能存在歧义，可以使用super关键字来解决，下面通过具体例子讲解：

class Vehicle {
    int maxSpeed = 100;
    void stop(){
    	System.out.println("Vehicle stop"); 
    }
}
	
class Car extends Vehicle{
	int maxSpeed = 120;
	void display() { 
	    /* print maxSpeed of base class (vehicle) */
	    System.out.println("Maximum Speed: " + super.maxSpeed); 
    }
    void stop(){
    	super.stop();
    } 
}
	
class Test { 
	public static void main(String[] args) { 
	     Car car= new Car(); 
	     car.display();
	     car.stop(); 
	} 
} 

输出结果：

Maximum Speed: 100
Vehicle stop

---

abstract

• abstract关键字可以修饰类或方法
• abstract类可以扩展，但不能直接实例化，抽象类的目的是由派生类继承
• abstract方法不在声明他的类中实现，但必须在某个子类中重写
• 抽象类既可以有抽象方法又可以拥有非抽象方法
• 当一个类中某个方法被abstract修饰，则该类也必须被abstract修饰

举例说明：

abstract class A  
{ 
    abstract void m1();  //abstract方法不在声明他的类中实现
      
    // 抽象类既可以有抽象方法又可以拥有非抽象方法 
    void m2() 
    { 
        System.out.println("This is a concrete method."); 
    } 
} 
   
class B extends A  
{  
    // B必须重写A中的抽象方法m1()
    void m1() { 
        System.out.println("B's implementation of m2."); 
    } 
} 
  
public class AbstractDemo  
{ 
    public static void main(String args[])  
    { 
        B b = new B(); 
        b.m1(); 
        b.m2(); 
    } 
} 

输出结果：

B's implementation of m2.
This is a concrete method.

---

this

基本上，this关键字用于引用类的当前实例。例如：

class Manager {
    Employees[] employees;
     
    void manageEmployees() {
        int totalEmp = this.employees.length;
        System.out.println("Total employees: " + totalEmp);
        this.report();
    }
     
    void report() { }
}

在上面的例子中，this关键字用在了两个地方：

• this.employees.length:用于获取类Manager当前实例的变量
• this.report(): 调用类Manager当前实例的方法

注意：不能使用this关键字访问静态变量或方法，因为静态成员属于静态类实例而不是对象实例