charat越界返回什么_Java基本语法方法修饰符返回类型参数列表异常列表

方法[method name]

定义

方法[method]是类的成员之一，(因为在java中，方法不能单独定义，它必须在类之中)。

修饰符 返回类型 方法名()[throws 异常类型]{
 //方法体
}

方法名字：只要是一个合法的名字就可以，尽可能有意义。如：getName,nextInt...

调用

当被调用的方法使用static修饰符修饰时:

通过类名来调用，也就是：ClassName.methodName();如：

double d = Math.sqrt(4.5);
String istr = Integer.toBinaryString(8);

当被调用的方法没有使用static修饰符修饰时:

通过对象来调用，也就是：obj.methodName();如：

Scanner sc = new Scanner(System.in);
//此处的sc就是对象[变量]
int i = sc.nextInt();

注：在Java中，方法之间是没有顺序的。

/* this 当前对象 same class context 上下文一个静态方法不能直接调用非静态方法。所以要先创建对象。*/

重载

在一个类中，具有相同方法名称但不同参数的方法就构成了方法的重载。什么叫方法的重载？

参数个数不同
参数类型不同
参数顺序不同如：

public class Demo{
 public int add(int a,int b){return a+b;}
 public double add(double a,double b){return a+b;}
 public double add(int a,double b){return a+b;}
 public double add(double a,int b){return a+b;}
}

当调用重载方法时，JVM是根据参数列表来判断出准确的方法的。

递归[recursive]

递归就是指方法直接或间接地调用自己。利用递归可以用简单的程序来解决一些复杂的问题，比如：斐波那契数列的计算、汉诺塔问题、快排等问题。递归结构包括两个部分：

定义递归头。解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。
递归体。解答：什么时候需要调用自身方法。

如：求一个整数的阶乘。5! = 5*4!; 4! = 4*3!; 3! = 3*2!; 2! = 2*1!; 1! = 1;使用数学公式就可以表达为：f(n) = n*f(n-1);所以，递归要有2个条件，也就是上面说的递归结构的两个部分。一要有规律，二要有退出时机。

注：使用递归时方法的效率不是很高，它对栈的容量有较大的要求，因为每一次的调用都是利用栈来保存中间的计算结果，直到最后一次递归返回结果。如果栈不够的话，则JVM会抛出StackOverflowException。

/* 求阶乘方法 */
public static long factorial(int n){
 if(n==1){//递归头
  return 1L;
 }else{//递归体
  return factorial(n-1);//n! = n * (n-1)!
 }
}

/* 所有用递归可以实现的方法都可以使用非递归实现。 */
/* 非递归求阶乘方法 */
public static long factorialLoop(int n){
 long result = 1;
 while(n > 1){
  result *= n * (n-1);
  n -= 2;
 }
 return result;
}

/* 求整数的二进制字符串形式 */
public String toBinary(int n){
 if(n==0){//退出条件
  return "";
 }
 return toBinary(n/2)+n%2;
}

/* 汉诺塔问题 */
public void move(char a, char b, char c, int n) {
 //
 if(n == 1){
  System.out.println(a+" -> "+c);
 }
 //调用自己
 move(a, c, b, n-1);
 System.out.println(a + " -> "+c);
 //再调用自己
 move(b, a, c, n-1);
}

修饰符[modifier]

访问控制修饰符piblic ,prootected,默认,private其他修饰符 static,abstract,final,syschronized,native,volatile... 注：修饰符之间是不没有顺序的。在java中，针对类的成员访问限权有四种，分别对应四种修饰符。

	全局	子类	同包	本身
public	Y	Y	Y	Y
protected	N	Y	Y	Y
默认	N	N	Y	Y
private	N	N	N	Y

返回类型[return type]

1.所有合法的数据类型【包含基本数据类型和自定义对象】

表示这个方法有返回值，则在代码体中必须有return语句，并返回与表示这个方法有一致类型的。2.void表示这个方法没用返回值，则在代码体中可以不写return语句，如果一定要写，只能写空返回，如：return;。

