常用類

包裝類

在類中查看屬性方法的快捷鍵：Ctrl+F12

java.lang包會(huì)默認(rèn)導(dǎo)入每個(gè)Java文件，所以我們不需要導(dǎo)入這個(gè)包，直接用包中的類就好了

• byte Byte

  short Short

  int Integer

  long Long

  float Float

  double Double

  char Character

  boolean Boolean

• 在Java中，類只能直接繼承一個(gè)類，但可以間接繼承多個(gè)類

• 包裝類就是八大基本類型對(duì)應(yīng)的類（前六個(gè)包裝類是直接繼承Number類，間接繼承object類，后兩個(gè)是直接繼承object類）

• 我們?yōu)槭裁匆氚b類？

  • 將基本類型包裝成為對(duì)應(yīng)的包裝類，就是為了獲取某些屬性，方法
  • 集合（存放數(shù)據(jù)的）只能存放引用數(shù)據(jù)類型

我們以integer類作講解，其他都一樣：（類的學(xué)習(xí)都是使用API幫助文檔）

• integer底層就是一個(gè)int類型的數(shù)據(jù)

• int類型數(shù)據(jù)的最大最小值，直接類名調(diào)用屬性就可以了，例如：

  System.out.println(Integer.MAX_VALUE);
  System.out.println(Integer.MIN_VALUE);
  

• integer類中沒有無參構(gòu)造器

  有參（字符串）構(gòu)造只能是可以轉(zhuǎn)換為int類型的字符串

• 自動(dòng)裝箱

  int類型轉(zhuǎn)換為integer，例如:

  Integer i1=12;
  //其實(shí)內(nèi)部進(jìn)行的操作是，Integer i1=Integer.valueOf(12);這步我們要通過反編譯工具才可以看到
  

• 自動(dòng)拆箱

  integer類型轉(zhuǎn)換為int類型，例如：

  int a=i1;
  

• compareTo方法，就是比較大小，例如：

  System.out.println(i1.compareTo(i2));//這個(gè)方法的返回值就是一個(gè)int類型
  

• equals方法，比較是否相等，比較的是數(shù)值，例如：

  System.out.println(i1.equals(i2));
  //等于比較的是地址，就是看是否為同一個(gè)值
  System.out.println(i1==i2);
  

• 自動(dòng)裝箱的重點(diǎn)：

  Integer i1=12;
  Integer i2=12;
  System.out.println(i1==i2);//返回值為true，因?yàn)橹翟?128到127之間就直接在一個(gè)數(shù)組中取值，所以為true
  /*
  如果不在這個(gè)范圍內(nèi)就會(huì)創(chuàng)建一個(gè)對(duì)象，不在那個(gè)數(shù)組里取值，而是自己創(chuàng)建對(duì)象存值，所以這也說明了
  自動(dòng)裝箱不一定會(huì)創(chuàng)建對(duì)象，還有數(shù)值超出那個(gè)范圍才會(huì)創(chuàng)建對(duì)象
  */
  

• intValue()方法，將integer轉(zhuǎn)換為int類型

  System.out.println(i1.intValue());
  

• parseInt()方法，將String類型轉(zhuǎn)換為int類型，字符串要可以轉(zhuǎn)換為int，不然會(huì)報(bào)異常

  int i = Integer.parseInt("12");
  

• valueof(int i)/(String s)方法，就是將int類型轉(zhuǎn)換為integer類型/將String類型轉(zhuǎn)換為int類型

String類

從屬于java.lang包

• String類的底層就是一個(gè)char類型的數(shù)組

• 創(chuàng)建對(duì)象時(shí)調(diào)用構(gòu)造器就是對(duì)底層char類型數(shù)組的賦值

  String類中有很多構(gòu)造器，可以通過創(chuàng)建對(duì)象調(diào)用構(gòu)造器，例如：

  String s1 = new String();
  String s2 = new String("abc");
  String s3 = new String(new char[]{'1', '2', '3'});
  

一般都是用對(duì)象名去調(diào)用方法

String類中的方法：

str1.length()，就是str1的長(zhǎng)度，底層就是char類型數(shù)組的長(zhǎng)度（返回結(jié)果為int值）

str1.isEmpty()判斷這個(gè)對(duì)象是否為空（返回結(jié)果為布爾值）

str1.charAt(2)得到該數(shù)組下標(biāo)（2）對(duì)應(yīng)元素的值（返回結(jié)果就是元素對(duì)應(yīng)的值）

