Java选择题日常记录——Day1—Day15
Day 1
Q1
下列表述错误的是？（）
- int是基本类型，直接存数值，Integer是对象，用一个引用指向这个对象。
- 在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过
- 封装的主要作用在于对外隐藏内部实现细节，可以增强程序的安全性
- final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性。
题解
final不能修饰接口
Q2
下面这三条语句输出结果：
System.out.println("is"+ (100 + 5));
System.out.println(100 + 5 + "is");
System.out.println("is"+ (100 + 5));
- is 1005, 1005 is, is 105
题解
在java中，“+” 和 “+=” 是经过重载的运算符，而java不允许程序员进行运算符的重载。
如果 “+” 之前是String，那么此时，“+” 的作用就是连接两个字符串；若此时 “+” 后面是基本数据类型的话，可以直接进行连接，若是引用数据类型的话，则会调用该对象的toString()方法。
Q3
要使某个类能被同一个包中的其他类访问，但不能被这个包以外的类访问，可以( )
- 让该类不使用任何关键字
- 使用private关键字
- 使用protected关键字
- 使用void关键字
题解
default和protected的区别是：前者只要是外部包，就不允许访问；后者只要是子类就允许访问，即使子类位于外部包。
总结：default拒绝一切包外访问；protected接受包外的子类访问
Q4
以下描述错误的一项是（ ）？
- 程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行 到了第几行，是线程隔离的
- 原则上讲，所有的对象都是在堆区上分配内存，是线程之间共享的
- 方法区用于存储JVM加载的类信息、常量、静态变量，即使编译器编译后的代码等数据，是线程隔离的
- Java方法执行内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的
题解
方法区和堆内存是线程共享的；程序计数器、虚拟机栈是线程隔离的
Q5
假设如下代码中，若t1线程在t2线程启动之前已经完成启动。代码的输出是（）
- Thread 2 sent notify. Thread 1 wake up
题解
执行obj.wait();时已释放了锁，所以t2可以再次获得锁，然后发消息通知t1执行，但这时t2还没有释放锁，所以肯定是执行t2，然后释放锁，之后t1才有机会执行。
Day 2
Q1
下面关于垃圾收集的描述哪个是错误的？
- 使用垃圾收集的程序不需要明确释放对象
- 现代垃圾收集能够处理循环引用问题
- 垃圾收集能提高程序员效率
- 使用垃圾收集的语言没有内在泄漏问题
题解
java的垃圾收集机制主要针对新生代和老年代的内存进行回收，不同的垃圾收集算法针对不同的区域；也会有内存泄露问题，例如访问资源文件，流不关闭，访问数据库等连接不关闭。
Q2
下面有关Java的说法正确的是（ ）
- 一个类可以实现多个接口
- 抽象类必须有抽象方法
- protected成员在子类可见性可以修改
- 通过super可以调用父类构造函数
- final的成员方法实现中只能读取类的成员变量
- String是不可修改的，且java运行环境中对string对象有一个对象池保存
题解
Q3
有关静态初始化块说法正确的是？
- 无法直接调用静态初始化块
- 在创建第一个实例前或引用任何静态成员之前，将自动调用静态初始化块来初始化
- 静态初始化块既没有访问修饰符，也没有参数
- 在程序中，用户可以控制何时执行静态初始化块
题解
Q4
下面哪些描述是正确的：（ ）
- b = null执行后b可以被垃圾回收
- a = null执行后b可以被垃圾回收
- a = null执行后a可以被垃圾回收
- a,b必须在整个程序结束后才能被垃圾回收
- 类A和类B在设计上有循环引用，会导致内存泄露
- a, b 必须在start方法执行完毕才能被垃圾回收
题解
Q5
在开发中使用泛型取代非泛型的数据类型（比如用ArrayList取代ArrayList），程序的运行时性能会变得更好。（）
- False
题解
使用泛型的好处：类型安全、消除强制类型转换、潜在的性能收益，所以泛型只是提高了数据传输安全性，并没有改变程序运行的性能；
泛型仅仅是java的语法糖，它不会影响java虚拟机生成的汇编代码，在编译阶段，虚拟机就会把泛型的类型擦除，还原成没有泛型的代码，顶多编译速度稍微慢一些，执行速度是完全没有什么区别的
Day 3
Q1
映射 (Map) 的key和value都不可重复。（ ）
- False
题解
Map接口有两个经典的子类分别是 Hashtable 和 Hashmap。
Hashtable 线程安全，不支持key和value为空，key不能重复，但value可以重复，不支持key和value为null；
Hashmap 非线程安全，支持key和value为空，key不能重复，但value可以重复，支持key和value为null。
Q2
以下是java concurrent包下的4个类，选出差别最大的一个
- Semaphore
- ReentrantLock
- Future
- CountDownLatch
题解
Semaphore：类，控制某个资源可被同时访问的个数;
ReentrantLock：类，具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大；
CountDownLatch： 类，可以用来在一个线程中等待多个线程完成任务的类；
Future：接口，表示异步计算的结果。
Q3
在11行添加什么能创建内部类的实例？
- InsideOne ei=eo.new InsideOne();
- eo.InsideOne ei=eo.new InsideOne();
- InsideOne ei=EnclosingOne.new InsideOne();
- EnclosingOne.InsideOne ei=eo.new InsideOne();
题解
Q4
对 Map 的用法，正确的有：
- new java.util.Map().put(“key” , “value”) ;
- new java.util.SortedMap().put(“key” , “value”) ;
- new java.util.HashMap().put( null , null ) ;
- new java.util.TreeMap().put( 0 , null ) ;
题解
Day 4
Q1
JVM内存不包含如下哪个部分( )
- Stacks
- PC寄存器
- Heap
- Heap Frame
题解
Q2
如下代码的输出是
eE
题解
由于arr[0] =0,所以在进入 test()方法里面会在第一个if 上抛出一个 NullPointerException,
接着会执行 finally 的语句, (finally语句先于 return 和 throw语句执行)，输出一个’e，
然后回到 main方法中，由于捕捉到异常，所以进入到catch语句中，然后打印一个’E’,
所以最终结果为"eE"
Q3
java8中，下面哪个类用到了解决哈希冲突的开放定址法
- LinkedHashSet
- HashMap
- ThreadLocal
- TreeMap
题解
threadlocalmap使用开放定址法解决haah冲突，hashmap使用链地址法解决hash冲突
Q4
下面关于Spring的说法中错误的是（）
- Spring是一系列轻量级Java EE框架的集合
- Spring中包含一个“依赖注入”模式的实现
- 使用Spring可以实现声明式事务
- Spring提供了AOP方式的日志系统
题解
Spring并没有为我们提供日志系统，我们需要使用AOP（面向方面编程）的方式，借助Spring与日志系统log4j实现我们自己的日志系统
Q5
以下哪个没有实现java.util.Map接口
- Hashtable
- HashMap
- Vector
- IdentityHashMap
题解
A，B，D都实现了Map接口，其中A与B的区别是一个是线程安全的，一个是线程不安全的；C中Vector是实现了List接口，是一个线程安全的List
Day 5
Q1
在第16行插入哪段代码可以获得一个Point对象的坐标?( )
- Point p = Line.getPoint();
- Line.Point p = Line.getPoint();
- Point p = (new Line()).getPoint();
- Line.Point p = (new Line()).getPoint();
题解
类Point定义在类Line中，类Line中有类Point的方法getPoint()，外部类Triangle要实现获取类Line中的内部类，需要：外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
- (1)把类定义在另一个类的内部，该类就被称为内部类。
举例：把类B定义在类A中，类B就被称为内部类。 - (2)内部类的访问规则
A:可以直接访问外部类的成员，包括私有
B:外部类要想访问内部类成员，必须创建对象 - (3)内部类的分类
A:成员内部类
B:局部内部类
C:匿名内部类 - (4)成员内部类访问规则
成员内部类不是静态的：
外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
成员内部类是静态的：
外部类名.内部类名 对象名 = new 外部类名.内部类名(); - (5)局部内部类
A:局部内部类访问局部变量必须加final修饰。
B:为什么呢?
因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。
所以，堆内存还是用该变量，而改变量已经没有了。
为了让该值还存在，就加final修饰。
通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是变量名。 - (6)匿名内部类(掌握)
A:是局部内部类的简化形式
B:前提
存在一个类或者接口
C:格式:
new 类名或者接口名() {
重写方法;
}
D:本质：
其实是继承该类或者实现接口的子类匿名对象
Q2
以下代码运行输出的是
- 输出：Person
- 没有输出
- 编译出错
- 运行出错
题解
- 1.一个java文件里，public 的类只能出现一个，只能出现一个，只能出现一个，否则，不管你用哪一个类名命名文件名编译器都会报错
- 2.关于多态。子类继承了父类的所有成员，包括private权限的成员变量，但是继承的子类具有私有变量的拥有权但是没有使用权
- 3.private的成员变量，根据权限修饰符的访问控制范围，只有在类内部才能被访问，就算是他的子类，也不能访问
Q3
问这个程序的输出结果
- Base SonB
- Son SonB
- Base Son SonB
- 编译不通过
题解
- 第25行new 了一个派生类，赋值给基类，所以下面的操作编译器认为base对象就是Base类型的，而Base类中不存在methodB()方法，所以编译不通过；
- 这类多态问题中，无论向上或向下转型，都记住一句话就可以了：编译看左边，运行看右边。意思编译时候，看左边有没有该方法，运行的时候结果看 new 的对象是谁，就调用的谁。
Q4
java中Hashtable, Vector, TreeSet, LinkedList哪些线程是安全的？
- Vector、Hashtable
题解
简单记忆线程安全的集合类： 喂！ SHE ！
喂是指 vector ， S 是指 stack ， H 是指 hashtable ， E 是指： Eenumeration
Q5
哪些是 setvar的重载？
- private void setVar(int a， float c， int b){}
- protected void setVar(int a， int b， float c){}
- public int setVar(int a， float c， int b){return a;}
- public int setVar(int a， float c){return a;}
题解
重载是在同一个类中，有多个方法名相同，参数列表不同(参数个数不同，参数类型不同),与方法的返回值无关，与权限修饰符无关，B中的参数列表和题目的方法完全一样了。
Day 6
Q1
以下哪项不是java基础类型（）
- int
- boolean
- String
- float
题解
数据类型包括基本数据类型和引用数据类型：
基本数据类型：byte,short,int,long,char,float,double,boolean；
引用数据类型：数组，接口，枚举，类，空类
Q2
子类A继承父类B, A a = new A(); 则父类B构造函数、父类B静态代码块、父类B非静态代码块、子类A构造函数、子类A静态代码块、子类A非静态代码块执行的先后顺序是？
- 父类Ｂ静态代码块->父类Ｂ构造函数->子类Ａ静态代码块->父类Ｂ非静态代码块->子类Ａ构造函数->子类Ａ非静态代码块
- 父类Ｂ静态代码块->父类Ｂ构造函数->父类Ｂ非静态代码块->子类Ａ静态代码块->子类Ａ构造函数->子类Ａ非静态代码块
- 父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ非静态代码块->父类Ｂ构造函数->子类Ａ非静态代码块->子类Ａ构造函数
- 父类Ｂ构造函数->父类Ｂ静态代码块->父类Ｂ非静态代码块->子类Ａ静态代码块->子类Ａ构造函数->子类Ａ非静态代码块
题解
静态优先级最高，而非静态初始化块的执行顺序要在构造函数之前
Q3
下面哪个选项正确创建socket连接？
- Socket s = new Socket(8080);
- Socket s = new Socket(“192.168.1.1”,8080)
- SocketServer s = new Socket(8080);
- Socket s = new SocketServer(“192.168.1.1”,8080)
题解
服务器端：ServerSocket提供的实例 ServerSocket server = new ServerSocket(端口号) ；客户端：Socket提供的实例 Socket client = new Socket(IP地址，端口号)
Q4
关于ASCII码和ANSI码，以下说法不正确的是（）？
- 标准ASCII只使用7个bit
- 在简体中文的Windows系统中，ANSI就是GB2312
- ASCII码是ANSI码的子集
- ASCII码都是可打印字符
题解
ASCII码包括一些特殊的空字符
Q5
类B从类A派生，则类B可以访问类A中的（ ）成员？
- public成员
- private成员
- protected成员
- 所有数据成员
- 所有函数成员
题解
数据成员包括ABC，函数成员也包括ABC；数据成员和函数成员默认是default访问权限，同一个包下的所有类都可以访问，类B不一定和类A同包，所以DE才错
Q6
下面说法正确的是？（）
- 调用Thread的sleep()方法会释放锁，调用wait()方法不释放锁
- ** 一个线程调用yield方法，可以使具有相同优先级线程获得处理器**
- 在Java中，高优先级的可运行的线程会抢占低优先级线程的资源
- java中，线程可以调用yield方法使比自己低优先级的线程运行
题解
yiled方法属于高风亮节的行为，这个坑位我不上了，后面跟我同级别的先上厕所。这样比较好记！
Q7
JDK提供的用于并发编程的同步器有哪些？
- Semaphore
- CyclicBarrier
- CountDownLatch
- Counter
题解
同步器是一些使线程能够等待另一个线程的对象，允许它们协调动作。
最常用的同步器是CountDownLatch和Semaphore，不常用的是Barrier 和Exchanger
Q8
下列流当中，属于处理流的是：（）
- FilelnputStream
- lnputStream
- DatalnputStream
- BufferedlnputStream
题解
按照流是否直接与特定的地方（如磁盘、内存、设备等）相连，分为节点流和处理流两类。
- 节点流：可以从或向一个特定的地方（节点）读写数据。如FileReader.
- 处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。
JAVA常用的节点流
- 文件 FileInputStream FileOutputStrean FileReader FileWriter 文件进行处理的节点流。
- 字符串 StringReader StringWriter 对字符串进行处理的节点流。
- 数 组 ByteArrayInputStream ByteArrayOutputStreamCharArrayReader CharArrayWriter 对数组进行处理的节点流
- 管 道 PipedInputStream PipedOutputStream PipedReaderPipedWriter对管道进行处理的节点流。
常用处理流（关闭处理流使用关闭里面的节点流）
- 缓冲流：BufferedInputStrean BufferedOutputStream BufferedReader BufferedWriter 增加缓冲功能，避免频繁读写硬盘。
- 转换流：InputStreamReader OutputStreamReader 实现字节流和字符流之间的转换。
- 数据流 DataInputStream DataOutputStream 等-提供将基础数据类型写入到文件中，或者读取出来.
流的关闭顺序
- 一般情况下是：先打开的后关闭，后打开的先关闭
- 另一种情况：看依赖关系，如果流a依赖流b，应该先关闭流a，再关闭流b。例如，处理流a依赖节点流b，应该先关闭处理流a，再关闭节点流b
- 可以只关闭处理流，不用关闭节点流。处理流关闭的时候，会调用其处理的节点流的关闭方法。
Day 7
Q1
程序Demo.java编译运行后输出的结果是：( )
- 3
题解
类的成员变量为int类型可以不初始化，默认值为0；方法中的局部变量为int类型必须初始化，没有默认值——main方法也是方法，其中的也是局部变量
Q2
关于抽象类叙述正确的是？ ( )
- 抽象类不能实现接口
- 抽象类必须有abstract class修饰
- 抽象类必须包含抽象方法
- 抽象类也有类的特性，可以被实例化
题解
Q4
以下程序段的输出结果为：
- false，true
题解
==可用于基本类型和引用类型：
当用于基本类型时候，是比较值是否相同；当用于引用类型的时候，是比较对象是否相同
- 使用Integer a = 1;或Integer a = Integer.valueOf(1); 在值介于-128至127直接时，作为基本类型。
- 使用Integer a = new Integer(1); 时，无论值是多少，都作为对象。
Q5
this调用语句必须是构造函数中的第一个可执行语句。
- 错误
题解
- 构造器中第一行默认是super()，一旦直接父类的构造器中没有无参的，那么必须显式调用父类的某个有参构造。
- 构造器中第一行的super()可以换成this()，但是this()和super()只能出现一个。
- super，this关键字与super()，this()不是一回事，前者表示当前调用者的父类与其本身，后者是为了构造器相互调用。
Q6
switch语句支持哪些类型数据：
- byte、short、int、char、String
Q7
关于Java中的数组，下面的一些描述，哪些描述是准确的：（ ）
- 数组是一个对象，不同类型的数组具有不同的类
- 数组长度是可以动态调整的
- 数组是一个连续的存储结构
- 一个固定长度的数组可类似这样定义: int array[100]
- 两个数组用equals方法比较时，会逐个便利其中的元素，对每个元素进行比较
- 可以二维数组，且可以有多维数组，都是在Java中合法的
题解
arr1.equal(arr2)是比较两个数组的地址；Arrays.equal(arr1, arr2)是比较两个数组的内容。
数组是一种引用数据类型，是继承Object类的，Object.equals()比较的是两个数组的地址
Q8
判断一块内存空间是否符合垃圾收集器收集的标准有哪些？
- 给对象赋值为null，以下没有调用过；给对象赋了新的值，重新分配了内存空间
Day 8
Q1
以下哪些表述是正确的的？
Q2
关于 Socket 通信编程，以下描述正确的是：（ ）
- 客户端通过new ServerSocket()创建TCP连接对象
- 客户端通过TCP连接对象调用accept()方法创建通信的Socket对象
- 客户端通过new Socket()方法创建通信的Socket对象
- 服务器端通过new ServerSocket()创建通信的Socket对象
题解
Q3
如果一个接口Cup有个方法use()，有个类SmallCup实现接口Cup，则在类SmallCup中正确的是？( )
- void use() { …}
- protected void use() { …}
- public void use() { …}
- 以上语句都可以用在类SmallCup中
题解
实现接口，就要实现接口的所有方法，相当于重写方法，
方法的重写需要满足：三同一大一小（方法名、返回值类型、形参相同；访问权限>=重写前；抛出异常<=重写前）
Day 9
Q1
socket编程中，以下哪个socket的操作是不属于服务端操作的（）？
- accept
- listen
- connect
- close
题解
Q2
以下代码段执行后的输出结果为
- -7
- -3
- 编译错误
- -5
题解
先执行括号中的i++，虽然i会变成-4，但是返回的临时量是-5，于是变成i = ++(-5)，出现错误。因为单目运算符++后面不能接字面量，只能接变量。
Q3
下面哪些情况下需要使用抽象类？
- 当一个类的一个或多个方法是抽象方法时
- 当类是一个抽象类的子类，并且不能为任何抽象方法提供任何实现细节或方法体时
- 当一个类实现多个接口时
- 当一个类实现一个接口，并且不能为任何抽象方法提供实现细节或方法体时
题解
- A项 一个类中有抽象方法则必须申明为抽象类
- B项 抽象类中的抽象方法必须由其子类实现，若子类不能实现则子类也必须定义为抽象类
- D项 一个类实现一个接口就必须实现其中所有的抽象方法，若该实现类不能实现接口中的所有方法则实现类定义为抽象类
Q4
在Java线程状态转换时，下列转换不可能发生的有（）？
- 初始态->运行态
- 就绪态->运行态
- 阻塞态->运行态
- 运行态->就绪态
题解
Day 10
Q1
ArrayList和LinkList的描述，下面说法错误的是？
- LinkedeList和ArrayList都实现了List接口
- ArrayList是可改变大小的数组，而LinkedList是双向链接串列
- LinkedList不支持高效的随机元素访问
- 在LinkedList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在ArrayList的中间插入或删除一个元素的开销是固定的
题解
D选项描述相反
Q2
下面关于JAVA的垃圾回收机制，正确的是（ ）
- 当调用“System.gc()”来强制回收时，系统会立即回收垃圾
- 垃圾回收不能确定具体的回收时间
- 程序可明确地标识某个局部变量的引用不再被使用
- 程序可以显式地立即释放对象占有的内存
题解
局部变量分为基本类型变量和引用变量：基本类型的变量名称和值都是存储在栈中；引用变量引用存储在栈中，而值在堆中
Q3
对于下面这段代码，以下说法正确的是：
- 程序会打出 “Value is 0”
- 程序会抛出 NullPointerException
- 非静态变量不能够被静态方法引用
- 编译器会抛出 "possible reference before assignment"的错误
题解
当类加载时，static静态方法随着类加载而初始化，此时实例对象还未被创建，但是非静态成员变量需要等到实例对象创建才会被初始化，故无法被引用
Q4
URL u =new URL(“http://www.123.com”);。如果www.123.com不存在，则返回______。
- http://www.123.com
- ””
- null
- 抛出异常
题解
new URL()时必须捕获检查异常，但这个异常是由于字符串格式和URL不符导致的，与网址是否存在无关。
URL的toString方法返回字符串，无论网址是否存在
Q5
从内存实现或者反射的角度来看，关于继承的说法正确的是（）。 注：此处的继承不代表能调用
- 子类将继承父类的所有的数据域和方法
- 子类将继承父类的其可见的数据域和方法
- 子类只继承父类public方法和数据域
- 子类只继承父类的方法，而不继承数据域
题解
在一个子类被创建的时候，首先会在内存中创建一个父类对象，然后在父类对象外部放上子类独有的属性，两者合起来形成一个子类的对象。
所以所谓的继承使子类拥有父类所有的属性和方法其实可以这样理解，子类对象确实拥有父类对象中所有的属性和方法，但是父类对象中的私有属性和方法，子类是无法访问到的，只是拥有，但不能使用
Q6
jdk1.8版本之前的前提下，接口和抽象类描述正确的有（ ）
- 抽象类没有构造函数
- 接口没有构造函数
- 抽象类不允许多继承
- 接口中的方法可以有方法体
题解
jdk1.8后接口中用static或default修饰的方法可以有方法体
Q7
下面的类哪些可以处理Unicode字符?
- InputStreamReader
- BufferedReader
- Writer
- PipedInputStream
题解
字符流是字节流根据字节流所要求的编码集解析获得的，可以理解为字符流=字节流+编码集；后缀是Stream的都是字节流，其他的都是字符流。
Q8
下面选项中,哪些是interface中合法方法定义?()
- public void main(String [] args);
- private int getSum();
- boolean setFlag(Boolean [] test);
- public float get(int x);
题解
interface中的方法默认为public abstract 的 ，变量默认为public static final
Day 11
Q1
关于final说法正确的是？ ( )
- final类的方法肯定不能被同一个包的类访问
- final类的方法能否被同一个包的类访问不是由final决定
- final方法等同于private方法
- final对象本身的引用和值都不能改变
题解
final变量：如果是基本数据类型，则其数值一旦初始化后就不能被改变；
如果是引用类型的变量，则对其初始化后，便不能再指向另一个对象，但是其里面的值是可以改变的。
Q2
**加粗样式如下的Java程序 **
public class Test {
public static void main(String[] args) {
System.out.println(args[0]);
}
}
若采用命令行“java Test one two three”调用，则程序输出的结果为：
- one
题解
采用命令行“ java Test one two three ”调用其中Test为调用的方法，而one two three则为Test方法里面main函数的参数；System.out.println(args[0]);表示输出第一个元素，故为one
Q3
以下Java程序运行的结果是:
public class Tester{
public static void main(String[] args){
Integer var1=new Integer(1);
Integer var2=var1;
doSomething(var2);
System.out.print(var1.intValue());
System.out.print(var1==var2);
}
public static void doSomething(Integer integer){
integer=new Integer(2);
}
}
- 1true
题解
java中引用类型的实参向形参的传递，只是传递的引用，而不是传递的对象本身。
Q4
在各自最优条件下,对N个数进行排序,哪个算法复杂度最低的是? （）
- 插入排序
- 快速排序
- 堆排序
- 归并排序
题解
Day 12
Q1
以下哪些对长度为50的字符串数组声明是正确的
- char a[][];
- String a[];
- String[] a;
- Object a[50];
- String a[50];
- Object a[];
题解
声明一个数组时，不能直接限定数组长度，只有在创建实例化对象时，才能对给定数组长度
- String a[]=new String[50]; √
- String d[50]; ×
Q2
以下哪个类包含方法flush()？（）
- InputStream
- OutputStream
- A 和B 选项都包含
- A 和B 选项都不包含
题解
一般在读写流(stream)的时候，数据是先被读到了内存中，再把数据写到文件中，当你数据读完的时候不代表你的数据已经写完了，因为还有一部分有可能会留在内存这个缓冲区中。
这时候如果你调用了close()方法关闭了读写流，那么这部分数据就会丢失，所以应该在关闭读写流之前先flush()
Q3
静态内部类不可以直接访问外围类的非静态数据，而非静态内部类可以直接访问外围类的数据，包括私有数据。（ ）
- True
题解
Q4
一个Java源程序文件中定义几个类和接口，则编译该文件后生成几个以.class为后缀的字节码文件。
- True
Day 13
Q1
Java.Thread的方法resume()负责重新开始被以下哪个方法中断的线程的执行（）。
- stop
- sleep
- wait
- suspend
题解
suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的 resume() 被调用，才能使得线程重新进入可执行状态
Q2
下面关于面向对象的一些理解哪些是错误的( )
- 面向对象的最重要的特性是支持继承、封装和多态
- 系统设计应该遵循开闭原则，系统应该稳定不不可修改，但应支持通过继承、组合等方式进行扩展
- 函数式的语言必然是面向对象的语言
- 面向对象设计时，每个类的职责应该单一，不要再一个类中引入过多的接口
- 过程式语言和面向对象的语言各有其优势，过程式语言更加灵活，面向对象语言更加强调抽象和封装
- Java和C++都是静态类型的面向对象编程语言
题解
无
Q3
对Collection和Collections描述正确的是
- Collection是java.util下的类，它包含有各种有关集合操作的静态方法
- Collection是java.util下的接口，它是各种集合结构的父接口
- Collections是java.util下的接口，它是各种集合结构的父接口
- Collections是java.util下的类，它包含有各种有关集合操作的静态方法
题解
**java.util.Collection 是一个集合接口 （接口单数） ；
java.util.Collections 是一个包装类 （类有很多方法，复数） **
Q4
下面的代码运行后，输出结果是什么？
public class Test{
static{ int x=5; }
static int x,y;
public static void main(String args[]){
x--;
myMethod( );
System.out.println(x+y+ ++x);
}
public static void myMethod( ){
y=x++ + ++x;
}
}
3
题解
- 静态语句块中x为局部变量，不影响静态变量x的值——即x=5没有用
- x和y为静态变量，默认初始值为0
- java中自增操作非原子性的
- main方法中：
- x–; // x = 0
- myMethod(); // x++;x = 0 | ++x; x = 1 | y不会变, y = 0
- x+y+ ++x; // 1+0+ (++1) = 1 + 0 + 2 = 3
Q5
instanceof运算符能够用来判断一个对象是否为:
- 一个类的实例
- 一个实现指定接口的类的实例
- 全部正确
- 一个子类的实例
题解
instanceof是JAVA中的关键字，用来判断：
一个对象是不是一个类的实例，是不是一个类的子类，是不是一个接口的实现类
Q6
下面代码运行结果是（）
public class Test{
public int add(int a,int b){
try {
return a+b;
}
catch (Exception e) {
System.out.println("catch语句块");
}
finally{
System.out.println("finally语句块");
}
return 0;
}
public static void main(String argv[]){
Test test =new Test();
System.out.println("和是："+test.add(9, 34));
}
}
finally语句块
和是：43
题解
在运行sout这一行时：
- test.add(9, 34)的执行，会在try中返回a+b=43，
- 但在返回前，先将43存储在栈内，然后执行finally内的代码块——输出“finally语句块”；
- 然后才返回43，输出“和是：43”
另外的例子：
public abstract class Test {
public static void main(String[] args) {
System.out.println(beforeFinally());
}
public static int beforeFinally(){
int a = 0;
try{
a = 1;
return a;
}finally{
a = 2;
}
}
}
/**output:
1
*/
同理：try代码块中会返回1，在执行finally代码块前，将a=1存在临时栈中；finally中虽然a又赋值为2，但并没有改变临时栈中的值。所以最后返回的仍是栈中的“a=1”
Q7
以下java程序代码，执行后的结果是（）
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"));
}
}
- Fred
- true
- 编译错误
- 运行时抛出异常
题解
1、使用了匿名内部类，并重写了Object中的重写了equals()方法
2、o对象调用了equals方法，无论如何都是返回true
Day 14
Q1
如果子类要调用父类的构造函数，则通过super（）调用来实现。
- True
题解
- 子类的每一个构造方法都必须显式或隐式调用父类的一个构造方法
- 如果不显式调用, 则系统隐式调用super()
- 调用父类构造方法(父类没有，系统提供)、被重写的方法是需要super关键字；其他不需要
Q2
抽象类方法的访问权限默认都是public。（ ）
- False
题解
-
关于抽象类
- JDK 1.8以前，抽象类的方法默认访问权限为protected
- JDK 1.8时，抽象类的方法默认访问权限变为default
-
关于接口
- JDK 1.8以前，接口中的方法必须是public的
- JDK 1.8时，接口中的方法可以是public的，也可以是default的
- JDK 1.9时，接口中的方法可以是private的
Q3
下列Java代码中的变量a、b、c分别在内存的____存储区存放。
class A {
private String a = “aa”;
public boolean methodB() {
String b = “bb”;
final String c = “cc”;
}
}
- 堆区、栈区、栈区
题解
- 堆区：只存放类对象，线程共享
- 栈区：存放方法局部变量，基本类型变量区、执行环境上下文、操作指令区，线程不共享
- 方法区：又叫静态存储区，存放class文件和静态数据，线程共享
Day 15
Q1
以下类型为Final类型的为（）
- HashMap
- StringBuffer
- String
- Hashtable
题解
- string的字符数组是final修饰的，所以字符数组不可以修改
- stringbuffer的字符数组没有final修饰，所以字符数组可以修改
- string与stringbuffer都是final修饰，只是限制他们所存储的引用地址不可修改
Q2
有如下一段代码，请选择其运行结果（）
public class StringDemo{
private static final String MESSAGE="taobao";
public static void main(String [] args) {
String a ="tao"+"bao";
String b="tao";
String c="bao";
System.out.println(a==MESSAGE);
System.out.println((b+c)==MESSAGE);
}
}
- true false
题解
hotspot中 编译时"tao"+“bao"将直接变成"taobao”，b+c则不会优化，因为不知道在之前的步骤中bc会不会发生改变，而针对b+c则是用语法糖，新建一个StringBuilder来处理
Q3
有以下类定义：
abstract class Animal{
abstract void say();
}
public class Cat extends Animal{
public Cat(){
System.out.printf("I am a cat");
}
public static void main(String[] args) {
Cat cat=new Cat();
}
}
- I am a cat
- Animal能编译，Cat不能编译
- Animal不能编译，Cat能编译
- 编译能通过，但是没有输出结果
题解
当一个实体类继承于一个抽象类，必须实现抽象类的抽象方法，抽象类本身没有错误，但是cat类编译通不过
Q4
**
下面程序的运行结果是：（ ）**
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");
}
- pingpong
- pongping
- pingpong和pongping都有可能
- 都不输出
- pong
- ping
题解
t.run是调用的Thead类中的run()方法，t.start才是执行线程，所以这题就是执行普通run()方法，先输出pong，在输出ping