1.Java 中应该使用什么数据类型来代表价格？
如果不是特别关心内存和性能的话，使用BigDecimal，否则使用预定义精度的 double 类型。
public static double add(double d1, double d2) {
// 进行加法运算
BigDecimal b1 = new BigDecimal(d1);
BigDecimal b2 = new BigDecimal(d2);
BigDecimal subtract = b1.subtract(b2);
System.out.println(subtract);
return b1.add(b2).doubleValue();
}
// 进行四舍五入
public static double round(double d,int len) {
//操作
BigDecimal b1 = new BigDecimal(d);
BigDecimal b2 = new BigDecimal(1);
// 任何一个数字除以1都是原数字
// ROUND_HALF_UP是BigDecimal的一个常量，
//表示进行四舍五入的操作
return b1.divide(b2, len, BigDecimal.ROUND_HALF_UP).doubleValue();
}
public static void main(String args[]){
System.out.println("加法运算：" + MyMath.round(MyMath.add(10.345, 3.333), 1));
}
2.怎么将 byte 转换为 String？
- byte数据里只能存字符和数字
- byte里存的数字实际上就是字符,byte转成String也就是,把每个数字转成字符,再拼成字符串
需要注意的点是要使用的正确的编码，否则会使用平台默认编码，这个编码可能跟原来的编码相同，也可能不同。
public void convertByteArrayToString() {
byte[] byteArray = new byte[] {87, 79, 87, 46, 46, 46};
String value = new String(byteArray);
System.out.println(value);
}
-----------------------------------------------------------------------------------
String str = "hello";
byte[] srtbyte = null;
srtbyte = str.getBytes("UTF-8");
String res = new String(srtbyte,"UTF-8");
System.out.println(res);
3.Java 中怎样将 bytes 转换为 long 类型？
public static long byteArrayToInt(byte[] byteArray) {
byte[] a = new byte[8];
int i = a.length - 1, j = byteArray.length - 1;
for (; i >###= 0; i--, j--) {// 从b的尾部(即int值的低位)开始copy数据
if (j >###= 0)
a[i] = byteArray[j];
else
a[i] = 0;// 如果b.length不足4,则将高位补0
}
// 注意此处和byte数组转换成int的区别在于，下面的转换中要将先将数组中的元素转换成long型再做移位操作，
// 若直接做位移操作将得不到正确结果，因为Java默认操作数字时，若不加声明会将数字作为int型来对待，此处必须注意。
long v0 = (long) (a[0] & 0xff) << 56;// &0xff将byte值无差异转成int,避免Java自动类型提升后,会保留高位的符号位
long v1 = (long) (a[1] & 0xff) << 48;
long v2 = (long) (a[2] & 0xff) << 40;
long v3 = (long) (a[3] & 0xff) << 32;
long v4 = (long) (a[4] & 0xff) << 24;
long v5 = (long) (a[5] & 0xff) << 16;
long v6 = (long) (a[6] & 0xff) << 8;
long v7 = (long) (a[7] & 0xff);
return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7;
}
4.我们能将 int 强制转换为 byte 类型的变量吗？如果该值大于 byte 类型的范围，将会出现什么现象？
Java 中 int 是 32 位的，而 byte 是 8 位的，所以，如果强制转化是，int 类型的高 24 位将会被丢弃，byte 类型的范围是从 -128 到 128。
5.存在两个类，B 继承 A，C 继承 B，我们能将 B 转换为 C 么？如 C = (C) B;
public class D{
public static void main(String[] args) {
// C c = new B(); //报错
C c = (C) new B();
c.run();
}
}
class A {
}
class B extends A{
public void run(){
System.out.println("b");
}
}
class C extends B{
}
6.哪个类包含 clone 方法？是 Cloneable 还是 Object？
java.lang.Cloneable 是一个标示性接口，不包含任何方法，clone 方法在 object 类中定义。并且需要知道 clone() 方法是一个本地方法，这意味着它是由 c 或 c++ 或 其他本地语言实现的。
public interface Cloneable{
}
7.Java 中 ++ 操作符是线程安全的吗？
不是线程安全的操作。它涉及到多个指令，如读取变量值，增加，然后存储回内存，这个过程可能会出现多个线程交差。
8.a = a + b 与 a += b 的区别(答案)
+= 隐式的将加操作的结果类型强制转换为持有结果的类型。如果两这个整型相加，如 byte、short 或者 int，首先会将它们提升到 int 类型，然后在执行加法操作。如果加法操作的结果比 a 的最大值要大，则 a+b 会出现编译错误，但是 a += b 没问题，如下：
byte a = 127;
byte b = 127;
b = a + b; // error : cannot convert from int to byte
b += a; // ok
byte a = 127;
byte b = 127;
b = (byte) (a + b);
a += b;
System.out.println(b); //没有(byte)会报错
System.out.println(a);
System.out.println(b);
-2
125
-2
9.我能在不进行强制转换的情况下将一个 double 值赋值给 long 类型的变量吗？
不行，你不能在没有强制类型转换的前提下将一个 double 值赋值给 long 类型的变量，因为 double 类型的范围比 long 类型更广，所以必须要进行强制转换。
double a = 123;
long b = (long) a;
10.3*0.1 == 0.3 将会返回什么？true 还是 false？
false，因为有些浮点数不能完全精确的表示出来。
System.out.println(4*0.1 == 0.4); //true
System.out.println(3*0.1 == 0.3); //false
11.int 和 Integer 哪个会占用更多的内存？
Integer 对象会占用更多的内存。Integer 是一个对象，需要存储对象的元数据。但是 int 是一个原始类型的数据，所以占用的空间更少。
12.为什么 Java 中的 String 是不可变的（Immutable）？
Java 中的 String 不可变是因为 Java 的设计者认为字符串使用非常频繁，将字符串设置为不可变可以允许多个客户端之间共享相同的字符串。更详细的内容参见答案。
Image.png
13.我们能在 Switch 中使用 String 吗?
从 Java 7 开始，我们可以在 switch case 中使用字符串，但这仅仅是一个语法糖。内部实现在 switch 中使用字符串的 hash code。
String string = "123";
switch (string) {
case "123":
System.out.println("123");
break;
case "abc":
System.out.println("abc");
break;
default:
System.out.println("defauls");
break;
}
//123
14.Java 中的构造器链是什么？
当你从一个构造器中调用另一个构造器，就是Java 中的构造器链。这种情况只在重载了类的构造器的时候才会出现
public class Test {
public static void main(String[] args) {
//子类的构造函数一定会
//隐式或显式调用父类的构造函数
Manager m = new Manager();
Manager m2 = new Manager("汤姆克鲁斯",10000000,300000);
}
}
class Person {
private String pname;
//建立空参构造函数
public Person()
{
System.out.println("创建人类");
}
public Person(String pname) {
super();
this.pname = pname;
System.out.println(getPname());
}
public String getPname() {
return pname;
}
public void setPname(String pname) {
this.pname = pname;
}
}
class Employee extends Person {
private double salary;
public Employee()
{
//隐式调用父类空参构造函数
//注意"隐式","空参"这两个关键字
System.out.println("创建员工");
}
public Employee(String pname,double s)
{
//this()和super()不能同时存在，因为都要在第一行
//带不带参数视具体情况而定
//this()自己调用自己的构造函数
//就这种情况，有pname这个参数，如果不用super()，则会隐式调用父类空参构造函数，那结果就是null
//super()调用父类的空参构造函数
//super(**)----父类的带参构造函数
super(pname);//显式调用父类带参构造函数
this.salary = s;
System.out.println(pname+"的工资是："+getSalary());
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
class Manager extends Employee {
private double benfit;
public Manager(String pname, double s,double b) {
super(pname, s);
this.benfit = b;
System.out.println(pname+"的工资是："+s+","+"奖金是"+getBenfit());
}
public Manager() {
System.out.println("创建经理");
}
public double getBenfit() {
return benfit;
}
public void setBenfit(double benfit) {
this.benfit = benfit;
}
}