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中的内容)
原文：https://www.cnblogs.com/hfut-freshguy/p/11574786.html