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        √     √           √            ×         ×

  (√代表类中可以访问到这个被权限修饰符修饰的成员变量)