常用类与异常体系

一、常用API
    （一）Math
        1.math的概述：math包含执行的基本数字运算方法；
        2.Math类的常用方法
            public static int   abs(int a)；返回参数的绝对值
            public static double ceil(double a)；返回大于或等于参数的最小double值，等于一个整数
            public static double floor(double a)；返回小于或等于参数的最大double值，等于一个整数
            public   static int round(float a)；按照四舍五入返回最接近参数的int
            public static int   max(int a,int b)；返回两个int值中的较大值
            public   static int min(int a,int b)；返回两个int值中的较小值
            public   static double pow (double a,double b)；返回a的b次幂的值
            public   static double random()；返回值为double的正值，[0.0,1.0)
    （二）System
        1.System包含几个字段和方法，它不能被实例化
        2.System类的常用方法
            public   static void exit(int status)；终止当前运行的   Java   虚拟机，非零表示异常终止
            public   static long currentTimeMillis()；返回当前时间(以毫秒为单位)
    （三）object
        1.Object类概述：
           （1）Object 是类层次结构的根，每个类都可以将 Object 作为超类。所有类都直接或者间接的继承自该类，换句话说，该类所具备的方法，所有类都会有一份
        （2）创建对象输出对象名，打印出的是toString方法中的地址；重写toStrinng（）方法就能打印出相应的类中的属性信息
        （3）重写toString方法的方式
            Alt + Insert 选择toString
            在类的空白区域，右键 -> Generate -> 选择toString
       2. equals
            （1）用于对象之间的比较，返回true和false的结果
                举例：s1.equals(s2);    s1和s2是两个对象
            （2）重写equals方法的场景
                不希望比较对象的地址值，想要结合对象属性进行比较的时候。
            （3）重写equals方法的方式
                alt + insert  选择equals() and hashCode()，IntelliJ Default，一路next，finish即可
    （四）Arrays（数组类）
        1.冒泡排序
            两相邻元素之间进行比较将大的放在后面的位置，每一轮比较次数减一
        Arrays包含用于操作数组的各种方法
        sout(Arrays.toString(数组名))；将数组转换位字符串形式打印出来
        Arrays.sort(数组名)；从小打到大排序
        构造方法用 private 修饰；防止外界创建对象
        成员用 public static 修饰；方便外界通过类名使用方法

二、Data（日期类）
    1.Date 代表了一个特定的时间，精确到毫秒
    2.使用Data类首先使用创建一个Data对象
    3.Date类构造方法
        public Date()
            分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
        public Date(long date)
            分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
    4.常用方法
        public long getTime()
            获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
        对象名.getTime()
            获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
        public void setTime(long time)
            设置时间，给的是毫秒值
        sout(对象名)；输出的是当前日期时间
        输出基准时间：long time =1000*60*60;       对象名.setTime(time);     sout(对象名)；
    4.SimpleDataFormat类
       （1） SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。
        使用这个类首先也要创建一个对象
       （2） SimpleDateFormat类构造方法
            public   SimpleDateFormat()
                构造一个SimpleDateFormat，使用默认模式和日期格式
            public SimpleDateFormat(String pattern)
                构造一个SimpleDateFormat使用给定的模式和默认的日期格式
        （3）SimpleDateFormat类的常用方法
            格式化(从Date到String)
                public final String format(Date date)：将日期格式化成日期/时间字符串
            解析(从String到Date)
                public Date parse(String source)：从给定字符串的开始解析文本以生成日期
    5.日期工具类
        （1）定义一个日期工具类(DateUtils)，包含两个方法：把日期转换为指定格式的字符串；把字符串解析为指定格式的日期，然后定义一个测试类(DateDemo)，测试日期工具类的方法
    6.Calendar类（抽象类）
        （1）Calendar类概述
            ①Calendar 为特定瞬间与一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法
            ②Calendar 提供了一个类方法 getInstance 用于获取这种类型的一般有用的对象。
                该方法返回一个Calendar 对象。
          ③ 其日历字段已使用当前日期和时间初始化：Calendar rightNow = Calendar.getInstance();
        （2）Calendar类常用方法
            public int   get(int field)；返回给定日历字段的值
            public abstract void add(int   field, int amount)；根据日历的规则，将指定的时间量添加或减去给定的日历字段
            public final void set(int year,int month,int date)；设置当前日历的年月日

