java 关键字

一.
  java的关键字共48种：
    1,基本类型值(3)：true,false,null.
    2,基本数据类型(8)：byte,boolean,short,char,int,long,float,double.
    3,控制语句(11)：
             循环(5)：for,do,while,break,continue.
   条件(6)：if,else,switch,case,default,return.
4,访问控制(3)：private,protected,public.
5,类，方法和变量修饰符(12)：abstract,class,extends,final,implements,
interface,native,new,static,synchronized,transient,
volatile.
6,错误处理(5)：catch,finally,throw,throws,try.
7,包相关(2)：import,package.
8,变量引用(3)：super,this,void.
9,其他(1)：instanceof

二.
  1.for(语句1;语句2;语句3){
  循环体;
    }
   ①先执行语句1.
   ②判断是否满足语句2，若不满足结束循环,若满足执行③.
   ③执行循环体,执行语句3,回到②.
 
  2.do{
       循环体;
    }
    while(条件语句);
    当条件语句为真时，执行循环体.
    while(条件语句){
               循环体；
    }
    当条件语句为真时执行循环体.
  do{ } while(); 与    while(){}的区别：
  do while 循环先执行一次循环体再判断条件语句是否为真
  while    循环先判断条件是否为真，若为真则执行循环体，为假不进行循环
  用do while,while 可以实现的循环判断均可用for循环实现，并且for循环的可读性,
    简洁性,在绝大多数情况下均优于以上两种循环,所以现在的代码中最多的循环语句为for循环
 
  3.if语句
   if(条件语句){
      语句1;
   }else{
   语句2;
   }
  首先判断条件语句是否为真,若为真,执行语句1;若为假,执行语句2.
  else语句可以省略,同时也可以有多个判断语句如：
  if(条件语句1){
  语句;
  }else if(条件语句2){
  语句;
  }
      .
      .
      .
  else if(条件语句3){
  语句;
  }
  4.switch 为多分枝语句
  基本格式为：
  int(char/byte/short) num = 值;
  switch(num){
    case 1: 语句1; break;
    case 2: 语句2; break;
    case 3:
    case 4:
    case 5: 语句3; break;
    default: 语句4;break(可要可不要);
  }
  switch语句的执行顺序为：
  判断num是否等于1;若等于执行语句1并跳出switch语句;
  判断num是否等于2;若等于执行语句2并跳出switch语句;
  判断num是否等于3或4或5;若等于执行语句3并跳出switch语句;
若num均不满足上边的条件执行语句4,并跳出switch语句 ;
  num 的值必须为int,char,byte,short
 
  5.continue,break与return
  continue 跳出当前迭代,执行下一个循环,即并不跳出该循环语句,只跳出该次循环.
  break跳出当前循环,即只跳出一条循环语句;break同时也用于switch语句跳出当前语句.
  return跳出多重循环,即跳出包含return的所有循环语句和if判断语句.
  6.private protected和public
  private(私有的) 可用于类,方法和变量;用private修饰的类,方法和变量只能在该类中引用
  protected(受保护的) 可用于类,方法和变量;用protected修饰的类,方法和变量只能在该类所在的包中引用
  public(共有的)  可用于类,方法和变量;可以在其他类和包中引用被public修饰的类,方法和属性
  7.interface
  定义接口的关键字
  接口是属性与方法的集合,接口用来规范一类事物的共性;接口中定义的均为抽象的方法
  继承接口的子类必须重写接口中的所有方法
  定义接口的格式：
  public interface Hello1{
    public String name;
    public void fight();//抽象方法
    public void run();
  }
  8.abstract
  定义抽象类的关键字
  抽象类中可以定义抽象方法和非抽象方法
  抽象类不能实例化对象,继承抽象类的子类可以重写父类中的所有抽象方法,也可以不重写,若不重写
  子类也必须定义为抽象类
  定义抽象类的格式：
  public abstract class Hello2{
    public void fight();//抽象方法
    public void fight2(){
   
    }//非抽象方法
  }
  9.class
  定义一般类的方法
  其格式为：
  public class Hello3{
   
  }
  一般类只可以继承一个一般的类和抽象类,但可以继承多个接口
  继承的格式为：
  public class Hello4 extends Hello3{//继承一般类的方法
 
  }
  public class Hello4 implements Hello1,Manager...{//继承接口的方法
 
  }
  public class Hello4 extends Hello3{//继承抽象类的方法
 
  }
  10.new
  实例化对象时应用
  如：有一个Panel类,实例化其对象：
  Panel panel = new Panel();

  11.final(最终的)
  用final修饰类,则该类不可被继承,但其中的方法别的类可以使用,可参见java.lang.String的使用方法
  用final修饰的方法,则该方法不可被重写 
  用final修饰常量,该常量只能被赋值一次不可再进行赋值,如：final int NUM = 16;则NUM不可再进行赋值
  用final修饰变量,此时final象C中的指针常量,即final所修饰的变量存的属性可以改变,但不可将另一个对象
  赋予该变量,即该对象存储的内容可以改变,但不能使该对象再次实例化.
  如：
  public class Value{
    int a=10;
  }
  public class Hello{
    final Va = new final();
  }
  public void main(String [] args){
    Hello hello = new Hello();
    hello.va = new Value(); //错,不能重新实例化final修饰的对象
  }
  12.static(静态的)
  用static修饰的变量为全局变量,即该变量只在内存中存在一份,当在一个类中改变它时该变量的值均被改变
  如：
  public class Panel extends JPanel{
  public static Color a = Color.RED;
  :
  :
  }
  public class Panel2 extends JPanel{
  Panel panel = new Panel();
  panel.a = Color.BLUE;
  }
  则Panel类中的a变量的值也被改变
  13.super
  继承父类的属性,方法
  super.value;//访问父类中的变量
  super.fight();//调用父类中的方法
  super.(参数);//调用父类中的构造方法
  14.this.
  指代当期的类,可以调用该类中的方法及所继承的父类的方法
  public class GameFrame extends JFrame{
  this.setSize(100,100,100);
  }
  15.
  try-catch-finally 异常处理
  try{
  可能引发异常的块;
  }catch(java.lang.Exception 或其子类){
  处理异常的代码;
  }finally{
  有无异常均执行的语句;
  }
  16.不常用的关键字：
  synchronized 线程同步
  transient 短暂的
  volatile 易失的
  native 本地
  throw 抛出一个异常对象
  throws 声明一个异常可能被抛出