Java中的單例、StringBuffer方法、基本數據類型的包裝類以及權限修飾符（基礎詳解）

單例

    單例的核心:
        在整個程序執行期間 有且 只有一個該類的對象存在

    如何去些?(如何去保證 程序中 有且只有一個對象)
        1.不讓外界創建對象
        2.整個對象我來創建(也不能讓外界訪問)
        3.需要對外開放整個對象的方法

    單例 餓漢式

        class Single{

            //創建單例對象
            //隨着類的加載而加載
            //由於整個對象不能被訪問不能被修改
            //所以用private修飾
            private static Single single = new Single();

            //構造方法私有化
            private Single(){

            }

            //開放一個訪問這個對象的方法
            public static Single getInstance(){
                return single;
            }
        }

    單例 懶漢式
         //只有你調用獲取對象的方法 纔有可能創建對象

         特點:延遲加載(懶加載)

         class SingleLazy{
             private static SingleLazy singlelazy = null;

             //構造方法私有化
             private SingleLazy(){

             }

             //獲取單例對象的方法
             public static SingleLazy getInstance(){
                 //如果沒有這個對象 再創建
                 //有這個對象了 就不創建了
                 if(singleLazy == null){
                     singleLazy = new SingleLazy();
                 }
                 return singleLazy;
             }
         }

StringBuffer

    StringBuffer是字符串的緩衝區
    特點:
        1.StringBuffer 相當於是一個 可以變得序列(操作的是 原字符串)
        2.是線程安全(耗費資源)

    (jdk 1.5 版本以後 出了 StringBuilder
    StringBuilder的方法和StringBuffer是一樣的
    兩者不同之處就是 StringBuilder 是線程不安全
    線程不安全 相對來說 省資源)

StringBuffer方法

    關於StringBuffer的方法有:
        1. 拼接
        2. 插入
        3. 刪除
        4. 反轉
        5. 替換
        6. String與StringBuffer的相互轉換

1. 拼接

    (使用append方法)

    public static void fun1(){
        //創建一個 StringBuffer
        StringBuffer sb = new StringBuffer();
        //拼接字符串(操作的是原對象)
        sb.append("ILoveJava");
        //如果直接打印對象 系統會幫你調 toString方法
        //例如:
        //StringBuffer sb1 = sb.append("ILoveJava");

        System.out.println(sb);
        //System.out.println(sb1);
        發現sb 和 sb1 打印出來的結果是一樣的
    }

2. 插入和修改

    插入(insert方法)

    public static void fun2(){
        //直接使用 字符串創建StringBuffer
        StringBuffer sb = new StringBuffer("ILovaJava");
        //插入一個字符 把字符插入到 索引位置上
        //sb.insert(offset, c);
        sb.insert(7,'e');
        System.out.println(sb);
        //打印結果爲 ILoveJaeva
    }

      //插入boolean 類型 就相當於 把 true/false 當字符串插入
      例如:
       sb.insert(7,true);
       這樣輸出來的結果就是 ILoveJatrueva

    修改(setcharAt方法)

    public static void fun3(){
        StringBuffer sb = new StringBuffer("ILovaJava");

        //給索引位置 進行 字符修改(替換)
        //sb.setCharAt(index, ch);
        sb.setCharAt(1, 'l')
        System.out.println(sb);
        //輸出的是IloveJava

        //傳入角標返回字符
        char charAt = sb.charAt(8);
        System.out.println(charAt);
        //輸出的是a

        //把 buffer轉成 字符數組
        //先變字符串然後再變 字符數組
        char[] charArray = sb.toString.toCharArray

    }

    //把 字符串 轉成 StringBuffer
    //StringBuffer sb = new StringBuffer(string);

刪除和反轉

    刪除(delete方法)
    public static void fun4() {
        StringBuffer sb = new StringBuffer();
        sb.append("ILoveJava");
        //刪除(刪頭不刪尾)
        sb.delete(0,3)
        System.out.println(sb);
        //輸出的是 veJava
    }

    注意:
        開始座標不能越界 結束座標越界 系統當清空 處理

     public static void fun5() {
        StringBuffer sb = new StringBuffer();
        sb.append("ILoveJava");
        //刪除字符
        sb.deleteCharAt(1)
        System.out.println(sb);
        //輸出的是 IoveJava
    }    

    反轉(使用reverse方法)

    public static void fun6() {
        StringBuffer sb = new StringBuffer();
        sb.append("ILoveJava");

        //反轉
        sb.reverse();
        System.out.println(sb);
        //輸出的是 avaJevoLI
    }

    反轉的案例:
        輸入一個字符串 反轉


    public static void fun7() {
        System.out.println("輸入");
        Scanner scanner = new Scanner(System.in);
        String string = scanner.nextLine();

        //轉成StringBuffer
        StringBuffer stringBuffer = new StringBuffer(string);
        //反轉
        stringBuffer.reverse();
        //轉換成字符串 輸出
        System.out.println(stringBuffer.toString());
    }