三、异常
    1.异常的概述
        异常就是程序出现了不正常的情况
    2.Error:严重问题，不需要处理
    3.Exception：称为异常类，它表示程序本身处理的问题
    （1）RuntimeException：在编译期间是不检查的，出现问题后，需要我们回来修改代码
    （2）非RuntimeException：编译期就必须处理的，否则程序不能通过编译，就更不能正常运行了
    4.jvm（虚拟机）默认处理异常的方式
        如果程序出现了问题，我们没有做任何处理，最终JVM 会做默认的处理，处理方式有如下两个步骤：
            （1）把异常的名称，错误原因及异常出现的位置等信息输出在了控制台
            （2）程序停止执行
    5.异常处理
        （1）定义格式：
            try {
    可能出现异常的代码;
} catch(异常类名 变量名) {
    异常的处理代码;
}
        （2）执行流程：
            ①程序从 try 里面的代码开始执行
            ②出现异常，就会跳转到对应的 catch 里面去执行
            ③执行完毕之后，程序还可以继续往下执行
        （4）Throwable成员方法：
            ①常用方法：
                public String getMessage()；返回此 throwable 的详细消息字符串； 通过对象名.get（）方法使用
                public String toString()；返回此可抛出的简短描述
                public void printStackTrace()；把异常的错误信息输出在控制台
        （5）编译时异常（受检异常）
            ①都是Exception类及其子类
            必须显示处理，否则程序就会发生错误，无法通过编译
        （6）运行时异常（非受检异常）
            ①都是RuntimeException类及其子类
            无需显示处理，也可以和编译时异常一样处理
        （7）throws方式处理异常
            ①格式：throws  异常类名；   注意：这个方法是跟在方法后面的
            ②编译时异常：必须要进行处理，两种方案：try..cath...或者throws，如果采用throws这种方案，将来调用谁处理
            ③运行时异常可以不处理，出现问题后，需要修改源代码
    6.自定义异常
        （1）throw：
            ①在方法体内，跟的是异常对象名
            ②表示抛出异常，由方法体内的语句处理
           ③ 执行throw一定抛出某种异常

四、请使用日期时间相关的API，计算出一个人已经出生了多少天。

package Guanqia11;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class Api {
    public static void main(String[] args) throws ParseException {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的出生日期，格式为yyyy-MM-dd");
        String birthdayDateString = sc.next();
        // 2.使用DateFormat类中的方法parse,把字符串的出生日期解析为Date格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date birthdayDate = sdf.parse(birthdayDateString);
        // 3.把Date格式的出生日期转换为毫秒值
        long birthdayDateTime = birthdayDate.getTime();
        // 4.获取当前的日期，转换为毫秒值
        long todayTime = new Date().getTime();
        // 5.使用当前日期的毫秒值-出生日期的毫秒值
        long time = todayTime-birthdayDateTime;
        // 6.把毫秒值的差值转换为天（s/1000/60/60/24)
        System.out.println(time/1000/60/60/24/365);
        sc.close();
    }
}