str5.equals(str6)判斷兩個(gè)對(duì)象值是否相等(返回值為布爾值)，內(nèi)部先判斷是否相等，在判斷長(zhǎng)度是否相等，在判斷值是否相等

• compareTo()方法

  String s4="abc";
  String s5="abcdef";
  System.out.println(s4.compareTo(s5));//返回4，4是長(zhǎng)度差1
  //這種情況下返回的就是長(zhǎng)度差，因?yàn)榍叭齻€(gè)字符是一樣的
  String s4="abc";
  String s5="defghj";
  System.out.println(s4.compareTo(s5));//返回的是ASCII碼
  //只要前三個(gè)字符中有一個(gè)不一樣，就會(huì)返回ASCII碼，只有前三個(gè)字符串全部一樣才會(huì)返回長(zhǎng)度差
  

• indexOf()方法

  System.out.println(s5.indexOf('f'));//輸出的值為元素對(duì)應(yīng)的下標(biāo)，是個(gè)int值
  

• API幫助文檔提供的是我們可以使用的方法，像private修飾的方法我們就不能使用，所以API文檔也不會(huì)提供給我們

• substring()方法，字符串的截取

  String s5="abcdef";
  String substring = s5.substring(2);
  System.out.println(substring);//輸出cdef
  String substring1 = s5.substring(2, 3);//這里只能輸出一個(gè)字符，因?yàn)樵贘ava很多地方都是包頭不包尾的
  System.out.println(substring1);//輸出c
  

• concat()方法，就是兩個(gè)字符串進(jìn)行拼接

  String s4="abc";
  String s5="abcdef";
  System.out.println(s4.concat(s5));//輸出abcabcdef
  

• replace()方法，就是將字符串中的一個(gè)字符替換為另一個(gè)字符

  String s4="abc";
  System.out.println(s4.replace('a', 'p'));//輸出結(jié)果為pbc,就是將a字符替換成為p字符
  

• 有返回值的方法可以先返回一個(gè)值，然后sout輸出，也可以直接sout輸出

• toUpperCase()方法，將字符串中全部字符轉(zhuǎn)換為大寫

  String s5="abcdef";
  System.out.println(s5.toUpperCase());//輸出結(jié)果為ABCDEF
  

• toLowerCase()方法，將字符串中的全部字符轉(zhuǎn)換為小寫

  String s5="AAAAAA";
  System.out.println(s5.toLowerCase());//輸出結(jié)果為aaaaaa
  

• trim()方法，去掉首尾空格

  String s5="      AAAA          AA         ";
  System.out.println(s5.trim());//輸出結(jié)果為AAAA          AA
  

• toString()方法，誰調(diào)用就返回誰

  String s5="asdfghj";
  System.out.println(s5.toString());//輸出結(jié)果為asdfghj
  

• valueOf()方法，將int類型的值轉(zhuǎn)換為字符串

  System.out.println(String.valueOf(12));
  

String內(nèi)存+反編譯驗(yàn)證

字符串定義的方式：

        String s1="abc";
        String s2="a"+"b"+"c";
        String s3="abc"+"";
        //字符串拼接，會(huì)進(jìn)行編譯期優(yōu)化，直接拼成最終你要的字符串
        String s4=s1+"";
        //變量參與運(yùn)算，就會(huì)在堆中開辟空間，會(huì)創(chuàng)建一個(gè)StringBuilder對(duì)象
        String s5=new String("abc");
        //創(chuàng)建對(duì)象，會(huì)在堆中開辟空間
        System.out.println(s1==s2);//輸出true
        System.out.println(s1==s3);//輸出true
        System.out.println(s1==s4);//輸出false
        System.out.println(s1==s5);//輸出false

編譯器優(yōu)化：自動(dòng)將s2，s3拼接為"abc"，將s4拼接為s1，直接拼成最終你要的字符串

變量的內(nèi)存地址是由第一個(gè)指向的位置決定的（我自己理解出的，不一定對(duì)）

• s1到s5在內(nèi)存中的存儲(chǔ)圖大致為：

  

• 壓棧（入棧）：對(duì)象名，變量名啥的都會(huì)被壓入棧中，具體怎么壓我現(xiàn)在也不知道

StringBuilder類

• 底層最重要的兩個(gè)數(shù)是char類型的數(shù)組和int類型的數(shù)

