java的关键字 this、super、final、static、

1、this关键字
（1）成员变量和局部变量同名
可以在成员变量名前面加上this.来区别成员变量和局部变量

package com.oracle.demo03;

public class person {
            private  String name;
            private int age;
            public person(String name, int age) {
                super();
                this.name = name;
                this.age = age;
            }
            public String getName() {
                return name;
            }
            public void setName(String name) {
                this.name = name;
            }
            public int getAge() {
                return age;
            }
            public void setAge(int age) {
                this.age = age;
            }
            
}

（2）调用构造方法
在构造方法中调用本类的其他构造方法this()【根据参数列表区分】
必须放在本构造方法的第一行

package com.oracle.demo01;

public class Demo02 {
    private String name;
    private  int age;
    public Demo02(String name,int age){
        this.name = name;
        this.age = age;
    }
    public  Demo02(){
        //在构造方法中调用本类的其他构造方法this()
        //必须放在本构造方法的第一行
        this("zhangsan",18);
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
}

测试类：

package com.oracle.demo01;

public class Demo01 {
     public static void main(String[] args) {
         Demo02   d = new Demo02();
         System.out.println(d.getName()+".."+d.getAge());
    }
}

2、super关键字
（1）子父类中构造方法的调用
隐式语句：super(); 【默认】
调用父类中的有参数构造方法：super(实参列表);
子类会继承父类中的内容，所以子类在初始化时，必须先到父类中去执行父类的初始化动作。
当父类中没有空参数构造方法时，子类的构造方法必须有显示的super语句，指定要访问的父类有参数构造方法。

package com.oracle.demo02;

public class person {
    public  person(String name,int age){
            System.out.println("父类构造");
    }
}

package com.oracle.demo02;

public class teacher  extends person{
            String name;
            int age;
            public teacher(){
                /*super("zhangsan",12);*/
                this("lisi",12);
                System.out.println("子类构造");
            }
            public teacher(String name,int age){
                super( name, age);
            }
}

package com.oracle.demo02;

public class test {
        public static void main(String[] args) {
            teacher   t = new teacher(); 
        }
}

效果如下：

（2）子类对象创建过程的细节
只要是构造方法默认第一行都是super();
如果第一行调用了this()构造方法，显示的super()语句可以间接调用。

package com.oracle.demo02;

public class person {
    public  person(String name,int age){
            System.out.println("父类构造");
    }
}

package com.oracle.demo02;

public class teacher  extends person{
            String name;
            int age;
            public teacher(){
                //super("zhangsan",12);
                this("lisi",12);
                System.out.println("子类构造");
            }
            public teacher(String name,int age){
                super( name, age);
            }
}

package com.oracle.demo02;

public class test {
        public static void main(String[] args) {
            teacher   t = new teacher(); 
        }
}

效果如下：

（3）super应用

package com.oracle.demo03;

public class person {
            private  String name;
            private int age;
            public person(String name, int age) {
                super();
                this.name = name;
                this.age = age;
            }
            public String getName() {
                return name;
            }
            public void setName(String name) {
                this.name = name;
            }
            public int getAge() {
                return age;
            }
            public void setAge(int age) {
                this.age = age;
            }
            
}

package com.oracle.demo03;

public class student extends person{

    public student(String name, int age) {
        super(name, age);    
    }
        
}

package com.oracle.demo03;

public class worker extends person{

    public worker(String name, int age) {
        super(name, age);        
    }
}

package com.oracle.demo03;

public class ceshi {
            public static void main(String[] args) {
                student  s = new student("小明",2);
                System.out.println(s.getAge()+s.getName());
                worker w = new worker("小红",80);
                System.out.println(w.getAge()+w.getName());
            }
}

效果如下：

3、final关键字
（1）final修饰的类不能被继承，但可以继承其他类

package com.oracle.demo04;
//final 修饰类（太监类）
//不能被继承，但可以继承其他类
public final class fu extends Object{
        
}

（2）final修饰的成员方法不能重写，但是不修饰的重写的可以加final修饰

package com.oracle.demo04;

public class fu2 {
        //被final修饰的方法
        public final void  xiuche(){
            System.out.println("修车");
        }
        public  void maiche(){
            System.out.println("卖车");
        }
}

package com.oracle.demo04;

public class son extends fu2{
    /*public  void  xiuche(){
        System.out.println("车");
    }*/
    public final void maiche(){
        System.out.println("车");
    }
}

（3）被final修饰的成员变量没有系统默认初始值，需要在创建对象前赋值，否则报错.

package com.oracle.demo04;

public class zi2 {
        public  void eat(){
            final int i = 2;
            //i = 2;  哪怕是原来的值也不行。
        }
}

注意：

（4）被final修饰的局部变量是常量，不能改变，如果是引用数据类型，可以对其属性进行修改。

package com.oracle.demo04;

public class fu2 {
        String name;
        //被final修饰的方法
        public final void  xiuche(){
            System.out.println("修车");
        }
        public  void maiche(){
            System.out.println("卖车");
        }
}

package com.oracle.demo04;

public class zi2 {
        public  void eat(){
            final  fu2 f= new fu2();
            //f=null;
            f.name = "lisi";
        }
}

4、static关键字
（1）被static修饰的成员变量属于类，不属于这个类的某个对象【清华大学】

package com.oracle.demo05;

public class student {
        String name;
        int age;
        static String schollname;
}

package com.oracle.demo05;

import javax.print.attribute.Size2DSyntax;

public class test {
    public static void main(String[] args) {
        student   s = new student();
        s.name = "小红";
        s.schollname = "北京大学";
        student   s1 = new student();        
        s1.name = "小明";
        s1.schollname = "清华大学";
        System.out.println(s.schollname+s1.schollname);
    }
}

效果如下：

（2）静态成员只能调用静态成员，不能调用非静态成员，非静态成员可以调用静态成员。

package com.oracle.demo05;

public class ceshi {
     
    static  int  a = 1;
     int  b = 2;
    public static void main(String[] args) {
        //静态成员可以调用静态成员方法
        eat();
        //静态成员不可以调用非静态成员方法
        //study();
        /*Cannot make a static reference to 
        the non-static method study() from the 
         type ceshi*/
        //静态成员方法可以调用静态成员变量
        System.out.println(a);
        //静态成员方法不可以调用非静态成员变量
        //System.out.println(b);
    }
    public static void eat(){
          
    }
    public  void study(){
        //非静态成员方法可以调用静态成员方法
          eat();
          //非静态成员方法可以调用静态成员变量
          System.out.println(a);
    }
}

（3）不能使用this/super【this、super属于对象，而静态属于类】

（4）定义静态常量：public static final  修饰变量 【接口】