常用類

常用類

內部類

分類

• 成員內部類
• 靜態內部類 static
• 區域性內部類
• 匿名內部類

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

class Outer{
	class Inner{
        
    }
}

特點：

• 編譯之後可生成獨立的位元組碼檔案 （.class）
• 內部類可直接訪問外部類的私有成員，而不破壞封裝
• 可為外部類提供必要的內部功能元件

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Body {
    private String body = "身體";
    class Header{
        
        public void show(){
            System.out.println(body);
        }
    }
}

成員內部類

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

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

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

• 當外部類、內部類存在重名屬性時，會優先訪問內部類屬性

• 成員內部類不能定義靜態成員(屬性)，但能包含靜態常量

package OOP.commonClass;
import OOP.commonClass.Outer.Inner;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Test {
    public static void main(String[] args) {
        //1、建立外部類物件
        Outer body = new Outer();
        //2、建立內部類物件
        Inner inner = body.new Inner();

        //一步到位
        Inner inner1 = new Outer().new Inner();
        
        inner.show();
        inner1.show();
    }
}

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
//外部類
public class Outer {
    private String body = "身體";
    private int length = 100;
    //成員內部類
    class Inner{
        private int age = 18;
        private final int high = 11;
        //屬性和外部類屬性名字相同
        private int length = 50;
        public void show(){
            //訪問外部類成員
            System.out.println(body);
            //內部類和外部類屬性重名，使用 外部類名.this.屬性 來訪問
            System.out.println(Outer.this.length);
            //訪問內部類成員
            System.out.println(age);
            System.out.println(length);
        }
    }
}

靜態內部類

• 不依賴外部物件，可直接建立或提供類名訪問，可宣告靜態成員
• 只有內部類才能用static修飾

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
//外部類
public class Outer {
    private String body = "身體";
    private int length = 100;
    //靜態內部類，級別和外部類相同
    static class Inner{
        private int age = 18;
		//靜態成員
        private static int count = 10000;
        public void show(){
            //訪問外部類成員
            //1、先建立外部類物件
            Outer out = new Outer();
            //2、呼叫外部類物件屬性
            System.out.println(out.body);
            System.out.println(out.length);
            //訪問內部類成員
            System.out.println(age);
            //呼叫靜態內部類的靜態屬性
            System.out.println(Inner.count);
        }
    }
}

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Test {
    public static void main(String[] args) {
        //直接建立靜態內部類物件
        Outer.Inner inner = new Outer.Inner();
        inner.show();
    }
}

區域性內部類

• 定義在外部類方法中，作用範圍和建立物件範圍僅限於當前方法
• 區域性內部類訪問外部類當前方法中的區域性變數時，因無法保障變數的生命週期與自身相同，變數必須修飾為final
• 限制類的使用範圍

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
//外部類
public class Outer {
    private String body = "身體";
    private int length = 100;

    //若為靜態方法，則不能訪問外部類屬性
    public void show(){
        //定義區域性變數
        String address = "桂林";
        //不能有靜態變數，但能有靜態常量final
        //private static int count = 10000;
        private final static int count = 10000;

        //區域性內部類：注意不能加任何訪問修飾符
        class Inner{
            //區域性內部類屬性
            public String phone = "111111";
            private int id = 111;

            public void print(){
                //訪問外部類的屬性
                System.out.println(Outer.this.body);
                System.out.println(Outer.this.length);
                //訪問內部類的屬性
                System.out.println(phone);
                System.out.println(id);
                //訪問區域性變數，jdk1.7要求：變數必須是常量final   jdk1.8自動新增final
                System.out.println(address/*相當於直接列印  "桂林"  */);
                // 等價於 System.out.println("桂林");
            }
        }
        //需要在方法裡 建立內部類物件，呼叫內部類物件的方法
        Inner inner = new Inner();
        inner.print();
    }
}

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Test {
    public static void main(String[] args) {
        //建立外部類物件
        Outer outer = new Outer();
        outer.show();
    }
}

匿名內部類

