Java笔记：数组，异常，泛型

// 静态初始化语法，即定义的时候就初始化好了所有的元素
int[] array1 = {100,55,30};
 动态初始化语法，初始化时只定义好数组中元素的个数，new int[5]表示创建一个
 有5个int类型元素的数组，但是并没有初始化数组中元素的值，只是赋予了默认值，即
 基本数据类型的默认值和引用类型的默认值null。
int[] array2 = new int[5];

 静态初始化语法
int[][] a = {
    {1,2,3},{4,5,6}
};

 动态初始化语法
int[][] array = int[3][4];

import java.util.Arrays;


public class ArrayToolsTest{
    static void main(String[] args){
        int[] myArray = {3,6,4};
         sort方法可以将一个数组排序，但是注意，sort方法并没有返回值，
         即不是返回排好序的数组，而是直接排序传入的数组
        Arrays.sort(myArray);

         二分查找算法的前提是需要数组已经排好序了
         返回值为元素在数组中的下标，元素在数组中不存在则返回-1
         但是这个方法多用来判断数组中有没有这个元素，因为如果数组中该元素
         不只一个的话，那么返回的下标不一定是第一个元素的下标
        int indexd = Arrays.binarySearch(myArray,1)">);
    }
}

 ThrowsTest{
     这里在编译时会发生错误，也就是编译时异常，之所以有这个异常
         因为在func定义中有throws关键字，表示这个方法在执行过程中可能会发生
         对应的异常（ClassNotFoundException），所以它的上一级必须去处理
         这个异常，不处理的话，编译器就会不通过。
        func();
    }
    
     使用throws关键字抛出可能发生的异常
    void func() throws ClassNotFoundException{
        System.out.println("my func!!!");
        
         使用throw手动抛出一个异常
        throw new ClassNotFoundException("未找到类异常！");
    }
}

 java.io.FileInputStream;
 java.io.FileNotFoundException;
 java.io.IOException;

 ExceptionTest {
     main(String[] args) {
        FileInputStream fis = null;
        try {
             将可能会发生异常的语句放在try的语句块中
             try语句块中的代码一定会去执行，直到发生异常为止
            fis = new FileInputStream("Z:Studytemp.md");
            System.out.println(10 / 0);
        } catch (ArithmeticException e) {   捕获可能会发生的异常
             捕获到异常后，对异常进行处理
             catch语句块中的代码只有捕获到异常之后才会执行
             ArithmeticException e这个语句相当于是声明一种引用类型的变量，类似于方法的形参，e保存的是异常对象的内存地址，并且可以在catch语句块中去使用这个对象引用e。
            System.out.println("发生算术异常！！！"catch (FileNotFoundException e) {   可以使用多个catch语句块捕获不同的异常
             多个catch时会从上到下依次捕获，执行了一个catch之后，其他的catch就不会执行了
             并且多个catch语句时，应该遵循从上到下的“从小到大”捕获，即具体异常在前，它的父类型依次往后
            System.out.println("文件不存在！！！"finally finally块中的语句无论是否发生异常都会处理，哪怕try块最后有个return语句
             执行到return语句时也会先执行finally中的语句，再执行return
             可以用来处理一些无论是否发生异常都要处理的操作，如关闭文件流等
            if (fis != ){
                {
                    fis.close();
                } catch(IOException e) {
                    e.printStackTrace();
                }
                
            }
            System.out.println("关闭文件等其他操作。。。");
        }
    }
}

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

 /*
   自定一个泛型只需要在类名之后使用<标识符>即可
   注意，此处的标识符是随意定义，就像变量名一样
  */
 class MyGenericTest<T> {
      main(String[] args) {
          定义的时候，传入的类型是什么，那么创建的对象使用的泛型类型就是什么类型
         MyGenericTest<String> mgt = new MyGenericTest<>();
         mgt.func("自定义泛型方法测试！");
     }
 
     
       如果想要使用泛型定义的类型，在方法参数中直接使用即可
      */
      func(T t){
         System.out.println(t);
     }
 }

  java.util.ArrayList;
  java.util.Iterator;
  java.util.List;
 
 
  GenericTest {
      指定集合中的元素类型为Pet，不能存储其它类型的元素
          使用new的时候可以不用再传入类型了，可以自动推断，此时的表达式<>也称为钻石表达式
          如果不指定泛型，也是可以的，默认就是Object类型
         List<Pet> petList = new ArrayList<>();
         Cat c = new Cat();
         Dog d =  Dog();
 
         petList.add(c);
         petList.add(d);
 
          迭代器的声明也需要加上泛型的定义
         Iterator<Pet> it = petList.iterator();
         while (it.hasNext()) {
              原本next方法返回值的类型为Object，使用泛型之后返回的类型直接就是指定
              的类型，不需要进行类型转换了。
             Pet p = it.next();
             p.play();
              当然，如果要使用具体的子类对象的方法，还是需要转型之后才能调用
             if (p instanceof Cat){
                 Cat myCat = (Cat)p;
                 myCat.sleep();
             }
              Dog){
                 Dog myDog = (Dog)p;
                 myDog.bark();
             }
         }
         
         输出结果：
         宠物在玩耍！
         猫咪在睡觉！
         宠物在玩耍！
         狗子在嚎叫！
         */
     }
 }
 
 
  Pet {
      play() {
         System.out.println("宠物在玩耍！");
     }
 }
 
 
 class Cat  sleep() {
         System.out.println("猫咪在睡觉！"class Dog  bark() {
         System.out.println("狗子在嚎叫！");
     }
 }