Java面试练习题（每天进步一点点）

提示：为了防止大家第一眼看到正确答案，正确答案放在每道题的题解后面！！！

!
!
!
!
!

1、protected访问权限要小于包访问权限。（ ）

A.正确
B.错误

题解：
Java类成员的访问控制权限： public > protected > 同包（default） > private

正确答案: B 你的答案: B (正确)

2、上述代码返回结果为：

Integer a = 1;
Integer b = 1;
Integer c = 500;
Integer d = 500;
System.out.print(a == b);
System.out.print(c == d);

A.true、true
B.true、false
C.false、true
D.false、false

题解：
Integer类型在-128–>127范围之间是被缓存了的，也就是每个对象的内存地址是相同的，赋值就直接从缓存中取，不会有新的对象产生，而大于这个范围，将会重新创建一个Integer对象，也就是new一个对象出来，当然地址就不同了，也就！=；

正确答案: B 你的答案: B (正确)

3、下面程序的运行结果是：（ ）

public static void main(String args[]) {
    Thread t = new Thread() {
		public void run() {
			pong();
		}
	};
	t.run();
	System.out.print("ping");
}
    
static void pong() {
	System.out.print("pong");
}

A.pingpong
B.pongping
C.pingpong和pongping都有可能
D.都不输出
E.pong
F.ping

题解：
t.run是调用的Thead类中的run()方法，t.start才是执行线程，所以这题就是执行普通run()方法，先输出pong，在输出ping。

正确答案: B 你的答案: B (正确)

4、下面有关List接口、Set接口和Map接口的描述，错误的是？

A.他们都继承自Collection接口
B.List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置
C.Set是一种不包含重复的元素的Collection
D.Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value

题解：
Map接口和Collection接口是同一等级的，所以A错误。
选项BCD都正确，详细知识可以查看博主关于集合小结的文章AryyayList，LinkedList，Vector，HashMap，HashTable区别

正确答案: A 你的答案: A (正确)

5、下列说法正确的是( )

A.volatile,synchronized 都可以修改变量，方法以及代码块
B.volatile，synchronized 在多线程中都会存在阻塞问题
C.volatile能保证数据的可见性，但不能完全保证数据的原子性，synchronized即保证了数据的可见性也保证了原子性
D.volatile解决的是变量在多个线程之间的可见性、原子性，而sychroized解决的是多个线程之间访问资源的同步性

题解：
synchronized关键字和volatile关键字比较：

• volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，实际开发中使用 synchronized 关键字的场景还是更多一些。
• 多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞
• volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。
• volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized关键字解决的是多个线程之间访问资源的同步性。

正确答案: C 你的答案: D (错误)

6、以下代码运行输出的是

public class Person{
    private String name = "Person";
    int age=0;
}
public class Child extends Person{
    public String grade;
    public static void main(String[] args){
        Person p = new Child();
        System.out.println(p.name);
    }
}

A.输出：Person
B.没有输出
C.编译出错
D.运行出错

题解：
1.一个java文件里，public 的类只能出现一个，只能出现一个，只能出现一个，否则，不管你用哪一个类名命名文件名编译器都会报错。
2.关于多态。子类继承了父类的所有成员，包括private权限的成员变量，但是继承的子类具有私有变量的拥有权但是没有使用权。
3.private的成员变量，根据权限修饰符的访问控制范围，只有在类内部才能被访问，就算是他的子类，也不能访问。

正确答案: C 你的答案: C (正确)

7、下面为true的是（）

Integer i = 42;
Long l = 42l;
Double d = 42.0;

(i == l)
(i == d)
(l == d)
i.equals(d)
d.equals(l)
i.equals(l)
l.equals(42L)

题解：
1、基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
int a = 220;
Integer b = 220;
System.out.println(a==b);//true
2、两个Integer类型进行“==”比较， 如果其值在-128至127 ，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关。
Integer c=3;
Integer h=3;
Integer e=321;
Integer f=321;
System.out.println(c==h);//true
System.out.println(e==f);//false
但如果是Integer与new Integer或new Integer与new Integer进行 == 比较，不管其值是否在-128至127，肯定会flase。
Integer a = 1;
Integer b = new Integer(1);
Integer a1 = 128;
Integer b1 = new Integer(128);
Integer a2 = new Integer(2);
Integer b2 = new Integer(2);
System.out.println(a == b);//false
System.out.println(a1 == b1);//false
System.out.println(a2 == b2);//flase
3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true。
Integer a=1;
Integer b=2;
Integer c=3;
System.out.println(c.equals(a+b));//true
4、基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。
int i=1;
int j = 2;
Integer c=3;
System.out.println(c.equals(i+j));//true

