this、super、static(静态)、final、instanceof

一、this

this: 代表本类的对象，this代表它所在函数所属对象的引用。简单说：哪个对象在调用this所在函数，this就代表哪个对象。 
this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。但凡本类功能内部使用了本类对象，都用this表示。

示例：

class ThisDemo {
    public static void main(String[] args) {
        Person p1 = new Person("张三",25);
        Person p2 = new Person("李四",30);
        boolean b = p1.compare(p2);
        System.out.println(p1.name+" "+p1.age);
        System.out.println(p2.name+" "+p2.age);
        System.out.println("年龄是否相等："+b);
    }
}

class Person {
    int age;
    String name;
    Person(int age){
        this.age = age;
    }
    Person(String name){
        this.name = name;
    }
    Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public boolean compare(Person p){
        return this.age == p.age;
    }
}

以上代码中，new一个对象 p1 的时候，通过Person类的构造函数传递了参数 “张三”和25，在Person类的构造函数中，this.age = age，意为把参数age的值传递给本类对象 p1 的age属性。

this即代表本类对象的引用。

Person p1 = new Person("张三",25); // 这个语句也能看出this关键字能在构造函数间调用

二、super

super 功能和this相似，只不过 super是在有继承时，对父类对象中成员的引用。

示例：

public class SuperDemo{
    public static void main(String[] args){
        Manager m = new Manager("张三",5000,"财务部");
        System.out.println(m.getDetails());
    }
}
class Employee{
    private String name;
    private int salary;
    Employee(String name,int salary){
        this.name = name;
        this.salary = salary;
    }
    public String getDetails(){
        return "姓名:"+name+" 工资:"+salary;
    }
}
class Manager extends Employee{
    private String department;
    Manager(String name,int salary,String department){
        super(name,salary);              //调用父类Employee()的构造方法。
        this.department = department;
    }
    public String getDetails(){
        //调用父类Employee()的getDetails()方法。
        return super.getDetails()+" 部门:"+department;  
    }
}

三、static

static 是静态的关键字，static用来修饰成员变量和成员函数

静态特点：

（1）随着类的加载而加载，存于方法区（数据区）中，静态变量生命周期最长，因为随着类的消失而消失。

（2）静态成员优先于对象而存在，就是类一加载进内存静态成员就有了，这时还没有对象。所以，静态方法中不能使用 this、super 关键字。

（3）静态成员被本类的所有对象所共享。

（4）静态成员可以直接被类名调用。

（5）静态方法只能访问静态成员。

静态的利弊：
利：对对象的共享数据单独存储，节省空间。没有必要每个对象中都存储一份， 可以直接被类名调用。
弊：生命周期过长，访问出现局限性（静态只能访问静态）。

实例变量(非静态)和类变量(静态)区别：
1、存放位置：类变量随着类的加载而存在于方法区(数据区)中，实例变量随着对象的建立而存在于堆内存中。
2、生命周期： 类变量生命周期最长，随着类的消失而消失，实例变量生命周期随着对象的消失而消失。

示例：

class StaticDemo{
    public static void main(String[] args){
        Person p = new Person();
        p.name = "张三";
        p.show();
    }
}
class Person {
    String name;   //非静态成员变量，实例变量
    static String country = "CN";  //静态成员变量，类变量
    public void show() {
        System.out.println(name+": "+country);
    }
}

四、final

final关键字可以修饰类、变量、方法。

final修饰的类不能被继承，为了避免被子类重写。

final修饰的变量作为常量，只能赋值一次不能被更改，既可以修饰成员变量也可以修饰局部变量。

final修饰的方法不能被重写。

class FinalDemo{
    public static void main(String[] args){
        SubDemo s = new SubDemo();
        s.show2();
    }
}
class Demo{
    final int x = 3;  //x被final修饰，x的值不能再更改。
    final int show1(){
        return 4;
    }
}
class SubDemo extends Demo{
    //void show1(){}  错误，show1()被final修饰不能被重写。
    public void show2(){
        System.out.println("x="+x+" y="+super.show1());
    }
}

五、instanceof

在Java中可以使用 instanceof 测试对象的类型，由该关键字构成的表达式的值为布尔类型

public class InstanceofDemo{
    public static void main(String[] args){
        Manager m = new Manager("张三",5000,"财务部");
        if(m instanceof Manager){   //若m是manager类型对象，则if表达式的值为ture，否测为false
            System.out.println(m.getDetails());
        }
        else if(m instanceof Employee){
            System.out.println(m.getDetails());
        }
        else{
            System.out.println("error");
        }
    }
}
class Employee{
    private String name;
    private int salary;
    Employee(String name,int salary){
        this.name = name;
        this.salary = salary;
    }
    public String getDetails(){
        return "姓名:"+name+" 工资:"+salary;
    }
}
class Manager extends Employee{
    private String department;
    Manager(String name,int salary,String department){
        super(name,salary);       //调用父类Employee()的构造方法。
        this.department = department;
    }
    public String getDetails(){
        //调用父类Employee()的getDetails()方法。
        return super.getDetails()+" 部门:"+department;
    }
}