JavaBasic_12

类

抽象：对象的共性

类：产生对象的模板（对于属性来讲，类规定有没有属性以及属性类型，具体的属性值因对象的不同而不同）

数据类型：数据集及基于这个数据集的操作

类：我们自定义类型（定义成员变量，基于数据集的成员方法）

对象：一个类的实例，利用模板创建出来的一个具体的实例。

同一类型的对象，同时存在多个，这多个对象区别，在于属性值

---

可变参数列表：形式参数，个数可以在声明方法的时候不确定

语法格式:(int...args) ...代表可变参数，形式参数的不确定

好处：

1.可变参数使我们的方法具有更强的灵活性，参数个数不定

2.在发生方法重载的时候，可变参数的优先级较低（低于具有确定参数列表的方法）

3.可变参数只能位于，方法形式参数列表的最后一个（参数列表中只能有一个可变变量）

4.jvm将可变参数当做，相应类型的数组来处理，所以，可变参数不能与相同数据类型的数组重载

5.在方法体中，我们可以直接将可变参数当做数组来用

6.当不传参数的时候，可变参数是一个包含0个元素的数组

public class Supplement02 {

    public static void main(String[] args) {
               //1个参数
        //testVariable(1);

        //多个参数
        //testVariable(1,2);
        //testVariable(1,2,3,4,5,6);

        //不传参数
        testVariable();
    }

//    可变参数的语法限制，只能位于参数列表的最后
//    public  static void testVariable(int... args, double... b) {
//
//        System.out.println("call  testVariable(int... args)");
//
//    }

//    public static void testVariable() {
//        System.out.println("test Varaibale()");
//    }

    public void testVariable(int i) {
    }
//
//
    public void testVariable(int i, int j) {
    }

//    相同数据类型的数组，不能与可变参数发生重载
//    public void testVariable(int[] a) {
//
//    }

    public static void testVariable(int... a) {
        System.out.println(a.length);
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
        System.out.println("test Varaibale()");
    }

}

其实每一种基本恩数据类型，都对应者和它对应的一个包装类：

int Interger

byte Byte

short Short

boolean Boolean

char Character

基本数据类型的装箱

包装类型的拆箱

对数组类型的引用不存在装箱和拆箱

public class Supplement03 {
    public static void main(String[] args) {

        //装箱  基本数据类型的变量直接赋值给一个包装类型的变量
        Integer i = 10;

        //jvm内部如何运行
        Integer integer = new Integer(10);
        i = integer;

        //拆箱  包装类对象直接赋值给基本数据类型的变量
        int j = new Integer(100);

//        char的包装类型是Character
//        Char c = 'a';
          Character c = 'a';

          int[] a = new int[10];
          //对于数组类型的 引用 不存在装箱和拆箱
          //Integer[] b = a;

          a[0] = new Integer(10);

          //“1122”
        int intValue = Integer.valueOf("1122");
        System.out.println(intValue);

        String s = Integer.toHexString(intValue);
        System.out.println(s);

    }
}

异常

---

异常：异常就是Java程序运行过程中出现的错误（通常有不同的程度），或者说不正常的情况。

我们Java语言中的异常对象：其实就是Java对不正常情况进行描述后的对象体现

常见异常：数组越界异常， 空指针异常

Throwable:按照不正常情况的“严重程度”来划分

Exception:虽然是不正常情况，但是这种不正常情况，还不算致命，我们自己（应用程序）仍然有可能解决

Error:描述的不正常情况，其程度非常严重，我自己（我们自己的程序）已经无法解决。stackoverFlow outOfMemmoryError

Exception:

RuntimeException：不太好，在程序运行之前预见的

                （在程序运行时，满足某些特殊的条件，才会发生异常）

CheckableException：可以在，异常发生之前，可轻易预见一些很容易出现的异常情况。通常，在程序运行之前做一些有些预见性的处理

当发生异常的时候，虚拟机的默认处理

1.从异常发生初，我们的代码被一分为二，在异常发生之前的代码，全部都已经执行

2.不执行我们异常之后的代码，捕获当前发生的异常，并且将当前发生的异常情况相关信息，封装成对象

3.将异常相关的信息全部输出到屏幕

4.输出完毕，jvm停止运行

开发者，开发者可以通过try-catch语句，当异常发生的时候，自己处理异常。

