java学习记录十二：权限修饰符,代码块,java内部类，自动拆装箱

素颜马尾好姑娘i 2021-09-08 11:36 235阅读 0赞

### java学习记录十二：权限修饰符,代码块,java内部类 ###

*  一、权限修饰符
 *   *  一、解释
     *  二、不同权限的访问能力
 *  二、代码块
 *   *  一、构造代码块
     *   *  一.解释
         *  二.写法
     *  二、静态代码块
     *   *  一、解释
         *  二、写法
     *  三、局部代码块
     *   *  一、解释
         *  二、写法
 *  三、Object类
 *   *  一、解释
     *  二、Object类常用方法
     *   *  一、toString方法
         *   *  一、解释
             *  二、写法
             *  三、特点
             *  四、重写toString方法
         *  二、equals方法
         *   *  一、解释
             *  二、写法
             *  三、Object类equals方法的特点
             *  二、重写equals方法
 *  四、Objects类
 *   *  一、解释
     *  二、写法
 *  五、native方法
 *   *  一、解释
 *  六、Date类
 *   *  一、解释
     *  二、构造方法
     *  三、时间定义
     *  四、写法
     *  五、Date类常用方法
     *   *  1.获取当前日期对象距离标准基准时间的毫秒值。
         *  2.设置当前日期对象距离标准基准时间的毫秒值.也就意味着改变了当前日期对象
         *  3.测试此日期是否在指定日期之后或者之前
 *  六、DateFormat类
 *   *  一、解释
     *  二、构造函数
     *  三、构造函数写法
     *  四、DateFormat类的常用方法
     *   *  1.将Date对象格式化为字符串
         *  2.将字符串解析为Date对象
 *  七、Calendar类
 *   *  一、解释
     *  二、获取GregorianCalendar对象
     *  三、Calendarl类常用方法
     *   *  1.获取当前日期的日历对象
         *  2.获取某个字段的值
         *  3.设置某个字段的值
         *  4.为某个字段增加/减少指定的值
         *  5.使用给定的 Date 设置此 Calendar 的时间
         *  6.判断此 Calendar 表示的时间是否在指定 Object 表示的时间之前或之后，返回判断结果。
 *  八、Math类
 *   *  一、解释
 *  九、System类
 *   *  一、解释
     *  二、System类常用方法
     *   *  1.终止当前运行的Java虚拟机，非零表示异常终止
         *  2.返回当前时间距离标准基准时间的毫秒值(以毫秒为单位)
         *  3.拷贝数组中的元素到另一个数组
 *  十、BigInteger类
 *   *  一、解释
     *  二、构造方法
     *  三、常用方法（加、减、乘、除）
 *  十一、BigDecimal类
 *   *  一、解释
     *  二、构造方法
     *  三、BigDecimal类常用方法（加、减、乘、除）
 *  十二、Arrays类
 *   *  一、解释
     *  二、常用方法
     *   *  1.按照数字顺序排列指定的数组
         *  2.返回指定数组的内容的字符串表示形式
 *  十三、包装类
 *   *  一、解释
     *  二、包装类分类
 *  十四、Integer类
 *   *  一、解释
     *  二、构造方法
     *  三、常用方法
     *   *  1.返回表示指定的 int 值的 Integer 实例
         *  2.返回保存指定String值的 Integer 对象
         *  3.Integer 对象转int基本类型
 *  十四、装箱和拆箱
 *   *  一、解释
     *  二、自动装箱与拆箱
 *  十五、字符串和基本类型之间的转换
 *   *  一、基本类型转String
     *   *  1.直接在数字后加一个空字符串
         *  2.通过String类静态方法valueOf()
     *  二、String类型转基本类型

# 一、权限修饰符 #

## 一、解释 ##

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限。

*  public：公共的
 *  protected：受保护的
 *  (空的)：默认的
 *  private：私有的

## 二、不同权限的访问能力 ##

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>public</th> 
   <th>protected</th> 
   <th>（空的）</th> 
   <th>private</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>同一类中</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td>同一包中(子类与无关类)</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>不同包的子类</td> 
   <td>√</td> 
   <td>√</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>不同包中的无关类</td> 
   <td>√</td> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

可见，public具有最大权限。private则是最小权限。

编写代码时，如果没有特殊的考虑，建议这样使用权限：

*  成员变量使用`private` ，隐藏细节。
 *  构造方法使用`public` ，方便创建对象。
 *  成员方法使用`public` ，方便调用方法。

# 二、代码块 #

## 一、构造代码块 ##

### 一.解释 ###

*  格式: \{\}
 *  位置: 类中,方法外
 *  执行: 每次在调用构造方法的时候,就会执行，在调用构造方法之前执行
 *  使用场景: 统计创建了多少个该类对象

### 二.写法 ###

public class Person{ 
        { 
            构造代码块执行了
        }
    }

## 二、静态代码块 ##

### 一、解释 ###

