Java基础总结——常用的关键字解析（this，super，instanceof，final，static）

一、this关键字

　　

this是一个引用，它指向自身的这个对象。

看内存分析图：

　　假设我们在堆内存new了一个对象，在这个对象里面你想象着他有一个引用this，this指向这个对象自己，所以这就是this，这个new出来的对象名字是什么，我们不知道，不知道也没关系，因为这并不影响这个对象在内存里面的存在，这个对象只要在内存中存在，他就一定有一个引用this。

上面的代码分析：

第一句Leaf leaf = new Leaf(100);在堆上new一个对象leaf。

第二句leaf.increament().increament().print();手下执行前半部分leaf.increament（）。调用increament（）方法，执行自加后返回this，

这里把this作为返回值，当有返回值的时候，首先会在栈里面给这个返回值分配一小块临时的存储空间&&&&&。这块存储空间里面的内容是this里面的内容。this指向它自身，所以栈内存里面的那块临时存储空间里面装的this也是指向堆内存里面的Leaf对象。

所以leaf.increament().increament().print();这句话里面的left.increament()这一小句话执行完之后，内存中的布局如下图所示。

　　

同理执行后面的 leaf.increament().increament().print();实际上是this.increament().print();内存如下：

所以最后的输出实际上就变成了this.this.print();注意每个this的含义都不相同，都指向不同的对象。

注意;在栈上面的this是因为执行了increament方法的返回值，必须在栈上存储，但是在堆中的this是每个在堆中的对象都存在的一个引用，自己指向自己，使用时就会出现注意区分。

二，super

　　在JAVA类中使用super来引用父类的对象，用this来引用当前对象，即两者都是一种引用，可以调用方法和属性，如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。怎么去引用里面的父类对象呢？使用super来引用，this指的是当前对象的引用，super是当前对象里面的父对象的引用。

 8 class FatherClass {
 9     public int value;
10     public void f() {
11         value=100;
12         System.out.println("父类的value属性值="+value);
13     }
14 }
  ChildClass extends FatherClass {
22     /**
23      * 子类除了继承父类所具有的valu属性外，自己又另外声明了一个value属性，
24      * 也就是说，此时的子类拥有两个value属性。
25      */
26     public int value;
30     public void f() {
31         super.f();//使用super作为父类对象的引用对象来调用父类对象里面的f()方法
32         value=200;//这个value是子类自己定义的那个value，不是从父类继承下来的那个value
33         System.out.println("子类的value属性值="+value);
34         System.out.println(value);//打印出来的是子类自定义的那个value的值，这个值是200
35         /**
36           因为在重写f（）方法的第一句“super.f();”是让父类对象的引用对象调用父类对象的f()方法，
38          * 即相当于是这个父类对象自己调用f()方法去改变自己的value属性的值，由0变了100。
39          * 所以这里打印出来的value值是100。（即已经改变后的值）
40          */
41         System.out.println(super.value);
42     }
43 }
46  * 测试类
50 public class TestInherit {
51     public static void main(String[] args) {
52         ChildClass cc = new ChildClass();
53         cc.f();
54     }
55 }

内存分析：main中第一句new了一个子类对象，第二句cc.f();执行super.f();   

这里有三个引用cc，this和super内存中如下    this指向对象自己，还有一个super，super指向当前对象里面的父对象。

　　方法体内的最后三句话都是执行打印value值的命令，前两句打印出来的是子类对象自己的那个value值，因此打印出来的结果为200，最后一句话打印的是这个子类对象里面的父类对象自己的value值，打印出来的结果为100。

三 ，instanceof 关键字

java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出这个对象是否是这个特定类或者是它的子类的一个实例。

1：属于比较运算符：

  2：用法：

       对象  instanceof 类;   即result = object instanceof class 

   该表达式是一个比较运算符，返回的结果是boolea类型  true|false

注意：使用instanceof关键字做判断时，两个类之间必须有关系。

即在编译状态中，class可以是object对象的父类，自身类，子类。在这三种情况下Java编译时不会报错。

在运行转态中，class可以是object对象的父类，自身类，不能是子类。在前两种情况下result的结果为true，最后一种为false。class为子类时编译不会报错。但运行结果为false。

应用（1）通过判断对象是哪个类的实例，从而实现不同的功能

// 定义一个功能函数，根据传递进来的对象的做不同的事情

// 如果是狗让其看家，如果是猫让其抓老鼠

