Java考试重点合肥工业大学_考试应对（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 interfacePrintable{2 public final int MAX=100;3 public abstract voidadd();4 public abstract float sum(float x,floaty);}5 class Exp implementsPrintable{6 public voidadd(){7 /*.....................*/}8 public float sum(float x,floaty){9 /*......................*/}10 /*......................*/}

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

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

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

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

接口回调：

1 interfaceShowMessage{2 voiddisplay(String s);}3 class TV implementsshowMessage{4 public voiddisplay(String s){5 System.out.println(s);} }6 class PC implementsshowMessage{7 public voiddisplay(String s){8 System.out.print(s);} }9 classExp{10 public static voidmain(String[]args){11 ShowMessage sm;12 sm=newTV();13 sm.display("TCL");14 sm=newPC();15 sm.display("Lenovo"); }

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

内部类与异常类

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

内部类仅供其外嵌类使用

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

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

1 public classOuter{2 Inner inner;3 public voidshowInner(){4 inner.speak();}5 classInner{6 voidspeak(){7 System.out.println("Inner.");} } }8 classTestInner{9 public static voidmain(String[] args){10 Outer test=newOuter();11 test.showInner();12 test.inner.speak();}

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

1 public classOuter{2 Inner inner;3 public voidshowInner(){4 inner.speak();}5 static classInner{6 voidspeak(){7 System.out.println("Inner.");} } }8 classTestInner{9 public static voidmain(String[] args){10 Outer test=newOuter();11 test.showInner();12 test.inner.speak();13 Outer.Inner inclass=newOuter.Inner();14 inclass.speak();}

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

1 abstract classSpeak{2 voidspeakhello();}3 classStudent{4 voidf(Speak sp){5 sp.speakhello();} }6 classTestNoName{7 Speak spk=newSpeak(){8 public voidspeakhello(){9 System.out.println("Hello.");} }10 Student stu=newStudent();11 stu.f(spk);12 stu.f(newSpeak(){13 public voidspeakhello(){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(intm){4 message="年龄"+m+"不合理";}5 public String toString(){//输出异常信息

6 returnmessage;} }7 classPeople{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 intgetAge(){15 System.out.println("年龄"+age+"合理");16 returnage;} }17 classTestException{18 public static voidmain(String[]args){19 People wang= new People(),zhang=newPeople();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负值,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 intx;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类：