Java数组、日期类、抽象类、接口、异常、集合

Arrays数组

1. Arrays.toString( 数组名字 )
   输出数字
2. Arrays.sort( 数组名字 )
   排序数字

基本类型和包装类

Integer

1. 用法：Integer.valueOf( 数字或"字符" )
2. 含义：将int 或 String 转换成Integer包装类型

int 与 String 的相互转换

1. int -----String

int number = 100;
//方式一 
String s1 = "" + number;
//方式二
String s2 = String.valueOf(number); 

2. String ----- int

String s = "100";
//方式一
Integer i = Integer.valueOf(s);
int x = i.intValue();
//方式二
int y = Integer.parseInt(s);

将数组中的数字进行排序

1. 定义一个字符串
2. 设法将这个字符串中分离出来数字

方法一：String [] 新数组名 = 旧的数组名.split();

方法二：int [] b = new int[旧数组的长度];
然后再遍历，运用Integer.parseInt(b[]);方法实现将String转换成为int 

3. 将数组进行排序

Arrays.sort(b);

4. 将字符串拆开之后，进行拼接

StringBuilder sb = new StringBuilder();
     for (int i = 0; i < b.length; i++) {
            if ( i == b.length-1){
                sb.append(b[i]);
            }else{
                sb.append(b[i]).append(" ");
            }
        }
        //使用了StringBuilder中的append方法，可以进行拼接操作

装箱与拆箱

1. 装箱

Integer i = Integer.valueOf(100);// 装箱
        Integer ii = 100; // 自动装箱

2. 拆箱

Integer i = Integer.valueOf(100);// 装箱
        Integer ii = 100; // 自动装箱
ii = ii.intValue() + 100;// 拆箱
ii += 100;// 自动拆箱

注意：如果ii的值为null，则不能调用方法，因此会返回一个空指针异常
NullPointerException; 因此我们需要在进行之时，先进行不是null的判断

Date

1. 输出当前的时间，其实是他自己重写了方法
    public static void main(String[] args) {
        Date d1 = new Date();
        System.out.println(d1);
2. 分配一个对象，规定为从基准时间开始计时指定的毫秒数
    long date = 1000*60*60;
        Date d2 = new Date(date);
        System.out.println(d2);
    }

相关的方法

1.      Date d = new Date();
        System.out.println(d.getTime()*1.0/1000/60/60/24/365+"年");// 输出为从1970年至今的毫秒值，然后sout做出了转换
   

2.      long date = 1000*60*60;
        d.setTime(date);
        System.out.println(d);
        输出的是1970年所指定的时间
        
         long date = System.currentTimeMillis();
        d.setTime(date); 
       System.out.println(d);
       输出的是现在的时间
   
   

抽象类

1. 抽象方法，必须在抽象类里面
2. 而且抽象方法，没有方法体

public abstract class Abstract {
    
    public abstract void eat();
    
}

3. 抽象类里面可以有不抽象的方法，也可以没有抽象方法，但是如果没有抽象方法，那么就没有意义了
4. 抽象类不是具体的，不能够直接创建方法，必须通过多态的方法

public abstract class Animal {

    public abstract void eat();
    public void sleep(){
        System.out.println("睡觉了zzzzzzzzzzz");
    }
}

因此就得使用继承这个抽象类，继承之后必须重写里面的方法

public class Cat extends Animal{

    @Override
    public void eat() {

    }
}

5. 抽象类的子类，要重写里面的抽象方法，非抽象的方法，不需要重写
6. 但是，如果抽象类的子类也是抽象类，那么就不需要再重写里面的方法

抽象类之中成员的特点

1. 可以定义一些成员

​```
public abstract class Abstract002 {
    
    int x = 20;
    final String s = "北京";
    
    public void show (){ 
        x = 40;注意：这里会将上面定义的x给覆盖掉，在子类调用的时候会输出40
        System.out.println(x);
        s = "上海";//注意： 因为s 已经被final 修饰了，修饰之后就会变成一个常量，所以不能再给它赋值了
        System.out.println(s);
    }
    
} 
​```

2. 可以生成构造方法，为了子类能够访问父类的初始化，但是一定不能够将其实例化
3. 当然也是能够定义一些方法，可以使抽象的方法，也可以是非抽象的方法，其中，非抽象的方法，可以提高代码的复用性，并且是由继承来保证

抽象类中对继承的子类操作方法

接口

1. 接口的定义
   
