DAY08 Java关键字及分析

关键字其实就是java的已经被赋予特定含义的单词，比如class、public等。注意的是，java已经将这些单词用了，所以我们在写代码定义变量的时候就不能随便使用了。就比方说有一个著名景点叫九寨沟，我们不能说在家门口挖一条九寨沟什么的。每个关键字都有特殊的作用，比如package是用于声明一个包，import用于引入一个包，class用于声明一个类。关键字还需要注意就是所有关键字都是小写的，程序中的标识符（包名，类名，方法名，变量名等）不能用关键字命名。

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

2.重点分析关键字
1)Java访问权限修饰符public  private  protected  默认的（default）
修饰：属性、方法、类
△public:公有的，当前工程下的任何一个类都可以通过当前对象访问公有的属性或者方法，一个类里只需写一次public

比如：声明一个eat包：

package eat;public class Eat {public Eat(){System.out.println("LiMing is eating cake. ");}}

然后我们创建一个Cake程序：

package eat;public class Cake {public static void main(String args[]){Eat eat =new Eat();}}

运行结果：LiMing is eating cake.

结论：可见public之后紧跟着的成员声明自己对当前工程下每个类的对象都是可用的。

△private：私有的，只有当前类的内部可以使用，也就是处于同一个包内的其他类是不可以访问private成员的，当然有一个好处就是private允许你随意改变其中成员，而不会影响到包内的其他类。

比如：修改一下Eat类

package eat;public class Eat {public Eat(){System.out.println("LiMing is eating cake. ");}private String taste = "GOOD!";}

在Cake程序中调用：

package eat;public class Cake {public static void main(String args[]){Eat eat =new Eat();eat.taste="";}}

运行结果：Exception in thread "main" java.lang.Error: Unresolved compilation problem:
                    The field Eat.taste is not visible at eat.Cake.main(Cake.java:6)

结论：private中，除了包含该成员的类之外，其他任何类都无法访问这个成员。只能在当前类访问该成员。

△protected:受保护的，当前工程下的同一个包可以通过当前对象访问公有的属性或者方法，不同包的子类可以继承到。

相同地：

package eat;public class Eat {public Eat(){System.out.println("LiMing is eating cake. ");}private String taste = "GOOD!";protected String make="HanMeimei make a chocolate cake.";}

Cake：

package eat;public class Cake {public static void main(String args[]){Eat eat =new Eat();//eat.taste="";eat.make = "";}}然而当我们在当前工程下再声明一个eatmore包：<pre name="code" class="java">package eat;public class Eat {//public Eat(){//System.out.println("LiMing is eating cake. ");//}private String taste = "GOOD!";protected String make="HanMeimei make a chocolate cake.";public int lalala;}

eatmore包：

package eatmore;import eat.Eat;public class Cake extends Eat{public static void main(String args[]){Eat eat = new Eat();eat.taste = "";eat.make = "";eat.lalala = 10;}}

eat包运行结果：LiMing is eating cake.

eatmore包运行结果：Exception in thread "main" java.lang.Error: Unresolved compilation problems:
    The field Eat.taste is not visible
    The field Eat.make is not visible
    at eatmore.Cake.main(Cake.java:8)

结论：由此可见public可以跨包访问，protected和private都不行。但protected可以在包内访问。

默认的（default）：当前工程下的同一个包可以通过当前对象访问公有的属性或者方法

注意：修饰类只能用public和默认的

2)this/super
this：当前类的对象，可以用来调用方法、构造方法、属性，它只能在方法内部使用，表示对调用方法的对象的引用。

大概是：

package eat;public class Eat {//public Eat(){//System.out.println("LiMing is eating cake. ");//}private String taste = "GOOD!";protected String make="HanMeimei make a chocolate cake.";public String cola;private void Drink(String drink){this.cola= drink;}}

super：父类的对象，可以调用父类的方法、构造方法、属性。当子类重写父类的方法后，子类对象将无法访问父类被重写的方法，super就是用于访问父类的成员的关键字。

例如：声明一个stopeating包，和一个Keepfit类：

package stopeating;public class Keepfit {public String n;public Keepfit(String m){System.out.println("调用减肥类构造方法");}}

Exercise类：

package stopeating;public class Exercise extends Keepfit{public Exercise() {//调用父类的构造方法super("");super.n="";System.out.println("调用运动类构造方法");}}

一个Succeed程序：

package stopeating;public class Succeed {public static void main(String args[]){Exercise e = new Exercise();}}

运行结果：调用减肥类构造方法
                    调用运动类构造方法

注意：子类构造方法必然会调用父类的构造方法，通过super关键字调用
      super关键字调用构造方法的使用必须出现在当前的函数第一行

3)final（最终的）
修饰：类、属性、方法、参数、局部变量
类：当前类不能被继承
属性：当前属性只能被赋值一次
方法：代表当前方法不能被重写
参数、局部变量：表示当前局部变量在使用范围内不能被修改

例如：声明一个continueeating包：

Fat类：

package continueeating;public final class Fat {public final int fruit;public Fat(int fruit){this.fruit = fruit;}public final void slim(final int fruit){final String fish;}}

Slim类：

package continueeating;public class Slim extends Fat{public void slim(){}}

Test类：

package continueeating;public class Test {public static void main(String args[]){Slim slim = new Slim();}}

运行结果：Exception in thread "main" java.lang.Error: Unresolved compilation problem:
    The type Slim cannot subclass the final class Fat
    at continueeating.Slim.<init>(Slim.java:3)
    at continueeating.Test.main(Test.java:5)
结论：由此可见，被final关键字修饰的方法和变量为最终方法和变量，子类不能对该方法进行重写。由于final这种特性，当在父类中定义某个方法时，如果不希望被子类重写，就可以使用该关键字修饰该方法。

4)static（静态的）
修饰：属性、方法、静态块
静态的属性和方法：在加载当前类的时候就会加载静态属性和方法到静态空间存储，static只有一份变量
注意：a.静态的方法不能直接使用非静态属性。

            b.类编译执行时先加载静态属性再静态方法，再非静态的属性和方法。

            c.静态方法要调用别的属性，可以创建一个对象来调用属性。

            d.静态块的内容在加载类的同时自动执行

例如：

△静态方法

定义一个静态方法：

package eating;public class Sport {//定义静态方法public static void swimming(){System.out.println("hahaha");}}

调用该静态方法：

package eating;public class Test {public static void main(String args[]){//调用静态方法Sport.swimming();}}

运行结果：hahaha

结论：Sport类中定义了静态方法swimming（），Test类中调用了该方法，由此可见静态方法不需要创建对象就可以调用。

△静态块

package eating;public class Sport {public static String swimming;//静态块static{swimming = "swim";System.out.println("Sport DONE");}}

package eating;public class Test {static{System.out.println("Test DONE");}public static void main(String args[]){Sport s1 = new Sport();Sport s2 = new Sport();}}

运行结果：Test DONE
                    Sport DONE

结论：从运行结果可以看到，程序中的段静态代码块都执行了，在Test类中创建了两个Sport对象，但Sport只有一份存储空间，所以这两个对象共享同一个swimming，且静态代码块只执行了一次，这就说明类在第一次使用时才会被加载，并且只会加载一次。

5）最后一个小例子

package teacher;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 teacher;public class Test {public static void main(String[] args) {Student.study();Student stu1 = new Student();Student stu2 = new Student();stu1.play();Student.study();}}

运行结果：1232354

6）关键字的运用在以后代码的编写上有着重要的地位，熟悉掌握每一个关键字代表的意思和用法很有必要的。