• 沒有類名的區域性內部類（一切特徵都與區域性內部類相同）
• 必須繼承一個父類或實現一個介面
• 定義類、實現類、建立物件的語法合併，只能建立一個該類的物件
• 優點：減少程式碼量
• 缺點：可讀性差

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Test {
    public static void main(String[] args) {
        //建立介面型別的變數
        /*UserService user = new User();
        user.service();*/

        //區域性內部類
        /*class User1 implements UserService{
            @Override
            public void service() {
                System.out.println("實現使用者1服務介面");
            }
        }
        UserService user = new User1();
        user.service();*/

        //匿名內部類最佳化（相當於建立了一個區域性內部類）可再最佳化為lambda表示式
        UserService user = new UserService() {
            @Override
            public void service() {
                System.out.println("實現使用者2服務介面");
            }
        };
        user.service();
        //lambda
        UserService user =()->{  System.out.println("實現使用者3服務介面");};
        user.service();
    }
}

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public interface UserService {
    //服務
    void service();
}

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class User implements UserService{
    @Override
    public void service() {
        System.out.println("實現使用者服務介面");
    }
}

Object類

• 超類、基類，所有類的直接或間接父類，位於繼承樹的最頂層
• 任何類，如沒有書寫extends顯示繼承某個類，都預設直接繼承0bject類，否則為間接繼承
• Object類中所定義的方法，是所有物件都具備的方法
• Object型別可以儲存任何物件
  • 作為引數，可接受任何物件
  • 作為返回值，可返回任何物件

包裝類

• 基本資料型別所對應的引用資料型別
• Object可同意所有資料，包裝類的預設值是null

基本資料型別	包裝型別
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

型別轉換與裝箱、拆箱

• 基本型別 --->引用型別 裝箱
• 引用型別 --->基本型別 拆箱

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Demo {
    public static void main(String[] args) {
        //型別轉換：裝箱，基本型別轉換成引用型別的過程
        //基本型別
        int num1 = 100;
        //使用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(200);
        int num2 = integer3.intValue();
        System.out.println("拆箱");
        System.out.println(num2);

        //JDK1.5後，提供自動裝箱和拆箱
        int num3 = 50;
        //自動裝箱
        Integer integer4 = num3;
        System.out.println("自動裝箱"+ integer4);
        //自動拆箱
        int num4 = integer4;
        System.out.println("自動拆箱"+ num4);

    }
}

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

  • Number父類中提供的6個共性方法
  • parseXXX()靜態方法

  注意：需保證型別相容，否則丟擲NumberFormatException異常

//基本型別和字串之間轉換
//1 基本型別轉字串
int n1 = 188;
//1.1 使用+號
String s1 = n1 + "";
//1.2 使用Integer中的toString()方法
String s2 = Integer.toString(n1);
//toString過載 轉換進位制
String s3 = Integer.toString(n1,16);
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);

//2字串轉基本型別
String str = "166";
//使用Integer.parseXXX();
int n2 = Integer.parseInt(str);
System.out.println(n2);

//boolean字串形式轉基本型別  "true"--->true   非"true"---> false
String str2 = "true";
String str3 = "t";
boolean b1 = Boolean.parseBoolean(str2); 
boolean b2 = Boolean.parseBoolean(str3);
System.out.println(b1);
System.out.println(b2);

整數緩衝區

• Java預先建立了256個常用的整數包裝型別物件
• 在實際應用中，對已建立的物件進行復用

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Demo {
    public static void main(String[] args) {
        Integer i1 = new Integer(100);
        Integer i2 = new Integer(100);
        //比較的是i1和i2指向的地址，不是數值
        System.out.println(i1 == i2);//false

        Integer i3 = Integer.valueOf(100);
        Integer i4 = 100;
        //實際上自動裝箱成 Integer i3 = Integer.valueOf(100);
        //   valueOf建立物件 會判斷數值大小，在-128 -- 127之間，會使用預先建立的包裝型別物件，進行復用
        //   本例中i3 和 i4 都是100，都會指向 整數緩衝區中值100的那個物件
        System.out.println(i3 == i4);//true

        Integer i5 = 200;
        Integer i6 = 200;
        //數值為200，超過127，所以建立了新的物件，不是複用整數緩衝區的物件
        System.out.println(i5 == i6);//false
    }
}

