日常Java练习题（每天进步一点点系列）

灰太狼 2022-10-07 13:55 108阅读 0赞

**提示：好多小伙伴反映，直接看到答案不太好，那我把答案的颜色设置为透明，答案位置还是在题目后面，需要鼠标选中才能看见（操作如下图），同时为了手机端的小伙伴（手机端也可以长按选中查看），我还会把所有答案放到文章最下面，希望给每天进步一点点的小伙伴更好的体验。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4MzkxNw_size_16_color_FFFFFF_t_70]

**承蒙各位厚爱，今天是2021年6月18日，挑战不断更Day03**

**1、下列程序段的输出结果是：（ ）  
public void complicatedexpression\_r()\{  
int x=20, y=30;  
boolean b;  
b = x > 50 && y > 60 || x > 50 && y < -60 || x < -50 && y > 60 || x < -50 && y < -60;  
System.out.println(b);  
\}  
正确答案: B 你的答案: B (正确)  
true  
false  
1  
0**

> **题解：  
> x>50为false，由于&&与操作，||或操作都是短路操作符，即与操作时一旦遇到false就停止执行后当前关系式中的后续代码，同理或操作时一旦遇到true也停止执行。  
> x>50&&y>60中x>50结果为false，所以就不需要判断y>60。继续判断第一个||或操作符后面的代码，结果为false || false || false || false。因此最终答案选择false。**

**2、关键字()表明一个对象或变量的引用在初始化后不能被修改。  
正确答案: B 你的答案: B (正确)  
private  
final  
static  
没有这种关键字**

> **题解：  
> 送分题，final**

**3、下面这三条语句  
System.out.println(“is ”+ 100 + 5)；  
System.out.println(100 + 5 +“ is”)；  
System.out.println(“is ”+ (100 + 5))；  
的输出结果分别是？ ( )  
正确答案: D 你的答案: D (正确)  
is 1005, 1005 is, is 1005  
is 105, 105 is, is 105  
is 1005, 1005 is, is 105  
is 1005, 105 is, is 105**

> **题解：  
> 1."is"说明后面的内容都会被强制转换为string，所以是最后结果是拼接起来的  
> 2.100+5先得到105，然后与is拼接  
> 3.先算括号内的**

**4、如果要建立一个java.scut.computer的包，叙述正确的是？ ( )  
正确答案: A 你的答案: A (正确)  
只需在代码中加入“package java.scut.computer;”一个语句，并且必须放在代码的第一行  
只需在代码中加入“package java.scut;”一个语句  
必须在代码中加入“package java.scut;”和“package java.scut.computer;”两个语句  
在代码中，不一定是第一句，只要是类定义前，加入package语句即可**

> **题解：  
> 第一行指的是最上面的那一行，别钻牛角尖**

**5、有时为了避免某些未识别的异常抛给更高的上层应用，在某些接口实现中我们通常需要捕获编译运行期所有的异常， catch 下述哪个类的实例才能达到目的：（）  
正确答案: B 你的答案: B (正确)  
Error  
Exception  
RuntimeException  
Throwable**

> **题解：**  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4MzkxNw_size_16_color_FFFFFF_t_70 1]

**6、根据以下代码段,执行new Child(“John”, 10); 要使数据域data得到10，则子类空白处应该填写( )。**

class Parent { 
        private int data;
        public Parent(int d){  data = d; }
    }
    class Child extends Parent{ 
        String name;
        public Child(String s, int d){ 
            ___________________
            name = s;
        }
    }

**正确答案: D 你的答案: D (正确)  
data = d;  
super.data = d;  
Parent(d);  
super(d);**

> **题解：  
> 1.super可以访问父类中public、default、protected修饰的成员变量，不能访问private修饰的成员变量。格式为super.成员名称。  
> 2.super可以访问父类中public、default、protected修饰的实例方法，不能访问private修饰的实例方法。格式为super.实例方法。  
> 3.super可以访问父类中public、default、protected修饰的构造方法，不能访问private修饰的构造方法，格式为super(参数).**

**7、下面字段声明中哪一个在interface主体内是合法的? （）  
正确答案: B 你的答案: B (正确)  
private final static int answer = 42;  
public static int answer = 42;  
final static answer = 42;  
int answer;**

> **题解：  
> 在接口中，属性都是默认public static final修饰的，所以：  
> A（错误）：不能用private修饰；  
> B（正确）：在接口中，属性默认public static final，这三个关键字可以省略；  
> C（错误）：没写属性的类型；  
> D（错误）：final修饰的属性必须赋值；**

**8、假设如下代码中，若t1线程在t2线程启动之前已经完成启动。代码的输出是（）**

public static void main(String[]args)throws Exception { 
        final Object obj = new Object();
        Thread t1 = new Thread() { 
            public void run() { 
                synchronized (obj) { 
                    try { 
                        obj.wait();
                        System.out.println("Thread 1 wake up.");
                    } catch (InterruptedException e) { 
                    }
                }
            }
        };
        t1.start();
        Thread.sleep(1000);//We assume thread 1 must start up within 1 sec.
        Thread t2 = new Thread() { 
            public void run() { 
                synchronized (obj) { 
                    obj.notifyAll();
                    System.out.println("Thread 2 sent notify.");
                }
            }
        };
        t2.start();
    }