*  格式:static\{\}
 *  位置: 类中,方法外
 *  执行: 当类被加载的时候执行,并只执行一次
 *  使用场景: 例如加载驱动,这种只需要执行一次的代码就可以放在静态代码块中

### 二、写法 ###

public class Person { 
        static { 
            System.out.println("Person 静态代码块");
        }
    
        { 
            System.out.println("Person 构造代码块");
        }
    
        public Person(){ 
            System.out.println("Person 构造方法");
        }
    }

## 三、局部代码块 ##

### 一、解释 ###

*  格式:\{\}
 *  位置: 方法中
 *  执行: 调用方法,执行到局部代码块的时候就执行
 *  使用场景: 节省内存空间,没有多大的意义

### 二、写法 ###

public class Test { 
        public static void main(String[] args) { 
      
            System.out.println("开始");
            { 
                int num1 = 10;
                System.out.println("局部代码块");
            }// 把局部代码块中的变量占用的空间会释放
    
            System.out.println("结束");
        }
    }

# 三、Object类 #

## 一、解释 ##

java.lang.Object\`类是Java语言中的根类，即所有类的父类。如果一个类没有特别指定父类，那么默认则继承自Object类。根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。-java中所有的类都是直接或者间接继承Object类,也就意味着,java中所有的类都拥有Object类中的那11个方法。每个类的构造方法默认会调用父类的空参构造方法。

## 二、Object类常用方法 ##

### 一、toString方法 ###

#### 一、解释 ####

返回该对象的字符串表示，其实该字符串内容就是：对象的类型名+@+内存地址值。由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

#### 二、写法 ####

// 创建Object对象
            Object obj = new Object();
            System.out.println(obj.toString());// java.lang.Object@50cbc42f
            System.out.println(obj);// java.lang.Object@50cbc42f

#### 三、特点 ####

*  toString方法返回的字符串内容格式为: 类的全路径+@+十六进制数的地址值
 *  直接打印对象名,其实就是打印对象调用toString方法返回的字符串内容
 *  要是一个类toString打印的不是地址值，而是内容，说明该类重写了toString方法

#### 四、重写toString方法 ####

class Person{ 
        String name;
        int age;
    
        public Person(String name, int age) { 
            this.name = name;
            this.age = age;
        }
        @Override//重写需要加上这个注解
        public String toString() { 
            // 使用快捷键生成默认格式(alt+insert)
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

### 二、equals方法 ###

#### 一、解释 ####

指示其他某个对象是否与此对象“相等”，Object类的equals()方法默认实心是==比较,也就是比较2个对象的地址值,对于我们来说没有用，如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。

#### 二、写法 ####

// 创建Object类对象
            Object obj1 = new Object();
            Object obj2 = new Object();
            System.out.println(obj1 == obj2);// false
            System.out.println(obj1.equals(obj2));// false 执行代码:obj1 == obj2

#### 三、Object类equals方法的特点 ####

*  Object类的equals()方法默认比较的是2个对象的地址值是否相等(==比较)
 *  由于java中所有类都是继承Object类,所以如果类中没有重写equals方法,默认就是地址值比较，String类就重写了equals方法，比较的是内容
 *  如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以重写equals方法，

#### 二、重写equals方法 ####

class Person { 
        String name;
        int age;
    
        public Person(String name, int age) { 
            this.name = name;
            this.age = age;
        }
        /*@Override //形参多态，只要参数数据类型是父类类型，就可以使用所有的子类类型 public boolean equals(Object obj) { // 自定义比较规则 //这边要向下转型，不然不能使用子类独有的成员。即obj.age访问报错。 //这里就是多态的弊端，所以要向下转型。出现多态就i要考虑到弊端。 //转型前最好判断一下是不是这个子类类型。 Person p = (Person) obj; //这里age的== 是int的==比较的是值，name是String类型，==比较的是地址值，所以要用equals，比较的是值。 return this.age == p.age && this.name.equals(p.name); }*/
       // 快捷键重写equals方法 alt+insert-->选择`equals() and hashCode()`进行自动代码生成。
        @Override
        public boolean equals(Object o) { 
            // 如果2个对象的地址值相同,就直接返回true,结束方法
            if (this == o) return true;
            // 如果传入的对象为null,就直接返回false,结束方法
            // 如果2个对象的类型不一致,就直接返回false,结束方法
            //getClass获取对象的类
            if (o == null || this.getClass() != o.getClass()) return false;
            // 来到这里,说明要比较的2个对象地址值不同,并且一定是Person类型
            Person person = (Person) o;// 向下转型
            // 比较所有属性是否相同
            return age == person.age &&
                    Objects.equals(name, person.name);
        }

# 四、Objects类 #

## 一、解释 ##

`java.util.Objects`类是**JDK7**添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashCode、返回对象的字符串表示形式、比较两个对象。在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题

## 二、写法 ##

//public static boolean equals(Object a, Object b):判断两个对象是否相等。
    //源码
    public static boolean equals(Object a, Object b) {   
        return (a == b) || (a != null && a.equals(b));  
    }
    
    
    public class Test { 
        public static void main(String[] args) { 
             String name1 = "张三";
            String name2 = new String("张三");
            String name3 = null;
            System.out.println(name1);// 张三
            System.out.println(name2);// 张三
    
            // 比较name1和name2字符串内容是否相同
            //System.out.println(name1.equals(name2));// true
            //System.out.println(name3.equals(name1));// 空指针异常NullPointerException,因为null不能调用方法
    
            System.out.println(Objects.equals(name1, name2));// true
            //这时候使用Objects.equals就不会报空指针异常，可以比较null值。
            System.out.println(Objects.equals(name3, name1));// false
        }
    }

# 五、native方法 #

## 一、解释 ##

在Object类的源码中定义了 **native** 修饰的方法， native 修饰的方法称为本地方法。这种方法是没有方法体的,我们查看不了它的实现,它是用来和其他编程语言进行交互的方法，当我们需要访问C或C++的代码时，或者访问操作系统的底层类库时，可以使用本地方法实现。也就意味着Java可以和其它的编程语言进行交互。本地方法的作用： 就是当Java调用非Java代码的接口。方法的实现由非Java语言实现，比如C或C++。

# 六、Date类 #

## 一、解释 ##

java.util.Date类 表示一个日期和时间，内部精确到毫秒。

## 二、构造方法 ##

**1.无参构造方法**

*  public Date()\`：从运行程序的此时此刻到时间原点经历的毫秒值,转换成Date对象，分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定long类型的构造参数，可以自定义毫秒时刻。

**2.有参构造方法**

*  public Date(long date)：将指定参数的毫秒值date,转换成Date对象，分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数，即写多少就是距离1970年1月1日00:00:00 GMT）偏差多少的时间。1000毫秒等于1秒。

## 三、时间定义 ##

**1.标准时间**  
叫世界协调时间/格林威治时间，又称为“历元（epoch）”，即1970年1月1日00:00:00 GMT  
**2.中国时间**  
是东八区时间，比标准时间快8小时，叫1970年1月1日00:00:00 CST  
1.中国人:一个星期的第一天是星期一,外国人:一个星期的第一天是星期天  
2.日历对象中的月份是: 0-11

## 四、写法 ##

// 创建当前统时间对应的日期对象
            Date date1 = new Date();
            System.out.println(date1);// Thu Sep 10 11:21:00 CST 2020
        //在使用println方法时，会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写，所以结果为指定格式的字符串
         // 创建以标准基准时间为基准 指定偏移1000毫秒
            Date date2 = new Date(1000);
            System.out.println(date2);// Thu Jan 01 08:00:01 CST 1970
            
           // 创建日期对象,表示1970年1月1日07:59:59
            Date date3 = new Date(-1000);
            System.out.println(date3);// Thu Jan 01 07:59:59 CST 1970

## 五、Date类常用方法 ##

### 1.获取当前日期对象距离标准基准时间的毫秒值。 ###

//public long getTime()：获取当前日期对象距离标准基准时间的毫秒值。
           // 创建当前统时间对应的日期对象
            Date date1 = new Date();
            System.out.println(date1);// Thu Sep 10 11:29:00 CST 2020
    
          // 创建以标准基准时间为基准 指定偏移1000毫秒
            Date date2 = new Date(1000);// 设置距离标准基准时间的毫秒值为1000
            System.out.println(date2);// Thu Jan 01 08:00:01 CST 1970
            
          // 获取当前日期对象距离标准基准时间的毫秒值。
            System.out.println(date1.getTime());// 1599708576604
            System.out.println(date2.getTime());// 1000

### 2.设置当前日期对象距离标准基准时间的毫秒值.也就意味着改变了当前日期对象 ###

// public void setTime(long time) 设置当前日期对象距离标准基准时间的毫秒值.也就意味着改变了当前日期对象
        // 创建当前统时间对应的日期对象
            Date date1 = new Date();
            System.out.println(date1);// Thu Sep 10 11:29:00 CST 2020
    
           // 创建以标准基准时间为基准 指定偏移1000毫秒
            Date date2 = new Date(1000);// 设置距离标准基准时间的毫秒值为1000
            System.out.println(date2);// Thu Jan 01 08:00:01 CST 1970
            
          // 修改date1距离标准基准时间的毫秒值为2000
            date1.setTime(2000);
            System.out.println(date1);// Thu Jan 01 08:00:02 CST 1970
            date2.setTime(2000);
            System.out.println(date2);// Thu Jan 01 08:00:02 CST 1970

### 3.测试此日期是否在指定日期之后或者之前 ###

//public boolean after(Date when) 测试此日期是否在指定日期之后。
           public boolean before(Date when) 测试此日期是否在指定日期之前。
          // 创建当前统时间对应的日期对象
            Date date1 = new Date();
            System.out.println(date1);// Thu Sep 10 11:29:00 CST 2020
    
           // 创建以标准基准时间为基准 指定偏移1000毫秒
            Date date2 = new Date(1000);// 设置距离标准基准时间的毫秒值为1000
            System.out.println(date2);// Thu Jan 01 08:00:01 CST 1970
    
    
          // 修改date1距离标准基准时间的毫秒值为2000
            date1.setTime(2000);
            System.out.println(date1);// Thu Jan 01 08:00:02 CST 1970
            date2.setTime(2000);
            System.out.println(date2);// Thu Jan 01 08:00:02 CST 1970
           // 创建当前统时间对应的日期对象
            Date date3 = new Date();
            System.out.println("date3表示的日期是否在date1之前:"+date3.before(date1));// false
            System.out.println("date3表示的日期是否在date1之后:"+date3.after(date1));// true

# 六、DateFormat类 #

## 一、解释 ##

java.text.DateFormat\` 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

*  格式化：按照指定的格式，把Date对象转换为String对象。
 *  解析：按照指定的格式，把String对象转换为Date对象。  
    由于DateFormat为抽象类，不能直接使用，所以需要常用的子类`java.text.SimpleDateFormat`。这个类需要一个模式（格式）来指定格式化或解析的标准。

## 二、构造函数 ##

public SimpleDateFormat(String pattern)\`：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。参数pattern是一个字符串，代表日期时间的自定义格式。  
常用的格式规则为：

<table> 
 <thead> 
  <tr> 
   <th>标识字母（区分大小写）</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>y</td> 
   <td>年</td> 
  </tr> 
  <tr> 
   <td>M</td> 
   <td>月</td> 
  </tr> 
  <tr> 
   <td>d</td> 
   <td>日</td> 
  </tr> 
  <tr> 
   <td>H</td> 
   <td>时</td> 
  </tr> 
  <tr> 
   <td>m</td> 
   <td>分</td> 
  </tr> 
  <tr> 
   <td>s</td> 
   <td>秒</td> 
  </tr> 
 </tbody> 
</table>

## 三、构造函数写法 ##

// 创建当前日期对象
            Date date1 = new Date();
             // 创建日期格式化对象,并且指定日期格式
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 格式化,日期格式随便指定

## 四、DateFormat类的常用方法 ##

### 1.将Date对象格式化为字符串 ###

//public String format(Date date)`：将Date对象格式化为字符串。
    // 创建当前日期对象
            Date date1 = new Date();
    
            // 创建日期格式化对象,并且指定日期格式
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 格式化,日期格式随便指定
    
            // 使用日期格式化对象,把日期对象转换为String对象
            String dateStr = sdf1.format(date1);
            System.out.println(dateStr);// 2020-09-10 12:02:56

