考试应对（Java语法速览）

1.从命令行输入数据

　　格式：Scanner reader=new Scanner(System.in);

　　此reader对象可以使用的方法：nextBoolean(),nextByte(),nextShort(),nextInt(),nextLong(),nextFloat(),nextDouble().

　　例如:   double x=reader.nextDouble();这样就通过键盘输入了一个double值，赋予x

2.数组

　　格式：初始化：int arrInt[ ][ ]=new int[10][10];(可以使用列表初始化，和c++没差)

　　int len=arrInt.length;(赋予len值为10)

　　复制数组:

　　　　1）arraycopy方法：System.arraycopy(sourceArray,int index1,copyArray,int index2,int length);

　　　　这里将sourceArray从索引index1开始的length个元素的值赋给copyArray(copyArray从index2开始接收这些数据）

　　　　2）copyOf方法：例如：int [ ] b=Arrays.copyOf(arrInt,10);这里将arrInt的前10个元素赋值给新数组

　　　　3）copyOfRange方法：例如：int[ ] c=Arrays.copyOfRange(arrInt,2,5);这里将arrInt从索引2开始到4的元素赋值给新数组，新数组长度为3

　　数组元素排序：

　　　　例如:Arrays.sort(arrInt);将数组arrInt中所有元素按升序排序

　　　　　　 Arrays.sort(arrInt,2,5);将数组arrInt从索引2到4的元素按升序排序

　　二分查找：int index=Arrays.binarySearch(arrInt,100);使用二分查找法查找arrInt中值为100的元素，返回该元素的索引（若没有则返回负值）

继承与接口

　　super关键字：

　　　　使用super调用父类的构造方法：必须使用在子类的构造方法的第一条语句，super（parameters);使用super（）调用父类不带参数的构造方法

　　　　也可以使用super调用被子类隐藏的成员或者方法：super.member;　　super.method(parameters);

　　final关键字：

　　　　final类不能被继承和拥有子类；

　　　　final方法不能被子类重写；

　　　　final变量即为常量。

　　向上转型对象（upcasting）:

　　　　Tiger tiger = new Animal ();（子类对象放到父类对象中，反之不可）

　　　　失去了子类新增的成员变量和方法，但是可以访问被子类继承或者隐藏的父类成员和方法（如果方法已被重写则使用的是重写的方法）

　　多态性：

　　　　父类的某个方法被子类重写时可以产生自己的功能行为

　　abstract类和方法：（抽象）

　　　　abstract class Abs{

　　　　　　/*.............................*/

　　　　　　abstract int min(int x,int y);}

　　　　抽象类允许声明抽象方法（没有函数体），当然在抽象类中也可以有普通的方法（如果抽象类中没有抽象方法也可以），不允许使用new创建抽象类的对象

　　　　对abstract类使用upcasting是利用多态性进行程序设计的核心技术之一

　　接口：

　　　　

 interface Printable{
     public final int MAX=100;
     public abstract void add();
     public abstract float sum(float x,float y);}
 class Exp implements Printable{
     public void add(){
         /*.....................*/}
     public float sum(float x,float y){
         /*......................*/}
         /*......................*/}

　　　　接口体中的所有方法都是抽象方法，所有量都是常量，public接口的所有访问权限都是public（即使成员的标识符不写也默认如此）

　　　　一个类如果想要实现接口，必须自己重写接口的所有方法，而且要标明public

　　　　如果interface前面没有标明public，则其仅提供包访问权限

　　　　父类实现的接口子类无需再写明（可直接使用）

