权限修饰符,方法及异常了解一下

权限修饰符

private 修饰的函数或者成员变量，只能在类内部使用。

default(默认权限) 修饰类,成员变量,成员方法,构造方法都能使用默认权限,即不写任何关键字

protected 修饰成员变量,成员方法,构造方法,不能修饰类(外部类,内部类不考虑)，可以在类及其子类内使用。

public 修饰类,成员变量,成员方法,构造方法，可以被任意访问。

方法

1).定义方法的格式：

? 修饰符 返回值类型 方法名 (形参类型 变量名,形参类型 变量名,...,形参类型 变量名){
? }

? 1).修饰符：

? 2).返回值类型：如果方法内部工作后会产生一个结果，并要将这个结果返回给调用代码， 这时就需要声明返回值类型。

? 3).方法名：自定义；

? 4).形参类型 变量名：如果方法工作时，需要外部数据，这时就需要声明形参。 它可以从方法外部接收数据。一个方法可以有多个形参，而且形参类型可以不同，根据方法需要。

2).注意事项：

? 1).定义的位置：类体中，方法外；

? 2).如果一个方法定义了非void的返回值类型，那么此方法内部的任何一个代码分支必须要保证返回一个此类型的值，否则编译错误：

public static int show(){//编译错误,此方法没有保证所有分支都有返回值
	int a = 5;
	if( a == 5){
	return 1;
	}
}		

3).如果一个方法声明了返回值类型为void，那么这个方法绝对不能返回任何类型的值；
? 但可以写"return;"语句，表示结束方法的执行：

public static void show(){
	int a = 5;
	if( a == 5){
	return;//OK的。表示：结束方法的执行
	}
}

? return:表示结束方法；

? break:表示：跳出循环；

? 注意：return;后面不能紧跟其它代码，无法被执行，编译错误；

当我们需要定义方法时，要根据方法的功能，来明确两件事：

? 1).方法工作时是否需要外部数据-->形参

? 2).方法工作后，是否有结果需要返回给调用处-->返回值

方法重载和重写

重载:

1. 方法名一致，参数列表中参数的顺序，类型，个数不同。
2. 重载与方法的返回值无关，存在于父类和子类，同类中。
3. 可以抛出不同的异常，可以有不同修饰符

重写:

1. 参数列表必须完全与被重写方法的一致，返回类型必须完全与被重写方法的返回类型一致。
2. 构造方法不能被重写，声明为final的方法不能被重写，声明为static的方法不能被重写，但是能够被再次声明。 如果父类方法访问修饰符为 private 则子类不能重写该方法。
3. 访问权限不能比父类中被重写的方法的访问权限更低。
4. 重写的方法能够抛出任何非强制异常（UncheckedException，也叫非运行时异常），无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。

异常

异常的继承体系以及异常的分类

1.异常继承体系为：异常的根类是 java.lang.Throwable，其下有两个子类：java.lang.Error 与 java.util.Exception 。而Exception又分为编译时期异常：checked异常，与运行时期异常：runtime异常

2.请描述你对错误(Error)的理解
? Error:表示不可修复的恶性的错误，只能通过修改代码规避错误的产生，通常是系统级别的，所以很严重。
3.请描述你对异常(Expection的理解)

? Exception:表示可修复的良性（相对于错误）的异常，异常产生后程序员可以并且应该通过代码的方式纠正，使程序继续运行，是必须要处理的。

4.请描述你对运行时异常(RuntimeException)的理解
? 运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。

throw关键字手动抛出异常

如果不希望自动抛出异常，那么我们可以使用throw关键字手动抛出异常。

? throw的作用： 手动抛出一个异常对象。

? throw的格式：

? throw new 异常类名();

? 在创建异常对象的时候，可以在构造方法中给出异常信息。

throws关键字的使用

throw： 用来手动抛出一个异常。

? throws： 表示进行异常声明， 声明这个方法是有可能抛出异常的。

throws的使用格式：

    修饰符 返回值类型 方法名(参数列表) throws 异常类名{
        方法体;
    }

throws的使用的注意事项：

1. 如果一个方法内抛出了编译时异常， 那么则必须要使用throws进行异常声明
2. 如果调用了一个使用throws声明了异常的方法，那么调用者如果进行try...catch（等会说）， 那么也需要使用throws进行异常声明。
3. 如果方法内抛出运行时异常，那么无需使用throws进行声明。
4. 如果在一个方法内有可能抛出多个异常，那么我们需要进行多个异常的声明。
5. 如果在一个方法内有可能抛出多个异常，那么我们也可以直接声明这些异常的父类异常。

