标签：建议 def mat 不能 app 不可变 数字 nbsp 虚拟
package wrapper;
?
/**
* 被 final 修饰的类就是所谓的 最终类（ 或者称作 不可变/不变类 ）
* 被 final 修饰的类 没有子类
* 被 final 修饰的变量称作 最终变量 （ 可以是 类变量、实例变量、局部变量、参数 ）
* */
?
public final class Decimal {
?
// 被 final 修饰的 类变量 在初始化之后不能 再次赋值
// 必须 显式赋值完成初始化
// 被 final 修饰的 类变量 被称作 【常量】
public final static long MAX_VALUE = Long.MAX_VALUE; // 常量的名称中 所有单词大写 多个单词之间用 _ 隔开
public final static long MIN_VALUE = Long.MIN_VALUE;
?
// 被 final 修饰的 实例变量 在初始化之后不能再次赋值
private final long value;
?
public Decimal(long value) {
// System.out.println("this.value:" + this.value ); // 失败 未初始化变量
this.value = value;
System.out.println("this.value:" + this.value );
}
?
public long getValue() {
return value;
}
public void setValue() {
// this.value = value; // 错误 无法为 value 赋值
}
public static Decimal valueOf(long value) {
return new Decimal(value);
}
?
public static void main(String[] args) {
// 在 堆内存中所创建的 Decimal 对象是 不可变的（ 因为其内部 实例变量的 值不可变 ）
Decimal d = new Decimal(100L);
System.out.println(d.getValue());
System.out.println(System.identityHashCode(d));
?
System.out.println("=============");
?
?
d = new Decimal(200L);
System.out.println(System.identityHashCode(d));
?
?
d = Decimal.valueOf(300L);
System.out.println(System.identityHashCode(d));
?
}
?
}
?
被 final 修饰的 类变量 在初始化之后不能 再次赋值 必须 显式赋值完成初始化
被 final 修饰的 类变量 被称作 【常量】
在 Java 9 之前通过 new 来获取 对应的包装类
在 Java 9 之后 通过 valueOf () 工厂方法来获取包装类
package wrapper;
?
/**
* 获得某种基本数据类型 数值 对应的 包装类类型的实例
* 在 Java 9 之前 使用包装类 的 构造方法创建实例
* 在 Java 9 开始使用 valueOf 等方法获取实例
*
*
* */
?
public class WrapperTest {
?
public static void main(String[] args) {
?
// Java 9 之前 使用构造方法创建 相对应的实例
byte b = 100;
Byte first = new Byte(b); // 但是从 Java 9 之后就不赞成使用
?
// Java 9 之前 使用构造方法创建 相对应的实例
short s = 100;
Short second = new Short(s); // 但是从 Java 9 之后就不赞成使用
?
?
// 从 Java 9 开始 建议使用 工厂方法来创建 包装类的实例
Integer third = Integer.valueOf(999); // 将 int 类型的数字 封装到 一个 Integer 实例中
System.out.println(third);
?
Long fourth = Long.valueOf(999L);
System.out.println(fourth); // fourth.toString()
?
?
System.out.println("===============");
System.out.println(fourth.getClass()); // 获取运行时 类型
System.out.println(fourth.hashCode()); // 获得哈希码值
System.out.println(fourth.toString()); // 获取字符串形式表示形式
?
?
// 即使变量 fourth 指向的对象对应的类 重写的 hashCode 方法 所返回的值
?
?
?
}
?
?
}
?
package wrapper;
?
/** 八中基本类型对应的包装类都有一个将相对应的基本类型数据封装成该类的对象的 valueOf 方法中
*
* */
?
public class WrapperTest2 {
public static void main(String[] args) {
// valueOf 接收一个与之对应的基本数据类型的数值做参数，返回的是一个 Byte 类型的对象
Byte b = Byte.valueOf((byte) 100);
System.out.println(b + "," + b.getClass());
?
Short s = Short.valueOf((short) 100);
System.out.println(s + "," + s.getClass());
?
Integer i = Integer.valueOf(1000);
System.out.println(s + "," + s.getClass());
?
Long l = Long.valueOf(10000L);
System.out.println(l + "," + l.getClass());
?
Float f = Float.valueOf(1455.252f);
System.out.println(f + "," + f.getClass());
?
Double d = Double.valueOf(1455.252);
System.out.println(d + "," + d.getClass());
?
Boolean z = Boolean.valueOf(true);
System.out.println(z + "," + z.getClass());
?
Character c = Character.valueOf(‘a‘);
System.out.println(c + "," + c.getClass());
?
?
?
}
}
?
1、基本数据类型的数值 被包装 到一个相应的包装类类型的实例中
在 Java 9 之前 使用包装类 的 构造方法创建实例
在 Java 9 开始使用 valueOf 等方法获取实例
2、将 用字符串形式表示的值 解析为 基本类型的数值后
再将 基本类型的数据 封装到 一个 相应的包装类类型的实例中
注意事项 Character类中没有 valueOf(String) 方法
3、将 字符串形式 表示的值解析为 基本数据类型的值
4、对于整数类型来说，其相应的包装类中可以将 字符串形式 表示的值
按照指定的 radix 解析为 相应的进制数 最大 36 进制
5、通常在 Java 语言中 radix 范围 [2,36]
Character.MIN_RADIX , Character.MAX_RADIX
八种基本数据类型对应的包装类中 除了 Character 类之外 都有一个将 字符串解析为 相对应的基本类型数值的方法
package wrapper;
?
/**
* 1、基本数据类型的数值 被包装 到一个相应的包装类类型的实例中
* 在 Java 9 之前 使用包装类 的 构造方法创建实例
* 在 Java 9 开始使用 valueOf 等方法获取实例
*
* 2、将 用字符串形式表示的值 解析为 基本类型的数值后
* 再将 基本类型的数据 封装到 一个 相应的包装类类型的实例中
* 注意事项 Character类中没有 valueOf(String) 方法
* 3、将 字符串形式 表示的值解析为 基本数据类型的值
*
* 4、对于整数类型来说，其相应的包装类中可以将 字符串形式 表示的值
* 按照指定的 radix 解析为 相应的进制数 最大 36 进制
* 5、通常在 Java 语言中 radix 范围 [2,36]
* Character.MIN_RADIX , Character.MAX_RADIX
*
* 八种基本数据类型对应的包装类中 除了 Character 类之外 都有一个将 字符串解析为 相对应的基本类型数值的方法
*
*
* */
public class WrapperTest4 {
public static void main(String[] args) {
final String x = "101";
?
// radix 进制 最大36进制
// Byte.parseByte("129"); // NumberFormatException
byte b = Byte.parseByte(x); // String ===> byte
System.out.println(b);
?
byte b2 = Byte.parseByte(x,2); // String ===> byte
System.out.println(b2);
?
short s = Short.parseShort(x); // String ===> byte
System.out.println(s);
?
short s2 = Short.parseShort(x,2); // String ===> byte
System.out.println(s2);
?
int i = Integer.parseInt(x); // String ===> byte
System.out.println(i);
?
int i2 = Integer.parseInt(x,36); // String ===> byte
System.out.println(i2);
?
long l = Long.parseLong(x); // String ===> byte
System.out.println(l);
?
long l2 = Long.parseLong(x,36); // String ===> byte
System.out.println(l2);
?
System.out.println("~~~~~~~~~~~~~~~");
?
float f = Float.parseFloat("3.14F");
System.out.println(f);
?
float f2 = Float.parseFloat("3.14");
System.out.println(f2);
?
double d = Float.parseFloat("3.14D");
System.out.println(d);
?
double d2 = Float.parseFloat("3.14");
System.