常用類

內部類的分類

成員內部類

靜態內部類

區域性內部類

匿名內部類

什麼是內部類

概念 在一個類的內部在定義一個完整的類

class Outer
{
    class Inner
    {
    
    }
  
}

內部類也會生成一個class檔案。

特點:1 編譯之後可以生成獨立的位元組碼檔案

2 內部類可以直接訪問外部類的私有成員，而不破壞封裝。

public class Body
{
   private String name;
   class Header
   {
     public void show()
     {
       System.out.println(name);
     }
 
​
   }
}

3 可以為外部類提供必要的功能元件

成員內部類

在類的內部定義，與例項變數 例項方法同級別的類

外部類的一個例項部分。建立內部類物件時，必須依賴外部類物件

Outer out = new Outer;
Inner in = out.new Inner;

   public static void main(String[] args) {
//     //1 先建立一個外部類物件
//     Outer outer = new Outer();
//     //2 建立內部類物件
//     Outer.Inner inner = outer.new Inner();
​
     //一步到位
     Outer.Inner inner = new Outer().new Inner();
 
    
     inner.show();
   }

當外部類 內部類存在同名的屬性時，會優先訪問內部類的屬性；這時要想訪問外部類的屬性時要在屬性名前面加Outer.this.

成員內部類不能定義靜態成員，但是可以包含靜態常量(final)

靜態內部類

不依賴外部類物件，可直接建立或通過類名訪問，可宣告靜態成員。 相當於一個外部類

普通的類不能加static 只有靜態內部類才能加static訪問。

public class TestOuter {
   public static void main(String[] args) {
     //直接建立靜態內部類物件
     Outer02.Inner inner = new Outer02.Inner();
 
     //呼叫方法
     inner.show();
   }
}

//外部類
public class Outer02 {
   private  String name = "xxx";
   private int age = 18;
   //靜態內部類:級別和外部類相同
   static class Inner
   {
     private  String address = "上海";
     private String phone = "111";
     //靜態成員
     private static int count = 1000;
     public void show()
     {
       //呼叫外部類的屬性
       //1 建立外部類物件
       Outer02 outer = new Outer02();
       //2 呼叫外部類物件的屬性
       System.out.println(outer.name);
       //呼叫靜態內部類的屬性和方法
       System.out.println(address);
       System.out.println(phone);
       //呼叫靜態內部類的靜態屬性
       System.out.println(Inner.count);
     }
   }
}

區域性內部類

定義在外部類方法中，作用範圍和建立物件範圍僅限於當前方法。

先需要知道的一點是:內部類和外部類是處於同一個級別的,內部類不會因為定義在方法中就會隨著方法的執行完畢就被銷燬.

