笔试&&面试经验

第一天:数据类型和Java基础

2017-06-16  本文已影响0人  压根儿没快乐过

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？

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;
    }
}
上一篇下一篇

猜你喜欢

热点阅读