java关键字的使用

java常用关键字总结

java中的关键字罗列如下：
[size=medium]public  private  protected  static  final  new  this  super  package  import  class    interface  extends implements   abstract  byte  short  int  float  long  double  char  boolean  enum  true  false  if  else  for  while  do  break  continue  return  swiitch  case  default  null  void  try  catch  finally  throw  throws  instanceof  synchronized  transient  assert  volatile  const  native  strictfp  goto

访问修饰符关键字：
    public ：公开的
    protected：受保护的
    private：私有的（控制可见性）
    默认的：系统根据类型默认设置的，例如接口系统默认为public
  1. public

   (1). 同一个文件夹中有且仅有一个public修饰的类，其他与public限定的同级别的类前不能用public、protected、private限定，直接“class+类名(){}”但是在一个public限定的类中，可以包含public或private或Protected或系统默认限定的类

/**
 * 创建一个测试类
 * @author CarmenCai
 *
 */
public class Test extends TestAB{
	//public类中可以创建public类
	public class Student{};
	private class Student1{};
	protected class Student2{};}

   (2).接口的关键字必须是public，因为接口中的方法没有方法体，需要其他类去实现，所以必须是public，而不能是protected或private

2.private
   (1).private 限定方法:表明该方法只能由类的内部方法或构造器调用，在继承时，父类中private限定的方法不能被调用；

   (2).private限定的构造器，则表明不能实例化一个该类的对象

3.protected
   (1).protected限定的方法，子类可以继承，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。

4.static：静态的（不需要实例化对象，直接使用类名进行调用），在内存只存储一次

  final：最终的(不可以改变值)

   (1).使用static关键修饰变量后，循环创建10个对象输出结果是什么？原因是为什么？

 private static int j=0;
		public Test(String a, int i, String str) {
			super(a, i);
			this.str = str;
			j++;
			System.out.println("j="+j);
		}
		public static void main(String[] args) {
			for (int i = 0; i < 10; i++) {
			//实例化对象
				Test t = new Test("ab", j, "子类");
			}
		}

输出的结果是j=1;j=2;......;=j=10;因为j是一个静态变量，只有一个内存地址，在主程序中，实例化了10次对象，每循环一次，构造中j的值改变一次，但是j在内存中只有一个。

  (2).将方法使用static关键字修饰

• 方法用static修饰后，该方法在内存中只有一块内存资源，方法要调用的属性必须是static修饰的,该方法可以直接由类名调用“类名.static方法”

private static String str;
	public static void study(){
	str="a";
	}

public static void study(int a){
	a++;
	System.out.println("a="+a);
	}
public static void main(String[] args) {
	for (int i = 0; i < 10; i++) {
	Test.study(0);//给i赋初始值0
	}
}

运行结果为10个a=1;a=1;a=1;a=1;a=1;a=1;a=1;a=1;a=1;a=1;同样，在主程序中对象创建了10次，相应的方法也调用了10次，但是由于方法是static,所以，方法永远在同一个内存块中，a只是值的改变

   (3).static可以修饰类
例：

public  class Test extends TestAB{
	//public类中可以创建public类
	public static class Student{};
	private static class Student1{};
	protected static class Student2{};}

但类Test不能定义为public static class ,而可以定义为public static abstract class
5.final
    表示属性一旦被分配内存空间就必须初始化并且以后不可变，方法一旦定义必须有实现代码并且子类里不可被覆盖

• 如果将类使用final关键字修饰，该类不能被继承，因此不能用final修饰抽象类和接口


• 如果将方法使用final关键字修饰,则当子类继承该类时，该方法不能被重写


• final关键字修饰属性，则属性值为常量，不可改变

6.this：当前的对象

7.super：调用当前类的父类的方法或者构造方法
     在构造器中，继承父类的方法，直接用super();并且super()必须写在构造器内的第一行,但是在一般方法中，super()的位置可以改变

public Test(String a, int i, String str) {
	//super(a, i);和this.str = str;的位置不能改变
	super(a, i);
	this.str = str;
	}

      当父类和子类中的方法相同时，就可以用this和super来区别调用的是子类的方法，还是父类的方法

8.package：定义包，包下面存放若干个文件

9.import ：引入某个包下的类。

10.class：用于定一个类文件

11.interface：定义接口

12.extends：实现类与类，类与接口，接口与接口之间的继承

13.implements：实现接口的方法

14.new：实例化对象时，申请空间

15.基本数据类型

byte：字节型，8bits
short：短整型，16bits
int：整型，32bits
long：长整型，64bits
float：浮点型，32bits
double：双精度，64bits
char：字符型，16bits
boolean：布尔型，true/false

16.instanceof:判断对象是否是某个类的实例，在队列中可用到

17.synchronized:同步

18.transient:瞬时的

19.assert：断言

20.goto：保留字
           在这里，共罗列了52个关键字，但是目前经常用到的只有以上9个，以及没有在上面细述的循环关键字（if else while do ）。在

这些关键字中，我用了近乎半个月的时间消化，期中，最让我头疼的是，this,super,static几个关键字。记得在做画图板，刚开始学习值传递时，我一直搞不懂在构造器中，this.是什么意思。因为不知道值传递到底是怎么回事，我就开始尝试用public static定义我要在另一

个类中使用的属性或对象，然后通过“类名.属性”的方式直接调用。

         然而，在画图板中，涉及了很多个类，特别是当时在使用颜色color时，由于在三个类中定义颜色的属性名均为public static color，

因此，导致我在画图板上获取颜色时，出现了混乱。从此，我又重新学习值传递。经过自己不断的摸索尝试和龙哥的讲解，我最终掌握

了这个知识点。经过这件事，我也明白了，我们不能图一时便捷，而在大工程上偷工减料，最终搬起石头砸自己的脚。也深刻体会到，

我们在使用一个关键字、或者一个系统类之前，一定要了解它的意义和本质，而不能以偏概全，自以为是。

       就目前情况看。static关键字我还需要继续研究，不断测试，不断总啊。当然，还有一些我目前还没接触的关键字，表示工程量浩大啊！