public class Outer {
   private String name = "劉德華";
   private int age = 35 ;
   public void show()
   {
     //定義區域性變數
     String address = "深圳";
     //區域性內部類:注意不能加任何訪問修飾符
     class Inner
     {
       //區域性內部類的屬性
       private String phone = "15588888888";
       private String email = "[email protected]";
       public void show2()
       {
         //訪問外部類的屬性
         System.out.println(Outer.this.name);
         System.out.println(Outer.this.age);
         //訪問內部類的屬性
         System.out.println(this.phone);
         System.out.println(this.email);
         //訪問區域性變數,jdk1.7要求，變數必須是常量,1.8之後可以省略final
         System.out.println(address);
​
​
       }
     }
     //建立區域性內部類物件
     Inner inner = new Inner();
     inner.show2();
   }

區域性內部類訪問外部類當前方法中的區域性變數時，因無法保障變數的生命週期與自身相同，變數必須修飾為final。

匿名內部類

沒有類名的區域性內部類(一切特徵都與區域性內部類相同)。

必須整合一個父類或者實現一個介面。

定義類 實現類 建立物件的語法合併，只能建立一個該類的物件

優點:減少程式碼量

缺點:可讀性差

Usb usb = new Usb()
{
   public void service() {
     System.out.println("連線電腦成功，風扇開始工作了.....");
  }
};
usb.service();

Object類

超類 基類，所有類的直接或間接父類，位於繼承樹的最頂層。

任何類，如果沒有extends顯示繼承某個類，都預設直接繼承Object類，否則為間接繼承。

Object類中所定義的方法，是所有物件都具備的方法。

Object型別可以儲存任何物件。

​ 作為引數，可以接受任何物件。

​ 作為返回值，可以返回任何物件。

getClass()方法

public final Class<?> getClass(){}

返回引用中儲存的實際物件型別

應用：通常用於判斷兩個引用中實際儲存物件型別是否一致。

Student s1 = new Student("aaa",20);
Student s2 = new Student("bbb",22);
//判斷s1和s2是不是同一個型別
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if(class1 == class2)
{
   System.out.println("s1和s2屬於同一個型別");
}
else
{
   System.out.println("s1和s2不是同一個型別");
}

hashCode()方法

public int hashCode(){}

返回該物件的雜湊嗎值

雜湊值根據物件的地址或字串或數字使用hash演算法計算出來的int型別的數值

一般情況下物件相同返回相同雜湊碼

toString()方法

public String to String(){}

返回該物件的字串表示(表現形式)。

可以根據程式需求覆蓋該方法，如:展示物件各個屬性值。

重寫toString()方法 alt+ins 選擇toString

equals()方法

public boolean equals(Object obj){}

預設實現為(this == obj),比較兩個物件地址是否相同

可進行覆蓋，比較兩個物件的內容是否相同。

equals方法覆蓋步驟

比較兩個引用是否指向同一個物件。

判斷obj是否為null

判斷兩個引用指向的實際型別是否一致

強制型別轉換

依次比較各個屬性是否相同

public boolean equals(Object obj) {
     //判斷兩個物件是否是同一個引用
     if (this == obj) return true;
     //判斷obj是否為null
     if (obj == null ) return false;
     //判斷是否同一個型別
/*     if(this.getClass()==obj.getClass())
     {
​
     }*/
     //instanceof 判斷物件是否是某種型別
     if(obj instanceof Student)
     {
       //4強制型別轉換
       Student s =(Student)obj;
       //5比較屬性
       if(this.name.equals(s.getName())&&this.age==s.age) return true;
       else return false;
     }
       return false;
   }

finalize()方法

當物件判定為垃圾物件時，由JVM自動呼叫此方法，用以標記垃圾物件，進入回收佇列。

垃圾物件：沒有有效引用指向此物件時，為垃圾物件。

垃圾回收：由GC銷燬垃圾物件，釋放儲存空間。

自動回收機制：JVM的記憶體耗盡，一次性回收所有垃圾物件。

手動回收機制：使用System.gc();通知JVM執行垃圾回收。

public static void main(String[] args) {
   new Student("aaa",20);
   new Student("bbb",20);
   new Student("ccc",20);
   new Student("ddd",20);
   new Student("eee",20);
   //回收垃圾
   System.gc();
   System.out.println("回收垃圾");
​
}

包裝類

什麼是包裝類？

基本資料型別所對應的引用資料型別。

Object類可同意所有資料，包裝類預設的值是null。

型別轉換與裝箱、拆箱

8種包裝類提供不同型別間的轉換方式

​ Number父類中提供的6個共性方法

​ parseXXX()靜態方法

注意：需保證型別相容，不然會出現NumFormatException異常

//裝箱和拆箱
int num = 10;
//型別轉換:裝箱：基本型別轉成引用型別
int num1 = 18;
//使用Integer類建立物件
Integer integer1 = new Integer(num1);
Integer integer2 = Integer.valueOf(num1);
System.out.println("裝箱");
System.out.println(integer1);
System.out.println(integer2);
//型別轉換:拆箱：引用型別轉成基本型別
Integer integer3 = new Integer(100);
int num2 = integer3.intValue();
System.out.println("拆箱");
System.out.println(num2);
​
//JDK1.5之後，提供了自動裝箱和拆箱
int age = 30;
//自動裝箱
Integer integer4 = age;
System.out.println("自動裝箱");
System.out.println(integer4);
//自動拆箱
int age2 = integer4;
System.out.println("自動拆箱");
System.out.println(age2);

int n1 = 100;
// 1.1使用+號實現
String s1 = n1+"";
// 1.2使用Integer中的toString()方法
String s2 = Integer.toString(n1);
System.out.println(s1);
System.out.println(s2);
​
//2 字串轉成基本型別
String str = "150";
//使用Internet.parseXXX();
int n2 = Integer.parseInt(str);
System.out.println(n2);
​
//boolean字串形式轉成基本型別,"true"------>true   非"true"------------>false
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);
System.out.println(b1);

