Java习题训练一

Java习题练习（源自牛客网）

1.有关java实例变量,局部变量,类变量和final变量的说法：

• 定义在类中的变量是类的成员变量，可以不进行初始化，Java会自动进行初始化，如果是引用类型默认初始化为null,如果是基本类型例如int则会默认初始化为0
• 局部变量是定义在方法中的变量，必须要进行初始化，否则不同通过编译
• 被static关键字修饰的变量是静态的，静态变量随着类的加载而加载，所以也被称为类变量
• 被final修饰发变量是常量

2.访问控制符

• 与未加访问控制符的缺省情况相比，public和protected修饰符扩大了属性和方法的被访问范围，private修饰符则缩小了这种范围

3. 子类继承了父类的所有属性和方法，不论是私有还是啥都继承了，只是不能够直接调用父类的私有属性和方法

4.构造器

构造方法是一种特殊的方法，具有以下特点：

• 构造方法的方法名必须与类名相同。
• 构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。
• 构造方法的主要作用是完成对象的初始化工作，它能够把定义对象时的参数传给对象的域。
• 一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构造器，这个构造器不执行任何代码。
• 构造方法可以重载，以参数的个数，类型，顺序。

5.看下面代码输出：（自动装箱典例）

package www.bitten.java;

/**
 * @Author : YangY
 * @Description :   自动装箱简例
 * @Time : Created in 8:52 2019/3/17
 */
public class Test {
    public static void main(String[] args) {
        //自动装箱
        Integer i1 = 100;         //-128~127之间，会返回一个已经存在得对象引用
        Integer i2 = 100;
        Integer i3 = new Integer(20);   //有new了肯定对象引用不一样嘛
        Integer i4 = new Integer(20);
        Integer i5 = 200;
        Integer i6 = 200;

        System.out.println(i1==i2);    //true
        System.out.println((i3==i4));  //false
        System.out.println(i5==i6);    //false
    }
}

其实当我们在为Integer赋值的时候，java编译器会将其翻译成调用valueOf()方法。比如Integer i=127翻译为Integer i=Integer.valueOf(127)

然后我们来看看valueOf()函数的源码：

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)   //high为127 ，low为-128
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

6.try，finally语句使用典例

public class Test {
    public static void main(String[] args) {
        int test = test();
        System.out.println("返回值为"+test);
    }
    public static int test() {
        try {
            System.out.println("try块的语句");
            return 2;
        }finally{
            System.out.println("finally块语句");
            //return 3;
        }
    }
}

输出：
try块的语句
finally块语句
返回值为2

如果末尾那句return 3不被注释，则会输出：
try块的语句
finally块语句
返回值为3

结论：无论如何都会执行finally块里面的语句，若try里面有返回值，则先执行finally里的语句再返回去执行try里的return语句，如果finally块里有return语句，则会覆盖try里的return语句；

7. 数据类型自动转换

若有定义语句： int a=10 ; double b=3.14 ; 则表达式 ‘A’+a+b 值的类型是 double型；

解析：

1. 在表达式中，char 和 short 类型的值，无论有符号还是无符号，都会自动转换成 int 或者 unsigned int（如果 short 的大小和 int 一样，unsigned short 的表示范围就大于 int，在这种情况下，unsigned short 被转换成 unsigned int）。因为它们被转换成表示范围更大的类型，故而把这种转换称为“升级（promotion）”。
2. 按照从高到低的顺序给各种数据类型分等级，依次为：long double, double, float, unsigned long long, long long, unsigned long, long, unsigned int 和 int。这里有一个小小的例外，如果 long 和 int 大小相同，则 unsigned int 的等级应位于 long 之上。char 和 short 并没有出现于这个等级列表，是因为它们应该已经被升级成了 int 或者 unsigned int。
3. 在任何涉及两种数据类型的操作中，它们之间等级较低的类型会被转换成等级较高的类型。

8. static 不能修饰局部变量⭐

结论：被static修饰的变量称为静态变量，静态变量属于整个类，而局部变量属于方法，只在该方法内有效，所以static不能修饰局部变量

public class Test {
    static String x = "1";
    static int y = 1;
    public static void main(String[] args) {
        static int z = 2;   //编译报错
        System.out.println(x+y+z);
    }
}

这段代码或许会认为输出：112，但细心的人会发现static int z = 2就会编译报错；

看下面这段代码，才会达到你想要的结果：

public class Test {
    static String x = "1";
    static int y = 1;
    public static void main(String[] args) {
        int z = 2;
        System.out.println(x+y+z);   //112
        System.out.println(x+(y+z));  //13
    }
}

9. switch表达式中参数问题

在Java7中，switch表达式中不能作为参数的是：（D）
A：int 型
B：枚举类型
C：字符串
D：浮点型

解析：在switch（expr1）中，expr1只能是一个整数表达式或者枚举常量（更大字体），整数表达式可以是int基本类型或Integer包装类型，由于，byte,short,char都可以隐含转换为int，所以，这些类型以及这些类型的包装类型也是可以的。显然，long、float、double类型不符合switch的语法规定，并且不能被隐式转换成int类型，所以，它们不能作用于swtich语句中。 注意：String类型是Java7开始支持的。

10.代码输出（匿名内部类）

public class Test {
    public static void main(String[] args) {   
        Object o = new Object() {  
             public boolean equals(Object obj) {  
                 return true; 
         }
     };   
     System.out.println(o.equals("Fred"));
     }
}

这里的创建了一个匿名内部类，对equals方法进行了覆写，所以输出：
true

11.try语句块的使用规则

try后面必须有catch块（）
答案：错误

解析：可以有如下3种形式（单独一个try编译报错）

1. try----catch
2. try----finally
3. try----catch----finally

看下面举例：

        try {
            int a = 4/0;
            System.out.println("try");
        }finally {
            System.out.println("finally");
        }

输出：
finally
Exception in thread “main” java.lang.ArithmeticException: / by zero
at com.bittech.thread.Test.main(Test.java:15)

Process finished with exit code 1

12.线程中被打断会抛出异常的方法

下面哪个行为被打断不会导致interruptedException？
A：Thread.join
B：Thread.sleep
C：Object.wait
D：CyclicBarrier.await
E：Thread.suspend

答案：E （多线程中断那一块有讲解）

13.String类的replaceAll方法的坑

        String str = "C.file.word".replaceAll(".","/")+"Java.class";
        System.out.println(str);

这段代码会输出甚麽？
正确答案：
///Java.class

分析：**由于replaceAll方法的第一个参数是一个正则表达式，而".“在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换成”/"。如果想替换的只是"."，那么久要写成"\\ ." **

但将replaceAll换成replace方法，

        String str = "C.file.word".replace(".","/")+"Java.class";
        System.out.println(str);

输出：
C/file/wordJava.class

14.final关键字（⭐）

下面说法错误的是：
A：final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性
B：final修饰的类肯定不能被继承
C：final修饰的方法不能被重载
D：final修饰的变量不允许被再次赋值
答案：AC

解析：
A：接口，抽象类都需要子类来实现，怎么能用final修饰呢，final修饰的类永远不能被继承
C：不能被覆写，不是重载