### 2.将字符串解析为Date对象 ###

//public Date parse(String source)`：将字符串解析为Date对象。
     // 创建字符串对象
            String str = "2020年09月09日 12时00分00秒";
    
            // 创建日期格式化对象,并且指定日期格式
            SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");// 解析,日期格式要和字符串日期格式一样
    
            // 解析
            Date date = sdf2.parse(str);
            System.out.println(date);// Wed Sep 09 12:00:00 CST 2020

# 七、Calendar类 #

## 一、解释 ##

java.util.Calendar类表示一个“日历类”，可以进行日期运算。它是一个抽象类，不能创建对象，我们可以使用它的子类：java.util.GregorianCalendar类。

## 二、获取GregorianCalendar对象 ##

**1.直接创建GregorianCalendar对象**

GregorianCalendar cal = new GregorianCalendar()

**2.通过Calendar的静态方法getInstance()方法获取GregorianCalendar对象**

// 创建当前时间的日历对象
            Calendar cal = Calendar.getInstance();
            System.out.println(cal);
            /*

## 三、Calendarl类常用方法 ##

### 1.获取当前日期的日历对象 ###

//public static Calendar getInstance()` 获取当前日期的日历对象
     // 创建当前时间的日历对象
            Calendar cal = Calendar.getInstance();
            System.out.println(cal);
            /*

### 2.获取某个字段的值 ###

/*public int get(int field)` 获取某个字段的值。 参数field:表示获取哪个字段的值,可以使用Calender中定义的常量来表示 Calendar.YEAR : 年 Calendar.MONTH ：月 Calendar.DAY_OF_MONTH：月中的日期 Calendar.HOUR：小时 Calendar.MINUTE：分钟 Calendar.SECOND：秒 Calendar.DAY_OF_WEEK：星期*/
               // 创建当前时间的日历对象
            Calendar cal = Calendar.getInstance();
               /// 获取cal日历对象年字段的值
            int year = cal.get(Calendar.YEAR);
            System.out.println(year);// 2020
    
    		 // 获取cal日历对象月字段的值
            int month = cal.get(Calendar.MONTH);
            System.out.println(month);// 8

