Java常见关键字及其用法（上）

1. final
2. static
3. this
4. super

1.final（四种用法）

1.修饰局部变量（只能一次赋值，终生不变）

• 修饰基本数据类型：修饰的数据变量值不可变
• 修饰引用数据类型：地址值不可变，内容能够变

注意事项：

1. 1 错误：

public static void main(String[] args) {
        final int c = 0;
        for (int i=0;i<10;i++)
        {
            c=i;                        //错误：没法为最终变量c分配值
        }
    }

1. 2正确：

public static void main(String[] args) {
        for (int i=0;i<10;i++)
        {
            final int c = 0;            //正确：局部变量，每次循环释放掉
        }
    }

2. 修饰成员变量（变量的数据值不可变）

• 成员变量有默认值，final修饰后须要手动赋值
• 经过构造方法对final修饰的成员变量进行赋值，须要保证全部重载的构造方法对final修饰的成员变量进行赋值，保证其修饰变量的初始化

选其一：

public class Demo {
    private final String name = "桑凤娇";//直接赋值
    public Demo(){}
    }

public class Demo2 {
    private final String name ;
public Demo2()
	{
    		name = "桑凤娇";//经过构造方法赋值
	}
 public Demo2(String name) {
        this.name = name;//经过构造方法赋值
    }
}

3.修饰类

用final修饰的这个类不能有任何子类

注意：一个类若是是final修饰的，其中全部的成员方法都没法进行覆盖（由于没有子类）

• 被final修饰的类，final类中的成员变量能够根据本身实际须要设计成final
• final类中的成员方法都会被隐式指定为final方法

修饰方法

用final修饰的方法不能被覆盖（不能重写：override）

2.static

static修饰的内容（随类的加载而加载，且加载一次；存储于固定的内存区域(静态区)，因此直接用类名进行调用；优先于对象存在，因此能够被全部对象共享）

修饰成员变量和成员方法，其中被修饰的成员都属于类，而不是单单属于某个对象，使用时用类能够直接调用，而不须要建立对象

• 类变量定义格式：static int num = 10;（static 数据类型 变量名;）
• 类方法定义格式：public static 返回值类型 方法名(){ }

 

1. 没有被static修饰的成员变量称为实例变量，实例变量属于某个对象
2. 类方法使用及其注意事项：

使用：

• static修饰的方法都属于静态方法（类方法），使用类名.方法名调用
• 定义格式：public static 返回值类型 方法名（参数列表）{}

注意：

package com.day02;
/**
 * @author SFJ
 * @date 2019/11/8
 * @time 22:19
 **/
public class Test1 {
    private String name="桑凤娇";
    static String idCard ="3709211998092033**";
    public static void method1()
    {
        method2();//错误，静态方法不能够直接访问非静态成员方法
        new Test1().method2();//正确，静态方法建立匿名对象访问非静态成员方法
        System.out.println(name);//错误，不能够直接访问非静态成员变量
        System.out.println(idCard);//正确，能够直接访问静态成员变量
    }
    public void method2()
    {
        System.out.println(idCard);//正确，非静态方法能够访问静态变量
        method1();//正确，非静态方法能够访问静态方法
    }
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        test1.method2();
    }
}

• 静态方法不能直接访问普通变量和成员方法，须要建立对象进行访问
• 静态方法能够直接访问静态方法和静态成员变量
• 在非静态方法中能够访问静态方法和静态成员变量
• 在静态方法中，不能直接使用super和this关键字

静态代码块：

• 定义在类的内部，任何方法的外部
• 定义格式： static{}

主要做用是给类变量进行初始化赋值

3.this(表示对当前对象的引用)

• 区分同名的函数参数和成员变量（this.成员变量名=参数----最经常使用）
• 在构造方法中(this()或者this(参数列表)，只能引用一个构造方法且只能在第一句)
• 注意：this不能用在static修饰的方法中，由于static修饰的方法属于类，而this指的是对对象的引用，冲突矛盾

• package com.day02;
  
  /**
   * @author SFJ
   * @date 2019/11/8
   * @time 22:53
   **/
  public class Test3 {
          private int i=0;
          Test3(int i) {//第一个构造器：有一个int型形参
              this.i = i + 1;//此时this表示引用成员变量ｉ，而非函数参数ｉ
              System.out.println("Int constructor i——this.i:  " + i + "——" + this.i);
              System.out.println("i-1:" + (i - 1) + "this.i+1:" + (this.i + 1));
              //从两个输出结果充分证实了i和this.i是不同的！
          }
          Test3(String s){ //  第二个构造器：有一个String型形参
              System.out.println("String constructor:  "+s);
          }
          Test3(int i,String s){//  第三个构造器：有一个int型形参和一个String型形参
              this(s);//this调用第二个构造器
              this.i=i++;//this以引用该类的成员变量
              System.out.println("Int constructor:  "+i+"/n"+"String constructor:  "+s);
          }
          public Test3 increment(){//增量
              this.i++;
              return this;//返回的是当前的对象，该对象属于（Test3）
          }
          public static void main(String[] args){
              Test3 t0=new Test3(21);
              Test3 t1=new Test3("桑凤娇");
              Test3 t2=new Test3(21,"桑凤娇");
              System.out.println(t1.increment().increment().increment().i);
              //t0.increment()返回一个在t0基础上ｉ++的Test3对象，
              //接着又返回在上面返回的对象基础上i++的Test3对象！
          }
  
      }

   

4.super(表示父类的引用)

• 子父类存在着同名的成员（包括变量和方法）时，在子类中默认是访问子类的成员，能够经过super关键字指定访问父类的成员；
• 建立子类对象时，默认会先调用父类无参的构造方法，能够经过super关键字指定调用父类的构造方法：

1. 若是在子类的构造方法上没有指定调用父类的构造方法，jvm会在子类的构造方法内加上super()语句
2. super关键字调用父类构造函数时，该语句必需要是子类构造函数中的第一个语句
3. super与this关键字不能同时出如今同一个构造函数中调用其余的构造函数。由于两个语句都须要第一个语句
4. 继承中，只要建立子类对象，默认必定会先调用父类无参构造方法建立父类对象

   package com.day02;
   
   /**
    * @author SFJ
    * @date 2019/11/8
    * @time 23:08
    **/
   public class Test4 {
       public static void main(String[] args) {
           Son s = new Son(3);
           System.out.println();  //4   
       }
   }
   class Father {
       int x = 1;
       Father() {
           System.out.println("父类无参的构造方法");
       }
       Father(int x) {
           this.x = x;
           System.out.println("父类有参的构造方法");
       }
       void speak() {
           System.out.println("我是父类");
       }
   }
   class Son extends Father {
       int y = 1;
       Son() {
           System.out.println("子类无参的构造方法");
       }
       Son(int y) {
           this.y = y+x;
           System.out.println("子类带参的构造方法");
       }
       void run() {
           super.speak(); //访问父类的函数
           System.out.println("我是子类");
       }
   }