• StringBuilder的無參構(gòu)造會(huì)調(diào)用父類的構(gòu)造器并給char類型數(shù)組確定長(zhǎng)度為16

  你要是調(diào)用有參構(gòu)造器的話會(huì)將數(shù)組長(zhǎng)度確定為你傳的那個(gè)數(shù)字，例如：

  StringBuilder stringBuilder = new StringBuilder(23);//開辟長(zhǎng)度為23的數(shù)組
  

  你要調(diào)用字符串有參構(gòu)造的話，開辟數(shù)組長(zhǎng)度為字符串長(zhǎng)度加默認(rèn)長(zhǎng)度16

  StringBuilder stringBuilder1 = new StringBuilder("abc");//開辟長(zhǎng)度為19的數(shù)組
  

  StringBuilder底層的char數(shù)組長(zhǎng)度要是不夠用了，它會(huì)重新創(chuàng)建一個(gè)數(shù)組，而String是不能重新創(chuàng)建數(shù)組

• String是不可變字符串，StringBuilder是可變字符串

StringBuilder的常用方法

StringBuilder與StringBuffer的區(qū)別聯(lián)系

利用數(shù)組擴(kuò)容原理（StringBuilder類的原理）創(chuàng)建一個(gè)類來模擬集合Arraylist：

注意細(xì)節(jié)：this就是調(diào)用本類的構(gòu)造器，而super是調(diào)用父類的構(gòu)造器

為什么我們要說一個(gè)類的底層是一個(gè)數(shù)組或變量啥的？

因?yàn)槲覀兛梢园l(fā)現(xiàn)所有的屬性和方法都是給那個(gè)數(shù)組或變量進(jìn)行操作，所以我們說這個(gè)類的底層就是一個(gè)數(shù)組或變量啥的

實(shí)現(xiàn)代碼為：

package 包;

import java.lang.management.MemoryUsage;

public class MyCollection {
    //底層是一個(gè)object數(shù)組
    Object[] value;
    //計(jì)數(shù)組中被占用的個(gè)數(shù)
    int size;
    //定義無參構(gòu)造
    public MyCollection(){
        value=new Object[3];//數(shù)組長(zhǎng)度賦值為3
    }
    //定義有參構(gòu)造，數(shù)組長(zhǎng)度由參數(shù)決定
    public MyCollection(int num){
        value=new Object[num];
    }
    //往數(shù)組里放東西的方法
    public MyCollection add(Object obj){
        value[size]=obj;
        size++;
        //一旦超出范圍，我們就要進(jìn)行數(shù)組的擴(kuò)容
        if (size>value.length-1){
            //擴(kuò)容:創(chuàng)建一個(gè)新的數(shù)組
            Object[] newObj=new Object[value.length*2+2];
            //將老數(shù)組中的東西復(fù)制到新數(shù)組中
            for (int i = 0; i <= value.length-1; i++) {
                newObj[i]=value[i];
            }
            //將value指向newObj，下次就是直接向新數(shù)組中放值
            value=newObj;
        }
        return this;
    }
    //取值
    public Object get(int index){
        if (index<0||index>=size){
            throw new RuntimeException("超出邊界");
        }
        return value[index];
    }
    //計(jì)數(shù)組長(zhǎng)度
    public int size(){
        return size;
    }
    //重寫toString方法
    public String toString() {
        StringBuilder sb = new StringBuilder("[");
        for (int i = 0; i < size; i++) {
            sb.append(value[i]+",");

        }
        sb.setCharAt(sb.length()-1,']');
        return sb.toString();
    }
    public static void main(String[] args) {
        MyCollection mc1 = new MyCollection();//調(diào)用無參構(gòu)造創(chuàng)建對(duì)象，定義數(shù)組長(zhǎng)度為3
        MyCollection mc2 = new MyCollection(3);//調(diào)用有參構(gòu)造，定義數(shù)組長(zhǎng)度為3
        mc1.add(1);
        mc1.add("aaa");
        mc1.add(3);
        mc1.add(4);//這個(gè)數(shù)組是能放3個(gè)，這是第四個(gè)，數(shù)組下標(biāo)越界
        mc1.add(5).add(6).add(7);
        //輸出數(shù)組元素
        for (int i = 0; i <= mc1.size()-1; i++) {
            System.out.println(mc1.get(i));
        }
        System.out.println(mc1);
        System.out.println(mc1.toString());
    }
}

時(shí)間處理類

• date類

          Date d = new Date();
          //打印出當(dāng)前系統(tǒng)的世間
          System.out.println(d);
  

