Java中的关键字

    所谓的关键字是指电脑语言里事先定义的,有特别意义的标识符,有时又叫保留字，还有特别意义的变量。

    Java的关键字对java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名。
   
    接下来介绍一下Java里常用的关键字：

    1、访问控制修饰符，可以应用于类、方法和字段（也就是在类中声明的变量）下面就是这些访问修饰符。
     权限从大到小依次为：
     public：在同一个工程里可以到处使用。
     protected：在同一个包中或者“不在同一个包中的子类”可以使用，所以说它的权限要比默认的大
     默认的：所有类的默认访问权限都是package访问，也就是说除非存在特定的访问修饰符（比如public、protected、private），否则可以从一个包中的任何类访问类成员
     private：只能在声明private（内部）类、方法或者字段的类中引用这些类、方法和字段，而在类的外部或者类的子类中，它们是不可见的。
     注：在这几个访问修饰符中，并不是范围越大越好，应该根据需要选择最适合的访问修饰符；在接口中的属性和方法必须是public ,默认是public；子类在重写父类的方法时候，不能减小方法的可见范围，原因是重写也叫覆写，修饰符、返回类型、参数就是要和父类一摸一样才叫覆写，意思是说各个地方都需要完美的盖住，在面向接口编程中，重写是子类有自己的逻辑要实现，同时又不破坏已写好程序逻辑的办法

     2、super 和  this
     super
     此关键字用于引用使用该关键字的类的父类，初学Java阶段主要用到它的地方是强制引用父类中的方法或属性。
     如果在子类的构造方法中，没有明显地写出super关键字来调用父类的某个构造方法，那么默认有如下语句：super();
     即调用父类的不带参数的构造方法。
     子类可以通过方法的重写隐藏继承的方法
     如果用户在子类中想使用被子类隐藏的成员变量或方法就可以使用关键字super。
     当super调用隐藏的方法时，该方法中出现的成员变量是被隐藏的成员变量

     this
     Java中为解决变量的命名冲突和不确定性问题，引入关键字“this”代表其所在方法的当前对象：
     当参数名和属性名相同的时候 ，那么使用this来区分参数和属性，加了this的表示属性，没有加的则表示参数；this是用来表示当前调用方法的对象，哪一个对象在调用方法，方法中的this就表示该对象，类似生活中的“我”这个词。
     this只能用于方法方法体内。当一个对象创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是this。因此，this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this。并且this只和特定的对象关联，而不和类关联，同一个类的不同对象有不同的this。
     下面给出一个使用super和this的实例，以便说明问题：
    
    class Person { 
    private String name; 
    public Person() { 
    name = "1号"; 
    } 
    public Person(String n) { 
    name = n; 
    } 
 
    public String getName() { 
    return name; 
    } 
    public void sayHello() { 
    System.out.println("大家好！我是" + name); 
    } 
    } 
    class Student extends Person { 
    private int sid; 
 
    public Student() { 
    super();//这是Eclipse中自动生成的，说明了“在子类的构造方法中，必须通过super的形式调用父类的构造方法，如果没有调用，JVM会以"super()"的形式调用父类的无参构造方法” 
    sid = -1; 
    } 
    public Student(String name,int id) { 
    //sid = id;//我试了下,把这句话放这里是编译不过去的 
    super(name); 
    sid = id; 
    } 
    public void sayHello() { 
    System.out.println("大家好！我是学生" + super.getName());
    //在子类中，super表示对父类的引用 
    } 
    }
    //程序的入口
    public class Test { 
    public static void main(String[] args) { 
    Person p = new Person("2号"); 
    p.sayHello(); 
    Student s1 = new Student(); 
    s1.sayHello(); 
    Student s2 = new Student("3号",001); 
    s2.sayHello(); 
    } 
 
    } 
/*运行结果:
   大家好！我是ZhangSan
   大家好！我是学生unknow
   大家好！我是学生LiSi
*/
   
   this

   class Person { 
   private String name; 
   public Person() { 
   //name = "unknow"; 
   //this(name);  这两种写法是错误的
   this("unknown");//调用本类当中的构造方法Person(String name) 
 
   } 
   public Person(String name) { 
   this.name = name;//this表示本类当前对象的引用 
   } 
 
   public String getName() { 
   return name; 
   } 
   public void sayHello() { 
   System.out.println("大家好！我是" + name); 
   } 
   } 

   public class Test{ 
   public static void main(String[] args) { 
   Person p = new Person("wangyinghua"); 
   p.sayHello(); 
 
   } 
 
   } 
//运行结果:大家好！我是wangyinghua


   3、final,static
    static：
    static意为静态的，只能定义属性，方法，代码块。
    被static修饰的成员变量和成员方法独立于该类的任何对象。
　　按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。
    静态方法 （静态成员的访问）
　　静态成员是属于类的，　调用一个静态方法就是“类名.方法名”,调用一个静态成员就是“类名.变量名”,
　　静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！
　　因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的。
　　static代码块
　　static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次，且Static代码块会在主函数之前执行。
    请看这段代码：


    public class A {

    public A(){

    System.out.print("A");
    }


    }
    ----------------------------------------------------------------------类B


    public class B extends A {

    public B(){
    System.out.print("B");
    }

    }
    ----------------------------------------------------------------------
  
    类C
 
    public class C {

    private static A a = new A();
    private B b = new B();

    public C(){
    System.out.print("C");
    }

    public static void main(String args[]){

    C.change();

    }

    public  static void change(){
    B b = new B();
    }



    }
 
    结果是： AAB

    final：
    final从字面上看有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。其特点有：
    final类不能被继承，没有子类，final类中的方法默认是final的；
    final方法不能被子类的方法覆盖，但可以被继承；
    final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
    final不能用于修饰构造方法；
    注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的；
    

     public final class A{}     表示不能被继承
     private final int age=100; 表示只能赋值一次，必须初始化，不能被修改
     public final void trst(){  表示不能被重写
     }
     final int age=100;         表示只能赋值一次，必须初始化，不能被修改