2. 接口中的方法也可以是抽象方法，因为接口是抽象的，同样如果"继承"了这个方法，也得需要重写方法
3. 注意：为什么我在上一条的继承用了引号呢？因为不能够使用关键字extends，而是应该使用implements
4. 接口是抽象的，不能够实例化，例如
   
5. 但是我们人仍然可以参照多态的形式进行，借助子类
   
6. 同样的， 如果子类“继承”接口，如果它本身是抽象类，则不用重写

接口中成员的特点

1. 里面的int定义的变量，是默认被final修饰的，所以不能够再给其赋值，而且默认被静态修饰，也就是说，可以被，类.该值调用；

也就是说，加不加final 与 static 都一样，只用第一个就可以

2. 其中的构造方法，必须是抽象的，然后子类调用后重写
   
   上方的图片说明如果不加上 public abstract 也是代表自己已经加上了

SimpleDateFormat

SDF的构造方法

一、格式化方法：从Date 到 String

1. 无参构造Format方法，输出默认模式下转化的日期表示

 public static void main(String[] args) {

        Date d = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat();
        String s = sdf.format(d);
// 调用SimpleDateFormat中的format方法，将日期格式化成为字符串String（默认的模式）
        System.out.println(s);
    }

2. 使用有参构造，不让它输出为默认的，让我们给他定义输出的格式，而且可读性也很好的

    public static void main(String[] args) {

        Date d = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年HH月dd日 HH:mm:ss");
       //我们使用的是有参构造，将日期按照我们的设想格式输出了；但是注意年月日等时间的表示
        String s = sdf.format(d);
        System.out.println(s);
    }

二、解析：从String 到 Date

1. 运用到parse方法，将给定的字符串按照其格式，输出为日期

String date = "2021-12-12 10:00:30";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//注意这里的格式需要对应
        String s1 = date;
        sdf2.parse(s1);
        System.out.println(date);

Calendar

1. 首先需要获取Calendar对象

Calendar c = Calendar.getInstance();

2. 可以调用年月日的方法：get
   （注意：一定要将月份加一）

int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;********
        //月是从0开始计数，所以需要加1
        int day = c.get(Calendar.DATE) ;

3. 将已经定义的指定的年月日进行增删：add

		c.add(Calendar.YEAR,-3);**********
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        //月是从0开始计数，所以需要加1
        int day = c.get(Calendar.DATE) ;
        System.out.println(year+" "+month+" " +day);

4. 进行年月日的设定：set

c.set(2022,11,3);
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH);
     //注意：这里的月份不用再+1了*********
        int day = c.get(Calendar.DATE) ;
        System.out.println(year+" "+month+" " +day);

5. 自检2月天demo
   步骤：1.让用户输入需要检测的年份
   2.获取那一年，并将日期设置为那一年的3月1日；
   3.然后修改这个日期的天数，并减少1
   4.获取这个天数，最后输出即可

  System.out.println("请输入你想要获取哪一年的2月份的年份？");
        Scanner sc = new Scanner(System.in);
        int year = sc.nextInt();
        Calendar c = Calendar.getInstance();
        c.set(year,2,1);//三月一日
        c.add(Calendar.DATE,-1);
        int date = c.get(Calendar.DATE);
        System.out.println(year+"年有" + date+"天");

Exception

1. JVM帮助我们做得事情
   

2. 我们自己如何处理异常
   一、 try,catch 方法，执行完后，程序人可以向下执行
   格式：
   演示实例：

     public static void method(){
        try{
            int [] a = {1,2,3};
            System.out.println(a[3]);
            //在此处如果出现异常，则就会产生异常对象哦
            //new ArrayIndexOutOfBoundsException()
        }catch(ArrayIndexOutOfBoundsException e){
        e.printStackTrace();
        //这里正是调用了前面自己产生的异常对象的反复
        }
    }

注意：这里的e.printStackTrace调用的方法，是显示是否超出数组的界限；
其中上面的超出数组的范围引用的，相当于new 了一个ArrayIndexOutOfBoundsException
还要注意，这个方法的处理后，跟JVM（java虚拟机）默认的处理是一样的，但是呢，可以执行后面的“end”

二、throwable的部分成员方法

1. getMessage()
   作用是：输出异常的标志index
2. toString()方法
   作用是：输出异常的原因以及结果；返回可抛出的简短信息

java.lang.ArrayIndexOutOfBoundsException: 3

3. printStackTrace()方法
   作用是：返回异常的最全的信息，因此我们经常调用这个方法将异常的错误信息输出到控制台

