JAVASE--05

异常

语法定义:

try {
    可能出现异常的代码片段
}catch(XXXException e){
        捕获try中出现的XXXException后的处理操作代码
}
    System.out.println("程序开始了");
    try {
        String string = "";
        System.out.println(string.length());
        System.out.println(string.charAt(0));
        /*
         * 在try中出错语句以下的代码都不会被执行
         */
        System.out.println("dfd");
    } catch (NullPointerException e) {
        System.out.println("出现了空指针");
    } catch (StringIndexOutOfBoundsException e) {
        System.out.println("字符串下标索引越界");
        /*
         * 应当有一个好习惯,在最后一个catch处捕获exception,防止未捕获的异常导致程序中断
         */
    } catch (Exception e){
        System.out.println("未知异常发生");
    }
    System.out.println("程序结束了");

finally块

finally块时定义在异常处理机制的最后一块.它可以直接跟在try之后或者最后一个catch之后.
finally可以保证只要程序执行到了try块当中,那么无论try块中的语句是否会抛出异常,finally都确保其内哦那个一定被执行.
* 通常会释放资源等操作放在finally中,如流的关闭操作.

try {
    String string = "";
    System.out.println(string.length());
    return ;
} catch (Exception e) {
    System.out.println("程序出错了");
}finally {
    System.out.println("finally块执行了");
}
标准流关闭
try {
    fos = new FileOutputStream("./demo./sf.dat");
    fos.write(1);
} catch (Exception e) {
    e.printStackTrace();
} finally {
    try {
        if(fos != null)
        fos.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

* JDK7后推出了一个新特性
* java 中实现了AotuClose接口的类,都可以被改特性自动关闭
try (FileOutputStream fos = new FileOutputStream("./demo/fos.dat");) {
    fos.write(1);
} catch (Exception e) {
    e.printStackTrace();
}

finally常见面试题

请说明:final,finally,finalize
finalize是Object定义的方法,该方法是被GC执行的额方法,当一个对象即将被GC释放前,GC会调用该方法.
调用该方法完意味着该对象即将被释放.
final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。内部类要访问局部变量，局部变量必须定义成final类型。
finally是异常处理语句结构的一部分，表示总是执行。
/*
 *System.out.println(test("0") + "," + test(null) + "," + test(""));//3,3,3
 */ 
public static int test(String str) {
    try {
        return str.charAt(0) - '0';
    } catch (NullPointerException e) {
        return 1;
    } catch (Exception e) {
        return 2;
    } finally {
        return 3;//返回值覆盖
    }
}
throw (new ...)& throws
Person:
/*
* 当一个方法使用throws声明一个异常的抛出时,那么调用这在调用该方法时就必须处理这个异常
*/
public void setAge(int age) throws Exception {
    if(age > 100 || age < 0) 
        /*
         * 当一个方法当中使用throw抛出什么异常,就要在方法上使用throws声明该异常的抛出,
         * 只有RuntimeException无需这样,其他类型异常则是必须的,否则编译不通过
         */
        throw new Exception("年龄不合法");
    this.age = age;
}
ThrowDemo:

/*
 * 通常一个方法抛出异常有两种情况throw
 * 1:方法当中遇到了满足语法要求,但是不满足业务逻辑需要
 * 2;方法中确实出现了异常,但是该异常不应该由该方法处理,会抛出给调用者解决
 */
try {
    /*
     * 当调用一个含有throws声明异常抛出的方法时,编译器提示必须处理该异常,处理的手段有
     * 两种:
     * 1:使用try...catch捕获并处理该异常
     * 2:继续在当前方法上使用throws声明并抛出异常
     */
    p.setAge(1000);
} catch (Exception e) {
    System.out.println("出错了");
}

子类重写父类含有throws声明异常抛出的方式和对throws的重写规则
重写的规则====>两同,两小,一大

public class ThrowsDemo {
public void dosome() throws IOException ,AWTException{}
}

class Son extends ThrowsDemo {

//  public void dosome() throws IOException, AWTException {} 抛出相同的异常√

//  public void dosome(){}  不抛出异常√

//  public void dosome() throws IOException{}  抛出父类的部分异常√

//  public void dosome() throws FileNotFoundException {}   抛出父类的异常的子类异常√

//  public void dosome() throws SQLException{}   不可以抛出额外异常×

//  public void dosome() throws Exception{}    不可以抛出比父类异常还大的异常×

}

e.printStackTrace();用于输出错误信息,有助于找到并解决错误

自定义异常

通常用来说明我们程序中的某个业务逻辑错误 因为java提供的 异常基本上没有描述实际项目中的业务错误, 这时我们可以自定义一个异常.

public class IllegalAgeException extends Exception {//:定义异常名称,见名知意
private static final long serialVersionUID = 1L;//添加版本号
/*添加构造方法*/
public IllegalAgeException() {
    super();
}

public IllegalAgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
    super(message, cause, enableSuppression, writableStackTrace);
}

public IllegalAgeException(String message, Throwable cause) {
    super(message, cause);
}

public IllegalAgeException(String message) {
    super(message);
}

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

网络编程

套接字Socket:

封装了TCP协议的通讯细节,让我们可以简单的使用它完成TCP通讯.
Socket链接后提供了两条流,通过两条流的读写操作完成与远端计算机的数据交换.
ServerSocket
 运行在服务端的ServerSocket主要有两个作用:
 1:向系统申请服务端口,客户端就是通过这个端口与服务端建立连接的.
 2:监听服务端口,一旦客户端与服务端建立连接,就会自动创建一个Socket,并通过该
 Socket与建立连接的客户端进行交互
客户端:

public class Client {
    /*
     * Socket套接字 
     * 封装了TCP协议的通讯细节,让我们可以简单的使用它完成TCP通讯 Socket链接
     * 后提供了两条流,通过两条流的读写操作完成与远端计算机的数据交换.
     */
    private Socket socket;

    /*
     * 用来初始化客户端
     */
    public Client() {
        try {//客户端连服务端,谁发起连接谁是客户端
            /*
             * 实例化Socket时需要传入两个参数:
             * 1:服务端的IP地址
             * 2:服务端的端口号
             * 通过IP地址可以找到服务端所在的计算机,通过端口可以找到运行在服务端
             * 的应用程序.
             * 注意:实例化Socket的过程就时连接的过程,若连接失败就会抛出异常
             */
            System.out.println("正在连接服务端...");
            socket = new Socket("localhost", 8088);//new的过程就是发起连接的过程
            System.out.println("与服务端连接成功!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /*
     * 客户端开始工作的方法
     */
    public void start() {
        try {
            /*
             * Socket提供的方法
             * OutputStream getOutputStream()
             * 该方法读取一个字节输出流,通过该流写出的数据会发送给远端计算机
             */
            OutputStream out = socket.getOutputStream();
            OutputStreamWriter osw = new OutputStreamWriter(out, "UTF-8");
            BufferedWriter bw = new BufferedWriter(osw);
            PrintWriter pw = new PrintWriter(bw,true);//聊天需要及时性

            pw.println("你好,服务端!");//必须使用println()方法===>br.readLine();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Client client = new Client();
        client.start();
    }
}

服务端:

package socket;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 聊天室服务端
 *
 * @author Mr.Huang
 * @date 2018年8月1日
 */
public class Server {
    /*
     * ServerSocket
     * 运行在服务端的ServerSocket主要有两个作用:
     * 1:向系统申请服务端口,客户端就是通过这个端口与服务端建立连接的.
     * 2:监听服务端口,一旦客户端与服务端建立连接,就会自动创建一个Socket,并通过该
     * Socket与建立连接的客户端进行交互
     */
    private ServerSocket serverSocket;

    /*
     * 用来初始化服务端
     */
    public Server(){
        try {
            /*
             * 实例化ServerSocket的同时深情服务端口
             */
            System.out.println("正在启动服务端...");
            serverSocket = new ServerSocket(8088);
            System.out.println("服务端启动完毕!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /*
     * 服务端开始工作的方法
     */
    public void start(){
        try {
            System.out.println("等待客户端连接...");
            Socket socket = serverSocket.accept();//阻塞方法
            System.out.println("与客户端连接成功!");
            /*
             * 接受客户端的输入
             * 通过Socket提供的方法:
             * InputStream getInputStream()
             * 读取该输入流的数据就是读取远端计算机发送过来的数据
             */
            InputStream is = socket.getInputStream();
            InputStreamReader isr = new InputStreamReader(is, "UTF-8");
            BufferedReader br = new BufferedReader(isr);

            String message = br.readLine();
            System.out.println("客户端说" + message);
            } catch (IOException e) {
                e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Server server = new Server();
        server.start();
    }
}