**正确答案: B 你的答案: B (正确)  
Thread 1 wake up  
Thread 2 sent notify.  
Thread 2 sent notify.  
Thread 1 wake up  
A、B皆有可能  
程序无输出卡死**

> **题解：  
> 选择B  
> 执行obj.wait();时已释放了锁，所以t2可以再次获得锁，然后发消息通知t1执行，但这时t2还没有释放锁，所以肯定是执行t2，然后释放锁，之后t1才有机会执行。**

**9、以下代码执行的结果是多少（）？**

public class Demo { 
    	public static void main(String[] args) { 
    		Collection<?>[] collections = 
    { new HashSet<String>(), new ArrayList<String>(), new HashMap<String, String>().values()};
    				Super subToSuper = new Sub();
    				for(Collection<?> collection: collections) { 
    	System.out.println(subToSuper.getType(collection));
    }
    }
    abstract static class Super { 
    	public static String getType(Collection<?> collection) { 
    		return “Super:collection”;
    }
    public static String getType(List<?> list) { 
    		return “Super:list”;
    }
    public String getType(ArrayList<?> list) { 
    		return “Super:arrayList”;
    }
    public static String getType(Set<?> set) { 
    		return “Super:set”;
    }
    public String getType(HashSet<?> set) { 
    		return “Super:hashSet”;
    }
    }
    static class Sub extends Super { 
    	public static String getType(Collection<?> collection) { 
                return "Sub"; }
    }
    }

**正确答案: C 你的答案: C (正确)  
A:Sub:collection  
Sub:collection  
Sub:collection  
   
B:Sub:hashSet  
Sub:arrayList  
Sub:collection  
   
C:Super:collection  
Super:collection  
Super:collection  
   
D:Super:hashSet  
Super:arrayList  
Super:collection**

> **题解：  
> 简单而言就是，静态方法不能被重写！  
> 考察点1：重载静态多分派——根据传入重载方法的参数类型，选择更加合适的一个重载方法  
> 考察点2：static方法不能被子类覆写，在子类中定义了和父类完全相同的static方法，则父类的static方法被隐藏，Son.staticmethod()或new Son().staticmethod()都是调用的子类的static方法，如果是Father.staticmethod()或者Father f = new Son(); f.staticmethod()调用的都是父类的static方法。  
> 考察点3：此题如果都不是static方法，则最终的结果是A. 调用子类的getType，输出collection**

**10、Java7特性中,abstract class和interface有什么区别。  
正确答案: A B D 你的答案: A B D (正确)  
抽象类可以有构造方法，接口中不能有构造方法  
抽象类中可以有普通成员变量，接口中没有普通成员变量  
抽象类中不可以包含静态方法，接口中可以包含静态方法  
一个类可以实现多个接口，但只能继承一个抽象类。**

> **题解：  
> 含有abstract修饰符的class即为抽象类，abstract类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。  
> 接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。  
> 下面比较一下两者的语法区别：  
> 1.抽象类可以有构造方法，接口中不能有构造方法。  
> 2.抽象类中可以有普通成员变量，接口中没有普通成员变量  
> 3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。  
> 4.抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然  
> eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。  
> 5.抽象类中可以包含静态方法，接口中不能包含静态方法  
> 6.抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。  
> 7.一个类可以实现多个接口，但只能继承一个抽象类。  
> 我们记住知识点就可以了，至于答案就不用太钻牛角了。  
> 针对本题：  
> 1、抽象类可以有构造，只不过不能new。  
> 2、接口中可以有变量，但是无论你怎么写，最后都是public static final的。  
> 3、抽象类中可以有静态方法，接口中也可以有。  
> 扩展：  
> 1、接口中可以有非抽象的方法，比如default方法（Java 1.8）。  
> 2、接口中可以有带方法体的方法。（Java 1.8）  
> 3、接口中的方法默认是public的。**

**答案汇总：  
1、正确答案: B  
2、正确答案: B  
3、正确答案: D  
4、正确答案: A  
5、正确答案: B  
6、正确答案: D  
7、正确答案: B  
8、正确答案: B  
9、正确答案: C  
10、正确答案:A B D**

> **以上部分题解来自牛客评论区，感谢评论区大佬的解释。**

> **每天进步一点点！  
> 不进则退！**

> **版权声明：**  
> **原创博主：牛哄哄的柯南**  
> **博主原文链接：[https://keafmd.blog.csdn.net/][https_keafmd.blog.csdn.net]**

**看完如果对你有帮助，感谢点赞支持！  
如果你是电脑端，看到右下角的 “一键三连” 了吗，没错点它\[哈哈\]**  
![在这里插入图片描述][20201023201048810.gif_pic_center]  
**加油！**

**共同努力！**

**Keafmd**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4MzkxNw_size_16_color_FFFFFF_t_70]: /images/20221005/20b9c6c908d5452ba58497bd04bd81e6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4MzkxNw_size_16_color_FFFFFF_t_70 1]: /images/20221005/4a865c6794784260a7e334221dc70b00.png
[https_keafmd.blog.csdn.net]: https://keafmd.blog.csdn.net/
[20201023201048810.gif_pic_center]: /images/20221005/0017b6b7f6a4411baec261fe565795a0.png