### 3.设置某个字段的值 ###

//public void set(int field,int value)设置某个字段的值
         // 创建当前时间的日历对象
            Calendar cal = Calendar.getInstance();
        // 设置cal日历对象中年字段的值为2030年
            cal.set(Calendar.YEAR,2030);
            System.out.println(cal.get(Calendar.YEAR));// 2030
    
            // 为cal日历对象的年字段的值+2
            cal.add(Calendar.YEAR,2);
            System.out.println(cal.get(Calendar.YEAR));// 2032

### 4.为某个字段增加/减少指定的值 ###

//public void add(int field,int amount)为某个字段增加/减少指定的值
    
        // 创建当前时间的日历对象
            Calendar cal = Calendar.getInstance();
        // 为cal日历对象的年字段的值+2
            cal.add(Calendar.YEAR,2);
            System.out.println(cal.get(Calendar.YEAR));// 2032
    
            // 为cal日历对象的年字段的值-1
            cal.add(Calendar.YEAR,-1);
            System.out.println(cal.get(Calendar.YEAR));// 2031
            System.out.println(cal.get(Calendar.MONTH));// 8

### 5.使用给定的 Date 设置此 Calendar 的时间 ###

//public void setTime(Date date) 使用给定的 Date 设置此 Calendar 的时间。
    
       // 创建当前时间的日历对象
            Calendar cal1 = Calendar.getInstance();// 2020年09月10日
    
            // 需求: 获取1998年10月10日对应的日历对象
            String birthdayStr = "1998年10月10日";
            // 把字符串的日期转换为Date类型的日期
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
            Date birthdayDate = sdf.parse(birthdayStr);
    
            // 调用cal的setTime方法,把日期对象传入
            cal1.setTime(birthdayDate);
    
            System.out.println("年:"+cal1.get(Calendar.YEAR));// 1998
            System.out.println("月:"+(cal1.get(Calendar.MONTH)+1));// 10
            System.out.println("日:"+cal1.get(Calendar.DAY_OF_MONTH));// 10