五、代码块、设计模式、final
    （一）代码块
       1） 定义：代码块又称为初始化块，属于类中的成员，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来；          但和方法不同，没有方法名，没有返回值，没有参数，只有方法体，而且不用通过对象或类显式调用，而是在加载类的时候，或创建对象时隐形调用
       2） 基本语法：[修饰符]{代码}；
            1.修饰符可选，要写也只能写static
            2.代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块
            3.逻辑语句可以为任何逻辑语句（输入、输出、方法调用、循环、判断等）
            4.{}；（分号）可以写上，也可以省略
        3）场景
            如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性
        用于处理构造器，代码块的执行优先于构造器，无论使用哪一个构造器都会先执行代码块
        4）注意事项：
            1.static代码块也叫做静态代码块，作用是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次；普通代码块，每创建一个对象，就执行；
            2.如果只是使用静态成员时，普通代码块并不会执行
            3.类加载
                （1）创建对象实例时（new）
                （2）创建子类对象实例，父类也会被加载，而且父类先被加载，子类后被加载
                （3）使用类的静态成员时（静态属性，静态方法）
            4.创建对象时，在一个类中调用顺序
                （1）调用静态代码块和静态属性初始化（注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用）
                （2）调用普通代码块和普通属性的初始化（注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按照他们的定义顺序调用）
                （3）调用构造方法
                     静态代码块会优先于普通代码块执行
            5.构造器的前面其实隐含了super（）和调用普通代码块，     静态代码块会优先于普通代码块执行
            6.继承关系（调用顺序）
                （1）父类静态代码块和静态属性（优先级一样，定义顺序调用）
                （2）子类的静态代码块和静态属性（优先级一样，定义顺序调用）
                （3）父类的普通代码块和普通属性初始化（优先级一样，定义顺序调用）
                （4）父类构造方法
                （5）子类的普通代码块和普通属性初始化（优先级一样，定义顺序调用）
                （6）子类的构造方法
            7.静态代码块只能直接调用静态成员（静态方法和静态变量），普通代码块可以调用任意成员
    （二）单例设计模式（一个人只有一个对象）
        1）定义：采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法
        2）饿汉模式
            步骤：1.构造器私有化，防止外部直接new；2.类的内部创建对象，同时初始化 ；3.向外暴露一个静态的公共方法。getlnstance  ；4.代码实现
            在类的加载时就创建了实例对象，可能会造成了对象的创建但未使用，造成资源的浪费
        3）懒汉模式
            步骤：1.构造器私有化，防止外部直接new；2.类的内部创建静态属性对象不用初始化（new） ；3.向外暴露一个静态的公共方法，判断属性对象是否为空，如果为空就new一个一对象（初始化）。getlnstance  ；4.代码实现
            只有当用户使用getlnstance  方法时，才返回实例对象，后面再次使用时，回返回上次创建的对象
    （三）final（最终的）
        1）可以修饰：类、属性、方法
        2）应用场景：
            1.当不希望被继承时，可以用final修饰
            2.当不希望父类的某个方法被子类覆盖/重写时
            3.当不希望类的某个属性被修改时
            4.不希望某个局部变量被修改
       3） 注意事项
            1.修饰属性一般又叫常量，一般用xx_xx_xx来命名（大写字母）
            2.修饰的属性在定义时，必须赋初值，并且以后不能在修改，赋值可以在如下位置之一：
                （1）定义时：如public final double TAX_RATE=0.08;
                （2）定义后在构造器中，变量名赋值
                （3）定义后在代码块中，变量名赋值
            3.如果final修饰的属性是静态的，则初始化的位置只能是
                （1）定义时
                （2）在静态代码块
                不能在构造器中赋值
            4.final类不能继承，但可以实例化
            5.如果类不是final类，但是含有final方法，则方法不可以重写，但是类可以被继承
            6.如果一个类是final类，就没有必要将方法修饰成final方法；因为final类不能被继承，从而里面的方法也不会被重写
            7.final不能修饰构造器
            8.final和static往往搭配使用，效率更高，底层编译器做了优化处理（一般用在定义变量，在调用final修饰的变量时，类不会加载，就不会执行类中的代码块）；
            9.包装类（Integer,Double,Float,Boolean等都是final），String也是final类

六、枚举
        1）枚举：把具体的对象一个一个例举出来的类，就成为枚举类
        2）简写：enum；枚举是一组常量的集合；枚举是一种特殊的类，里面包含一组有限的特定对象
        3）自定义枚举类： 
            1.将构造器私有化
            2.去掉set（）方法，防止属性被修改；提供get方法
            3.在枚举内部，直接创建固定的对象（类型为静态的static）
            4.优化，可以把对象创建为最终态的静态对象
            5.枚举对象名全部使用大写（final修饰的属性都大写）
        4）enum关键字实现枚举
            1.使用关键字enum替代class
            2.在定义属性前，直接大写：对象名（实参例表），相当于创建对象
            3.如果有多个对象时，对象名（实参例表）之间用逗号隔开
            4.定义对象一定要写在最前面
           5） 注意事项：
                1.使用enum关键词，会自动继承Enum类，而且是一个final类
                2.对象名（实参例表）格式，必须知道，他调用的哪一个构造器
                3.如果使用无参构造器  创建枚举对象，则实参例表和小括号都可以省略
                4.当多个枚举对象时，使用逗号隔开，最后一个用分号
                5.枚举对象必须写在最前面
                6.枚举继承Enum类，可以使用父类里的方法：.name()获取枚举名字;  .ordinal()获取枚举是第几个对象，从0开始编号；  .valuse()返回一个数组，里面包含所有的枚举对象；  .valueof() :将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则会报错；  枚举对象.compareTo(枚举对象)比较两个枚举常量，比较的就是编号，返回值为：前一个对象编号减去后面这个对象的编号，根据返回值就能判断对象的前后顺序
        继承