String類

• 字串是常量，建立後不可改變
• 字串字面值儲存在字串池（在方法區中）中，可以共享
• String s = "hello"; 產生一個物件，字串池中儲存
• String s = new String("hello"); 產生兩個物件，堆和池各儲存一個

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Demo {
    public static void main(String[] args) {
        String name = "hello";//儲存在字串池中
        name = "zhangsan";//“zhangsan” 賦值給name變數，給字串賦值時，沒有修改資料，
                          // 而是在開闢一個空間存放“zhangsan”，並且name指向“zhangsan”
        String name2 = "zhangsan";//如果字串池中有“zhangsan”，則直接指向它

        //另一種建立方式， new String();
        String str = new String("java");//建立兩個物件，一個在字串池，一個在堆，
        							 //堆中的物件指向字串池的物件
        String str2 = new String("java");
        System.out.println(str == str2);//false
        System.out.println(str.equals(str2));//true
    }
}

常用方法

• public int length()：返回字串的長度
• public char charAt(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做拆分
• equals()：比較內容是否相同
  • equalsIgnoreCase()：比較時忽略大小寫
• compareTo()：比較字元在字典裡的位置

案例：

package OOP.commonClass;

import java.util.Arrays;
import java.util.Locale;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Demo {
    public static void main(String[] args) {
        String str = "this is a text";
        //1
        String[] arr = str.split(" ");
        for (String s : arr) {
            System.out.println(s);
        }
        //2
        String replace = str.replace("text", "practice");
        System.out.println(replace);
        //3
        str.replace("text", "easy text");
        //4
        String str1 ="";
        for (String s : arr) {
            char first = s.charAt(0);
            char upperCase = Character.toUpperCase(first);
            //substring(下標);獲得從下標開始的後面的字串
            str1 = str1 + upperCase + s.substring(1)+ " ";
        }
        System.out.println(str1);
    }
}

可變字串

• StringBuffer：可變長字串，JDK1.0提供，執行效率慢、執行緒安全
• StringBuilder：可變長字串，JDK5.0提供，執行效率快、執行緒不安全

和String的區別：

1. 效率比String高
2. 比String省記憶體

package OOP.commonClass;

import java.util.Arrays;
import java.util.Locale;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Demo {
    public static void main(String[] args) {
        //StringBuffer sb = new StringBuffer();
        StringBuilder sb = new StringBuilder();
        //1 append(); 追加
        sb.append("Hello World");
        System.out.println(sb.toString());
        sb.append("Hello java");
        System.out.println(sb.toString());
        //2 insert(); 新增
        sb.insert(0,"I am first");
        System.out.println(sb.toString());
        //3 replace();  替換
        sb.replace(0,10,"I am second");
        System.out.println(sb.toString());
        //4 delete();
        sb.delete(0,5);
        System.out.println(sb.toString());
        //5 清空
        sb.delete(0,sb.length());
        System.out.println(sb.length());
    }
}

BigDecimal類

• 位置：java.math包

• 作用：精確計算浮點數

• 建立方式：BigDecimal bd = new BigDecimal("1.0");

• 方法：

  • BigDecimal add (BigDecimal bd) 加

  • BigDecimal subtract(BigDecimal bd) 減

  • BigDecimal multiply(BigDecimal bd) 乘

  • BigDecimal divide(BigDecimal bd) 除

    除不盡時使用：

    • 除法: divide (BigDecimal bd, int scal, RoundingMode mode)
    • 引數scal ：指定精確到小數點後幾位
    • 引數mode ：
      • 指定小數部分的取捨模式，通常採用四捨五入的模式
      • 取值為 BigDecimal.ROUND_HALF_UP

package OOP.commonClass;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Locale;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Demo {
    public static void main(String[] args) {
        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);

        //除不盡 ROUND_HALF_UP 四捨五入
        BigDecimal r6 = new BigDecimal("10").divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP);
        System.out.println(r6);
    }
}

Date類

