理解java中的关键字

java关键字
提起关键字相信大家都并不陌生吧！比如说我们经常用到的static、final、super.等等有很多，但是它们的具体用法和注意事项有哪些呢？下面是本人对这些的一点小小的总结，希望能够对大家有帮助。
包
package ：
包是java中一个有效管理类的机制，通过关键字package声明一个包，格式一般为：package 包名;    如果原文件中省略了包语句，则源文件定义的类被默认为是无名包的一部分。
import：
在java编程过程中，我们有时需要用到别的包下的类或者是java本身提供的类，那么我们就要用import语句来引入这个包，才能用到里面的文件。如果要引用包里的全部类，比如：import java.awt.*; 若只引用包里具体的某个类 只需：import java.util.Date;就可以啦！

2访问权限
当一个类创建了一个对象之后，该对象可以通过“.”运算符操作自己的变量、使用类中的方法，但对象操作自己的变量和使用类中的方法是有一定的限制的。所谓访问权限是指对象是否可以通过“.”来操作自己的变量或方法。
访问限制修饰符有：public、private、protected（这个时候也许你会马上想到另一种 访问修饰符------“友好的”即系统默认的，但它不是关键字）
①private
用关键字private修饰的成员变量或方法称为私有变量和私有方法，例：
class student{
private String name;//name被修饰成私有成员变量
private void study(){//study方法被修饰为私有方法
...........}
}
需要知道的是：如果类中的某个成员变量或方法被修饰为私有变量，则只能在本类中可以使用这个成员变量或方法，不能在类外通过对象名来调用这个属性或方法。例：
class student{
private String name;//name被修饰成私有成员变量
private void study(){//study方法被修饰为私有方法
...........}
class people{
student stu=new student();//创建一个Student 的对象
//stu.name="张三";//不能调用本类的私有属性
//stu.study();//不能调用本类的私有方法

}
public static void main(String [] args){
sudent stu=new student();//创建一个Student 的对象
stu.name="张三";//可以调用本类的私有属性
stu.study();//可以调用本类的私有方法
}
}


②public
用pubic修饰的成员变量或方法称为共有变量或共有方法