### 6.判断此 Calendar 表示的时间是否在指定 Object 表示的时间之前或之后，返回判断结果。 ###

//boolean before(Object when) `判断此 Calendar 表示的时间是否在指定 Object 表示的时间之前，返回判断结果。
    //boolean after(Object when) 判断当前日历对象的时间是否在指定日历对象时间之后
    
         // 创建当前时间的日历对象
            Calendar cal1 = Calendar.getInstance();// 2020年09月10日
    
            // 需求: 获取1998年10月10日对应的日历对象
            String birthdayStr = "1998年10月10日";
            // 把字符串的日期转换为Date类型的日期
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
            Date birthdayDate = sdf.parse(birthdayStr);
    
            // 调用cal的setTime方法,把日期对象传入
            cal1.setTime(birthdayDate);
            // 创建当前时间的日历对象
            Calendar cal2 = Calendar.getInstance();// 2020年09月10日
            System.out.println("cal1表示的时间是否在cal2表示的时间之前:"+cal1.before(cal2));// true
            System.out.println("cal1表示的时间是否在cal2表示的时间之后:"+cal1.after(cal2));// false

# 八、Math类 #

## 一、解释 ##

*  java.lang.Math(类): Math类包含执行基本数字运算的方法。
 *  它不能创建对象，它的构造方法被“私有”了。因为他内部都是“静态方法”，通过“类名”直接调用即可。

二、Math常用方法

/* public static int abs(int a) 获取参数a的绝对值： public static double ceil(double a) 向上取整 例如:3.14 向上取整4.0 public static double floor(double a) 向下取整 例如:3.14 向下取整3.0 public static double pow(double a, double b) 获取a的b次幂 public static long round(double a) 四舍五入取整 例如:3.14 取整3 3.56 取整4 public static int max(int a, int b) 返回两个 int 值中较大的一个。 public static int min(int a, int b) 返回两个 int 值中较小的一个。*/
            System.out.println("10的绝对值:"+Math.abs(10));// 10
            System.out.println("-10的绝对值:"+Math.abs(-10));// 10
    
            System.out.println("3.14向上取整:"+Math.ceil(3.14));// 4.0
            System.out.println("3.54向上取整:"+Math.ceil(3.54));// 4.0
            System.out.println("-3.54向上取整:"+Math.ceil(-3.54));// -3.0
    
            System.out.println("==================================");
            System.out.println("3.14向下取整:"+Math.floor(3.14));// 3.0
            System.out.println("3.54向下取整:"+Math.floor(3.54));// 3.0
            System.out.println("-3.54向下取整:"+Math.floor(-3.54));// -4.0
    
            System.out.println("==================================");
            System.out.println("2的3次幂:"+Math.pow(2,3));// 8.0
    
            System.out.println("==================================");
            System.out.println("3.14四舍五入取整:"+Math.round(3.14));// 3
            System.out.println("3.54四舍五入取整:"+Math.round(3.54));// 4
            System.out.println("-3.54四舍五入取整:"+Math.round(-3.54));// -4
    
    
            System.out.println("==================================");
            System.out.println("获取10和20的最大值:"+Math.max(10,20));// 20
            System.out.println("获取10和20的最小值:"+Math.min(10,20));// 10