void doSomething(Animal a) {

if (a instanceof Dog) {

System.out.println("小狗看家");

} else if (a instanceof Cat) {

System.out.println("抓老鼠");

}

应用（2）下面是String中equals的方法源码

equals方法是Object父类的方法，重写后也是先判断是否为同一对象，利用instanceof关键字判断是否是String的实例（任何字符串都是String的实例），如不是对字符串中每个字符进行比较

四， final关键字

  final关键字可以用于四个地方。用于修饰类、类的属性（即变量），方法以及方法的形式参数

1,修饰类

当用final修饰一个类时，表明这个类不能被继承。这时需要注意被final修饰的类中的属性和方法都会被隐式地指定为final的，即不能被重写（即覆盖）。

2：final修饰方法：

：该方法是最终方法，不能被重写（即锁定方法）

：当一个类被继承，那么所有的非私有函数都将被继承，如果有的函数不想被子类继承并重写可以将该函数final修饰

注：类的private方法会隐式地被指定为final方法。

3，final修饰变量

　　对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。但是对象自身的内容可以被修改。

注：常量一般被修饰为final，如下

深入理解：

1.类的final变量和普通变量有什么区别？

2 3 4 5 6 7 8 9 10 11

public  class  Test {      public  static  void  main(String[] args)  {          String a =  "hello2" ;           final  String b =  "hello" ;          String d =  "hello" ;          String c = b +  2 ;           String e = d +  2 ;          System.out.println((a == c)); //true          System.out.println((a == e));//false      } }

当final修饰的变量是基本数据类型以及String类型时，如果在编译期间能知道它的确切值，则编译器会把它当做编常量使用（即被final修饰的变量在没有运行时就已经被初始化赋值，此时就相当于一个常量）即在行String c = b + 2; 这里的b相当于一个常量hello，所以不用运行就可以确定c的值

而对于变量d的访问却需要在运行时通过链接来进行。


（1）执行a==c的时候，String是应用类型，因为==比较的是引用，equals比较的是内容。不是我忽悠大家，你们可以在自己的机子上运行一 下，

结果是true！原因很简单，String对象a被放进常量池里了，再次出现“hello2”字符串的时候，、JVM很兴奋地把c的引用也指向了 “java”对象.

（2）执行a==e的时候，JVM确实会对形如String d= "hello"; 的String对象放在字符串常量池里，但是它是在编译时刻那么做的，

而String e = d+2; 是在运行时刻才能知道（我们当然一眼就看穿了，可是Java必须在运行时才知道的，人脑和电脑的结构不同），

也就是说d+2是在堆里创建的， e引用当然不可能指向字符串常量池里的对象.

2被final修饰的引用变量指向的对象内容可变吗？

　在上面提到被final修饰的引用变量一旦初始化赋值之后就不能再指向其他的对象，那么该引用变量指向的对象的内容可变吗？看下面这个例子：

1 2 3 4 5 6 7 8 9 10 11

public  class  Test {      public  static  void  main(String[] args)  {          final  MyClass myClass =  new  MyClass();          System.out.println(++myClass.i);  //输出结果是1.      } }   class  MyClass {      public  int  i =  0 ; }

这段代码可以顺利编译通过并且有输出结果，输出结果为1。这说明引用变量被final修饰之后，虽然不能再指向其他对象，但是它指向的对象的内容是可变的。

3，static与final的区别与联系

static和final经常一起使用
static修饰的时候代表对象是静态的（类加载时进行初始化的，内存中只有一个），而final修饰的时候代表对象只能赋值一次，
他们连用的时候是因为定义的那个对象既要它是静态的，也要求它的值不能再被修改（或者该引用不能指向其他对象）。

很多时候会容易把static和final关键字混淆，static作用于成员变量用来表示只保存一份副本，而final的作用是用来保证变量不可变。看下面这个例子：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public  class  Test {      public  static  void  main(String[] args)  {          MyClass myClass1 =  new  MyClass();          MyClass myClass2 =  new  MyClass();          System.out.println(myClass1.i);          System.out.println(myClass1.j);          System.out.println(myClass2.i);          System.out.println(myClass2.j);        } }   class  MyClass {      public  final  double  i = Math.random();      public  static  double  j = Math.random(); }

　　运行这段代码就会发现，每次打印的两个j值都是一样的，而i的值却是不同的。从这里就可以知道final和static变量的区别了。

这里final修饰基本数据类型，则其数值一旦在初始化之后便不能更改；这里定义了两个对象，所以对他们两个对象来说属性i只初始化了一次，每次初始化的值都不相同，这与final修饰变量不冲突，即只能初始化一次。

静态变量是随着类加载时被完成初始化的，它在内存中仅有一个，且JVM也只会为它分配一次内存(只初始化一次)。

4，关于网上流传的”当你在方法中不需要改变作为参数的对象变量时，明确使用final进行声明，会防止你无意的修改而影响到调用方法外的变量“这句话，我个人理解这样说是不恰当3的。

　　因为无论参数是基本数据类型的变量还是引用类型的变量，使用final声明都不会达到上面所说的效果。

　看下面这段代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

public  class  Test {      public  static  void  main(String[] args)  {          MyClass myClass =  new  MyClass();          StringBuffer buffer =  new  StringBuffer( "hello" );          myClass.changeValue(buffer);          System.out.println(buffer.toString());      } }   class  MyClass {            void  changeValue( final  StringBuffer buffer) {          buffer.append( "world" );      } }

　　运行这段代码就会发现输出结果为 helloworld。很显然，用final进行修饰并没有阻止在changeValue中改变buffer指向的对象的内容。有人说假如把final去掉了，万一在changeValue中让buffer指向了其他对象怎么办。有这种想法的朋友可以自己动手写代码试一下这样的结果是什么，如果把final去掉了，然后在changeValue中让buffer指向了其他对象，也不会影响到main方法中的buffer，原因在于java采用的是值传递，对于引用变量，传递的是引用的值，也就是说让实参和形参同时指向了同一个对象，因此让形参重新指向另一个对象对实参并没有任何影响

五，static关键字

目录：一.static关键字的用途二.static关键字的误区三.常见的笔试面试题

一.static关键字的用途

       方便在没有创建对象的情况下来进行调用（方法/变量）。

　　很显然，被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

　　static可以用来修饰类的成员方法、类的成员变量，另外可以编写static代码块来优化程序性能。

1）static方法

　　static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。

　　但是要注意的是，虽然在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法/变量的。举个简单的例子：

　　在上面的代码中，由于print2方法是独立于对象存在的，可以直接通过类名调用。而在ptint2()方法中由于你无法预知在print1方法中是否访        问了非静态成员变量，所以也禁止在静态成员方法中访问非静态成员方法。

　　因此，如果说想在不创建对象的情况下调用某个方法，就可以将这个方法设置为static。我们最常见的static方法就是main方法，至于为什么        main方法必须是static的，现在就很清楚了。因为程序在执行main方法的时候没有创建任何对象，因此只有通过类名来访问。

　　另外记住，关于构造器是否是static方法可参考：http://blog.csdn.net/qq_17864929/article/details/48006835

总结一下，对于静态方法需要注意以下几点：
（1）它们仅能调用其他的static 方法。
（2）它们只能访问static数据。

（3）它们不能以任何方式引用this 或super。

（4）static变量和方法都可以通过类名直接调用。

2）static变量（存放在数据区）

　　static变量也称作静态变量，静态变量和非静态变量的区别是：   静态变量是随着类加载时被完成初始化的，它在内存中仅有一个，且JVM也只会为它分配一次内存(只初始化一次)，同时类所有的实例都共享静态变量，可以直接通过类名来访问它。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

可见，static变量并不是所在类的某个具体对象所有，而是该类的所有对象所共有的，静态变量既能被对象调用，也能直接拿类来调用。

3）static代码块

　　static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候（也就是在在main函数加载之前就会执行static代码块），会按照static块的顺序来执行每个static块，并且只会执行一次。

因为它的特性:只会在类加载的时候执行一次。所以很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。

注意误区：

（1）能通过this访问静态成员变量吗？

　　虽然对于静态方法来说没有this，那么在非静态方法中能够通过this访问静态成员变量吗？（即在非静态方法中new对象，通过this调用静态成员变量）先看下面的一个例子，这段代码输出的结果是什么？

1 2 3 4 5 6 7 8 9 10 11 12

public  class  Main {　　      static  int  value =  33 ;        public  static  void  main(String[] args)  throws  Exception{          new  Main().printValue();      }        private  void  printValue(){          int  value =  3 ;          System.out.println( this .value);      } }

　　这里面主要考察对this和static的理解。this代表什么？this代表当前对象，那么通过new Main()来调用printValue的话，当前对象就是通过new Main()生成的对象。而static变量是被对象所享有的，因此在printValue中的this.value的值毫无疑问是33。在printValue方法内部的value是局部变量，根本不可能与this关联，而这里调用的是this所指对象的属性，所以输出结果是33。在这里永远要记住一点：静态成员变量虽然独立于对象，但是不代表不可以通过对象去访问，所有的静态方法和静态变量都可以通过对象访问（只要访问权限足够）。

（2）、static能作用于局部变量么？

　　在C/C++中static是可以作用域局部变量的，但是在Java中：static是不允许用来修饰局部变量。不要问为什么，这是Java语法的规定。

（3）、static和final一块用表示什么？
      static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！ 
      对于变量，表示一旦给值就不可修改，并且通过类名可以访问。 
      对于方法，表示不可覆盖，并且可以通过类名直接访问。

案例解析

1.下面这段代码的输出结果是什么？

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

public  class  Test  extends  Base{        static {          System.out.println( "test static" );      }            public  Test(){          System.out.println( "test constructor" );      }            public  static  void  main(String[] args) {          new  Test();      } }   class  Base{            static {          System.out.println( "base static" );      }            public  Base(){          System.out.println( "base constructor" );      } }

  View Code

　　至于为什么是这个结果，我们先不讨论，先来想一下这段代码具体的执行过程，在执行开始，先要寻找到main方法，因为main方法是程序的入口，但是在执行main方法之前，必须先加载Test类，而在加载Test类的时候发现Test类继承自Base类，因此会转去先加载Base类，在加载Base类的时候，发现有static块，便执行了static块。在Base类加载完成之后，便继续加载Test类，然后发现Test类中也有static块，便执行static块。在加载完所需的类之后，便开始执行main方法。在main方法中执行new Test()的时候会先调用父类的构造器，然后再调用自身的构造器。因此，便出现了上面的输出结果。

2.这段代码的输出结果是什么？

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

public  class  Test {      Person person =  new  Person( "Test" );      static {          System.out.println( "test static" );      }            public  Test() {          System.out.println( "test constructor" );      }            public  static  void  main(String[] args) {          new  MyClass();      } }   class  Person{      static {          System.out.println( "person static" );      }      public  Person(String str) {          System.out.println( "person " +str);      } }     class  MyClass  extends  Test {      Person person =  new  Person( "MyClass" );      static {          System.out.println( "myclass static" );      }            public  MyClass() {          System.out.println( "myclass constructor" );      } }

  View Code

　　类似地，我们还是来想一下这段代码的具体执行过程。首先加载Test类，因此会执行Test类中的static块。接着执行new MyClass()，而MyClass类还没有被加载，因此需要加载MyClass类。在加载MyClass类的时候，发现MyClass类继承自Test类，但是由于Test类已经被加载了，所以只需要加载MyClass类，那么就会执行MyClass类的中的static块。在加载完之后，就通过构造器来生成对象。而在生成对象的时候，必须先初始化父类的成员变量，因此会执行Test中的Person person = new Person()，而Person类还没有被加载过，因此会先加载Person类并执行Person类中的static块，接着执行父类的构造器，完成了父类的初始化，然后就来初始化自身了，因此会接着执行MyClass中的Person person = new Person()，最后执行MyClass的构造器。

3.这段代码的输出结果是什么？

1 2 3 4 5 6 7 8 9 10 11 12 13

public  class  Test {            static {          System.out.println( "test static 1" );      }      public  static  void  main(String[] args) {                }            static {          System.out.println( "test static 2" );      } }

  View Code

　　虽然在main方法中没有任何语句，但是还是会输出，原因上面已经讲述过了。另外，static块可以出现类中的任何地方（只要不是方法内部，记住，任何方法内部都不行），并且执行是按照static块的顺序执行的。

4、静态代码块的初始化顺序

class Parent {
    static String name = "hello";
    {
        System.out.println("parent block");
    }
    static {
        System.out.println("parent static block");
    }

    public Parent() {
        System.out.println("parent constructor");
    }
}

class Child extends Parent {
    static String childName = "hello";
    {
        System.out.println("child block");
    }
    static {
        System.out.println("child static block");
    }

    public Child() {
        System.out.println("child constructor");
    }
}

public class TestStatic {

    public static void main(String[] args) {
        new Child();// 语句(*)
    }
}

问题：当执行完语句(*)时，打印结果是什么顺序？为什么？

输出结果：

parent static block
child static block
parent block
parent constructor
child block
child constructor

分析:当执行new Child()时，它首先去看父类里面有没有静态代码块，如果有，它先去执行父类里面静态代码块里面的内容，当父类的静态代码块里面的内容执行完毕之后，接着去执行子类(自己这个类)里面的静态代码块，当子类的静态代码块执行完毕之后，它接着又去看父类有没有非静态代码块，如果有就执行父类的非静态代码块，父类的非静态代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有非静态代码块，如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕再去执行子类的构造方法，这个就是一个对象的初始化顺序。

总结:
对象的初始化顺序:首先执行父类静态的内容，父类静态的内容执行完毕后，接着去执行子类的静态的内容，当子类的静态内容执行完毕之后，再去看父类有没有非静态代码块，如果有就执行父类的非静态代码块，父类的非静态代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有非静态代码块，如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕再去执行子类的构造方法。总之一句话，静态代码块内容先执行，接着执行父类非静态代码块和构造方法，然后执行子类非静态代码块和构造方法。

注意:子类的构造方法，不管这个构造方法带不带参数，默认的它都会先去寻找父类的不带参数的构造方法。如果父类没有不带参数的构造方法，那么子类必须用supper关键子来调用父类带参数的构造方法，否则编译不能通过。