整數緩衝區

java預先建立了256個常用的整數包裝型別物件

在實際應用當中，對已建立的物件進行復用。(-128到127)

//面試題
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
​
​
System.out.println(integer1==integer2);
​
Integer integer3 = 100;//自動裝箱
Integer integer4 = 100;
System.out.println(integer3==integer4);
​
Integer integer5 = 200;
Integer integer6 = 200;
System.out.println(integer5==integer6);

只要呼叫Integer.valuein()，並且數值在整數緩衝區的範圍內(-128到127)之間，這兩個Integer型別就是相等的。

String類

String

字串是常量，建立之後不可改變。

字串字面值儲存在字串池中，可以共享。

String s = "Hello";產生一個物件，字串池中儲存。

String s =new String("Hello");//產生兩個物件，堆、池中各一個。

常用方法

public int length(); 返回字串的長度

public char charArt(int index); 根據下標獲取字元

public boolean contains(String str);判斷當前字串是否包含str

public char[] toCharArray(); 字串轉換為陣列

public int indexOf(String str); 查詢str首次出現的下標，存在，則返回該下表;不存在，則返回-1

public int lastIndexOf(String str); 查詢字串在當前字串中最後一次出現的下表索引

public String trim(); 去掉字串前後的空格

public String toUpperCase(); 將小寫轉換為大寫

public boolean endWith(String str); 判斷字串是否以str結尾

public String replace(char oldChar,char newChar); 將舊字串替換成新字串

public String[] split(String str); 根據str作拆分

System.out.println("-------------字串方法的使用1-------------");
​
//字串方法的使用
//1. length();返回字串的長度
//2. charArt(int index);返回某個位置的字元
//3. contains(String str);判斷是否包含某個子字串
String content = "Java是世界上最好的程式語言,Java,Java真香";
System.out.println(content.length());
System.out.println(content.charAt(10));
System.out.println(content.contains("程式語言"));
​
System.out.println("-------------字串方法的使用2-------------");
//4. toCharArray();返回字串對應的陣列
//5. indexOf();返回子字串首次出現的位置
//6. lastIndexOf();返回字串最後一次出現的位置
​
System.out.println(Arrays.toString(content.toCharArray()));
System.out.println(content.indexOf("Java"));
System.out.println(content.indexOf("Java",4));
System.out.println(content.lastIndexOf("Java"));
System.out.println("-------------字串方法的使用3-------------");
//7. trim();去掉字串前後的空格
//8. toUpperCase();把小寫轉換為大寫 toLowerCase();大寫轉換為小寫
//9. endWith(str);判斷是否以str結尾 startWith(str);判斷是否以str開頭
​
String content2 = "   hello World   ";
System.out.println(content2.trim());
System.out.println(content2.toUpperCase());
System.out.println(content2.toLowerCase());
String filename = "hello.java";
System.out.println(filename.endsWith(".java"));
System.out.println(filename.startsWith("hello"));
System.out.println("-------------字串方法的使用4-------------");
//10. replace(char old,char new); 用新的字元或字串替換舊的字元或字串
//11. split(); 對字串進行拆分
​
System.out.println(content.replace("Java","php"));
​
String say = "java is the best programing language";
String[] arr = say.split("[ ,]+");
System.out.println(arr.length);
for(String string:arr)
{
   System.out.println(string);
}
​
//補充兩個方法equals 、compareTo();比較大小
System.out.println("--------------補充-----------------");
String s1 = "hello";
String s2 = "Hello";
System.out.println(s1.equals(s2));
System.out.println(s1.equalsIgnoreCase(s2));//忽略大小寫
​
String s3 = "abc"; //97 98 99
String s4 = "xyz"; //120 121 122
System.out.println(s3.compareTo(s4));//結果-23
​
String s5 = "abc";
String s6 = "abcxyz";
System.out.println(s5.compareTo(s6));//結果-3