• date類中的其他表示時(shí)間的方法

  Date d = new Date();
          //打印出當(dāng)前系統(tǒng)的時(shí)間
          System.out.println(d);
          //以下是過期的打印時(shí)間的方法
          System.out.println(d.toGMTString());
          System.out.println(d.toLocaleString());
          System.out.println(d.getYear());//當(dāng)前年份減去1900
          System.out.println(d.getMonth());//返回的是0到11之間的數(shù)，5表示6月
          System.out.println(d.getDate());//月份中的某一天，值在0到31之間
          System.out.println(d.getDay());//返回的是星期幾
  
          //以下兩個(gè)打印的都是毫秒數(shù)，但是為什么第二個(gè)是常用的吶？
          System.out.println(d.getTime());//返回的是毫秒數(shù)
          System.out.println(System.currentTimeMillis());//因?yàn)樗挥脛?chuàng)建對(duì)象，不用導(dǎo)包，直接調(diào)用
  
  //java.sql.Date 年月日
          //java.util.Date 年月日時(shí)分秒
          java.sql.Date sqlDate=new java.sql.Date(12122121l);
          System.out.println(sqlDate);
  //將String類型轉(zhuǎn)換為java.sql.Date
          java.sql.Date date = sqlDate.valueOf("2019-10-10");
  
  //java.util.Date轉(zhuǎn)換為java.sql.Date(util.Date調(diào)用自己的方法充當(dāng)sql.Date的參數(shù))
          java.sql.Date date1 = new java.sql.Date(new Date().getTime());
          //java.sql.Date轉(zhuǎn)換為java.util.Date(類轉(zhuǎn)類，用的是繼承關(guān)系，父類子類的關(guān)系)
          Date date2=date1
  

• java.sql包下還有兩個(gè)時(shí)間類，Time,Timestamp類，知道有這兩個(gè)類就行了

• String轉(zhuǎn)換為java.util.Date

  //String----->java.util.Date
          //1. String----->java.sql.Date
          java.sql.Date date3 = java.sql.Date.valueOf(2019-1-8);
          //2. java.sql.Date----->java.util.Date
          Date date4=date3;
  

  這種方法有局限：valueOf方法中字符串格式必須為：年--月--日

  實(shí)現(xiàn)開發(fā)工作中將String轉(zhuǎn)換為java.util.Date需要借助Dateformat類（日期格式化）

  //創(chuàng)建實(shí)現(xiàn)類對(duì)象時(shí)需要確定日期的格式，字符可以是多個(gè)也可以是單個(gè)，例如：y-M-d h-m-s
  SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh-mm-ss");
          try {
              //parse方法的作用：String----->Date
              //這里的日期格式必須和確定的日期格式相同
              Date parse = simpleDateFormat.parse("2100-12-10 10-20-30");
              System.out.println(parse);
          } catch (ParseException e) {
              e.printStackTrace();
          }
  //format方法的作用：Date----->String
  //這里轉(zhuǎn)換為的String格式為創(chuàng)建對(duì)象時(shí)確定的日期格式
          String format = simpleDateFormat.format(new Date());
          System.out.println(format);
  

字符代表的意思：

• 類創(chuàng)建對(duì)象失敗的原因：

  1. 接口
  2. 抽象類
  3. 沒有無參構(gòu)造，需要用有參構(gòu)造創(chuàng)建對(duì)象
  4. 無參構(gòu)造被private修飾