参数列表[parameters]

参数列表就是局部变量【Local variable】，它的语法与变量一样，只是不能初始化。如有多个参数，则每个参数之间使用逗号隔开。

如：

public int add(int a,int b){
 //...
}

当这个参数被调用[invoke]之时，它的参数才会有值【传递进来】。

所以，对于参数，有两种叫法：形参，是在方法的定义时所叫，它只有类型，暂时无值。实参，实在方法的调用时所叫，它既有类型又有值。

异常列表

异常定义

java异常[exception]定义：是一种“信号”传递机制如：

int i = ...;
int j = ...;

if(i / j == ...) { //有可能会出现异常【除0异常】
 //...
}
//...

一段代码中，如果存在“有可能”出现异常的代码，而你的程序中又没有针对它做出“处理”，则一旦出现异常，程序就有可能会异常结束，从而达不到你的预期。

会有哪些异常？

java的异常可以分为：A. 运行时异常，也叫未检查异常；B. 非运行时异常,也叫已检查异常；

运行时异常，也叫未检查异常

所有直接或间接继承于RuntimeException异常的类都叫未检查异常，有：NullPointerException 空指针异常ClassCastException 类型转换异常ArrayIndexOutofBoundsException 下标越界异常 ... 以上这类异常都有一个共性：都是在JVM内部造成的，而不是由外部环境引起的。所以，这种异常可以说是由程序员编码粗心造成的。解决方案是：希望程序员编码谨慎，比如：对象使用之前做非空判断，....

非运行时异常,也叫已检查异常

它们直接或间接继承于Exception类，或者换句话说，只要不是RuntimeException的子类，就是已检查异常。如：IOException,SqlException,FileNotFoundException,NetException, ... 以上这些异常也有一些共性，就是它们都是由JVM外部环境造成的，所以，对于此类异常，光编码谨慎是不够的，还有做出处理。

注：在java中，对异常还有更高层次的抽象，叫可抛出的，由java.lang.Throwable来表示。

java.lang.Throwable
 \- java.lang.Error [错误] 无需处理它
 \- java.lang.Exception [异常] 重视
    \- RuntimeException 未检查异常
    \- 直接继承或间继承于 Exception 的类

如何处理异常？

有如下两种处理方式A. 消极处理方式，B. 积极处理方式。

消极处理方式

利用关键字 throws 把异常抛出。如：

public void ma() throws InterruptedException {
    Scanner sc = new Scanner(System.in);
    System.out.print("please enter int>");
    //
    int i = sc.nextInt(); //这个方法有可能会抛出异常的。
    //但是，由于是未检查异常，所以，可以不用处理。
    
    //...
    Thread.sleep(1000); //这个方法也是有可能会抛出异常的.
    //这个异常是已检查异常，所以，必需要做出处理
    //...
}

积极处理方式

利用 try catch finally 语句块来处理这个语句块有多种不同的变种。如：

try {
    //有可能出现异常的代码
    ...
} catch(异常类型 e) {
    //...做日志，或者可以恢复...
} catch (异常类型 e) {
    //...
}

还有：

try {
    //有可能出现异常的代码
    ...

} catch(异常类型 e) {
    //...做日志，或者可以恢复...
} finally {
    //... 一般做释放资源
}
//....

注：不管try块中的代码是否出现了异常，finally块总会执行，除非在try块中执行了 System.exit(1) //退出JVM 进程

还有：

try {
    //....
    ...
} finally {
    //...一般做释放资源
}

自定义异常类

自定义异常类一般是自定义已检查异常。只需要定义一个类继承 java.lang.Exception 类即可，并且重写父类的构造方法。

如：

public class BalanceNotEnoughException extends Exception {
    public BalanceNotEnoughException() { super(); }

    public BalanceNotEnoughException(String msg) { super(msg); }

    public BalanceNotEnoughException(Throwable cause) { super(cause); }

    public BalanceNotEnoughException(String msg,Throable cause){
        super(msg,cause);
    }
}