　　　　接口回调：

 interface ShowMessage{
     void display(String s);}
 class TV implements showMessage{
     public void display(String s){
         System.out.println(s);}    }
 class PC implements showMessage{
     public void display(String s){
         System.out.print(s);} }
 class Exp{
     public static void main(String[]args){
         ShowMessage sm;
         sm=new TV();
         sm.display("TCL");
         sm=new PC();
         sm.display("Lenovo");    }

　　　　　　非常类似于upcasting，通过接口变量中存放对象的引用，使用对应类中重写的方法

内部类与异常类

　　内部类：与c++不同，Java允许在类的内部声明另一个类

　　　　内部类仅供其外嵌类使用

　　　　1）外嵌类的成员变量在内部类中仍然有效，内部类中的方法也可以调用外部类的方法

　　　　2）内部类中不能声明类变量和类方法，外嵌类可以使用内部类声明对象作为外嵌类中的成员

 public class Outer{
     Inner inner;
     public void showInner(){
         inner.speak();}
     class Inner{
         void speak(){
             System.out.println("Inner.");}    }    }
 class TestInner{
     public static void main(String[] args){
         Outer test=new Outer();
         test.showInner();
         test.inner.speak();}

　　　　内部类可以是static类（其他类不能是static）,这样程序可以在其他类中使用static内部类创建对象（static内部类不能调用外嵌类的成员变量）

 public class Outer{
     Inner inner;
     public void showInner(){
         inner.speak();}
     static class Inner{
         void speak(){
             System.out.println("Inner.");}    }    }
 class TestInner{
     public static void main(String[] args){
         Outer test=new Outer();
         test.showInner();
         test.inner.speak();
                 Outer.Inner inclass=new Outer.Inner();
                 inclass.speak();}

　　匿名类：就是一个没有名字的子类可以重写父类的方法，匿名类的类体中不能声明static成员变量和方法，直接使用父类的构造方法

 abstract class Speak{
     void speakhello();}
 class Student{
     void f(Speak sp){
         sp.speakhello();}    }
 class TestNoName{
     Speak spk=new Speak(){
         public void speakhello(){
             System.out.println("Hello.");}    }
     Student stu=new Student();
     stu.f(spk);
     stu.f(new Speak(){
         public void speakhello(){
             System.out.println("Hello,I'm a student.");}    }    }

　　　　可以使用匿名类配合接口实现（与上面配合抽象类的情形一致）

　　异常类：

　　　　异常对象可以调用以下方法输出或得到异常信息：

　　　　　　public String getMessage();

　　　　　　public void printStackTrace();

　　　　　　public String toString();

　　　　try-catch语句：try中的语句一旦发生异常立即转到相应异常类型的catch语句，catch的参数是Exception类的某个子类（几个catch的参数不能有父子关系）

 try{
     /*可能发生异常的语句*/}
 catch(ExceptionSubClass1 e){
     /*..................*/}
 catch(ExceptionSubClass2 e){
     /*..................*/}
 /*.......................*/

　　　　自定义异常类：

 public class IntegerException extends Exception{//设立自定义的Exception类的子类
     String message;
     public IntegerException(int m){
         message="年龄"+m+"不合理";}
     public String toString(){//输出异常信息
         return message;}    }
 class People{
     private age=1;
     public void setAge(int Age)throws IntegerException{//在方法声明时使用throws关键字指出要产生的异常
         if(age<=0||age>=130){
             throw new IntegerException(age);}//创建异常对象并使用throw关键字抛出异常对象，结束方法
         else{
             this.age=age;}    }
     public int getAge(){
         System.out.println("年龄"+age+"合理");
         return age;}    }
 class TestException{
     public static void main(String[]args){
         People wang= new People(),zhang=new People();
         try{(wang.setAge(88);//在try-catch语句块中调用能产生异常的方法
         System.out.println(wang.getAge());}
         catch(IntegerException e){
             System.out.println(e.toString());}
         try{zhang1.setAge(900);
             System.out.println(zhang.getAge());}
         catch(IntegerException e){
             System.out.println(e.toString());}    }    }

　　finally子语句：

　　　　try{}

　　　　catch(ExceptionSubClass e){}

　　　　finally{sentence}

　　　　不管try-catch部分是否异常，都将执行finally中的语句（除非try-catch语句中有程序退出代码）

　　断言语句assert：

　　　　格式:assert booleanExpression；或者 assert booleanExpression:messageException;(其中messageExpression是值为String的表达式,如果booleanExpression==false,输出messageExpression中的内容)，Java 默认关闭断言语句，欲开启则使用-ea语句：java -ea className

常用实用类　

　　String类：（String类是final类，故不能写该类的子类）　

　　　构造方法：String s=new String("This is a String");或String anotherStr=new String(s);

　　　　　可以用字符数组构造String：char[ ]a={'a','s','s'};　　String str=new String(a);(等效于：String str=new String("ass");)

　　　　　可以提取字符数组的一部分构造String: char[ ] b={'a','s','s','h','o','l','e'}; String shit = new String(b,3,4);(等效于 String shit = new String("hole");)从索引3开始的4个元素

　　　　　可以用字符串常量构造String：String str = "holy";

　　　常用方法：

　　　　　str.length();获取字符串str的长度

　　　　　str1.equals(str2);判断str1和str2的值是否相同（忽略大小写），返回boolean

　　　　　str.startsWith(String s1); str.endsWith(String s2);判断str的前缀是否为s1，后缀是否为s2，返回boolean

　　　　　str.regionMatches(boolean b,int firstStart, String other, int otherStart,int length);

　　　　　　从str的firstStart索引开始的长度为length的子串和otherString的从otherStart开始的长度同为length的子串进行比较，boolean b如果为true则忽略大小写

　　　　　str.compareTo(String s);按字典序比较str和s的大小，str==s->0,str<s->负值,str>s->正值

　　　　　str.compareToIgnoreCase(String s);与上式一样，只不过忽略大小写

　　　　　str.contains(String s);判断str是否包含s,返回boolean

　　　　　str.indexOf(String s);返回str中首次出现s的位置，如果没出现s则返回-1

　　　　　str.substring(int startpoint);获得str从索引startpoint开始到结尾的一个字串

　　　　　str.trim();得到去掉前后空格的str

　　　String和基本数据的相互转化：

　　　　　这里仅以int类型举例，其他类型相同原理：

 int x;
 String s="2352534";
 x=Integer.parseInt(s);//将String对象转换为int类型

 int n=13513;
 String str=String.valueOf(n);//将int对象转换为String类型

 //使用Long类的以下方法获得整数的各种进制的字符串表示
 Long num=23513;
 String str2=Long.toBinaryString(num);
 String str8=Long.toOctalString(num);
 String str16=Long.toHexString(num);
 String strP=Long.toString(num,int p);//返回整数的p进制表示

　　　对象的字符串表示：toString方法  返回形式：对象的类名@对象的引用的字符串表示，toString方法可以在该类中重写：

　　　　public string toString(){

　　　　　　return "what you wanna express";}

　　　将字符串赋值给字符数组：

　　　　　str.getChars(int start,int end,char ch[ ],int offset);将str从索引start到end-1的部分赋值给ch，ch从索引offset处开始存放这些字符

　　　　　char[ ] c = str.toCharArray();将str的全部字符存放在c中

　　　字符串与字节数组：

 byte[ ]d="FuckingHell".getBytes();//将当前字符串转换为字节数组
 try{
 byte[ ]d2="FuckingHell".getBytes("utf-8");//使用指定字符编码进行转换
 }
 catch(Exception exp){}
 String s=new String(d,7,4);//将字节数组d从索引7开始的4个字节构造字符串对象

　　　　正则表达式：（具体详见java.util.regex包中的Pattern类）

　　　　　　str.matches(String regex);判断str是否与regex指定的正则表达式匹配，返回boolean

　　　　　　String result = str.replaceAll(String regex, String replacement);

　　　　　　　　将str中所有与regex指定的正则表达式匹配的部分替换为replacement，返回新的字符串，但是str的值不变

　　　　　　String afterSplitWord[ ]=str.split(String regex);将regex作为分隔标记，将str不满足regex指定的正则表达式的部分作为单词储存在字符串数组中

　　StringBuffer类：与String类不同，StringBuffer类能创建可以修改的字符串序列

　　　　例如：StringBuffer sb = new StringBuffer("我喜欢");

　　　　　　　sb.append("吃饭");//这样sb就由“我喜欢”变成了“我喜欢吃饭”，append方法中的参数除了String类型也可以是其他类型

　　　　　　　sb.charAt(int n);//得到索引n位置上的字符

　　　　　　　sb.setCharAt(int n,char ch);//将索引n上的字符设置为ch

　　　　　　　sb.insert(int index,String str);//将str制定的字符串插入到索引index的位置（返回当前对象的引用）

　　　　　　　sb.reverse();//将当前对象的字符翻转

　　　　　　　sb.delete(int startIndex,int endIndex);//删除当前对象从索引startIndex到endIndex-1的子串（返回当前对象的引用）

　　　　　　　sb.deleteCharAt(int index);//删除索引index处的字符

　　　　　　　sb.replace(int startIndex,int endIndex,String str);//从索引startIndex到endIndex-1的字串替换为str指定的字符串（返回当前对象的引用）

　　StringTokenizer类:

　　　　与split方法不同的是，StringTokenizer类不以正则表达式作为分解标志

　　　　例如：StringTokenizer(String s);//使用默认的分割标记

　　　　　　　StringTokenizer(String s,String delim);//使用delim中字符的任意组合作为分隔标记

　　Scanner类：