1.常见关键字分类
跟类相关：package(包) class（类） abstract（抽象） extends（继承） implements（实现） interface（接口）
跟属性相关：static final
跟方法相关：void
跟访问权限有关：public private protected
跟异常相关：try catch finally throw throws
八大基本数据类型：int long short byte char boolean double float
跟循环判断相关：if for switch case while break return continue
其他：this super new
保留字：goto default


这些关键字都是我们平时写代码常用的，其中有些关键字很容易理解，也没有很深刻的意思，
比如八大基本数据类型，就仅仅表示数据的类型。其中还有一些关键字是很重要，很难理解的。
现在我们就来着重分析这些关键字。


1）访问权限修饰符public private protected(当我们没有给出权限修饰符时，系统会有一个默认的权限修饰符default
   既然是权限修饰符，那么他们的访问权限就有高低之分，下面是他们之间权限的对比：
   （√ 代表可以访问， ×代表不能访问）
   
                     同一个类       同一个包       不同包的子类        不同的包
      public           √       √           √             √


      protect          √              √           √             ×


      default          √              √           ×             ×


      private          √              ×           ×             ×


   由上面表格可以看出：public    在当前工程下任何一个类都可以通过当前对象访问属性或方法
                       protected 在当前工程的同一个包可以通过当前对象访问属性或方法，不同的包的子类可以继承到
                       default   在当前工程下同一个包可以通过当前对象访问属性或方法，但是不同的包的子类不能继承到
                       private   有当前类的内部可以使用
   注意事项：修饰类只能用public和default，其中public修饰的类是主类，必须与包名相同，default（可以不写）修饰的类是辅类。
2）this 和 super
   this：指代当前类的对象，可以用来调用方法，构造方法和属性
   super：指代父类的对象，可以调用父类的方法，构造方法和属性
   注意事项：子类构造方法必然会调用父类色构造方法，通过super关键字调用
             super关键字调用构造方法的使用必须出现在当前函数第一行
   代码示例：
            package com.huaxin.keywords3;


public class A {
public String t;
public A(String s){
System.out.println("调用A类构造方法");
}
}
           package com.huaxin.keywords3;


public class B extends A{
public B(){
//调用父类的构造方法
super("");
super.t="";
System.out.println("调用B类构造方法");
}
}
   其中，第二段代码中的super("");就是调用父类的构造方法，只能放在第一行
   如果将super("");和super.t="";换一个位置，则会报错。


3）final
   final可以修饰类、属性、方法、参数、局部变量
   修饰类时，代表当前类不能被继承
   修饰属性时，代表当前属性只能被复制一次
   修饰方法时，代表当前方法不能被重写
   修饰参数、局部变量时，表示当前局部变量在使用范围内不能被修改
   代码示例：
            package com.huaxin.keywords4;


public final class A {

}
            package com.huaxin.keywords5;
                public B extends A{
}
    如果这样就会报错，因为A被final修饰，不能被B继承
           package com.huaxin.keywords4;


public  class A {
public final int a = 10;
public A(int a){
this.a = a;
}

public final void test(final int a){
final String b;
}
} 
     上面代码中，int a = 10被final修饰，所以a的值不能改变了
                 方法test被final修饰了，所以test方法不能被重写
                 参数列表 int a 被final修饰了，所以无论test方法被调用多少次，传过来的a的值都是第一次传过来的值。
4）static
   修饰属性、方法、静态代码块（用一对大括号括起来的代码叫代码块，在前面加上static修饰就变成了静态代码块，静态代码块可以优化代码执行效率，因为它只在类被加载时执行一次）
   静态的属性和方法在加载当前类的时候就会加载静态属性和方法到静态空间存储
   注意：静态的方法不能直接使用非静态变量和非静态成员方法。
   代码示例
   package com.huaxin.keywords5;


public class Student {
public String address;
public static String name;
static{
System.out.println(1);
}
{
System.out.println(2);
}
public Student(){
System.out.println(3);
}
public static void study(){
System.out.println(4);
}
public void play(){
System.out.println(5);
}
}


package com.huaxin.keywords5;


public class Test {
public static void main(String[] args) {
Student stu1 = new Student();
Student stu2 = new Student();
stu1.play();
Student.study();
}
}
  代码执行结果为1 2 3 2 3 5 4
  在类被加载时，会执行静态代码块仅一次，执行System.out.println(1);然后在测试类中，创建了两个对象，stu1和stu2，两次执行System.out.println(2);和构造函数System.out.println(3);各一次，然后stu1.play();调用play方法，执行System.out.println(5);最后通过Student.study();调用静态方法，执行System.out.println(4); 
  
代码示例  
        package hduasidias;


public class Students {
public String address;
public static String name;
}
        package hduasidias;


public class Test {
public static void main(String[] args) {
Students.name = "张三";
Students stu1 = new Students();
Students stu2 = new Students();
Students stu3 = new Students();
stu1.name = "李四1";
stu2.name = "李四2";
stu3.name = "李四3";

System.out.println(Students.name);

}
}
   输出结果为：李四4
   所以，这里所有对象共享一个静态属性，name，当给name赋值的时候，原来的name的值被覆盖，所以输出的是最后赋值的值。
                           
  注意事项：
1：静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法和静态成员变量的。
2：最常见的静态方法是main方法，main方法是程序的接口，在执行main方法时，不需要创建任何对象，所以main方法必须是静态的。
3：static成员变量的初始化按照定义的顺序初始化。
4：静态属性所有对象共享一个
5）break、return、continue
break：跳出当层循环
return：结束当前方法
continue：跳出当次循环，直接进入下一次循环
  注意事项：break只跳出它自己所在的循环，如果还有外层循环还是要继续执行的
例如：package com.huaxin.xunhuan;


public class Test {
public static void main(String[] args) {
for(int i = 0;i < 3;i++){
for(int j = 0;j < 3;j++){
if(j == 1){
System.out.print("* ");
break;
}
System.out.print("1 ");

}
System.out.println("");
}
}
}
输出结果为：1 * 
   1 * 
            1 * 


所以，break只是跳出了j的循环，而外层循环i还要继续。


 package com.huaxin.xunhuan;


public class Test {
public static void main(String[] args) {
for(int i = 0;i < 3;i++){
if(i==1){
continue;
}
System.out.print(i+" ");
}
}
}
输出为：0 2
所以，continue只是跳出当次循环，没有输出1，但是下面的循环还是要执行的 


public class TestReturn{
public static void main（String[] args）
{
for （int i = 0; i < 3 ; i++ ）{
System.out.println（"i的值是" + i）；
if （i == 1）{
return;


　　                }


                }


　　       }


　  　}


输出结果为：i的值是0
            i的值是1
与continue和break不同的是，return直接结束整个方法，不管这个return处于多少层循环之内