• Calendar類（日歷）

  很強(qiáng)大，但是我們用得少

  注意：Calendar類本身（抽象類）不能創(chuàng)建對(duì)象，但我們可以讓類通過調(diào)用方法來創(chuàng)建對(duì)象，也可以創(chuàng)建它實(shí)現(xiàn)類的對(duì)象來創(chuàng)建對(duì)象，例如：

  Calendar cal1 =Calendar.getInstance();
          Calendar cal2 = new GregorianCalendar();
  

  Calendar類中的方法：

  //獲取方法：
  System.out.println(cal1.get(Calendar.YEAR));//輸出2021
          System.out.println(cal1.get(Calendar.MONTH));//輸出的月份是當(dāng)前月份減1
          System.out.println(cal1.get(Calendar.DATE));//輸出20號(hào)
          System.out.println(cal1.get(Calendar.DAY_OF_WEEK));//輸出的是一個(gè)星期中的第幾天，例如：星期六是一個(gè)星期中   的第七天
          System.out.println(cal1.getActualMaximum(Calendar.DATE));//輸出這個(gè)月中最大的一天
          System.out.println(cal1.getActualMaximum(Calendar.MONTH));//輸出11，就是12月的意思，因?yàn)閺?開始
          System.out.println(cal1.getActualMinimum(Calendar.DATE));//一個(gè)月中最小的一天肯定是1
          
  //設(shè)置方法：
  cal1.set(Calendar.DATE,16);//修改為16號(hào)
          cal1.set(Calendar.MONTH,9);//修改為9月
          cal1.set(Calendar.YEAR,2051);//修改為2051年
          System.out.println(cal1);
  

  • String----->Calendar，先轉(zhuǎn)換為date，在轉(zhuǎn)換為Calendar

  Calendar cal = Calendar.getInstance();
          //String----->Calendar
          //String----->Date
          Date date = Date.valueOf("2019-2-10");
          //Date----->Calendar
          cal.setTime(date);
          System.out.println(cal);
  

  打印輸出日歷表：

  package 包;
  
  import java.sql.Date;
  import java.util.Calendar;
  import java.util.Scanner;
  
  public class Test {
      public static void main(String[] args) {
          System.out.print("請(qǐng)輸入你想要查看的日期：--(格式例如：2019-10-10):");
          Scanner sc=new Scanner(System.in);
          String str = sc.next();//這個(gè)方法使用來接收鍵盤輸入的，接收到數(shù)據(jù)后要返回一個(gè)值
          //String----->Calendar  為什么要轉(zhuǎn)為Calendar類型？ 答：因?yàn)檫@個(gè)類比較強(qiáng)大，只有轉(zhuǎn)化為Calendar類才可以進(jìn)行后續(xù)步驟
          Date valueOf = Date.valueOf(str);
          Calendar cal = Calendar.getInstance();
          cal.setTime(valueOf);//轉(zhuǎn)換成功
          System.out.println("日\(chéng)t一\t二\t三\t四\t五\t六");
          int count=0;
          //求出這個(gè)月中的最大天數(shù)
          int actualMaximum = cal.getActualMaximum(Calendar.DATE);
          //獲取當(dāng)天的天數(shù)
          int nowDay = cal.get(Calendar.DATE);
          //修改
          cal.set(Calendar.DATE,1);
          //空格
          int num = cal.get(Calendar.DAY_OF_WEEK);
          for (int i = 1; i <=num-1 ; i++) {
              System.out.print("\t");
          }
          count+=(num-1);
          for (int i = 1; i <= actualMaximum; i++) {
              if (i!=nowDay){
                  System.out.print(i+"\t");
              }else{
                  System.out.print(i+"*\t");
              }
              count++;
              if (count%7==0){
                  System.out.println();
              }
          }
      }
  }
  

枚舉

• 用enum關(guān)鍵字來表示

• 枚舉的定義

  public enum Test {
     SPRING,SUMMER,AUTUMN,WINTER;
  }
  

• 枚舉的創(chuàng)建

  public void test1(){
          //枚舉的創(chuàng)建
          Test test=Test.SPRING;
      }
  

• 枚舉的常用方法

  //values()方法，將枚舉直接變成數(shù)組，屬性就是元素，類型就是枚舉名
  public class TestEnum {
      @Test
      //加上這個(gè)注釋就可以直接執(zhí)行，不需要main方法
      public void test(){
          Season[] values = Season.values();
          for (Season value : values) {
              System.out.println(value);
          }
      }
  }
  //ordinal()方法
  Season[] values = Season.values();
          for (Season value : values) {
              System.out.println(value.ordinal());
          }
  

• 用枚舉來做一個(gè)交通信號(hào)燈的實(shí)例

  import org.junit.Test;
  
  public class TestEnum {
      TrafficLight light=TrafficLight.RED;
      public void test(){
          switch (light){
              case RED:
                  this.light=TrafficLight.GREEN;break;
              case GREEN:
                  this.light=TrafficLight.YELLOW;break;
              case YELLOW:
                  this.light=TrafficLight.RED;break;
          }
      }
      @Test
      public void test1(){
  
          for (int i = 0; i < 11; i++) {
              test();
              System.out.println(light);
          }
      }
  }
  

• 枚舉的構(gòu)造方法只能用private修飾

