关键字小谈

Java常用关键字总结
在java中除了跟c语言中共有的一些关键字外，还有一些其他的，c语言中没有的关键字。比如public，protected，private，static，final，super，this等。其中public，protected，private属于可见性修饰关键字。所谓的可见性就是一个访问权限的问题，被可见性修饰关键字修饰的类，属性，方法等，根据关键字的不同，其他类的对象对其的访问权限也不同。
首先，我们来讲讲public关键字。它字面上的意思即是“公共的”的意思，它是公开性最高的一个关键字，它可以用来修饰一个类，这时，这个由public修饰的类可以被其他包中的类的对象访问。它也可以用来修饰方法，此时，这个被修饰的方法可以被其他包中的类调用。它还可以用来修饰属性，此时可以通过对象.属性的方式来访问该属性。
注意：子类在继承父类时，父类的方法是public修饰的，则在重写该方法时不能缩小其可见性。
然后是protected关键字。它的公开性次于public。它修饰的方法只能在同一个包里面可以访问，子类也可以继承。但是由于不能被其他包的类和对象访问，这个关键字比较少用。
最后是private关键字。它是可见性范围最小的限定符，只能在同一个类中进行访问调用。一般类中的属性都是由private修饰的，再由public的方法来对其进行调用。如果其他类想要调用该属性则可以通过该public的方法就行了。用private修饰属性有利于程序的封装；子类不能继承父类中用private修饰的方法。

示例：
先创建一个Animal类
package 关键字;

/**
* 动物类
*
* @author Administrator
*
*/
public class Animal {
// 定义private属性name
private String name;
public String color;

public void eat(){
System.out.println("吃东西");
}
private void say(){
System.out.println("说话");

}
public void showColor(){
System.out.println("颜色是"+color);

}
}

创建一个Cat类，继承Aniamal类，重写其中的eat方法
package 关键字;
/**
* 创建一个Cat类继承Animal类
* @author Administrator
*
*/
public class Cat extends Animal{
/**
* 重写父类的eat方法
*/
public void eat(){
System.out.println("猫吃鱼");
}


}
创建一个主类，运行程序
package 关键字;
/**
* 创建一个主类
* @author Administrator
*
*/
public class MainTest {
public static void main(String[] args) {
//创建一个Animal的对象
Animal a=new Animal();
//调用eat方法
a.eat();
//如果调用say方法则会报错
//a.say();
//对Animal对象设置color
a.color="red";
//对Animal对象调用showColor方法
a.showColor();
//创建Cat的对象
Cat c=new Cat();
//对Cat对象调用eat和showColor方法，但不能调用say方法
c.color="white";
c.eat();
c.showColor();
}
}



其他关键字：
1、 this关键字
this指的是本类目前正在被操作的一个对象，就是在本类中如果要访问或初始化本类的属性，或者调用本类中的方法。不用构造一个对象，this就可以代替这个将要被使用的对象。This还可以在构造方法中调用本类的某一个构造方法。
示例：
package 关键字;

/**
* 创建一个Student类
*
* @author Administrator
*
*/
public class Student {
// 属性
private String name;
private int number;

// 无参构造方法
public Student() {
System.out.println("父类的无参构造方法");
}

// 带name参数的构造方法
public Student(String name) {
// 用this();调用本类的带name和number参数的构造方法
this(name, 0);
System.out.println("姓名"+name);
}

// 带name和number参数的构造方法
public Student(String name, int number) {
// this用作本类当前在操作的一个对象，引用参数赋值
this.name = name;
this.number = number;
System.out.println("姓名"+name+"学号"+number);
}
public void study(){
System.out.println("学习中");
}

}创建一个主类：然后运行程序
package 关键字;

/**
* 主类,用于测试程序
*
* @author Administrator
*
*/
public class MainTest {
public static void main(String[] args) {
String s="Anny";
Student stu1 = new Student();
Student stu3 = new Student(s,80);
}
}

