关键字总结

最常见关键字总结

1------访问修饰符

public 公开 在不同的包里可访问
private 私有的 只能在同一个class中访问
protected 受保护的 在同一个包里可访问

2----java中常见的结构关键字

package---定义包的关键字
class ---定义类得关键字
interface---定义接口的关键字

3-----关于数据基本类型
byte 8bit
char 16bit
short 16bit
int 32bit
float 32bit
long 64bit
double 64bit
boolean {true/false}

4----特殊的数据类型
String 用final定义的表示不可继承
enum---枚举型

5-----与父类和子类的对象有关的
this 表示当前对象 this.属性 --表现当前对象的属性
super 表示调用父类对象 super()是调用构造方法 super.方法名/属性名 是调用父类的属性和方法

6----定义修改界限的和使用范围的关键字

final-----可以用来修饰属性方法和类（final修饰的属性为常量 用final修饰的方法不可重写重载 final修饰的类不可以继承）
static---用来定义静态表示全局的概念（可以用来修饰属性和方法 不可以修饰类）
---一起可以定义接口中的常量，全局的

7-----继承和实现关键字

extends--继承 一般可以多层继承 不可以多继承
impements ---实现 实现接口的关键字

8---语句结构中的关键字
if--else--判断语句
do---while----判断语句
switch ----判断语句
case
default
for---循环语句----跳出循环 break 结束整个循环 continue 结束本次循环

9----特别的几个
new--开辟空间
null----String类型没有赋值则为空值
abstract---定义抽象方法和抽象类
void---返回值为空
return ---返回值
import----导入要使用的类
instanceof---判断是否为你实例化的对象

10----保留关键字
const
goto
不生熟悉的关键字总结：
-------异常
try
检查该段代码是否是异常
catch
捕捉异常
finally
不管异常是否进行 都要执行的代码块
------动作

throw
抛出异常
throws
不处理 提交到程序的更高层


不懂的关键字集合（前2个和线程有关）
-----修饰符
volatile
Java语言的关键字，用在变量的声明中表示这个变量是被同时运行的几个线程异步修改的。

synchronized 关键字，
代表这个方法加锁,相当于不管哪一个线程A每次运行到这个方法时,都要检查有没有其它正在用这个方法的线程B（或者C D等）,有的话要等正
在使用这个方法的线程B（或者C D）运行完这个方法后再运行此线程A,没有的话,直接运行 它包括两种用法：synchronized 方法和 synchronized 块。

transient
Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，
然而非transient型的变量是被包括进去的。

strictfp：
Java2向Java语言增加了一个新的关键字strictfp。与Java2同时产生的浮点运算计算模型很轻松的使某些处理器可以以较快速度进行浮点运算
（例如奔腾处理器）。这个浮点运算计算模型在计算过程中，不需要切断某些中介值。如果用strictfp来修饰类或方法，可以确保浮点运算
（以及所有切断）正如它们在早期Java版本中那样准确（即使用原始的浮点运算模型）。切断只影响某些操作的指数。当一个类被strictfp修饰，
所有该类的方法都自动被strictfp修饰。坦白说，很多程序员从未用过strictfp，因为它只对非常少的问题有影响。

native：
有时你希望调用不是用Java语言写的子程序，或者你希望调用一个专用的第三方的库，例如统计学包。虽然这种情况比较少，但Java提供了
native关键字，该关键字用来声明本机代码方法。

----------测试--------

 package keywords;

//测试static关键字
public class ManagerTools {
  public  static void main(String args[]){
	  //直接用类名调用静态方法
	  ManagerTools.work();
	  //创建一个对象然后调用非静态方法
	  ManagerTools mt =new  ManagerTools();
	  mt.workNoStatic();
	  ManagerTools.count=10;
	  //创建5个managertools的对象
	  for(int i=0;i<5;i++){
		  ManagerTools m = new ManagerTools();
		  m.count=i;
	  }
	  System.out.println("count的属性值是"+mt.count);
  }

public  void workNoStatic() {
	System.out.println("静态方法中");

}

public  static void work() {
	System.out.println("非----静态方法中");

}
private static int count =0;
private String name="默认名字";
}

package keywords;

public class Student {
  private String name;
  private int scro;
public Student(){
	  this("默认名字");
  }
  public Student(String name){
	  this.name=name;
  }
  /**
   * 学习几小时
   * @param hour：学习时长
   */
  public String study(int hour){
	  //学习时间和学分的对应关系
	  scro +=hour/3;
	  return name+"学习中，学分是"+scro;
  }
  public String getName(){
	  return name;
  }
  public void setName (String name){
	  this.name=name;
  }
  public int getScro(){
	  return scro;
  }
  public void setScro(int scro ){
	  this.scro=scro;
  }
}

package keywords;
public class UNStudent extends Student{
   public  UNStudent (){
	   //在子类构造函数中调用父类的构造函数
	   super("未知大学生");
   }
   /**
    * 重写父类中继承的study方法：
    */
   public String study(int  hour){
	   //调用父类中的方法
	   String sus=super.study(hour);
	   String myResult ="这是我的学习结果";
	   return "父类中的方法调用结果是："+sus+myResult;
   }
   public static void main(String args[]){
	   UNStudent uns = new UNStudent();
	   String result=uns.study(10);
	   System.out.println("执行结果是："+result);
   }
}