java中常用关键字总结

关键字的定义
所谓关键字就是在java中有固定的，有特殊含义的标示符，是不能用来当做变量名的。例如：常见的八中基本数据类型：byte,short,int,long,float,double,char,Boolean,还有其他的如：class,interface,implements,extends,public等等。

常用关键字的作用与用法
访问限定符：
public：用public修饰的成分表示是公有的， 可以放在类前，表示这个类可以被其他包中的类的对象所访问，是公开性最高的一个关键字。如果放在方法前，表示该方法可以被其它包中的类调用。放在属性前面，就可以直接通过 对象.属性 格式来访问对象的属性。Public限定的类在一个文件中只能有一个，表示该类是公有类，且文件名必须与类名相同。

protected：用protected修饰的成分表示是受保护的，它限定的方法子类可以继承，同包内可以访问，如果是在不同的包中，则不可以被访问。

(什么都不写，默认的)：如果什么都不写，则表示是“friendly”，相应的成分可以被所在包中的各类的对象访问。

private：被private限定的成员只能被这个类本身访问，在这个类之外是不可见的。在方法前面加上private，则该方法就只能由类内部的方法或者构造器调用，在类继承时，父类中的private方法不能被子类继承。

现在在Eclipse中定义一个Student类，在该类中定义了public的name，protected的code，什么都不写的age和private的num这几个属性，具体代码如下：

public class Student {

public String name;

protected String code;

int age;

private String num;


}
然后在同一个包当中定义一个Test类，在Test中创建一个Student类的对象，并对name,code,age,num赋值，前面三个成员变量都能够在Test类中使用，当使用num时，Eclipse就会报错，说找不到该成员变量，具体代码如下：


public class Test {

public static void main(String args[]){

Student st = new Student();

st.name = "AAA";

st.code = "123456";

st.age = 23;

}
}

同样在另外的一个包当中定义一个NUstudent类继承父类Student，然后在Test类中创建一个NUstudent类的对象来使用它从父类中继承的四个成员变量，在Eclipse中很清楚的看到前两个成员变量都能够使用，当使用age,num时就会报错，具体代码如下：
public class UNstudent extends Student {

}

public class Test {

public static void main(String args[]){

Student st = new Student();

UNstudent st1 = new UNstudent();

st.name = "AAA";

st.code = "123456";

st.age = 23;

st1.name = "BBB";
st1.code = "987654";
}
}
从以上的代码中就可以知道public修饰的成分都可以被在同一个工程中的其他类的对象访问；protected修饰的成分可以被在同一个包中的类以及它的子类的对象访问；什么都没有写的，只能被同一个包当中的类的对象所访问，它的子类的对象不能够访问；private只能在同一各类中使用。

this：通常有两个作用：第一个作用是指当前类的某个对象，第二个作用是在构造方法中的第一行调用当前类某一个构造方法，并且只能调用一次。
下面的这段代码演示了this的这两个作用：
public class Student {

private String name;

public Student(String name){
this.name = name;
}

public Student(){
this("AAA");
}

public void study(){
System.out.println(name+"正在学习");
}
public static void main(String args[]){

Student st = new Student("zhangsan");

Student st1 = new Student();

st.study();
st1.study();

}
}
运行结果如下：
zhangsan正在学习
AAA正在学习
上面的这段代码重载了Student类的构造方法，第一个构造方法中的this是指当前类的对象，第二个构造方法中的this是根据括号内的参数情况调用第一个构造方法。

super：通常是指当前类的父类的对象。
下面来代码示例，体会super的用法。
首先定义Student类
public class Student {

private String name;

public Student(String name){
this.name = name;
}

public Student(){
this("AAA");
}

public void study(){
System.out.println(name+"正在学习");
}

}
然后定义一个Student类的子类，并在其中使用super关键字
public class UNstudent extends Student {

public UNstudent(){
//在子类的构造方法中使用父类的构造方法
super("BBB");
}

//重写父类的方法
public void study(){
System.out.println(getName()+"正在学习,很生猛");
}

public static void main(String args[]){

Student st = new Student("zhangsan");

UNstudent st1 = new UNstudent();

st.study();
st1.study();

}
}
运行结果：
zhangsan正在学习
BBB正在学习,很生猛
然后再把UNstudent类的构造方法中调用父类构造方法的那一句去掉，如下：




public class UNstudent extends Student {

public UNstudent(){
//在子类的构造方法中使用父类的构造方法

}

//重写父类的方法
public void study(){
System.out.println(getName()+"正在学习,很生猛");
}

public static void main(String args[]){

Student st = new Student("zhangsan");

UNstudent st1 = new UNstudent();

st.study();
st1.study();

}

}
运行结果如下：
zhangsan正在学习
AAA正在学习,很生猛
通过执行的结果对比分析可知道子类的在构造方法中会先调用父类的一个无参数的构造方法，系统在创建子类对象时，其实也再创建父类的对象，可以使用super关键字引用到父类的对象从而调用父类中的方法。在子类的构造方法中通过super调用父类的构造方法必须在第一行，且只能调用一次。

final：final关键字意为“最终的”，放在属性前面，属性的值就是常量，即这个属性的值不可改变，并且该变量只能被赋值一次，要么在定义时就给该属性赋值，要么在构造方法中给该属性赋值。放在方法前面，当子类继承时，该方法是不可以被重写的。当修饰类时，表示该类是不能被继承的，所以final关键字不能用于接口中。此外，final关键字还有一个作用就是在定义方法时用来修饰方法的参数，使得参数的更改不会影响到该方法的调用。

static：当static关键字修饰的变量时，称为类变量或静态变量。当static关键字修饰的方法时，称为类方法或静态方法。
下面先来看类变量的代码示例：



public class Student {

public static String name;

public Student(String name){
this.name = name;
}

public void study(){
System.out.println(name+"正在学习");
}

public static void main(String args[]){

Student st1 = new Student("张三");
Student st2 = new Student("李四");
st1.study();
st2.study();

}

}
运行结果：
李四正在学习
李四正在学习
稍微调整一下上面的示例代码，如下：
public class Student {

public static String name;

public Student(String name){
this.name = name;
}

public void study(){
System.out.println(name+"正在学习");
}
public static void main(String args[]){
Student st1 = new Student("张三");
st1.study();
Student st2 = new Student("李四");
st2.study();
}
}
运行结果：
张三正在学习
李四正在学习
从以上的运行结果分析可知道，类的某个对象的static属性值被改变后，这个类的所有的对象的static属性值都会被改变。

现在来看类方法的代码示例：
public class Student {

//静态方法
public static void study(){
System.out.println("AAA正在学习");
}

//非静态方法
public void play(){JAVA关键字的总结
System.out.println("BBB正在打篮球");
}
public static void main(String args[]){
Student.study();
Student st = new Student();
st.play();
}
}
运行结果：
AAA正在学习
BBB正在打篮球
从上面的程序中可以看出，静态方法不需要通过创建该类的对象调用直接使用 类名.静态方法名() 调用即可，而非静态方法则必须通过创建该类的对象，通过对象来调用。