2、 super关键字
this指的是当前本类的对象，而super指的是当前类的父类对象。即super可以调用父类的方法。还可以在子类构造方法中调用父类的构造方法，写作super();（该写法为调用无参构造方法），但是它只能写在子类构造方法中的第一行，也就意味着只能使用一次。
示例：
创建学生类
public class Student {
// 属性
private String name;
private int number;

// 无参构造方法
public Student() {
System.out.println("父类的无参构造方法");
}

// 带name参数的构造方法
public Student(String name) {
// 用this();调用本类的带name和number参数的构造方法
this.name=name;
System.out.println("姓名"+name);
}

public void study(){
System.out.println("学习中");
}
}

创建学生类子类
package 关键字;
/**
* 创建一个UNStudent类，继承Student类
* @author Administrator
*
*/
public class UNStudent extends Student{
//在子类中调用父类的构造方法
public UNStudent(){
super();
}
}

创建主类
package 关键字;

/**
* 主类,用于测试程序
*
* @author Administrator
*
*/
public class MainTest {
public static void main(String[] args) {
UNStudent us=new UNStudent();
}
}

3、 final关键字
final的字面意思是“最终的”，也就是不可改变的。如果用它来修饰属性，也就代表这个属性是常量，不可以被修改。如果用来修饰方法，子类 在继承父类该方法时不能重写该方法，只能进行调用。它还可以用来修饰类，这样的类不能被继承。
4、 static关键字
static可以用来修饰类，方法，属性和代码段。由它修饰的都是静态的。当用于修饰类的时候，不能用于修饰普通类，只能用于内部类。

当static用来修饰方法的时候，称为静态方法。它与非静态方法的区别就是，静态方法在调用时不需要创建对象来调用。直接以类名.方法名就可以调用了。它在类刚刚被加载的时候就执行了。
示例：
Student类
package 关键字;

/**
* 创建一个Student类
*
* @author Administrator
*
*/
public class Student {
// 属性
private String name;
private int number;

// 无参构造方法
public Student() {

}

public static void study(){
System.out.println("学习中");
}
public void play(){
System.out.println("玩耍");
}

}
主类
package 关键字;

/**
* 主类,用于测试程序
*
* @author Administrator
*
*/
public class MainTest {
public static void main(String[] args) {
//调用静态方法，不用创建对象
Student.study();
//调用非静态方法，需要创建对象
Student st=new Student();
st.play();
}
}


当static用来修饰属性的时候，称为类属性。它与静态方法一样不用创建对象来调用，而是直接调用。还有，类中的某一个对象的static属性值被该表后，这个类的所有对象的static属性的值都会变。在static方法中可以直接调用static修饰的属性，但是如果要调用其他修饰符修饰的属性，就要创建对象。
示例：
Student类
package 关键字;

/**
* 创建一个Student类
*
* @author Administrator
*
*/
public class Student {
// 属性
private static String name;
private int number;

// 无参构造方法
public Student() {

}
public void setName(String name){
this.name=name;
}
public  void study(){
System.out.println(name+"学习中");
}
public void play(){
System.out.println(name+"玩耍");
}
}
主类
package 关键字;

/**
* 主类,用于测试程序
*
* @author Administrator
*
*/
public class MainTest {
public static void main(String[] args) {
//调用静态方法，不用创建对象
Student st1 =new Student();
//调用非静态方法，需要创建对象
Student st2=new Student();
st1.setName("小红");
st2.setName("小明");
st1.study();
st1.study();
}
}


当static用来修饰代码段的时候，它在类刚刚被加载的时候就执行了。它的执行顺序是在main函数之前的。可以测试一下以下程序
示例：
package 关键字;

/**
* 主类,用于测试程序
*
* @author Administrator
*
*/
public class MainTest {
public static void main(String[] args) {
System.out.println("main函数执行");
}
static{
System.out.println("静态代码段执行");
}
}
输出结果是“静态代码段执行” “main函数执行”。[/align][/align]