linkin大话面向对象--java关键字

java中的关键字有以下几个,他们不能作任何其它的用途。 发现没，java中的关键字全是小写，java是严格区分大小写的。

abstract  default  null  synchronized  boolean  do  if  package  this  break  double  implements  private  threadsafe  byte  else  import  protected  throw  extends  instanceof   

case  false  int  return  true  catch  final  interface  short  try  char  finally  long  static  void  class  float  native  super  while  for  new  switch  continue  public  transient

static用法：static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。 

有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ，所以它被声明为static。

注意了：静态成员不能访问非静态成员。因为类成员是属于类的，类成员的作用域比实例成员的作用域更大，完全可能出现类成员已经初始化完成了，但是实例成员还不曾初始化的情况，如果允许类成员访问实例成员将会引起大量错误。

public class Linkin {
   public static void test(){
       System.out.println("梦想终究还是要有的，万一实现了呢。。。");
   }
   public static void main(String[] args) {
    Linkin linkin = null;
    //The static method test() from the type Linkin should be accessed in a static way
    //这里eclipse会自动提示，null对象也可以访问它所属的类成员。我们应该尽量绕开这个误区，类成员就用类名作为主调来访问。
    linkin.test();
   }

}

this用法：this表示当前对象。当前对象 ： 当前正在调用实例成员的对象。换言之：谁调用了方法，谁就是当前对象

1，方法间的相互调用。

2，this.字段，当全局变量和局部变量重名是，this表示这个全局变量，其实也就是那个对象。

3，构造器中相互调用，但是此时this([参数])必须写在构造方法第一行。不可以在构造器以外的任何方法里面调用构造器，这个一般不会出现的，而且在一个构造器中调用另外一个构造器，只能调用一次

注意了：this不能用在static修饰的方法里和static修饰的代码块里。

super用法：表示父类对象的默认引用

1，如果子类要调用父类被覆盖的实例方法，可用super作为调用者调用父类被覆盖的实例方法。

2，使用super调用父类方法

3，使用super调用父类的构造方法

注意了：this不能出现在static修饰的方法中，super也一样不能出现在static修饰的方法中。

this和super对比：注意的是使用super()和this()在同一个构造方法中是不可能同时显示出现的。

No.	区别点	this	super
1	使用	调用本类中的字段或方法	从子类调用父类中的字段或方法
2	构造	可以调用本类构造方法，且有一个构造方法要作为出口	从子类调用父类的构造方法，不管子类如何安排最终一定会去调用，默认调用的是父类中的无参构造方法
3	要求	调用自身构造方法时放在构造方法首行	调用父类构造方法时放在子类构造方法首行
4	特殊	表示当前对象	表示父类对象

final用法：

final可以修饰类,方法,变量。
final修饰类不可以被继承，但是可以继承其他类。  
final修饰的方法不可以被覆盖,但可以覆盖父类方法。
final修饰的变量称为常量，这些变量只能赋值一次。内部类在局部时，只可以访问被final修饰的局部变量。 
final修饰的引用类型变量,表示该变量的引用不能变,而不是该变量的值不能变。比如说数组或者对象。


通常规范中：常量名称所有字母大写，若有多个单词组成，单词间使用下划线连接。
public static final修饰的常量称为全局常量；
public static final double PI = 3.14159265358979323846;
public static final String APP_SEPARATOR = "/"; 

• 可执行"宏替换"的final变量：

对于一个final变量来讲：不管他是类field，实例field，还是局部变量，只要满足下面3个条件，这个变量就不再是一个变量，而是相当于一个直接量。
1，使用final修饰符修饰
2，在定义该final变量时指定了初始值
3，该初始值可以在编译时就去确定下来

• 不可变类：

不可变类的意思就是创建该类的实例后，该实例的属性是不能改变的。java提供的8种包装类和String都是不可变类，当创建他们的实例后，其实例的属性是不能改变的。