# 九、System类 #

## 一、解释 ##

java.lang.System\`类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作。

## 二、System类常用方法 ##

### 1.终止当前运行的Java虚拟机，非零表示异常终止 ###

//public static void exit(int status) 终止当前运行的Java虚拟机，非零表示异常终止
            System.out.println("开始");
            System.out.println("执行");
            //System.exit(0);// 程序正常退出
            //System.exit(-1);// 程序非正常退出

### 2.返回当前时间距离标准基准时间的毫秒值(以毫秒为单位) ###

//public static long currentTimeMillis() 返回当前时间距离标准基准时间的毫秒值(以毫秒为单位)
          // 获取当前时间距离标准基准时间的毫秒值
            Date date = new Date();
            System.out.println(date.getTime());
            System.out.println(System.currentTimeMillis());

### 3.拷贝数组中的元素到另一个数组 ###

/*public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 拷贝数组中的元素到另一个数组 参数1src: 源数组 参数2srcPos:源数组要拷贝的元素的起始索引(从哪个索引位置开始拷贝) 参数3dest: 目标数组 参数4destPos:目标数组接收拷贝元素的起始索引(从哪个索引位置开始接收) 参数5length:需要拷贝多少个元素(拷贝多少个)*/
                              // 拷贝数组元素到另一个数组中
            int[] arr1 = { 1,2,3,4,5,6,7,8};
            int[] arr2 = { 10,20,30,40,50,60,70,80};
            // 需求:把arr1中的3,4,5,6,7元素拷贝到arr2数组中,使得arr2数组变成{10,3,4,5,6,7,70,80};
            System.arraycopy(arr1,2,arr2,1,5);

# 十、BigInteger类 #

## 一、解释 ##

java.math.BigInteger 类，不可变的任意精度的整数。如果运算中，数据的范围超过了long类型后，可以使用  
BigInteger类实现，该类的计算整数是不限制长度的。

## 二、构造方法 ##

BigInteger(String value) 将 BigInteger 的十进制字符串表示形式转换为 BigInteger。超过long类型的范围，已经不能称为数字了，因此构造方法中采用字符串的形式来表示超大整数，将超大整数封装成BigInteger对象。

## 三、常用方法（加、减、乘、除） ##

<table> 
 <thead> 
  <tr> 
   <th>方法声明</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>add(BigInteger value)</td> 
   <td>返回其值为 (this + val) 的 BigInteger，超大整数加法运算</td> 
  </tr> 
  <tr> 
   <td>subtract(BigInteger value)</td> 
   <td>返回其值为 (this - val) 的 BigInteger，超大整数减法运算</td> 
  </tr> 
  <tr> 
   <td>multiply(BigInteger value)</td> 
   <td>返回其值为 (this * val) 的 BigInteger，超大整数乘法运算</td> 
  </tr> 
  <tr> 
   <td>divide(BigInteger value)</td> 
   <td>返回其值为 (this / val) 的 BigInteger，超大整数除法运算，除不尽取整数部分</td> 
  </tr> 
 </tbody> 
</table>

// 创建一个BigInteger类的对象,表示一个无限大的整数
            BigInteger b1 = new BigInteger("1000000000000000000000");
            BigInteger b2 = new BigInteger("1223435453543654354354");
    
            // b1 + b2
            BigInteger res1 = b1.add(b2);
            System.out.println("b1 + b2 = "+res1);// 2223435453543654354354
    
            // b1 - b2
            BigInteger res2 = b1.subtract(b2);
            System.out.println("b1 - b2 = " + res2);// -223435453543654354354
    
            // b1 * b2
            BigInteger res3 = b1.multiply(b2);
            System.out.println("b1 * b2 = "+res3);// 1223435453543654354354000000000000000000000
    
            // b1 / b2
            BigInteger res4 = b1.divide(b2);
            System.out.println("b1 / b2 = " + res4);// 0 10/3=3
    
    
            // int a = 1000000000000;// 编译报错,因为超出了int类型所能表示的数据范围
            // long l = 1000000000000000000000L;// 编译报错,因为超出了long类型所能表示的数据范围
        }

# 十一、BigDecimal类 #

## 一、解释 ##

表示超大小数，解决小数运算问题，有些小数运算有精度问题。对于浮点运算，不要使用基本类型，而用"BigDecimal类型。dobule类型的数据封装成BigDecimal还是有精度问题建议用字符串包装。

## 二、构造方法 ##

**1.将double类型的数据封装为BigDecimal对象**

//BigDecimal(double val)：将double类型的数据封装为BigDecimal对象
    BigDecimal b1 = new BigDecimal(0.09);

**2.将 BigDecimal 的字符串表示形式转换为 BigDecimal**

//BigDecimal(String val) 将 BigDecimal 的字符串表示形式转换为 BigDecimal 
    BigDecimal b1 = new BigDecimal("0.09");

**3.区别**  
第一种方法还是有可能存在精度问题，推荐使用第二种。

## 三、BigDecimal类常用方法（加、减、乘、除） ##

<table> 
 <thead> 
  <tr> 
   <th>方法声明</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public BigDecimal add(BigDecimal value)</td> 
   <td>加法运算</td> 
  </tr> 
  <tr> 
   <td>public BigDecimal subtract(BigDecimal value)</td> 
   <td>减法运算</td> 
  </tr> 
  <tr> 
   <td>public BigDecimal multiply(BigDecimal value)</td> 
   <td>乘法运算</td> 
  </tr> 
  <tr> 
   <td>public BigDecimal divide(BigDecimal value)</td> 
   <td>除法运算</td> 
  </tr> 
 </tbody> 
</table>

注意：对于divide方法来说，如果除不尽的话，
                    就会出现java.lang.ArithmeticException异常。此时可以使用divide方法的另一个重载方法；
    
                    BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode):
                                    divisor：除数对应的BigDecimal对象；
                                    scale:精确的位数；
                                    roundingMode取舍模式  RoundingMode枚举: RoundingMode.HALF_UP 四舍五入

igDecimal b1 = new BigDecimal("0.09");
            BigDecimal b2 = new BigDecimal("0.01");
            BigDecimal res1 = b1.add(b2);
            System.out.println("res1:"+res1);// 0.10
    
            // 减法运算:
            BigDecimal b3 = new BigDecimal("1.0");
            BigDecimal b4 = new BigDecimal("0.32");
            BigDecimal res2 = b3.subtract(b4);
            System.out.println("res2:"+res2);// 0.68
    
            // 乘法运算
            BigDecimal b5 = new BigDecimal("1.015");
            BigDecimal b6 = new BigDecimal("100");
            BigDecimal res3 = b5.multiply(b6);
            System.out.println("res3:"+res3);// 101.500
    
            // 除法运算
            BigDecimal b7 = new BigDecimal("1.301");
            BigDecimal b8 = new BigDecimal("100");
            BigDecimal res4 = b7.divide(b8);
            System.out.println("res4:"+res4);// 0.01301
    
            // 加法运算: 有问题的
            BigDecimal b9 = new BigDecimal(0.09);
            BigDecimal b10 = new BigDecimal(0.01);
            BigDecimal res5 = b9.add(b10);
            System.out.println("res5:"+res5);// res5:0.0999999999999999968774977432417472300585359334945678710937
    
            // 除法运算: 有问题的
            /*BigDecimal b11 = new BigDecimal("10"); BigDecimal b12 = new BigDecimal("3"); BigDecimal res6 = b11.divide(b12);// 报异常 System.out.println("res6:"+res6);*/
    
            /*BigDecimal b13 = new BigDecimal("20"); BigDecimal b14 = new BigDecimal("3"); BigDecimal res7 = b13.divide(b14);// 报异常 System.out.println("res7:"+res7);*/
    
            // 注意：对于divide方法来说，如果除不尽的话，
            // 就会出现java.lang.ArithmeticException异常。此时可以使用divide方法的另一个重载方法；
            BigDecimal b11 = new BigDecimal("10");
            BigDecimal b12 = new BigDecimal("3");
            BigDecimal res6 = b11.divide(b12,2, RoundingMode.HALF_UP);
            System.out.println("res6:"+res6);// 3.33
    
            BigDecimal b13 = new BigDecimal("20");
            BigDecimal b14 = new BigDecimal("3");
            BigDecimal res7 = b13.divide(b14,3,RoundingMode.HALF_UP);
            System.out.println("res7:"+res7);// 6.667
    
    
            // System.out.println(0.09+0.01);// 期望: 0.10 实际:0.09999999999999999
           // System.out.println(1.0 - 0.32);// 期望; 0.68 实际:0.6799999999999999
           // System.out.println(1.015 * 100);// 期望:101.500 实际:101.49999999999999
           // System.out.println(1.301 / 100);// 期望:0.01301 实际:0.013009999999999999
        }

# 十二、Arrays类 #

## 一、解释 ##

java.util.Arrays类：该类包含用于操作数组的各种方法（如排序和搜索）

## 二、常用方法 ##

### 1.按照数字顺序排列指定的数组 ###

//public static void sort(int[] a)：按照数字顺序排列指定的数组
         int[] arr = { 12,334,53,543,43,32};
        System.out.println("排序之前的数组:"+Arrays.toString(arr));//[12, 334, 53, 543, 43, 32]
        // 对arr数组中的元素进行升序排序
        Arrays.sort(arr);
        System.out.println("排序之后的数组:"+Arrays.toString(arr));//[12, 32, 43, 53, 334, 543]

### 2.返回指定数组的内容的字符串表示形式 ###

区分静态的tostring和非静态的tostring()

//public static String toString(int[] a)：返回指定数组的内容的字符串表示形式
            int[] arr = { 12,334,53,543,43,32};
            System.out.println("排序之前的数组:"+Arrays.toString(arr));//[12, 334, 53, 543, 43, 32]
            // 对arr数组中的元素进行升序排序
            Arrays.sort(arr);
            System.out.println("排序之后的数组:"+Arrays.toString(arr));//[12, 32, 43, 53, 334, 543]

# 十三、包装类 #

## 一、解释 ##

ava提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，对基本数据类型进行包装成对象，然后进行操作。

## 二、包装类分类 ##

<table> 
 <thead> 
  <tr> 
   <th>基本类型</th> 
   <th>对应的包装类（位于java.lang包中）</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>Byte</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>Integer</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>Double</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>Character</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>Boolean</td> 
  </tr> 
 </tbody> 
</table>

# 十四、Integer类 #

## 一、解释 ##

将int类型的基本类型，包装成一个对象类型，为Integer类型。

## 二、构造方法 ##

**1.根据int值创建**

//public Integer(int value)：根据 int 值创建 Integer 对象(过时)
    Integer i1 = new Integer(10);// i1对象表示的整数就是10

**2.根据字符串类型创建**

//public Integer(String s)：根据 String 值创建 Integer 对象(过时)
       Integer i3 = new Integer("100");// i3对象表示的整数就是100

## 三、常用方法 ##

### 1.返回表示指定的 int 值的 Integer 实例 ###

//public static Integer valueOf(int i)：返回表示指定的 int 值的 Integer 实例
     Integer i2 = Integer.valueOf(10);// i2对象表示的整数就是10

### 2.返回保存指定String值的 Integer 对象 ###

//public static Integer valueOf(String s)：返回保存指定String值的 Integer 对象
        Integer i4 = Integer.valueOf("100");// i4对象表示的整数就是100

### 3.Integer 对象转int基本类型 ###

Integer i1 = new Integer(10);// i1对象表示的整数就是10
         // Integer--->int
            int num1 = i1.intValue();

# 十四、装箱和拆箱 #

## 一、解释 ##

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“

*  **装箱**：从基本类型转换为对应的包装类对象。
 *  **拆箱**：从包装类对象转换为对应的基本类型。

## 二、自动装箱与拆箱 ##

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。

// int--->Integer
      ///手动装箱，这里也可直接int接收。
        Integer i1 = new Integer(10);// i1对象表示的整数就是10
        Integer i2 = Integer.valueOf(10);// i2对象表示的整数就是10
        //所有包装类都有valueOf方法转对应的包装类型。
    
        // 手动拆箱
        // Integer--->int
        int num1 = i1.intValue();
        int num2 = i2.intValue();
    
    
    
        // 自动装箱
        Integer i3 = 10;
    
        // 自动拆箱
        int num3 = i3;

可以将“包装类”和“基本类型”混合使用，比较方便

# 十五、字符串和基本类型之间的转换 #

区分包装类和基本数据类型，字符串是引用数据类型。它和其它基本类型的转换又不一样。

## 一、基本类型转String ##

### 1.直接在数字后加一个空字符串 ###

//int --- String
            int number = 100;
            //方式1
            String s1 = number + "";
            System.out.println(s1);

### 2.通过String类静态方法valueOf() ###

int number = 100;
         //public static String valueOf(int i)
            String s2 = String.valueOf(number);
            System.out.println(s2);

## 二、String类型转基本类型 ##

除了Character类之外，**其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型**：

*  `public static byte parseByte(String s)`：将字符串参数转换为对应的byte基本类型。
 *  `public static short parseShort(String s)`：将字符串参数转换为对应的short基本类型。
 *  `public static int parseInt(String s)`：将字符串参数转换为对应的int基本类型。
 *  `public static long parseLong(String s)`：将字符串参数转换为对应的long基本类型。
 *  `public static float parseFloat(String s)`：将字符串参数转换为对应的float基本类型。
 *  `public static double parseDouble(String s)`：将字符串参数转换为对应的double基本类型。
 *  `public static boolean parseBoolean(String s)`：将字符串参数转换为对应的boolean基本类型。  
    **以Integer类为例**

// 基本类型--->字符串:
            String str1 = 100 + "";// str1字符串的内容:"100"
            String str2 = String.valueOf(100);// str2字符串的内容: "100"
    
            // 字符串--->基本类型:
            int num1 = Integer.parseInt(str1);
            int num2 = Integer.parseInt(str2);
            System.out.println(num1+num2);// 200

如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出`java.lang.NumberFormatException`异常。