Java基本类型

2019-11-03 19:03:48 by冲冲

1、两个float型相减丢失精度，如何解决？

使用BigDemical装饰器模式

public class Test {

    public static void main(String[] args) {

        float a = 2.030944f;

        float b = 1.001085f;

        System.out.println(a - b);// 1.0298591

        BigDecimal c = new BigDecimal(Float.toString(a));

        BigDecimal d = new BigDecimal(Float.toString(b));

        BigDecimal resultSub = c.subtract(d);       //减法

        BigDecimal resultAdd = resultSub.add(d);    //加法

        BigDecimal resultMul = c.multiply(d);       //乘法

        BigDecimal resultDiv = c.divide(d);         //除法

        System.out.println(resultSub.floatValue());//1.029859

        System.out.println(resultAdd.floatValue());//2.030944

    }

}

2、方法的值传递和对象传递

public class Test {

    public void change(String str, char ch[]) {

        str = "test ok";

        ch[0] = 'g';

    }

    public static void main(String args[]) {

        String str = new String("good");

        char[] ch = {'a', 'b', 'c'};

        Test ex = new Test();

        ex.change(str, ch);

        System.out.print(str + " and " + ch); //good and gbc

    }

}

3、Integer类的==和equals()

public class Test {

    public static void main(String[] args) {

        Integer a = 1;

        Integer b = 2;

        Integer c = 3;

        Integer d = 3;

        Integer e = 321;

        Integer f = 321;

        Long g = 3L;

        Long h = 2L;

        // 当Integer处于-128~127，使用内存栈创建值，并将对象指向该值；当不处于该区间，在堆重新new对象。

        System.out.println(c == d);             //true

        System.out.println(e == f);             //false

        // 自动拆箱

        System.out.println(c == (a + b));       //true

        System.out.println(c.equals(a + b));    //true
        // 包装类的equals()方法会使用instanceof判断类型

        System.out.println(g == (a + b));       //true

        System.out.println(g.equals(a + b));    //false

        System.out.println(g.equals(a + h));    //true

    }

}

4、==和equals()

public class Test {

    public static void main(String[] args) {

        Long u = 127L;

        Long v = 127L;

        System.out.println(u == v);       //true

        //[-128,127]在栈内存创建，并指向对象；其余的重新new对象

        u = 128L;

        v = 128L;

        System.out.println(u == v);       //false

        String x = new String("hello");

        String y = "hello";

        System.out.println(x.equals(y));  //true

        System.out.println(x == y);       //false

        x = x.intern();

        System.out.println(x==y);         //true

}

5、多线程的start()和run()

public class Test {

    public static void main(String[] args) {

        Thread t = new Thread() {

            public void run() {

                pong();

            }

        };

        t.run();

        System.out.print("ping");

        //线程要使用start()开启，仅仅调用run()依然在本线程运行，输出结果是pongping

    }

    private static void pong() {

        System.out.print("pong");

    }

}

6、switch

public class Test {

    public static void main(String[] args) {

        System.out.println(getValue(2));

        //输出结果10

        //如果case没有break，则会继续往下执行

    }

    public static int getValue(int i) {

        int Test = 0;

        switch (i) {

            default:

                System.out.println("default");

            case 1:

                Test = Test + i;

            case 2:

                Test = Test + i * 2;

            case 3:

                Test = Test + i * 3;

        }

        return Test;

    }

}

7、变量作用域

public class MeaningOfThis {

    public final int value = 4;

    public void doIt() {

        int value = 6;

        Runnable r = new Runnable() {

            public final int value = 5;

            public void run() {

                int value = 10;

                System.out.println(this.value);

            }

        };

        r.run();

    }

    public static void main(String... args) {

        MeaningOfThis m = new MeaningOfThis();

        m.doIt();

        //输出结果5，因为this指向对象r

    }

}

8、父类和子类的构造方法关系

如果没有给类创建一个构造方法，java编译器会自动添加一个没有参数且方法体为空的构造方法。如果已经人为地添加一个构造方法，java编译器就不会添加构造方法，但是子类构造器就必须显式调用该父类的人为构造方法。

class Person {

    String name = "No name";

    public Person(String nm) {

        name = nm;

    }

}

class Employee extends Person {

    String empID = "0000";

    public Employee(String id) {

        empID = id;

    }

}

public class Test {

    public static void main(String args[]) {

        Employee e = new Employee("123");

        System.out.println(e.empID);

        //编译报错

    }

}

修改方案1

class Employee extends Person {

    String empID = "0000";

    public Employee(String id) {

        super("Railway Employee");  //父类没有默认的空参构造器，所以必须调用带参构造器

        empID = id;

    }

}

修改方案2

class Person {

    String name = "No name";

    public Person(String nm) {

        name = nm;

    }

    public Person() {}  //给父类添加不带参数的构造器，子类就可以隐式调用

}

9、基本数据类型溢出

public class Test {

    public static void main(String[] args) {

        int a = Integer.MAX_VALUE;

        long b = a + 1;

        System.out.println(a);//2147483647

        System.out.println(b);//-2147483648

    }

}

10、finally是否执行？

public class Test {

    public static void main(String[] args) {

        System.out.println(findResult()); //3

    }

    public static int findResult(){

        try {

            return 1;

        } catch (Exception e) {

            return 2;

        } finally {

            return 3;

        }

    }

}

11、溢出

public class Test {

    public static void main(String[] args) {

        byte b = 127;

        b = (byte)(b+1);

        System.out.println(b); //-128

    }

}

12、+=

short s1 = 1;

s1 = s1+1;    //s1+1得到int型的结果，同样是不能自动向下转换，编译报错

s1 += 1;      //底层是 s1 = (short)s1 + 1;

巴特西

【Java面试题】-- Java基本类型

Java基本类型

1、两个float型相减丢失精度，如何解决？

2、方法的值传递和对象传递

3、Integer类的==和equals()

4、==和equals()

5、多线程的start()和run()

6、switch

7、变量作用域

8、父类和子类的构造方法关系

9、基本数据类型溢出

10、finally是否执行？

11、溢出

12、+=

最新文章

热门文章