java常量设计和常量池

常量
1、常量：一种不会修改的变量
-java没有constant关键字
-不能修改，final
-不会修改/只读/只要一份，static
-方便访问public
public class StaticBlock {
public final static double pi=3.14;
public static final String country=“China”;
public static void main(String[] args){
System.out.println(StaticBlock.pi);
System.out.println(StaticBlock.country);
}
}
static保证只有一份，final保证值不会被修改，那么这个变量就是常量
2、特殊的常量：接口里面定义的变量默认都是常量

常量池
1、java为很多基本类型的包装类/字符串都建立常量池
2、常量池：相同的只存储一份，节省内存，共享访问
3、基本类型包括的包装类
-Boolean、Byte、Short、Integer、Long、Character、Float、Double
-Boolaen：true，false
-Byte：-128-127，Charac：0-127
-Short，Int，Long：-128-127
-Float，Double：没有缓存（常量池）
public class StaticBlock {
public static void main(String[] args){
Short s1=1000;
Short s2=1000;
boolean c,d,e;
System.out.println(c=(s1= =s2));//false
Float f1=0.5f;
Float f2=0.5f;
System.out.println(d=(f1= =f2));//false
Integer i1=127;
Integer i2=127;
System.out.println(e=(i1= =i2));//true
}}

4、java为常量字符串都建立常量池缓存机制
public class StaticBlock {
public static void main(String[] args){
String s1=“abc”;
String s2=“abc”;
String s3=“ab”+“c”;
String s4=“a”+“b”+“c”;//都是常量，编译器将优化
System.out.println(s1= =s2);//true
System.out.println(s1= =s3);//true
System.out.println(s1= =s4);//true
}}
5、基本类型的包装类和字符串都有两种创建方式
-常量式赋值创建，放在栈内存（将被常量化）栈内存读取速度快但容量小
Integer a=10；
String b=“abc”
-new对象进行创建，放在堆内存（不会常量化）堆内存读取速度慢但容量大
Integer c=new Integer（10）；
String d=new String（“abc”）
new根据构造函数来创建对象
这两种创建方式导致创建的对象存放的位置不同

常量池的作用
（1）节约内存
（2）共享访问
/**

• @author ppf
• @create 2020/07/30/22:35
  /
  public class StaticBlock {
  public static void main(String[] args){
  int i1=10;
  Integer i2=10;//自动装箱
  System.out.println(i1= =i2);//true
  //自动拆箱，基本类型和包装类进行比较，包装类自动拆箱
  Integer i3=new Integer(10);
  System.out.println(i1= =i3);//true
  //自动拆箱，基本类型和包装类进行比较，包装类自动拆箱
  System.out.println(i2= =i3);//false
  //两个对象比较，比较其地址
  //i2是常量，存放在栈内存中，i3是new对象，存放在堆内存中
  Integer i4=5;
  Integer i5=5;
  System.out.println(i1==(i4+i5));//true
  System.out.println(i2==(i4+i5));//true
  System.out.println(i3==(i4+i5));//true
  //i4+i5操作会使得i4，i5自动拆箱为基本类型并运算得到10
  //基础类型10和对象比较，将会使对象自动拆箱，做基本类型比较
  Integer i6=i4+i5;//操作使得i4,i5自动拆箱，得到10，因此i6=i2
  System.out.println(i1= =i6);//true
  System.out.println(i2= =i6);//true
  System.out.println(i3= =i6);//false
  }}
  ——————————————————————————————————
  java编译器会优化以及确定的变量
  /*
• @author ppf
• @create 2020/07/30/22:35
  */
  public class StaticBlock {
  public static void main(String[] args) {
  String s0 = “abcdef”;
  String s1 = “abc”;
  String s2 = “abc”;
  String s3 = new String(“abc”);
  String s4 = new String(“abc”);
  System.out.println(s1 == s2);//true 常量池
  System.out.println(s1 == s3);//false 一个栈内存，一个堆内存
  System.out.println(s3 == s4);//false 两个都是堆内存
  String s5 = s1 + “def”;//s1是变量，编译器不会优化
  String s6 = “abc” + “def”;//都是常量，编译器会优化成abcdef
  String s7 = “abc” + new String(“def”);//涉及到new变量，编译器不会优化
  System.out.println(s5 == s6);//false
  System.out.println(s6 == s7);//false
  System.out.println(s0 == s6);//true
  String s8 = s3 + “def”;//涉及到new对象，编译器不会优化
  String s9 = s4 + “def”;//涉及到new对象，编译器不会优化
  String s10 = s3 + new String (“def”);// 同上
  System.out.println(s8 == s9); //false
  System.out.println(s9 == s10); //false
  System.out.println(s8 == s10); //false
  }}