引用 面向对象 String类（6）

类型 

1.基本类型

2.引用类型

引用本质上是一个低配指针 

C中的指针要结合内存来理解，把内存想象成一个大走廊，走廊上有很多房间，每个房间有一个自己的编号（0开始 依次递增）这个编号称为“地址” 创建一个变量来保存这个地址，这样的变量就是一个指针变量

引用本质上就是一个指针（引用就对应一小块内存空间，里面存的就是一个地址）

    int[] arr1 = new int[]{1,2,3,4};
     int[] arr2 = arr1;
        System.out.println(arr1[0]);
        System.out.println("修改0号元素的值");
        arr2[0] = 100;
        System.out.println(arr1[0]);
        }

1
修改0号元素的值
100

关于引用指向对象的一些规则

1.只有引用指向对象，没有对象指向引用

2.对象可以被多个引用指向

3.操作引用，其实操作的是引用指向的对象

JAVA中的引用支持操作就是这几个：

1.  “.”成员访问操作[解引用]

2. [ ] 数组特有的[解引用]

3.= 修改引用中保存的地址的值

4.== 比较引用中保存的地址是否相同（判断两个引用是否对应到同一个对象）

类：自定义类型

对象：自定义类型创建出来的对象

this

1.this指向当前对象的引用

2.this 的类型就是当前这个类的类型

3.this 这个引用的指向不能修改

4.this 也可以用来调用方法

5.this 不能是null

public class Cat {

    public String name;
    public String gender;

    public Cat(String name,String gender) {
        this.name = name;
        this.gender=gender;
        this.eat("鱼");
    }
    public void eat(String food){
        System.out.println(name + "正在吃" + food);

JAVA中的包 和磁盘上的目录是一一对应的

内部类是一个比较少用的语法

把类的定义写道另外一个类中。

1.普通的内部类/成员内部类

2.静态内部类（内部类前头用 static）

3.匿名内部类（相对比较常用）

4.局部内部类（基本没啥用）

字符串比较

public class Test {
    public static void main(String[] args) {
        String a = new String("Hello");
        String b = new String("Hello");
        String a1 = "hello";
        String b1 = "hello";
//此时的比较是直接比较a和b引用里面存的地址是否一样
        System.out.println(a==b);
//        如果比较字符内容 用.equals方法
        System.out.println(a.equals(b));
    }
}

常量 ：和变量相对 “hello”这就是常量（字符串的字面值常量）

池：计算机中一个非常重要的术语.   池的目的是为了降低开销，提高效率 本质是把频繁使用的东西提前保存好，以备用到的时候，随时就能用。

JAVA 会把一些字符串常量放到内置的“字符串常量池”中

常量池是JVM划分的一个内存区域，JVM一运行的时候，就会专门搞一个区域作为常量池。

        String a = new String("hello").intern();
        System.out.println(a=="hello");
        }
    }

true

调用 intern 方法，就会拿着当前这个字符串里的内容在字符串常量池中找，看当前这个内容是否存在于池中

如果存在直接返回该池中的地址

如果不存在，则把当前字符串的内容加到常量池中，返回池中的地址。

JAVA的 String 是不可变对象（对象本身不能修改）

1.方便放到池中，如果是可变对象，一旦池中的内容发生改变，就会影响到所有引用这个池对象的结果

2.对象内容不可变，则对象的hashCode也不可变，方便和hash表这样的结构配合使用

3.对象不可变，线程安全更有保证

String s = “hello” =>“hello” 这种操作，在java中，只能通过构造一个新的对象来完成。

       String str = "hello";
//        通过反射的方式修改“hello”的内容
//        特殊手段，而不是常规手段

//        1.获取String的类对象
//        2.根据“value”这个字段名字，在类对象中拿到相应的字段（仍然是图纸的一部分，相当于
//        局部放大图纸
       Field valueField =  String.class.getDeclaredField("value");
//       让value这个private的成员也能被访问到
        valueField.setAccessible(true);
//       3.根据图纸，把str这个对象拆开，取出里面的零件
      char[] value = (char[]) valueField.get(str);
//      4.修改零件内容
        value[4] = 'a';
        System.out.println(str);
        

        }
    }

hella

反射和封装是背道而驰的

JAVA中的 final 主要是两个功能

1.final 修饰一个变量，表示是常量，如果修饰的是引用类型，表示引用的指向不能修改（引用中存的地址不能改）

2.final 修饰一个类，表示这个类不能被其他类继承

字符串常见操作

1.字符串的比较

a.比较相等  b.比较大小 c.不区分大小写的比较 （字典序，先比较首个字符unicode值的大小）

        String a = "hello";
        String b = "hallo";
//        compareTo 返回的是一个int
//        a比b小，返回一个小于0的结果
//        a比b大，返回一个大于0的结果
//        a和b相等，返回一个0
        int result =  a.compareTo(b);
        System.out.println(result);


4

字符串的替换

        String a = "Hello world";
        String b = "world";
        String result = a.replaceAll(b,"java");
        System.out.println(result);
Hello java

字符串拆分/切分

       String a = "Hello world java";
       String[] result= a.split("");
        System.out.println(Arrays.toString(result));

[H, e, l, l, o,  , w, o, r, l, d,  , j, a, v, a]