try...catch的使用

? 之前处理异常的方式都是甩锅， 把异常抛给调用者， 除了可以把异常抛给调用者之外，我们可以使用try...catch解决这个异常

try...catch： 表示捕获处理， 表示真正解决掉了这个异常。

try...catch格式：

    try {
        可能会出现问题的代码
    } catch(异常类名 变量名) {
        出现异常后执行的代码
    }

try...catch的执行流程

? 第一种情况： 如果try中的代码没有遇到问题， 那么代码会跳过catch继续往下执行。

? 第二种情况： 如果try中的代码出现了异常， 并且catch捕获到了这个异常，代码会从try直接执行到catch。

? 第三种情况： 如果try中的代码出现了异常，但是catch没有捕获到， 这个异常会依旧往外抛，抛给调用者。

小结：
异常处理有两种方式：

            1. 往外抛（甩锅）： throw, throws
            2. 决异常： try...catch

finally代码块

try...catch后面可以在追加一个finally，finally中的代码，无论如何都会执行。

格式：
    try {
        【A:可能会出现问题的代码】
    } catch (要捕获的异常类名 变量名) {
        【B:出现异常会执行的代码】
    } finally {
        【C: 一定会执行的代码】
    }

执行流程：

? 第一种情况： 如果try中的代码没有问题， 那么执行流程为【A】【C】

? 第二种情况： 如果try中的代码有异常，并且catch捕获到了这个异常， 那么执行流程为：【A】【B】【C】

? 第三种情况： 如果try中的代码有异常，但是catch没有捕获到这个异常，那么执行流程为：【A】【C】 抛出异常

finally中的代码一定会执行， 通常finally中的代码都用作资源回收（IO流中的关闭流， JDBC中的释放连接）

继承中方法重写的异常注意事项

继承关系中方法重写时异常的注意事项：

1. 如果父类方法没有抛出异常，那么子类重写该方法时也不能抛出异常, 如果该方法中有异常，只能try...catch
2. 如果父类方法抛出了异常， 那么子类重写该方法时，可以抛，也可以不抛. 如果抛， 那么要么抛出和父类方法相同的异常，要么抛出父类方法的子类异常。

上面的注意事项只适用于编译时异常。

多catch处理的注意事项

如果要使用try...catch语句捕获多个异常，那么可以在这个语句后面跟上多个catch

    try {
        可能会出现问题的代码
    } catch(要捕获的异常类 变量名) {
        出现该异常后的处理方式
    } catch(要捕获的异常类 变量名) {
        出现该异常后的处理方式
    } catch(要捕获的异常类 变量名) {
        出现该异常后的处理方式
    }

执行流程：

    1. 会先执行try中的代码。
    2. 如果try中的代码没有异常，那么所有的catch都不会执行。
    3. 如果try中的代码有异常，那么哪个catch先捕获到这个异常，那么就执行哪个catch中的语句。 剩下的catch就不再执行了

注意事项：如果使用catch捕获多个异常，那么父类异常不能放在子类异常的前面。

Throwable的常见方法

在Throwable中有一些方法可以获取到异常信息。

? void printStackTrace()： 将详细的异常信息进行输出。

? String getMessage()： 获取简单异常信息，并将该异常信息返回。

 try {
        可能会出现问题的代码
    } catch(要捕获的异常类 变量名) {
        出现该异常后的处理方式
        //调用printStackTrace输出异常信息  e.printStackTrace();
        //String getMessage()： 获取简单异常信息，并将该异常信息返回。      
    }

上面的方法不能直接创建对象，然后去调用，需要放在catch中去使用

try,catch,finally

　　异常处理中，try、catch、finally的执行顺序，大家都知道是按顺序执行的。如果try中没有异常，则顺序为try→finally，如果try中有异常，则顺序为try→catch→finally。

1、不管有没有出现异常，finally块中代码都会执行；

2、当try和catch中有return时，finally仍然会执行；

3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，不管finally中的代码怎么样，返回的值都不会改变，仍然是之前保存的值），所以函数返回值是在finally执行前确定的；

4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

权限修饰符,方法及异常了解一下

原文：https://www.cnblogs.com/JavaUrl/p/13910181.html