• 只有創(chuàng)建了構(gòu)造器，枚舉的屬性后才會(huì)有括號(hào)

  @Test
      public void test5(){
          //創(chuàng)建枚舉  枚舉屬性中的值會(huì)直接傳到構(gòu)造器中,可以用構(gòu)造器來給枚舉的屬性賦值
          Orientation north = Orientation.NORTH;
          System.out.println(north.getcity());
      }
  

• EnumMap是一個(gè)類（要求所有的鍵都來自同一個(gè)枚舉） 是Map的子類

  @Test
      public void test9(){
          //EnumMap
          EnumMap<Orientation,String> map=new EnumMap<>(Orientation.class);//括號(hào)中要寫鍵的class
          //第二個(gè)尖括號(hào)中的泛型可以不寫
          map.put(Orientation.NORTH,"beijing");
          map.put(Orientation.SOUTH,"nanjing");
          map.put(Orientation.WEST,"xizang");
          map.put(Orientation.EAST,"shanghai");
          //先獲取他們所有的鍵
          for (Orientation o:map.keySet()){
              System.out.println(o+":"+map.get(o));
          }
      }
  

Math，Random類

• Math類從屬于java.lang包，無參構(gòu)造被private修飾

  Math類下的一些靜態(tài)的屬性與方法

  package 包;
  
  import java.sql.Date;
  import java.util.Calendar;
  import java.util.Scanner;
  import static java.lang.Math.*;//靜態(tài)導(dǎo)入：將Math類中的靜態(tài)的東西全部導(dǎo)入
  public class Test {
      public static void main(String[] args) {
          //圓周率
          System.out.println(PI);
          //次冪
          System.out.println(pow(3.0,2.0));
          //開平方
          System.out.println(Math.sqrt(9.0));
          //向上取值
          System.out.println(Math.ceil(9.1));
          //向下取值
          System.out.println(Math.floor(9.9));
          //四舍五入
          System.out.println(Math.round(5.1));
          //隨機(jī)數(shù)   范圍[0.0,1.0)之間
          System.out.println(Math.random());
          //絕對(duì)值
          System.out.println(Math.abs(-9.2));
          //取小
          System.out.println(Math.min(2.0,9.8));
          //取大
          System.out.println(Math.max(2.0,9.6));
      }
          //如果本類中有相同的方法，那么優(yōu)先走本類中的，本類中沒有，就去靜態(tài)導(dǎo)入類中找
          public static double sqrt(double d){
              return 8.8;
      }
  }
  

• Random類

  //只要你給的數(shù)是一個(gè)值，它產(chǎn)生的隨機(jī)數(shù)就永遠(yuǎn)是那些，例如：你傳入了5，輸出的隨機(jī)數(shù)就只會(huì)是那些
          //你要想讓這些隨機(jī)數(shù)變，就必須一直改變參數(shù)
          Random r = new Random(5);
          for (int i = 1; i <= 10; i++) {
              System.out.println(r.nextInt());
          }
  //可以通過這個(gè)方式來改變隨機(jī)數(shù)
  
  Random r = new Random(System.currentTimeMillis());
          for (int i = 1; i <= 10; i++) {
              System.out.println(r.nextInt());
          }
  
  //也可以通過這樣的方式來改變隨機(jī)數(shù)
  
  public static void main(String[] args) {
          //因?yàn)闊o參構(gòu)造內(nèi)部調(diào)用的是納秒，所以無參構(gòu)造的隨機(jī)數(shù)是一直變的
          Random r = new Random();
          for (int i = 1; i <= 10; i++) {
              //還可以是nextDouble/nextBoolean/nextInt
              System.out.println(r.nextBoolean());
              /*
              調(diào)用nextDouble方法默認(rèn)隨機(jī)數(shù)范圍是0.0到1.0之間，取0.0不取1.0
             我們可以在nextInt方法內(nèi)指定范圍，指定數(shù)字是多少，范圍就是0到多少
             例如：指定參數(shù)為10，隨機(jī)數(shù)的范圍就是0到10，取0不取10
               */
          }
      }
  

  要想讓隨機(jī)數(shù)一直都是變的：1. 要么是一直改變有參構(gòu)造的參數(shù)（通過調(diào)用毫秒等），2. 要么是直接通過無參構(gòu)造創(chuàng)建對(duì)象

  學(xué)習(xí)random類的原因是：Math調(diào)用隨機(jī)數(shù)的底層是調(diào)用random類的nextDouble方法,所以Math.random的范圍是在0.0--1.0之間