三、编译时异常和运行时异常的区别（受检异常和非受检异常）

1. //运行时异常(这里没有报错，而是在运行的时候才出现错误）

    public static void method(){
            int[] a = {1, 2, 3};
            System.out.println(a[3]);//ArrayIndexOutOfBoundsException是一个RuntimeException
    }

2. //编译时异常（我们必须处理他，否则会显示异常，但是上面的运行时异常不同，他可以不显示，也可以手动显示）

    public static void method2(){
        String s = "2020-10-22";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date d = null;
        try {
            d = sdf.parse(s);
        } catch (ParseException e) {
            e.printStackTrace();//自动给与了这个
        }
        System.out.println(d);
    }

四、throws处理异常
处理是在方法层面

 public static void method2() throws ParseException

其中运行时时异常，直接throws后便可以直接执行
但是编译时异常，throws后仍然需要在源程序中try-catch

五、自定义异常

自测步骤：
1.创建一个ScoreException，Teacher，TeacherTest
2.在ScoreException中创建两个方法，一个无参构造，另一个是有参构造；并且抛出Exception异常
3.在Teacher中抛出ScoreException异常，并且自定义其中的异常if else
4.在teacherTest中根据具体是，让用户输入成绩并且用自己的定义的异常来检测

throws与throw的区别

集合

Collection

Collection<String> c = new ArrayList<String>

1. Collection运用多态的方法，进行创建
   其中一个方法是；c.add(“内容”);
2. 相关方法
3. Alt+7打开类的窗口，可以看见类的所有信息
4. Interator其实是一个接口（迭代器）
   Iterator it = c.iterator()
   相关方法：1.add方法
   2.next（）方法，获取其中的元素，可以输出
   3.hasNext（）方法，如果有元素的话，返回0
   4.可以用while来遍历数组，并输出其中的元素

public static void main(String[] args) {
        Collection<String> c = new ArrayList<String>();
        c.add("good ");
        c.add("idea?");
        c.add("goodbye");
        Iterator<String> it = c.iterator();// Iterator是一个接口
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        if (it.hasNext()){
//            System.out.println(it.next());
//        }
//        if (it.hasNext()){
//            System.out.println(it.next());
//        }
//        if (it.hasNext()){
//            System.out.println(it.next());
//        }
//        if (it.hasNext()){
//            System.out.println(it.next());
//        }
        while (it.hasNext()){
//            System.out.println(it.next());
            String s = it.next();
            System.out.println(s);
           这样做的原因是，我们有时候需要用这个元素做其他的事情
        }

    }

5. 案例
   

6. List
   
   
   一定要注意：我们在错做的时候，要做到我们操作的索引是存在的；否则会出现异常（或者是连续的）
   注意：数组的长度这里用size（）

7. 案例
   

8. list的并发修改异常
   
   运用itreator遍历集合的时候会默认将modCount加一，因此会造成预期值与实际值不符；因此会抛出ConcurrentModificationException异常

但我们运用for循环遍历的话就不会出现

public static void main(String[] args) {
        List<String> l = new ArrayList<String>();
        l.add("hello");
        l.add("good");
        l.add("new_year");
//        Iterator<String> i = l.iterator();
//        while (i.hasNext()){
//            String s = i.next();
//            System.out.println(s);
//            if(s.equals("hello")){
//                l.add("javaee");
//            }
//        }
        for (int i = 0; i < l.size(); i++) {
            String s = l.get(i);
            if(s.equals("good")){
                l.add("heool");
            }
        }
        System.out.println(l);
    }

9. ListIterator
   

10. 增强for循环
格式：

public static void main(String[] args) {
        int [] x = {1,2,3,5};
        for(int i:x){
            System.out.println(i);
        }
        System.out.println("=================");

        String [] s = {"hello","java","world"};
        for(String i:s){
            System.out.println(i);
        }
        System.out.println("==============");
        
        List<String> l = new ArrayList<String>();
        l.add("hello");
        l.add("new");
        l.add("world");
        for(String i:l){
            System.out.println(i);
        }
    }

其中：其可以实现一般的int，String数组的遍历输出；也可以实现List数组；**注意：**增强for循环本质上是Iterator迭代器，验证如下

 for(String i:l){
            if(i.equals("hello")){
                l.add("javaee");
            }

于是会抛出如下的异常

Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:911)
	at java.util.ArrayList$Itr.next(ArrayList.java:861)
	at Collection.For_Plus.For.main(For.java:27)