当我们使用了try-catch语句，虚拟机就不会再帮我们做默认异常处理

当我们使用try-catech代码块来处理异常的时候：

1.首先，jvm不再执行默认的异常操作

2.我们的程序，不再被一分为2（一部分执行，一部分不执行）

3.我们可以通过try-catch代码块，来对发生的异常情况做处理

我们需要知道的是，从异常发生，到异常处理的过程

1.当在try-catch语句中发生了异常的时候，首先，jvm捕获到异常，仍然将该异常的相关信息封装成异常对象

2.当构造异常对象之后，利用异常对象，通过catch语句，来将异常对象传递给我们的程序，怎么通过catch语句传递给我们的呢？通过catch代码块中参数的形式，将异常对象传递给我们

3.catch之后的语句，继续正常执行(jvm认为我们已经在catch，作了相应的异常处理)

public class ExeptionDemo2 {

    public static void main(String[] args) {
        int i = 100;

        int j = 1;

        //在此处发生除零异常

        //当发生除零异常的时候： 结果：发生了除0异常
        //                         异常已经发生过了

        //当没有发生除零异常的时候，结果 异常已经发生过了
        try {
            int k = i / j;
        } catch(Exception e) {
            // 当异常发生的时候，会执行catch代码块当中的内容
            // 在catch代码块中，我们的应用程序就有机会，来处理当前发生的异常情况
            System.out.println("发生了除0异常");
        }

        //当有了try-catch语句之后，即使在try代码块中发生了异常，我们在try-catch代码块之后的程序
        // 仍然可以正常运行
        System.out.println("异常已经发生过了");
    }
}

当发生多个异常的时候：

第一种处理多个异常的方式:一个try块，对应多个catch分支

try-catch成对出现：catch 代码块只处理相应try代码块出现的异常

Throwable类是Java语言中所有错误或异常的超类

只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型

Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。

Error 是 Throwable 的子类，用于指示合理的应用程序不应该试图捕获的严重问题

在Exception的子类中，除了RuntimeException的其他所有直接子类的，都统称为编译时异常或者checkableException(不是一个类型，只是一个统称)

当try-catch多个异常的时候的执行流程：

1.当try块中的某条语句发生异常的时候，jvm捕获正在发生的异常，将异常的相关信息封装成一个异常对象

2.得到异常对象之后，jvm终止同一try块中发生异常位置之后的，代码的正常执行

3.转而开始，跳转到catch代码块的执行，其执行流程是，按照catch代码块的书写顺序，依次匹配，匹配实际发生异常的类型和catch代码块中声明的捕获的异常类型

4.当发现，实际发生的异常类型与某catch代码块中声明的捕获的异常类型，兼容的时候，就开始进入catch代码块，执行该catch代码块中的代码

5.catch分之，jvm同时只会匹配一个

6.当try块中发生的异常，在我们的多个catch代码块，没有任何一个catch代码块声明的异常类型与之匹配（我们开发者并未处理该种类型异常），此时jvm又会执行默认的异常处理流程。

第二种处理异常的方式：

每一个异常用专门的try-catch代码块来处理

捕获多个异常的情况：

如果有多个catch语句，则没有继承关系的异常前后顺序无所谓

但是如果出现了继承关系的异常，则子必须在父之前

public class ExceptionDemo3 {

    public static void main(String[] args) {
        //第一种处理多个异常的方式
        try{
            //除0异常
            //int i = 9 / 0;
            System.out.println("/ by 0");

            //数组越界异常
            int[] a = new int[10];
            //System.out.println(a[10]);
            //System.out.println("array index outoutbounds");

            //空指针异常
            a = null;
            System.out.println(a[0]);
            System.out.println("null pointer");
        } catch (ArithmeticException e) {
            System.out.println("发生了除零异常");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("发生数组越界异常");
        } catch (Exception e) { // Exception 是所有异常的父类兼容所有子类类型的异常
            //通常该catch分支，用来捕获代码中隐藏的（开发者没有考虑到的异常类型）
        }

        //第二种处理异常的方式，是：
        //除0异常
        try {
            int i = 9 / 0;
            System.out.println("/ by 0");
        }catch (ArithmeticException e) {
            System.out.println("第二种方式ArithmeticException");
        }

        //数组越界异常
        //这个时候要注意作用域了： int[] a
        int[] a = new int[10];
        try{
            System.out.println(a[10]);
            System.out.println("array index outoutbounds");
        }catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("第二种方式ArrayIndexOutOfBoundsException");
        }