案例演示

需求：

​ 已知String str = " this is a text";

​ 1.將str中的單詞單獨提取出來

​ 2.將str中的text替換為practice

​ 3.在text前插入一個easy

​ 4.將每個單詞的首字母改為大寫

String str = "this is a text";
//1.將str中的單詞單獨提取出來
System.out.println("----------將str中的單詞單獨提取出來----------");
String[] arr = str.split(" ");
for (String s :arr
   )
{
   System.out.println(s);
​
}
//2.將str中的text替換為practice
System.out.println("----------將str中的text替換為practice----------");
String str2 = str.replace("text","practice");
System.out.println(str2);
​
//3.在text前插入一個easy
System.out.println("----------在text前插入一個easy----------");
String str3 = str.replace("text","easy text");
System.out.println(str3);
​
//4.將每個單詞的首字母改為大寫
for (int i = 0; i < arr.length; i++)
{
   char first = arr[i].charAt(0);
   //把第一個字元轉成大寫
   char upperfirst = Character.toUpperCase(first);
​
   String news = upperfirst+arr[i].substring(1);
   System.out.println(news);
​
​
}

可變字串

StringBuffer：可變長字串，JDK1.0提供，執行效率慢、執行緒安全。

StringBuilder:可變長字串,JDK5.0提供，執行效率快，執行緒不安全。

StringBuffer sb = new StringBuffer();
//1 append();追加
sb.append("Java世界第一");
System.out.println(sb.toString());
sb.append("Java真香");
System.out.println(sb.toString());
//2 insert();插入
sb.insert(0,"我在最前面");
System.out.println(sb.toString());
​
//3 replace();替換
sb.replace(0,5,"hello");
System.out.println(sb.toString());
​
//4 delete();刪除
sb.delete(0,5);
System.out.println(sb.toString());
​
//5 reverse();翻轉
sb.reverse();
System.out.println(sb.toString());
​
//清空
sb.delete(0,sb.length());
System.out.println(sb.toString());

/**
 * 驗證StringBuilder效率高於String
 *
 * */