正确答案: G 你的答案: G (正确)

8、Java网络程序设计中,下列正确的描述是（）

A.Java网络编程API建立在Socket基础之上
B.Java网络接口只支持tcP以及其上层协议
C.Java网络接口只支持UDP以及其上层协议
D.Java网络接口支持IP以上的所有高层协议

题解：

• UDP
  Java的java.net包中，提供了两个类DatagramSocket和DatagramPacket来支持UDP的数据报（Datagram）通信
  其中DatagramSocket用于在程序之间建立传送数据报的通信通道，DatagramPacket则用来表示一个数据报。DatagramSocket发送的每个包都需要指定地址，而DatagramPacket则是在首次创建时指定地址，以后所有数据的发生都通过此socket。
  UDP的客户端编程也是4个部分：建立连接、发送数据、接受数据和关闭连接。
  https://blog.csdn.net/qq_38180223/article/details/81502584
• TCP
  Java实现TCP数据传输涉及到的类有Socket、ServerSocket；TCP分客户端服务端，而UDP不分客户端服务端
  https://blog.csdn.net/yy455363056/article/details/80210461

正确答案: A D 你的答案: A D (正确)

9、下面哪些具体实现类可以用于存储键，值对，并且方法调用提供了基本的多线程安全支持：()

java.util.ConcurrentHashMap
java.util.Map
java.util.TreeMap
java.util.SortMap
java.util.Hashtable
java.util.HashMap

题解：

• Hashtable是线程安全的哈希表，它是通过synchronized来保证线程安全的；即，多线程通过同一个“对象的同步锁”来实现并发控制。Hashtable在线程竞争激烈时，效率比较低（此时建议使用ConcurrentHashMap）。当一个线程访问Hashtable的同步方法时，其它线程如果也在访问Hashtable的同步方法时，可能会进入阻塞状态。
• Collections.synchronizedMap()使用了synchronized同步关键字来保证对Map的操作是线程安全的。
• ConcurrentHashMap是线程安全的哈希表。在JDK1.7中它是通过“锁分段”来保证线程安全的，本质上也是一个“可重入的互斥锁”（ReentrantLock）。多线程对同一个片段的访问，是互斥的；但是，对于不同片段的访问，却是可以同步进行的。在JDK1.8中是通过使用CAS原子更新、volatile关键字、synchronized可重入锁实现的。

正确答案: A E 你的答案: A E (正确)

10、Which test would return true?

Integer s=new Integer(9);
Integer t=new Integer(9);
Long u=new Long(9);

(s==u)
(s==t)
(s.equals(t))
(s.equals(9))
(s.equals(new Integer(9))

题解：

• int和int之间，用==比较，肯定为true。基本数据类型没有equals方法
• int和Integer比较，Integer会自动拆箱，== 和 equals都肯定为true
• int和new Integer比较，Integer会自动拆箱，调用intValue方法, 所以 == 和 equals都肯定为true
• Integer和Integer比较的时候，由于直接赋值的话会进行自动的装箱。所以当值在[-128,127]中的时候，由于值缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是直接从缓存中获取已经创建好的Integer对象。而当大于这个区间的时候，会直接new Integer。
  • 当Integer和Integer进行==比较的时候，在[-128,127]区间的时候，为true。不在这个区间，则为false
  • 当Integer和Integer进行equals比较的时候，由于Integer的equals方法进行了重写，比较的是内容，所以为true
• Integer和new Integer ： new Integer会创建对象，存储在堆中。而Integer在[-128,127]中，从缓存中取，否则会new Integer.
  所以 Integer和new Integer 进行==比较的话，肯定为false ; Integer和new Integer 进行equals比较的话，肯定为true
• new Integer和new Integer进行==比较的时候，肯定为false ; 进行equals比较的时候，肯定为true
  原因是new的时候，会在堆中创建对象，分配的地址不同，==比较的是内存地址，所以肯定不同。
• 装箱过程是通过调用包装器的valueOf方法实现的。
  拆箱过程是通过调用包装器的xxxValue方法实现的（xxx表示对应的基本数据类型）。
• 总结：Byte、Short、Integer、Long这几个类的valueOf方法实现类似的。所以在[-128,127]区间内，==比较的时候，值总是相等的（指向的是同一对象），在这个区间外是不等的。
  而Float和Double则不相等， Boolean的值总是相等的。

正确答案: C D E 你的答案: C D E (正确)