成员变量是类初始化或者对象初始化而初始化的。当类初始化时，系统会为该类的属性分配内存，并分配默认值；当创建对象时，系统会为该对象的属性分配内存，并分配默认值。也就是说，当执行静态初始化块时可以对类属性赋初始化值，当执行普通初始化块时，构造器时可以对实例属性赋初始值。因此，成员变量的初始值可以在定义该变量时指定默认值，也可以在初始化块或者构造器中指定初始值。对于final修饰的成员变量来讲，一旦有了初始值，就不能被重新赋值，如果既没有在定义成员变量时指定初始值，也没有在初始化中，构造器中为成员变量指定初始值，那么这些变量的值将一直是系统分配的默认值，那么这些成员变量就完全失去了存在的意义。
所以呢？特别注意了：java语法规定，final修饰的成员变量必须由程序员显式指定初始值。

public class Test08 {
    final int a;
    final int b;
    final int c = 1;
    //The blank final field c may not have been initialized
    //既没有指定默认值，也没有在初始化块或者构造器中指定初始值，编译报错
    //final int d;
    
    public Test08(){
        //系统不会对final成员属性进行默认的初始化，这里final成员a还没有值，直接访问编译报错
        //System.out.println(a);
        a=1;
        //final变量c已经赋值过一次了，这里重新赋值，编译报错
        //c=2;
    }
    
    {
        b = 2;
    }
    
    public void test(){
        //普通方法不能为final修饰的成员变量赋值或者指定初始化
        //a = 4;
    }

}

public class Linkin {
    public static void main(String[] args) {
        final String str = "LinkinPark";
        final String huhu = "binger"+1314;
        final String str1 = str+huhu;
        //普通的变量，不会执行"宏替换"
        String str2 = "LinkinPark";
        String str3 = str2+huhu;
        //true
        System.out.println(huhu == "binger1314");
        //true
        System.out.println(str1 == "LinkinParkbinger1314");
        //false
        System.out.println(str3 == "LinkinParkbinger1314");
    }
  
}

break，continue,return 3个关键字用法：
break：用于结束一个循环，跳出循环体。注意了是完全终止循环本身。
continue：终止本次循环，接着下一次的循环。注意了这里并没有完全终止循环本身。
return：不是专门用来结束循环的，他的功能是结束一个方法。不管这个return处于几层循环都直接结束这个方法。

public class Linkin {
    public static void main(String[] args) {
        for (int a = 0; a <= 5; a++) {
            System.out.println(a);
            if (a == 2) {
                System.out.println("这里调用了break...");
                break;
            }
        }
        System.out.println("调用了上面的break的话，只是单纯的跳出上面那个循环，这行字会打印出来...");
        for(int a = 0; a <= 5; a++){
            System.out.println(a);
            if (a == 2) {
                System.out.println("这里调用了continue...");
                continue;
            } 
        }
        System.out.println("调用了上面的continue的话，只是单纯的跳出上面那个循环，这行字会打印出来...");
        for(int a = 0; a <= 5; a++){
            System.out.println(a);
            if (a == 2) {
                System.out.println("这里调用了return...");
                return;
            } 
        }
        System.out.println("调用了上面的return的话，这个方法就直接结束了，这行字不会打印出来...");
    }
    
}

值得注意的是，return还用于返回非void方法的返回值。这个很简单，就不做多的墨迹了。break和continue不仅可以结束其所在的循环，还可以结束其外层循环。

public class Linkin {
    public static void main(String[] args) {
        outer: for (int a = 0; a <= 3; a++) {
            for (int b = 0; b <= 3; b++) {
                System.out.print("a=" + a + ";b=" + b + "   ");
                if (b == 1) {
                    break outer;
                }
            }
        }
        System.out.println("=================");
        outer: for (int a = 0; a <= 3; a++) {
            for (int b = 0; b <= 3; b++) {
                System.out.print("a=" + a + ";b=" + b +"   ");
                if (b == 1) {
                    continue outer;
                }
            }
        }
    }
}