        //空指针异常
        try{
            a = null;
            System.out.println(a[0]);
            System.out.println("null pointer");

        }catch (NullPointerException e) {
            System.out.println("第二种方式 NullPointerException");
        }

    }

}

jdk1.7异常新特性

try{

}

catch(exception | exception |...){

//表明该异常分之可以处理多个异常类型

}

//假设，对于数组越界异常和空指针异常，处理这两种异常的操作完全相同。

如果使用jdk7的新特性就可以少写重复的代码

public class ExceptionDemo4 {

    public static void main(String[] args) {

        try {
            int i = 9 / 0;
            System.out.println("/ by 0");

            //数组越界异常
            int[] a = new int[10];
            //System.out.println(a[10]);
            //System.out.println("array index outoutbounds");

            //空指针异常
            a = null;
            System.out.println(a[0]);
            System.out.println("null pointer");

        }catch (ArrayIndexOutOfBoundsException | NullPointerException e) {

            //在这里写一些处理数组异常的代码  a

        }catch (ArithmeticException e) {
            //处理除0异常     b
        }
        int  j = 100 / 0;
    }
}

编译时异常

必须在编译前处理，否则无法通过编译（类比于我上班的时候忘记带钥匙的情况）

public class CheckableException {

    public static void main(String[] args) {

        //简单时间格式类对象 用表征时间格式的字符串（"yyyy-MM-dd HH:mm:ss"），来初始化一个简单时间格式类对象
        //这个对象，可以帮助我们，根据一个表示时间的字符串，来创建一个相应的时间类

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //编译时异常
        try {
            Date parseDate = format.parse("2010-1-01 00:01:02");
            System.out.println(parseDate.getTime());
            System.out.println(parseDate.getYear());
            System.out.println(parseDate.getMonth());
            System.out.println(parseDate.toString());
        } catch (ParseException e) {
            System.out.println("发生了编译时异常");
        }

        //运行时异常
        int i = 0 / 0;

    }
}

throws关键字

---

对于可能发生可检查异常（编译时异常）的方法或构造函数，

可以在 方法头部分 使用throws语句声明可能可发生的 异常列表

之前所讲的所有异常处理方式，都是通过try-catch语句自己处理异常，在哪里处理呢？

在异常发生的地方处理

//异常处理的第二种方式：抛出异常（挡在异常发生的地方，不知道该如何处理该异常）

异常列表可以包括一个或多个异常类处(异常发生的上层)，对于运行时异常，如果在方法调用处不做任何处理，这个运行时异常会继续向上抛出，知道抛出main方法，这就意味着我们最终如果一直没人处理的话，这个异常就会抛给jvm

异常抛出的时候，会抛出到方法调用

throw关键字

---

throw关键字，可以让我们自己抛出异常

在方法体中可以通过throw语句抛出异常

throw 如果抛出的异常对象属于可检查的异常，则必须与方法的异常列表

public class Throws {

    public static void main(String[] args) {

        //页面1调用解析时间的方法
        String  page1Time = null;
        try {
             page1Time = parseTime("2010");
        } catch (ParseException e) {
            page1Time = "--:--:--";
        }

        System.out.println(page1Time);

        //页面2调用解析时间的方法
        String  page2Time = null;
        try {
            page2Time = parseTime("2011");
        } catch (ParseException e) {
            page2Time = "";
        }
        System.out.println(page2Time);

        //调用方法产生运行时异常
        testThrowsRuntimeException();
//        try{
//
//
//        } catch (Exception e) {
//            System.out.println("捕获到异常了");
//        }
    }

    //在方法声明中可以通过，throws关键字声明，方法抛出哪些类型的异常
    public static void testThrows( ) throws  ClassNotFoundException, DataFormatException {

    }

    public static String parseTime(String time) throws ParseException {

//        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//        Date parse = format.parse(time);
//        return parse.toString();
        return "";
    }

    //如果要抛出的是运行时异常
    public static void testThrowsRuntimeException() throws ArithmeticException {

        int i = 1 / 0;
    }

}

throws和 throw

---

throws

用在方法后，跟异常类名

可跟多个异常类名，由方法调用者处理

