Java学习day12：static关键字，字符串声明，字符串常量池

声明：该专栏本人重新过一遍java知识点时候的笔记汇总，主要是每天的知识点+题解，算是让自己巩固复习，也希望能给初学的朋友们一点帮助，大佬们不喜勿喷(抱拳了老铁！)

往期回顾：

Java学习day11：异常-CSDN博客

Java学习day10：多态、向下转型、instanceof关键字-CSDN博客

Java学习day09：super、final关键字，抽象类和接口-CSDN博客

......

Java学习day12：static关键字，字符串声明，字符串常量池

一、static关键字（static：静态）

1.1生活角度来理解静态资源

公共的资源的都属于静态的东西，对象可以使用静态的资源，但是和对象无关。

比如，图书馆里的饮水机，就是一种静态资源，人这种对象可以通过水杯去接水来使用，但不能说饮水机是他的，也就是说，对象可以用静态资源，但是跟对象没关系。

1.2Java中的静态

1.2.1作用

（1）修饰成员变量，使其成为静态属性

（2）修饰成员方法，使其成为静态方法

（3）修饰代码块，使其成为静态代码块

1.2.1.1static修饰成员变量

1.2.1.1.1语法格式:

static 数据类型变量名;

1.2.1.1.2注意事项:

1.使用static修饰的变量叫静态变量
2.代码中对象还没有创建的时候，如果加载了类，static修饰的属性已经存在了，和对象没有关系。只和类本身有关。

1.2.1.1.3示例

首先来说大家要记住，对象是可以调用静态属性并赋值，输出的。同时标准的来说，是用类来调用，所以会发现，对象和类都可调用静态属性并赋值。

但是在输出的时候，是以最后一次赋值结果为准，不管是谁调用赋值的，所以大家可以直接认为，静态属性只有一个，所有的赋值修改都是基于这一个属性

class Person {
 String name;
 int age;
 static String country;
}
public class Demo2 {
 public static void main(String[] args) {
  Person sb = new Person();
  sb.name = "张三";
  sb.age = 23;
  Person.country = "中国";
  //The static field Person.country 
  //should be accessed in a static way
  System.out.println(sb.country);//中国
  System.out.println(Person.country);//in a static way
  sb.country = "PRC";
  System.out.println(Person.country);//PRC
 }

}

1.2.1.1.4实际内存分析

当然，看看实际的内存分析，会发现对象调用和类调用的静态属性是在不同分区的，对象调用在堆区，而类调用是在方法区。但是，但是！赋值修改会互通。

大家实际开发的时候，记住用类.静态属性去调用就OK。

1.2.1.2static修饰成员方法

1.2.1.2.1语法格式

public static 返回值方法的名字 (参数列表) {}
调用静态方法：类.方法名字();

1.2.1.2.2示例

class Dog {
 public void eat () {
  System.out.println("普通的成员方法");
 }
 public static void sleep () {
  System.out.println("睡吧不用看家了");
 }
}
public class Demo3 {
 public static void main(String[] args) {
  Dog.sleep();
  //Dog.eat();只能拿对象来调用这个方法eat
  Demo3.test();
 }
 public static void test () {
  System.out.println("嘻嘻");
 }

}

这里需要注意的，只能用类调用静态方法，也只能用对象调用普通方法，如果方法写在main主函数里，就用主类名直接调用，而且还可以省略主类名

虽然在某些情况下，Java 编译器可能允许使用对象来调用静态方法或使用类名来调用普通方法，但这并不代表这样做是推荐的或是符合最佳实践的。建议在编写代码时，尽量遵循通用的编程规范和最佳实践。

1.2.1.3static修饰代码块

1.2.1.3.1语法格式

static {
语句体
}

只要这个类加载，那么静态代码块一定会执行

执行顺序: 静态代码块-->构造代码块-->构造方法

1.2.1.3.2示例1

class Cat {
 public Cat () {
  System.out.println("无参构造方法");
 }
 {
  System.out.println("构造代码块");
 }
 static {
  System.out.println("静态的代码块");
 }
}
public class Demo4 {
 public static void main(String[] args) {
  Cat cat = new Cat();
 }

}

最后输出结果验证执行顺序

再次强调，修饰成静态的方法、属性、代码块都跟对象无关，而只跟类有关

所以可以在示例里看到，调用的时候，需要用类名.静态属性/静态方法/静态代码块

同时注意最后的结果，静态代码块会先执行，这个在开发中会用到的

1.2.1.3.3示例2

package com.qfedu.a_static;

class Man {
 static String name;//静态的属性  和对象无关的
 //静态方法
 public static void eat () {
  System.out.println("吃饭喝酒");
 }
 //静态代码块
 static {
  System.out.println("嘻嘻");
 }
}
public class Demo1 {
 public static void main(String[] args) {
  //咋使用 类.静态的属性
  Man.name = "狗蛋";
  System.out.println(Man.name);
  //使用  类.静态方法名字()
  Man.eat();
  
 }

}

二、字符串声明

先强调一个知识点：

== 比较的是内存地址
equal比较的是地址，如果地址不一样再去比较内容。如果内容一样就是true
开发中字符串的比较使用的是equals

2.1直接声明

对象创建在栈区

栈区如果对象内容一致，则是同一个内存地址，用==号比较时，结果为true

2.2创建string对象

对象创建在堆区

2.3内存分析

这里堆区的字符串常量池可能大家有点懵，没事的，马上就讲。

