/*
* 代理模式
*/
public class NetWorkTest {
public static void main(String[] args) {
Server server=new Server();
ProxyServer proxyServer = new ProxyServer(server);
proxyServer.browse();
}
}
interface NetWork{
public void browse();
}
//被代理类
class Server implements NetWork{
public void browse() {
System.out.println("真实的服务器访问网络");
}
}
//代理类
class ProxyServer implements NetWork{
private NetWork work;
//初始化
public ProxyServer(NetWork work) {
this.work=work;
}
public void check() {
System.out.println("联网之前的检查工作");
}
public void browse() {
check();
work.browse();
}
}
import java.util.Scanner;
/* java.lang.Throwable
* |-----java.lang.Error:一般不编写针对性的代码进行处理。
* |-----java.lang.Exception:可以进行异常的处理
* |------编译时异常(checked)
* |-----IOException
* |-----FileNotFoundException
* |-----ClassNotFoundException
* |------运行时异常(unchecked,RuntimeException)
* |-----NullPointerException
* |-----ArrayIndexOutOfBoundsException
* |-----ClassCastException
* |-----NumberFormatException
* |-----InputMismatchException
* |-----ArithmeticException
*/
public class ExceptionTest {
//ArithmeticException
@org.junit.Test
public void test6() {
int a=10;
int b=0;
System.out.println(a/b);
}
//InputMismatchException
@org.junit.Test
public void test5() {
Scanner scanner=new Scanner(System.in);
int score=scanner.nextInt();
System.out.println(score);
}
//NumberFormatException
@org.junit.Test
public void test4() {
String str="123";
str="abc";
int num=Integer.parseInt(str);
}
//ClassCastException
@org.junit.Test
public void test3() {
Object obj=new Object();
String str=(String)obj;
}
//ArrayIndexOutOfBoundsException
@org.junit.Test
public void test2() {
int[] arr=new int[10];
System.out.println(arr[10]);
}
//NullPointerException
@org.junit.Test
public void tste1() {
// int[] arr=null;
// System.out.println(arr[3]);
String str="abc";
str=null;
System.out.println(str.charAt(0));
}
}
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import org.junit.Test;
/*
* 一、异常的处理:抓抛模型
*
* 过程一:"抛":程序在正常执行的过程中,一旦出现异常,就会在异常代码处生成一个对应异常类的对象。
* 并将此对象抛出。一旦抛出对象以后,其后的代码就不再执行。
*
* 关于异常对象的产生:① 系统自动生成的异常对象
* ② 手动的生成一个异常对象,并抛出(throw)
*
* 过程二:"抓":可以理解为异常的处理方式:① try-catch-finally ② throws
*
*
* 二、try-catch-finally的使用
*
* try{
* //可能出现异常的代码
*
* }catch(异常类型1 变量名1){
* //处理异常的方式1
* }catch(异常类型2 变量名2){
* //处理异常的方式2
* }catch(异常类型3 变量名3){
* //处理异常的方式3
* }
* ....
* finally{
* //一定会执行的代码
* }
*
* 说明:
* 1. finally是可选的。
* 2. 使用try将可能出现异常代码包装起来,在执行过程中,一旦出现异常,就会生成一个对应异常类的对象,根据此对象
* 的类型,去catch中进行匹配
* 3. 一旦try中的异常对象匹配到某一个catch时,就进入catch中进行异常的处理。一旦处理完成,就跳出当前的
* try-catch结构(在没有写finally的情况)。继续执行其后的代码
* 4. catch中的异常类型如果没有子父类关系,则谁声明在上,谁声明在下无所谓。
* catch中的异常类型如果满足子父类关系,则要求子类一定声明在父类的上面。否则,报错
* 5. 常用的异常对象处理的方式: ① String getMessage() ② printStackTrace()
* 6. 在try结构中声明的变量,再出了try结构以后,就不能再被调用
* 7. try-catch-finally结构可以嵌套
*
* 体会1:使用try-catch-finally处理编译时异常,是得程序在编译时就不再报错,但是运行时仍可能报错。
* 相当于我们使用try-catch-finally将一个编译时可能出现的异常,延迟到运行时出现。
*
* 体会2:开发中,由于运行时异常比较常见,所以我们通常就不针对运行时异常编写try-catch-finally了。
* 针对于编译时异常,我们说一定要考虑异常的处理。
*/
public class ExceptionTest1 {
@Test
public void tets1() {
String str="123";
str="abc";
int num=0;
try {
num=Integer.parseInt(str);
}catch(NumberFormatException e) {
System.out.println("出现数值转换异常了");
}
}
}