• Date表示特定的瞬間，精確到毫秒。Date類中的大部分方法都已經被Calendar類中的方法所取代
• 時間單位
  • 1秒=1000毫秒
  • 1毫秒=1000微秒
  • 1微秒=1000納秒

Calendar類

• Calendar提供了獲取或設定各種日曆欄位的方法
• 構造方法
  • protected Calendar()： 由於修飾符時protected，所以無法直接建立該物件

package OOP.commonClass;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Locale;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Demo {
    public static void main(String[] args) {
        //1 建立Calendar物件
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime());
        //2 獲取時間資訊
        //Year
        int year = calendar.get(Calendar.YEAR);
        //month 從0-11 實際的要加上1
        int month = calendar.get(Calendar.MONTH);
        //day
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        //hour
        int hour = calendar.get(Calendar.HOUR_OF_DAY);
        //minute
        int minute = calendar.get(Calendar.MINUTE);
        //second
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year + "年" + (month + 1) + "月" + day + "日" + hour + ":" + minute + ":" + second);
        //修改時間
        Calendar calendar1 = Calendar.getInstance();
        calendar1.set(Calendar.DAY_OF_MONTH,5);
        System.out.println(calendar1.getTime().toLocaleString());
        //add方法修改時間
        calendar1.add(Calendar.HOUR,1);
        System.out.println(calendar1.getTime().toLocaleString());
        //補充 獲得最大和最小日期
        int maximum = calendar1.getActualMaximum(Calendar.DAY_OF_MONTH);
        System.out.println(maximum);
        int minimum = calendar1.getMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(minimum);
    }
}

SimpleDateFormat類

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

• 進行格式化（日期 ->文字）、解析（文字 ->日期）

• 常用的時間模式字母

  

package OOP.commonClass;

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

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Demo {
    public static void main(String[] args) throws ParseException {
        //1 建立SimpleDateFormat物件 y 年 M 月 d 日 H 小時 m 分 s 秒
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss", Locale.CHINA);
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日");
        //建立Date
        Date date = new Date();
        //格式化Date
        String str = sdf.format(date);
        System.out.println(str);

        //解析 字串 -> 日期
        //parse()裡格式要和上面規定的對應 不對應的話就報錯
        //如下面這一句就會報錯
        Date parse = sdf.parse("1990年6月8日");
        //這句不會報錯
        Date parse1 = sdf1.parse("1990年6月8日");
        System.out.println(parse.toLocaleString());
        System.out.println(parse1.toLocaleString());
    }
}

System類

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

package OOP.commonClass;


import java.util.Arrays;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Demo {
    public static void main(String[] args)  {
        //複製
        //src：源陣列
        //srcPos：從哪個位置開始複製 0
        //dest：目標陣列
        //destPos：目標陣列的位置
        //length：複製的長度
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        int[] dest = new int[10];
        System.arraycopy(arr,0,dest,0,arr.length);
        //Arrays.copyOf(Original,newLength)也是呼叫System.arraycopy()
        System.out.println(Arrays.toString(dest));

        //獲取時間
        long r = 0;
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            for (int j = 0; j < 1000000000; j++) {
                r = i+j;
            }
        }
        System.out.println(r);
        long endTime = System.currentTimeMillis();
        System.out.println("用時：" + (endTime - startTime)+"ms");

        //System.gc(); 告訴垃圾回收器回收
        new Student(18,"aaa");
        new Student(19,"bbb");
        new Student(20,"ccc");
        System.gc();
        
        //退出jvm
        System.exit(0);
        
    }
}

總結

• 內部類：
  • 在一個類的內部再定義一個完整的類
  • 成員內部類、靜態內部類、區域性內部類、匿名內部類
• Object類：
  • 所有類的直接或間接父類，可儲存任何物件
• 包裝類：
  • 基本資料型別所對應的引用資料型別，可以使0bject統一所有資料
• String類：
  • 字串是常量，建立之後不可改變，字面值儲存在字串池中，可以共享
• BigDecimal類：
  • 可精確計算浮點數
• Date類
  • 特定時間
• Calendar類
  • 日曆
• SimpleDateFormat類
  • 格式時間
• System
  • 系統類