三、字符串常量池

3.1为什么要有字符串常量池

首先对象的分配要付出时间和空间上的开销，字符串可以说是和 8 个基本类型一样常用的类型，甚至比 8 个基本类型更加常用，故而频繁的创建字符串对象，对性能的影响是非常大的，所以，用常量池的方式可以很大程度上降低对象创建、分配的次数，从而提升性能。

3.2字符串赋值方式

这部分知识点有点绕，希望大家尽量理解。

同时声明，这段知识点来自以下博文，大家更可以看看原文，写得很好。

90%的同学都没搞清楚的 Java 字符串常量池问题（图文并茂） - 古时的风筝的个人空间 - OSCHINA - 中文开源技术交流社区

3.2.1字面量赋值

如String s1 = "古时的风筝"

这种方式叫做字面量声明，也就用把字符串用双引号引起来，然后赋值给一个变量。

这种情况下会直接将字符串放到字符串常量池中，然后返回给变量。

此时再声明一个内容相同的字符串，会发现字符串常量池中已经存在了，那直接指向常量池中的地址即可。

所以 s1== s2 的结果是 true。

3.2.2new String () 方式

基本上不建议这么用，除非有特殊的逻辑需要。
String a = "古时的";
String s2 = new String(a + "风筝");

此时需要考虑的情况：

1.字符串常量池之前已经存在相同字符串
比如在使用new之前，已经用字面量声明的方式声明了一个变量，此时字符串常量池中已经存在了相同内容的字符串常量。

1.首先会在堆中创建一个 s2 变量的对象引用；
2.然后将这个对象引用指向字符串常量池中的已经存在的常量；

2.字符串常量池中不存在相同内容的常量
之前没有任何地方用到了这个字符串，第一次声明这个字符串就用的是 new String () 的方式，这种情况下会直接在堆中创建一个字符串对象然后返回给变量。

new String () 不管常量池中有没有，都会在堆中新建一个对象，新建出来的对象，当然不会和其他对象相等。

3.2.3intern () 池化

好多地方说，如果字符串常量池中不存在的话，就先把字符串先放进去，然后再引用字符串常量池的这个常量对象，这种说法是有问题的，只是 new String()的话，如果池中没有也不会放一份进去。那什么时候会放到字符串常量池呢，就是在使用intern()方法之后。

intern()的定义：如果当前字符串内容存在于字符串常量池，存在的条件是使用equas()方法为ture，也就是内容是一样的，那直接返回此字符串在常量池的引用；如果之前不在字符串常量池中，那么在常量池创建一个引用并且指向堆中已存在的字符串，然后返回常量池中的地址。

还是考虑两种情况：

1.准备池化的字符串与字符串常量池中的字符串有相同 (equas () 判断)

此时s1 == s2 会返回 fasle。然后我们调用 s2 = s2.intern ()，将池化操作返回的结果赋值给 s2，就会发生如下的变化。

2.字符串常量池中不存在相同内容的字符串

使用了 intern () 之后发生了什么呢，在常量池新增了一个对象，但是并没有将字符串复制一份到常量池，而是直接指向了之前已经存在于堆中的字符串对象。因为在JDK1.7之后，字符串常量池不一定就是存字符串对象的，还有可能存储的是一个指向堆中地址的引用，现在说的就是这种情况，注意了，下图是只调用了s2.intern()，并没有返回给一个变量。其中字符串常量池（0x88）指向堆中字符串对象（0x99）就是intern()的过程。

注意此时只是调用了intern()池化函数，没有赋值给s2，所以此时s2没有指向字符串常量池

只有当我们把 s2.intern () 的结果返回给 s2 时，s2 才真正的指向字符串常量池。

3.2.4示例

综上，我们通过一个示例体会，你是否能准确讲述出每个对比结果的原因？

public class Test {

    public static void main(String[] args) {
        String s1 = "古时的风筝";
        String s2 = "古时的风筝";
        String a = "古时的";
      
        String s3 = new String(a + "风筝");
        String s4 = new String(a + "风筝");
        System.out.println(s1 == s2); // 【1】 true
        System.out.println(s2 == s3); // 【2】 false
        System.out.println(s3 == s4); // 【3】 false
        s3.intern();
        System.out.println(s2 == s3); // 【4】 false
        s3 = s3.intern();
        System.out.println(s2 == s3); // 【5】 true
        s4 = s4.intern();
        System.out.println(s3 == s4); // 【6】 true
    }
}

如果大家都能准确说出每个结果的原因，那基本就没什么问题了。

如果不能，那就再多看几遍。

【1】：s1 == s2 返回 ture，因为都是字面量声明，全都指向字符串常量池中同一字符串。

【2】: s2 == s3 返回 false，因为 new String () 是在堆中新建对象，所以和常量池的常量不相同。

【3】: s3 == s4 返回 false，都是在堆中新建对象，所以是两个对象，肯定不相同。

【4】: s2 == s3 返回 false，前面虽然调用了 intern () ，但是没有返回，不起作用。

【5】: s2 == s3 返回 ture，前面调用了 intern () ，并且返回给了 s3 ，此时 s2、s3 都直接指向常量池的同一个字符串。

【6】: s3 == s4 返回 true，和 s3 相同，都指向了常量池同一个字符串。

以上，就是今天的所有知识点了。字符串常量池的问题有点绕，但是不难，大家静下心慢慢看，慢慢理解，不是什么大问题。

加油吧，预祝大家变得更强！