表示可能抛出这些异常，但不一定会抛

throw

用在方法体内，后跟异常对象名

只能抛出一个异常对象

表示抛出异常，由方法体内的语句产生

执行throw语句必然抛出某种异常

finally

---

完整的try-catch流程应该是:try — catch —finally

特点：

被finally控制的语句块一定会执行（不管try内是否有抛出异常）

==特殊情况，走到finally之前jvm退出了。==

不管是否发生异常，finally语句块中的代码都会执行。

finally有啥用？ 用于释放资源

在以下4种特殊的情况下，finally块不会被执行

1.在finally语句块中发生了异常。

2.在前面的代码中使用了System.exit()退出程序。

3.程序所在的线程死亡

4.关闭cpu

public class FinallyStatement {

    public static void main(String[] args) {

//        try{
////            int i = 1 / 1;
////            System.exit(0);
////            return;
//
//            //finally 有啥用呢？
//
//            // 申请了操作系统资源
//            // 使用操作系统资源
//
//        } catch (ArithmeticException e) {
//            System.out.println(e.getMessage());
//        } finally {
//            //如果申请资源后因异常执行释放，finally这句确保
//            // 用完之后，释放
//            System.out.println("执行了finally语句块");
//        }
        System.out.println(testFinally());
    }

    public static int testFinally() {

          int i = 10;

          try{
              int j = i / 0;
          } catch (ArithmeticException e) {
              //如果没有下面finally的return i，则
              //return i=10;
              return i;
          } finally {
           //finally一定执行，return i，i=100
              i = 100;
              return i;
          }
    }
}

自定义异常

---

自定义异常的意义在哪里呢？

在于一旦定义了自定义异常，就意味着，产生了一种全新异常类型

在程序中使用自定义异常类，大体可以分为以下几个步骤：

（1）创建自定义异常类

（2）在方法中通过throw关键字抛出异常对象

（3）如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则在方法的声明处通过throws关键字指明要抛给方法调用者的异常，继续进行下一步操作。

（4）在出现异常方法的调用者中捕获并处理异常。

//创建自定义异常

public class MyException extends Exception{
    public MyException(String ErrorMessage){
        super(ErrorMessage);
    }
}

public class TestMyException {

    public static void main (String[] args) thr            ows Exception {

        //throw new MyCheckableException("我的异常");
        // throw new Exception("我的异常");

        try{
            //除0异常
            //int i = 9 / 0;
            System.out.println("/ by 0");

            //数组越界异常
            int[] a = new int[10];
            //System.out.println(a[10]);
            //System.out.println("array index outoutbounds");

            //空指针异常
            a = null;
            System.out.println(a[0]);
            System.out.println("null pointer");

            //假设我的产品有一段代码，在这段代码中会产生，jdk没办法可以描述你这种异常类型的异常类
            throw new MyCheckableException("我的异常");
        } catch (ArithmeticException e) {
            System.out.println("发生了除零异常");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("发生数组越界异常");
        } catch (MyCheckableException e) {

        }
        catch (Exception e) { // Exception 是所有异常的父类兼容所有子类类型的异常
            //通常该catch分支，用来捕获代码中隐藏的（开发者没有考虑到的异常类型）

        }
    }
}

//自定义编译时异常异常
class MyCheckableException extends Exception {
    public MyCheckableException(String s) {
        super(s);
    }
}

运行时异常

---

RuntimeException异常是程序运行过程中产生的异常。Java类库每个包中都定义了异常类，所有这些类都是Throwable类的子类。

Throwable类派生了两个子类，分别是Exception和Error类。

Error类及其子类用来描述Java运行系统中的内部错误以及资源耗尽的错误，这类错误比较严重。

Exception类称为非致命性类，可以通过捕捉处理使程序继续运行。

Exception类根据错误发生原因分为RuntimeException异常和除RuntimeException之外的异常。

异常的使用原则

---

Java异常强制用户去考虑程序的强健性和安全性。异常处理不应用来控制程序的正常流程，其主要作用是捕获程序在运行时发生的异常并进行相应的处理。

编写代码处理某个方法可能出现的异常时，可遵循以下几条原则：

在当前方法声明中使用try-catch语句捕获异常。

一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或者异常的子类。

如果父类抛出多个异常，则覆盖方法必须抛出哪些异常的一个子集，不能抛出新的异常。