public class Demo06 {
   public static void main(String[] args) {
     long start = System.currentTimeMillis();
/*     String string = "";
     for (int i = 0; i <99999 ; i++) {
       string+=i;
​
     }
     System.out.println(string);*/
     StringBuilder sb = new StringBuilder();
     for (int i = 0; i <99999 ; i++) {
       sb.append(i);
​
     }
     long end = System.currentTimeMillis();
     System.out.println(end-start);
   }

BigDecimal

思考:一下程式輸出是多少

public static void main(String[] args) {
   double d1 = 1.0;
   double d2 = 0.9;
   System.out.println(d1-d2);
}

0.09999999999999998

很多實際應用中更需要精確運算，而double是近似值儲存，不在符合要求，需要BigDecimal。

位置:java.math包中

作用:精確計算浮點數

建立方式:BigDecimal bd = new BigDecimal(“1.0”);

方法:

​ BigDecimal add(BigDecimal bd) 加

BigDecimal subtract(BigDecimal bd) 減

​ BigDecimal mutiply(BigDecimal bd 乘

​ BigDecimal divide(BigDecimal bd 除

除法:divide(BigDecimal bd,int scal,RoundingMode mode);

引數scale:精確到小數點後幾位

引數mode:

​ 指定小數部分的取捨模式，通常採用四捨五入的模式。

​ 取值為BigDecimal.ROUND_HALF_UP。

​

​

 double d1 = 1.0;
 double d2 = 0.9;
 System.out.println(d1-d2);
​
 //BigDecimal,大的浮點數精確計算
 BigDecimal bd1 = new BigDecimal("1.0");
 BigDecimal bd2 = new BigDecimal("0.9");
 //減法
 BigDecimal r1 = bd1.subtract(bd2);
 System.out.println(r1);
​
 //加法
 BigDecimal r2 = bd1.add(bd2);
 System.out.println(r2);
​
 //乘法
 BigDecimal r3 = bd1.multiply(bd2);
 System.out.println(r3);
​
 //除法
BigDecimal r4 =  new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));
 System.out.println(r4);
 
//保留幾位小數
 BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
 System.out.println(r5);

Date

Date表示特定的瞬間，精確到毫秒。Date類中的大部分方法已經被Calendar類中的方法所取代。

時間單位

​ 1秒=1000毫秒

​ 1毫秒=1000微秒

​ 1微秒=1000納秒

//1.建立date物件
//今天
Date date1 = new Date();
System.out.println(date1.toString());
System.out.println(date1.toLocaleString());
//昨天
Date date2 = new Date(date1.getTime()-(60*60*24*1000));
System.out.println(date2.toLocaleString());
//2.方法after before
System.out.println(date1.after(date2));
System.out.println(date1.before(date2));
​
//比較 compareTo();
int d = date1.compareTo(date2);
System.out.println(d);
​
//比較是否相等equals
System.out.println(date1.equals(date2));     

Calendar

Calendar提供了獲取或設定各種日曆欄位的方法。

構造方法

​ protected Calendar();由於修飾符是protected所以無法直接建立該物件

public static void main(String[] args) {
   //1.建立Calendar物件
   Calendar claendar = Calendar.getInstance();
   System.out.println(claendar.getTime().toLocaleString());
   System.out.println(claendar.getTimeInMillis());
   //2.獲取時間資訊
   //獲取年
   int year = claendar.get(claendar.YEAR);
   //月
   int month = claendar.get(claendar.MONTH);
   //日
   int day = claendar.get(claendar.DATE);
   //小時
   int hour = claendar.get(claendar.HOUR_OF_DAY);
   //分鐘
   int minute = claendar.get(claendar.MINUTE);
   //秒
   int second = claendar.get(claendar.SECOND);
   System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+"時"+minute+"分"+second+"秒");
   //3.修改時間
   Calendar calendar2 = Calendar.getInstance();
   calendar2.set(Calendar.DAY_OF_MONTH,5);
   System.out.println(calendar2.getTime().toLocaleString());
​
   //4.add方法修改時間
   calendar2.add(Calendar.HOUR,1);
   System.out.println(calendar2.getTime().toLocaleString());
​
   //5.補充方法
   int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
   int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
   System.out.println(max);
   System.out.println(min);
​
}

SimpleDateFormat

SimpleDateFormat是一個以語言環境有關的方式來格式化和解析日期的具體類。

進行格式化(日期 -> 文字)、解析(文字 -> 日期)。

常用的時間模式字母

public static void main(String[] args) throws Exception{
   //1.建立一個SImpleDateFormat物件
   SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
   //2.建立Date
   Date date = new Date();
   //格式化Date(把日期轉換成字串)
   String str = sdf.format(date);
   System.out.println(str);
   //解析(把字串轉換成日期)
   Date date2 = sdf.parse("1990年08月09日 11:11:23");
   System.out.println(date2);
}

System類

System系統類，主要用於獲取系統的屬性資料和其他操作，構造方法私有的。

public static void main(String[] args) {
   //arraycopy:陣列的複製
   //src:原陣列
   //srcPos:從哪個位置開始複製
   //dest:目標陣列
   //destPos:目標陣列的位置
   //length:複製的長度
   int[] arr = {1,33,55,23,12,55,23};
   int[] dest = new int[8];
   System.arraycopy(arr,0,dest,0,arr.length);
   for (int i = 0; i < dest.length; i++) {
     System.out.println(dest[i]);
​
   }
   //Arrays.copyOf(original,newLength)
   System.out.println(System.currentTimeMillis());
   long start = System.currentTimeMillis();
   for (int i = 0; i < 9999999 ; i++) {
     for (int j = 0; j < 9999999; j++) {
       int result = i+j;
​
     }
​
   }
   long end = System.currentTimeMillis();
   System.out.println(end-start);
​
   //System.gc();告訴垃圾回收器回收
   new Student("aaa",19);
   new Student("bbb",19);
   new Student("ccc",19);
​
   System.gc();
​
   //4.退出JVM
   System.exit(0);
   System.out.println("程式結束了");
}