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类: