考试应对（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是利用多态性进行程序设计的核心技术之一
接口：
1 interface Printable{ 2 public final int MAX=100; 3 public abstract void add(); 4 public abstract float sum(float x,float y);} 5 class Exp implements Printable{ 6 public void add(){ 7 /*.....................*/} 8 public float sum(float x,float y){ 9 /*......................*/} 10 /*......................*/}
接口体中的所有方法都是抽象方法，所有量都是常量，public接口的所有访问权限都是public（即使成员的标识符不写也默认如此）
一个类如果想要实现接口，必须自己重写接口的所有方法，而且要标明public
如果interface前面没有标明public，则其仅提供包访问权限
父类实现的接口子类无需再写明（可直接使用）
接口回调：
1 interface ShowMessage{ 2 void display(String s);} 3 class TV implements showMessage{ 4 public void display(String s){ 5 System.out.println(s);} } 6 class PC implements showMessage{ 7 public void display(String s){ 8 System.out.print(s);} } 9 class Exp{ 10 public static void main(String[]args){ 11 ShowMessage sm; 12 sm=new TV(); 13 sm.display("TCL"); 14 sm=new PC(); 15 sm.display("Lenovo"); }
非常类似于upcasting，通过接口变量中存放对象的引用，使用对应类中重写的方法
内部类与异常类
内部类：与c++不同，Java允许在类的内部声明另一个类
内部类仅供其外嵌类使用
1）外嵌类的成员变量在内部类中仍然有效，内部类中的方法也可以调用外部类的方法
2）内部类中不能声明类变量和类方法，外嵌类可以使用内部类声明对象作为外嵌类中的成员
1 public class Outer{ 2 Inner inner; 3 public void showInner(){ 4 inner.speak();} 5 class Inner{ 6 void speak(){ 7 System.out.println("Inner.");} } } 8 class TestInner{ 9 public static void main(String[] args){ 10 Outer test=new Outer(); 11 test.showInner(); 12 test.inner.speak();}
内部类可以是static类（其他类不能是static）,这样程序可以在其他类中使用static内部类创建对象（static内部类不能调用外嵌类的成员变量）
1 public class Outer{ 2 Inner inner; 3 public void showInner(){ 4 inner.speak();} 5 static class Inner{ 6 void speak(){ 7 System.out.println("Inner.");} } } 8 class TestInner{ 9 public static void main(String[] args){ 10 Outer test=new Outer(); 11 test.showInner(); 12 test.inner.speak(); 13 Outer.Inner inclass=new Outer.Inner(); 14 inclass.speak();}
匿名类：就是一个没有名字的子类可以重写父类的方法，匿名类的类体中不能声明static成员变量和方法，直接使用父类的构造方法
1 abstract class Speak{ 2 void speakhello();} 3 class Student{ 4 void f(Speak sp){ 5 sp.speakhello();} } 6 class TestNoName{ 7 Speak spk=new Speak(){ 8 public void speakhello(){ 9 System.out.println("Hello.");} } 10 Student stu=new Student(); 11 stu.f(spk); 12 stu.f(new Speak(){ 13 public void speakhello(){ 14 System.out.println("Hello,I'm a student.");} } }
可以使用匿名类配合接口实现（与上面配合抽象类的情形一致）
异常类：
异常对象可以调用以下方法输出或得到异常信息：
public String getMessage();
public void printStackTrace();
public String toString();
try-catch语句：try中的语句一旦发生异常立即转到相应异常类型的catch语句，catch的参数是Exception类的某个子类（几个catch的参数不能有父子关系）
1 try{ 2 /*可能发生异常的语句*/} 3 catch(ExceptionSubClass1 e){ 4 /*..................*/} 5 catch(ExceptionSubClass2 e){ 6 /*..................*/} 7 /*.......................*/
自定义异常类：
1 public class IntegerException extends Exception{//设立自定义的Exception类的子类 2 String message; 3 public IntegerException(int m){ 4 message="年龄"+m+"不合理";} 5 public String toString(){//输出异常信息 6 return message;} } 7 class People{ 8 private age=1; 9 public void setAge(int Age)throws IntegerException{//在方法声明时使用throws关键字指出要产生的异常 10 if(age<=0||age>=130){ 11 throw new IntegerException(age);}//创建异常对象并使用throw关键字抛出异常对象，结束方法 12 else{ 13 this.age=age;} } 14 public int getAge(){ 15 System.out.println("年龄"+age+"合理"); 16 return age;} } 17 class TestException{ 18 public static void main(String[]args){ 19 People wang= new People(),zhang=new People(); 20 try{(wang.setAge(88);//在try-catch语句块中调用能产生异常的方法 21 System.out.println(wang.getAge());} 22 catch(IntegerException e){ 23 System.out.println(e.toString());} 24 try{zhang1.setAge(900); 25 System.out.println(zhang.getAge());} 26 catch(IntegerException e){ 27 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类型举例，其他类型相同原理：
1 int x; 2 String s="2352534"; 3 x=Integer.parseInt(s);//将String对象转换为int类型 4 5 int n=13513; 6 String str=String.valueOf(n);//将int对象转换为String类型 7 8 //使用Long类的以下方法获得整数的各种进制的字符串表示 9 Long num=23513; 10 String str2=Long.toBinaryString(num); 11 String str8=Long.toOctalString(num); 12 String str16=Long.toHexString(num); 13 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中
字符串与字节数组：
1 byte[ ]d="FuckingHell".getBytes();//将当前字符串转换为字节数组 2 try{ 3 byte[ ]d2="FuckingHell".getBytes("utf-8");//使用指定字符编码进行转换 4 } 5 catch(Exception exp){} 6 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类：