class student{
public String name;//name被修饰成私有成员变量
public void study(){//study方法被修饰为私有方法
...........}
当在任何一个类中创建了student 的对象后，该对象可以访问自己的public变量和public方法
class people{
student stu=new student();//创建一个Student 的对象
stu.name="张三";//可以调用该类的共有属性，合法
stu.study();//可以调用该类的共有方法，合法
}

③protected
用protected修饰的成员变量和方法被称为受保护的成员变量和受保护的方法
class student{
protected String name;//name被修饰成受保护的成员变量
protected void study(){//study方法被修饰为受保护的方法
...........}
当在另外一个类中用student 创建对象时，如果这个类与类student 在同一个包中，那么该对象能访问自己的protected属性和方法，如果不在同一个包中，则不能访问了
假如类people 和类student在同一个包下
class people{
student stu=new student();//创建一个Student 的对象
stu.name="张三";//可以调用该类的protected属性，合法
stu.study();//可以调用该类的protected方法，合法
}
定义和继承（实现）类、接口、抽象类的关键字
①class
class用来定义一个类的关键字，比如上面我们提到的class student{} 就是用class来定义一个student类的。一般格式为
class 类名{//类的声明
类体内容}
②abstract
abstract 是用来定义抽象类或者抽象方法的关键字
用abstract 修饰的抽象方法：只允许声明不可以实现的方法
用abstract 修饰的抽象类：
abstract class A{
..........}
抽象类有以下几个特点：
abstract 类中可以有abstract 方法，而且不允许使用fianl修饰的abstract 方法
abstract 类不能用new运算符创建对象
③interface
interface 是用来声明接口的关键字，格式为：
interface 接口名字{
..........}//注意：结构体中只允许方法的声明，不允许实现
④implements
如果一个类想要声明自己使用一个或多个接口，就要用关键字implements了，多个接口要用逗号隔开 格式为：
class A implements B,C{
.......}
注意：如果一个类实现了某个接口，那么这个类必须实现该接口中的所有方法，且方法的名字、返回类型、参数个数及类型必须与接口中的完全一致
⑤extends
在类的声明中，通过使用关键字extends 来声明一个子类 格式为：
class 子类名 extends父类名{
.....}
注意：
a.一个类只能有一个父类，也就是只能单继承
b.如果子类和父类在同一个包内，则子类可以继承父类中不是private的变 量和方法；如果子类和父类不在一个包中，子类可以继承父类protected、 public变量和方法

数据类型的关键字
①八大基本数据类型byte、short、int 、long、float、double、boolean、char
②空类型：void
③表示值：null、true、false
注意：null是引用数据类型的默认值如String 就默认等于null。true、false则是两种布尔值。

循环、条件的关键字
①最常见的循环：for,格式：
for（表达式1;表达式2;表达式3）{...循环体....}
表达式1：负责完成变量的初始化
表达式2：是值为boolean型的表达式，称为循环条件
表达式3：用来修正循环条件，改变循环条件
②while
一般格式：
while（循环的条件表达式）{
...........}
③do--whiile
一般格式：
do{
.........}while(循环条件的表达式);
注意：do--whiile  和while 循环语句的区别是：do--whiile至少被执行一次，因为判断循环条件是否成立的语句写在循环体的后面。
④控制语句：
Java中的控制语句有两种，即条件语句和switch开关语句
由if关键字声明的语句称为条件语句，格式一般为：
if(判断条件){
..........}
else if(判断条件){//如果有多种判断 则需要用到else if 语句
.........}
.............
else{
.........}
b.switch语句是多分枝的开关语句，其格式一般为：
switch（表达式）{
case 常量1：
若干语句
break;
case 常量2：
若干语句
break;
...........
case 常量n：
若干语句
break;
default:若干语句
}
注意：这里我们谈到了break关键字，它是结束循环的关键字，结束循环还有另一个关键字是：continue，那么它们的区别在哪儿呢？ break是终止循环，不再执行循环体，而continue是结束本次循环，进行下一次循环。
实例化对象、以及对方法、属性等修饰的关键字
a.实例化对象关键字：new
class people{
student stu=new student();//创建一个Student 的对象
stu.name="张三";//可以调用该类的共有属性，合法
stu.study();//可以调用该类的共有方法，合法
}
在这个例子中，我们可以看到通过关键字new 创建一个student的对象stu。
b.static、final、this、super、return
static：用static修饰的变量和方法称为 类变量和类方法
那么 它们与普通方法和普通变量有哪些不同呢？其实很简单，对于类变量，不同对象的实例变量将被分配不同的内存空间，但是类变量是共享一个空间，也就是说，改变其中一个对象的这个类变量，其他对象的这个类变量也就跟着改变了。而对于类方法和普通方法，普通方法是只有在该类创建对象后才会分配入口地址，而类方法在被加载到内存中时就分配了入口地址。
final.可以修饰类，成员变量和方法中的参数
修饰类：则该类不能被继承，不能有子类
修饰成员变量：则该成员变量就是一个常量，常量就必须赋初值，而且之后不能再发生改变
修饰方法：则该方法不能被重写
this.:this是指当前对象自己
当一个类中要明确指出使用对象自己的变量或函数时就要用到this关键字；比如：
public class Hello{
String s="hello";
public Hello(String s){
System.out.println("s="+s);
System.out,println("1-this.s="+this.s);
this.s=s;
System.out,println("2-this.s="+this.s);

public static void main(String[] args){
Hello h=new Hello("hello!")；
}
}
}运行结果是：
s=hello!
1-this.s=hello
2-this.s=hello!

Super:如果子类中定义的成员变量或者是方法与父类的变量名 方法一样的话，那么子类就隐藏了父类的方法，也就是这个时候如果用子类创建一个对象，对象会优先执行子类的方法和属性，而不是父类的。如果想要调用被隐藏的父类的方法，则需要super关键字了，格式是：
super.方法名（）;
另外一种情况：子类是不能继承父类的构造方法的，若要调用父类的构造方法，也要用到super关键字，格式是：super（x,y,....），注意：这里是直接super(),括号里直接写父类构造方法的参数值。
Return：当方法的类型为void时，则方法内不需要返回值，但是如果为八大基本类型或者其他引用类型，则需要在方法体内返回对应的类型值，格式为：return 参数名;
异常的关键字
所谓异常就是程序运行时可能出现的一些错误，这个时候就会抛出异常，异常处理会改变程序的控制流程
try----catch
Java使用try----catch处理异常时，将可能出现错误的操作放在try部分，当某个语句发生异常后，try部分会立即结束执行，而转向相对应的catch操作，所以程序发生异常后的处理是放在catch里面的。格式为：
try{
可能发生异常的语句}
catch(Exception1 e){
处理异常的操作}
catch(Exception2 e){
处理异常的操作}

throw和throws
在程序中，我们可以扩展异常类来定义自己的异常类，然后规定哪些方法产生这样的异常，这里声明要产生的异常需要用关键字throws，并在该方法中给出产生异常后的操作，并用关键字throw抛出该异常对象，导致该方法结束，catch就是用来捕获throw抛出的异常对象的。