替換和截取字符串

    替換(使用replace方法)

    public static void fun8() {
        StringBuffer sb = new StringBuffer();
        sb.append("ILoveJava");
        //開始座標不能越界
        //sb.replace(start, end, str)
        //開始座標不能越界 結束座標越界 相當於後面全部替換
        sb.replace(1, 5, "Like" );
        System.out.println(sb);
        //輸出的是 ILikeJava
    }

    截取字符串(substring方法)

    public static void fun9() {
        StringBuffer sb = new StringBuffer();
        sb.append("ILoveJava");

    //字符串截取 返回一個新的字符串給你
    //因爲是返回一個新的字符串 不是改變原字符串
    //所以需要接受一下這個新的字符串
    String substring = sb.substring(5)
    System.out.println(substring);
    //輸出的是Java

    String substring2 = sb.substring(0, 5);
    System.out.println(substring2);
    //輸出的是 ILove
    }

總結

      StringBuffer和StringBuilder的區別:
      StringBuffer 線程安全 效率低(耗費系統資源)
      StringBuilder 線程不安全的 效率高(相對於StringBuffer耗費資源少)

      StringBuffer和StringBuilder 使用方法一樣

      String和StringBuffer的區別
      String 是 不可變的 線程不安全的
      StringBuffer 是可變的 操作的是 對象本身

    public class Demo0 {

    public static void fun10(String string) {
        string = "ilovejava";
    }

    public static void fun11(StringBuffer sBuffer) {
        sBuffer.append("hh");
    }

    public static void fun12(StringBuilder sBuilder) {
        sBuilder.append("xx");
    }
    public static void main(String[] args) {

        //測試字符串當參數的方法
        //字符串作爲參數的時候 跟基本數據類型 作爲參數一樣
        //相當於是 值的傳遞
        String string = "ILoveJava";
        fun8(string);
        System.out.println(string);

        //測試StringBuffer 作爲參數
        //StringBuffer 作爲參數的時候 跟 引用數據類型一樣 
        //相當於是 地址 的 傳遞
        StringBuffer sBuffer = new StringBuffer("ILoveJava");
        fun9(sBuffer);
        System.out.println(sBuffer);

        //StringBuilder
        //也是地址的傳遞
        StringBuilder sBuilder = new StringBuilder("ILoveJava");
        fun10(sBuilder);
        System.out.println(sBuilder);
    }

基本數據類型的包裝類

 基本數據類型  包裝類
  byte          Byte
  short         Short
  int           Integer
  long          Long
  float         Float
  double        Double
  boolean       Boolean
  char          Character

    爲什麼要把基本數據類型 封裝成一個類?

    在類中可以聲明方法 可以使用對象調方法 

Integer方法

    public static void fun13(){
        //創建一個Integer
        Integer integer1 = new Integer(10);
        System.out.println(integer1);
        //打印出來的是 10

        //把字符串 轉換成 Integer
        //注意: 是數字格式的字符串 才能轉換
        Integer integer2 = new Integer("100");
        System.out.println(integer2);
        //打印出來的是 100
    }

進制

    public static void fun14(){
        int a = 60;
        //轉成2進制
        System.out.println(Integer.toBinaryString(a));
        //轉成8進制
        System.out.println(Integer.toOctalString(a));
        //轉成16進制
        System.out.println(Integer.toHexString(a));
    }

int 和Integer 之間的轉換 (靜態方法)

     public static void fun15(){
        //把int類型轉換成 Integer類型
        Integer num1 = Integer.valueOf(10);
        //把Integer類型 轉換成int 類型
        int num2 = num1,intValue();
    }

String 和 Integer 之間的轉換

    public static void fun15(){
        //String 轉 Integer
        Integer num3 = Integer.valueOf("100")
        //Integer 轉 String
        String string3 = num3.toString();
        //把字符串 轉換成int
        int num4 = Integer.parseInt("100")
    }

權限修飾符

    權限修飾符(訪問權限 能不能訪問到)
  1.public(公開的)
  2.private(私有的)
  3.protected(受保護的)
  4.default(默認的) 什麼都不寫

                本類  同包類     同包子類     不同包類   不同包子類
  public         √     √           √            √         √
  private        √     ×           ×            ×         × 
  protected      √     √           √            ×         √
  default        √     √           √            ×         ×

  (√代表類中可以訪問到這個被權限修飾符修飾的成員變量)