《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！
}
for语句中有三个子句。
初始值 stmt语句在循环开始之前完成，通常是为了初始化迭代变量。
每次循环完成之前都要测试条件表达式。循环不是如果布尔表达式为false（与while循环相同）则执行。下一个值的stmt语句在执行body之后完成。它通常会增加迭代变量。
关于Java类的结构，哪三种说法是正确的？
A、 一个类只能有一个私有构造函数。
B、 方法可以与字段（成员变量）同名。
C、 类可以具有重载的静态方法。
D、 公共类必须有一个main方法。
E、 方法是类的必需组件。
F、 字段（成员变量）在使用前不需要初始化。
说明：A:私有构造函数阻止类被其显式实例化
如果程序员没有为类提供构造函数，那么系统将始终提供默认的公共无参数构造函数。
要禁用此默认构造函数，只需向类添加一个私有的无参数构造函数。这个私有构造函数可能是空的。
B： 以下操作很好：
int cake（）{
int cake=0；
返回（1）；
C： 我们可以在Java中重载静态方法。关于方法重载静态方法
与普通方法一样，为了重载静态方法，您需要提供
另一个具有相同名称但方法签名不同的静态方法。
class MissingInfoException extends Exception{}
class AgeOutofRangeException extends Exception{}
public class Candidate {
String name;
int age;
Candidate(String name,int age) throws Exception{
if(name == null){
throw new MissingInfoException();
} else if(age <= 10 || age >= 150){
throw new AgeOutofRangeException();
}else{
this.name = name;
this.age = age;
}
}
public String toString(){
return name+" age: " + age;
}
}
Given the code fragment
4.public class Test {
-
public static void main(String[] args){
-
Candidate c = new Candidate("James",20); -
Candidate c1 = new Candidate("Willams",32); -
System.out.println(c); -
System.out.println(c1); -
}
11.}
哪个更改使代码能够打印以下内容？
A、 将第5行替换为
public static void main（String[] args）throws MissingInfoException，
AgeOutOfRangeException{
B、 将第5行替换为public static void main（String[] args）throws.Exception{
C、 将第6行和第7行封闭在try块中，并添加：
catch（missingInfoException e2）{/代码在此处}
catch（AgeOutofRangeException e3）{/代码在此处}
catch（Exception e1）{/代码在此处}
D、 将第6行和第7行封闭在try块中，并添加：
catch（missingInfoException e2）{/代码在此处}
catch（AgeOutofRangeException e3）{/code-goes here}
进行的哪两个修改使代码能够编译和运行？
A、 在每个print语句后添加break语句
B、 在switch代码块中添加默认部分
C、 将每个大小写标签中的字符串文本更改为整数
D、 将变量day的类型更改为String
E、 按升序排列箱子标签
==比较地址值是否一致
equals比较的内容是否一致
s变量是static修饰的
static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本【存放在方法区】，它当且仅当在类初次加载时会被初始化【加final和不加final的static变量初始化的位置不一样】。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
static成员变量的初始化顺序按照定义的顺序进行初始化。
Given
public class TestApp {
public static void main(String[] args) {
TestApp t = new TestApp();
try {
t.doPrint();
t.doList();
} catch (Exception e) {
e.printStackTrace();
}
}
private void doList() throws Exception {
throw new Error(“Error”);
}
private void doPrint() throws Exception {
throw new RuntimeException(“Exception”);
}
}
What is the result?
下面哪一项与上面的代码片段等价？
第一个元素arr[0]尚未定义，值为空
语句1、语句2和语句3应该分别是什么，以便生成结果呢
package com.itzheng.ocjp2;
public class SuperTest {
public static void main(String[] args) {
//statement1
Square sq1 = new Square();
//statement2
sq1.foo(“bar”);
//statement3
sq1.foo();
}
}
class Shape{
public Shape(){
System.out.println(“Shape:constructor”);
}
public void foo(){
System.out.println(“Shape:foo”);
}
}
class Square extends Shape{
public Square(){
super();
}
public Square(String label){
System.out.println(“Square:constructor”);
}
public void foo(){
super.foo();
}
public void foo(String lable){
System.out.println(“Square:foo”);
}
}
循环当中的if语句判断当前是否有偶数，如果有偶数就讲isChecked=true
public class Series {
public static void main(String[] args) {
int arr[] = {1,2,3};
for (int var : arr){
int i = 1;
while (i <= var);
System.out.println(i++);
}
}
}
D、 编译失败
E、 循环执行无限次
每次for循环，i会多次被赋值为1 ，所以为死循环
哪两个是Java异常类？
SecurityException是一个运行时异常
IllegalArgumentException不合法的参数异常
为了使代码成功编译，您应该做哪两个修改？
import java.io.IOException;
class X {
public void printFileContent() throws IOException {
throw new IOException();
}
}
public class Test {
public static void main(String[] args) throws IOException {
X xobj = new X();
xobj.printFileContent();
}
}
一个方法声明为接受三个参数。
程序调用此方法并传递只有两个参数。结果如何？
A、 编译失败。
B、 第三个参数的值为null。
C、 第三个参数的值是void。
D、 第三个参数的值为零。
E、 第三个参数为其声明的类型提供了适当的falsy值。
F） 方法尝试访问第三个参数时发生异常
哪两个操作将改进类的封装？
A、 将字段的访问修饰符从public更改为private
B、 从类声明中删除公共修饰符
C、 将方法的返回类型更改为void
D、 返回数组或ArrayList内容的副本，而不是直接引用
哪三个成员必须有私人访问修饰符以确保保持这种不变性？
此类需要保护sum字段上的不变量。
哪三个成员必须具有私有访问修饰符才能确保保持不变？
A. x字段
B. y栏位
C.sum字段
D. ComputerSum（）构造函数
E. setX（）方法
F. setY（）方法
答案：C，E，F
说明：sum字段和两个用于更新sum字段的方法（setX和SetY）。
哪个语句最能描述封装？
A、 封装确保了类的设计，使得只能从其他对象访问对象的某些字段和方法。
B、 封装确保了类的设计，使它们的方法是可继承的。
C、 封装确保类可以使用声明为抽象的字段和方法进行设计。
D、 封装确保可以设计类，以便在方法具有参数mytypex时，MyType的任何子类都可以传递给该方法。
哪两个类正确地使用了shape类？
说明：当一个抽象类是子类时，子类通常为其父类（E）中的所有抽象方法提供实现。但是，如果没有，那么子类也必须声明为抽象（B）。注意：抽象类是声明为抽象的类–它可以包含也可以不包含抽象方法。抽象类不能实例化，但可以子类化
说明：代码加倍（iObj++，iVar++）；将两个变量从10增加到11。
public class MyFor1 {
public static void main(String[] args) {
int[] x = {6,7,8};
for (int i : x){
System.out.print(i+" ");
i++;
}
}
}
class Alpha{
public String doStuff(String msg){
return msg;
}
}
class Beta extends Alpha{
public String doStuff(String msg){
return msg.replace(‘a’,‘e’);
}
}
class Gamma extends Beta{
public String doStuff(String msg){
return msg.substring(2);
}
}
public class Test6 {
public static void main(String[] args) {
List strs = new ArrayList();
strs.add(new Alpha());
strs.add(new Beta());
strs.add(new Gamma());
for (Alpha t: strs) {
System.out.println(t.doStuff(“Java”));
}
}
}
此题书上的题库错误答案选择B
说明：选项A和C是正确答案。在方法声明中，使用关键字throws。
所以在第1行，我们必须使用选项A。
要真正抛出异常，使用关键字throw并创建一个新的异常，所以在第2行我们必须使用throw和new关键字，即选项C。
最后，它看起来像：public void method（）抛出异常{throw new Exception0；参考：httpsy/docs.oracle.com/javase/tutorial/essential/io/fileOps.html#例外正确答案是：在第1行，填写抛出。在第2行，填写“扔新”
A、 Reading Card
Checking Card
B、 编译只在n1行失败。
C、 编译只在n2行失败。
D、 编译只在n3行失败。
E、 编译在第n2行和第n3行都失败。
实际测试结果是D
public class App {
public static void main(String[] args) {
int i = 10;
int j = 20;
int k = j += i/5;
System.out.println(i+" : " + j + " : " + k);
}
}
Stirng中的trim()方法的作用就是去掉字符串前面和后面的空格.
isEmpty() 方法用于判断字符串是否为空。
str在去除空格后没有将值赋给str所以str当中的值不变
public class Msg {
public static String doMsg(char x){
return “Good Day!”;
}
public static String doMsg(int y){
return “Good Luck”;
}
public static void main(String[] args) {
char x = 8;
int z = ‘8’;
System.out.println(doMsg(x));
System.out.println(doMsg(z));
}
}
实际运行结果选择 A
强制转换类型是不会影响其值的变化的
public class Test3 {
public static void main(String[] args) {
String names[] = new String[3];
names[0] = “Marry Brown”;
names[1] = “Nancy Red”;
names[2] = “Jessy Orange”;
try {
for (String n:names){
try{
String pwd = n.substring(0,3) + n.substring(6,10);
System.out.println(pwd);
}catch (StringIndexOutOfBoundsException e){
System.out.println(“string out of limits”);
}
}
}catch (ArrayIndexOutOfBoundsException e){
System.out.println(“array out of limits”);
}
}
}
substring
public substring(int beginIndex, int endIndex)
返回一个新字符串，它是此字符串的一个子字符串。
该子字符串从指定的 beginIndex 处开始，一直到索引 endIndex - 1处的字符。因此，该子字符串的长度为 endIndex-beginIndex。
public class String1 {
public static void main(String[] args) {
String s = “123”;
if(s.length() > 2){
s.concat(“456”);
for(int x =0;x < 3;x++){
s += “x”;
}
System.out.println(s);
}
}
}
s.concat(“456”);没有赋值会s
class X{
public void mx(){
System.out.println(“Xml”);
}
}
class Y extends X{
@Override
public void mx() {
System.out.println(“Xm2”);
}
public void mY(){
System.out.println(“Ym”);
}
}
public class Test {
public static void main(String[] args) {
X xRef = new Y();
Y yRef = (Y)xRef;
yRef.mY();
xRef.mx();
}
}
实际运行结果为A
哪三个是foo的有效替换，以便程序编译和运行？
说明：
不正确：
not A:以下行导致编译错误：
System.out.printin（str[]）；
非C:编译错误行：
for（StringO sub:arrf0D）
非D：输出：C。
public class Test {
static String[][] arr = new String[3][];
private static void doPrint(){
//insert code here
for (int i = 0; i < arr.length; i++) {
int j = arr[i].length-1;
System.out.print(arr[i][j]);
}
}
public static void main(String[] args) {
String[] class1 = {“A”,“B”,“C”};
String[] class2 = {“L”,“M”,“N”,“O”};
String[] class3 = {“I”,“J”};
arr[0]=class1;
arr[1]=class2;
arr[2]=class3;
Test.doPrint();
}
}
public class X {
public static void main(String[] args) {
String theString = “Hello World”;
System.out.println(theString.charAt(11));
}
}
关于Java字节码，哪种说法是正确的？
A、 它可以在任何平台上运行。
B、 它只能在任何平台上运行，只要它是为那个平台编译的。
C、 它可以在任何具有Java运行时环境的平台上运行。
D、 它可以在任何有Java编译器的平台上运行。
E、 它可以在任何平台上运行，前提是该平台同时具有Java运行时环境和Java编译器。
run on 继续
only if 只有当
compiled 编写 ; 编纂 ; 编译 ; compile的过去分词和过去式
the Java 渣华道98号
compiler 编纂者 ; 汇编者 ; 编著者 ; 编译程序
Environment(影响个体或事物行为或发展的)环境; 客观环境; 自然环境; 生态环境; (运行)环境; 工作平台; 软件包;
选项D是正确答案。
代码无法编译，因为我们不能对集合类型使用基元，所以在这段代码中，第7行尝试使用int，
导致编译错误。
我们应该用包类Integer。整数在那里。所以选项D是正确的
interface Contract{}
class Super implements Contract{}
class Sub extends Super{}
public class Ref {
public static void main(String[] args) {
List objs = new ArrayList();
Contract c1 = new Super();//line n1
Contract c2 = new Sub();
Super s1 = new Sub();
objs.add(c1);
objs.add(c2);
objs.add(s1);//line n2
for (Object itm:objs){
System.out.println(itm.getClass().getName());
}
}
}
实际运行结果选择A
interface Contract{}
class Super implements Contract{}
class Sub extends Super{}
public class Ref {
public static void main(String[] args) {
List objs = new ArrayList();
Contract c1 = new Super();//line n1
Contract c2 = new Sub();
Super s1 = (Super) c1;
objs.add(c1);
objs.add(c2);
objs.add(s1); //line n2
for (Object itm:objs){
System.out.println(itm.getClass().getName());
}
}
}
您应该如何在第n1行的ElectricAccount类中编写方法，以便成员
可变账单总是等于成员变量kwh乘以成员可变利率的值？
客户使用的任何电量（由customer类的实例表示）
必须通过useElectricity方法向客户账单（由会员变量账单表示）缴款。
customer类的实例永远不能篡改或减少成员变量bill的值。
公共类中字段声明的受保护修饰符意味着该字段
A、 无法修改
B、 可以在课外读，但不能写
C、 只能从这个类及其子类中读取和写入包裹
D、 可以从这个类及其在任何包中定义的子类进行读写
周期类的ofDays()方法用于从给定的天数中获取一个周期作为参数。该参数以整数形式接受。此方法返回具有给定天数的Period。
说明：
为了创建，我们在LocalDate类中使用了以下方法：
public static LocalDate of（intyear，int month，int dayOfMonth）
在这里，我们需要记住的是，这个月不是以零为基础的，所以如果你通过了一个月，那么
这个月是一月。
然后我们使用了1天的period对象，并将其添加到date对象中，使之成为当前日期
所以最终产量是2015-03-27。因此，方案A是正确的。
public class Test {
int sum = 0;
public void doCheck(int number){
if(number % 2 == 0){
break;
}else {
for(int i = 0; i < number;i++){
sum += i;
}
}
}
public static void main(String[] args) {
Test obj = new Test();
System.out.println(“Red”+obj.sum);
obj.doCheck(2);
System.out.println(“Orange”+obj.sum);
obj.doCheck(3);
System.out.println("Green "+obj.sum);
}
}
Switch中的break,跳出语句,代码如下
break在循环中的使用,这里以for循环为例; 注意:单循环代码如下
break在循环中的使用,这里用双for循环为例
Java 当中if语句内不能使用break
关于顶级类的默认构造函数，哪个语句是正确的？
A、 它可以接受争论。
B、 它的声明中有私有访问修饰符。
C、 它可能过载。
D、 子类的默认构造函数总是调用其超类的无参数构造函数。
答案：D
说明：在Java和C中，“default constructor”都是指一个空构造函数，如果没有为类定义构造函数，编译器会自动生成该构造函数。默认构造函数也是空的，这意味着它什么也不做。程序员定义的不带参数的构造函数也称为默认构造函数。
哪两个修改，当独立进行时，允许代码打印joe:true:100.0？
变量没有赋予初值
class Star{
public void doStuff(){
System.out.println(“Twinkling Staf”);
}
}
interface Universe{
public void doStuff();
}
class Sun extends Star implements Universe{
public void doStuff() {
System.out.println(“Shining Sun”);
}
}
public class Bob {
public static void main(String[] args) {
Sun obj2 = new Sun();
Star obj3 = obj2;
((Sun)obj3).doStuff();
((Star)obj2).doStuff();
((Universe)obj2).doStuff();
}
}
运行结果A
public class Test2 {
int fvar;
static int cvar;
public static void main(String[] args) {
Test2 t = new Test2();
//insert code here to write field variables
}
}
以下哪项将打印当前时间？
LocalTime是一个接口，因此我们不能对它们使用new关键字。所以选项A和C是不正确的。
为了获得当前时间，我们可以在LocalTime接口上调用now方法。所以选项C是正确的。
选项D不正确，因为在LocalTime接口中今天没有调用方法
哪两个语句正确地描述了检查异常？
A、 这些都是编写良好的应用程序应该预料到并从中恢复的特殊情况。
B、 这些是应用程序外部的异常情况，应用程序通常无法预料或从中恢复。
C、 这些是应用程序内部的异常情况，应用程序通常无法预料到或无法从中恢复。
D、 作为RuntimeException和Error的子类的每个类都被归类为checked异常。
E、 作为异常子类的每个类（不包括RuntimeException及其子类）都被归类为checked Exception。
答案：B，D
说明：勾选异常：
（B） 表示程序直接控制范围之外的无效条件
（无效的用户输入、数据库问题、网络中断、缺少文件） 是异常的子类
这有点令人困惑，但也要注意RuntimeException（unchecked）本身就是Exception（checked）的一个子类。
方法必须为其引发的所有已检查异常建立一个策略
实现（或者将检查的异常传递到堆栈的更高层，或者以某种方式处理它）
int float double 前面的可以赋值给后面的，但是后面的不能赋值给前面的
答案：B
说明：循环（对于（intpos=0；pos<=4；pos++）{），它应该是pos<=3，原因是一个异常，被捕获。然后打印正确的总和。
哪个选项可以替换XXX以使代码打印135？
public class Series {
private boolean flag;
public void displaySeries(){
int num = 2;
while (flag){
if(num % 7 == 0){
flag = false;
System.out.println(num);
num += 2;
}
}
}
public static void main(String[] args) {
new Series().displaySeries();
}
}
答案选择E
结果是什么？
A、 2 46810 12
B、 2468101214
C、 编译失败
D、 程序打印两个无限次的倍数
E、 程序没有打印任何内容
正确答案：C
12/10=1
哪行代码初始化学生实例？
子类继承父类后自动在子类的无参的构造方法当中调用父类的无参构造
当在“l/在此处插入代码片段行插入哪个代码片段时，启用该代码要成功地将arra元素更改为大写？
A虽然正确但是重复定义了上面的内容
不正确：不是B:阵列长度是3，但子阵列有2、3和4个元素。索引将越界。
不是B：子阵列的长度不同。索引将越界。
not D：编译错误
E编译错误
哪两个选项放在main方法的n1行时编译失败
class DBConfiguration{
String user;
String password;
}
public class DBHandler {
DBConfiguration configuration(String name,String pawword){
//insert code here
}
public static void main(String[] args) {
DBHandler r = new DBHandler();
DBConfiguration dbConf = r.configuration(“manager”,“manager”);
}
}
在第6行必须插入哪个代码片段才能编译代码？
答案：B
说明：while语句不正确。它具有for语句的语法。
while语句在特定条件为真时连续执行一个语句块。
其语法可表示为：
while（表达式）{
报表
}
while语句计算表达式，该表达式必须返回布尔值。
如果表达式的计算结果为true，
while语句执行while块中的语句。
while语句继续测试表达式并执行其块，直到表达式的计算结果为false。
引用：while和do while语句
public class Test {
static void dispResult(int[] num){
try{
System.out.println(num[1] / (num[1] - num[2]));
}catch (ArithmeticException e){
System.err.println(“first exception”);
}
System.out.println(“Done”);
}
public static void main(String[] args) {
try{
int arr[] = {100,100};
dispResult(arr);
}catch (IllegalArgumentException e){
System.err.println(“Second exception”);
}catch (Exception e){
System.err.println(“third exception”);
}
}
}
public class Test {
public static void main(String[] args) {
int numbers[];
numbers = new int[2];
numbers[0] = 10;
numbers[1] = 20;
numbers = new int[4];
numbers[2]=30;
numbers[3]=40;
for (int x : numbers){
System.out.print(" "+x);
}
}
}
class Alpha{
public String[] main = new String[2];
Alpha(String [] main){
for(int ii = 0; ii < main.length;ii++){
this.main[ii] = main[ii]+5;
}
}
public void main(){
System.out.print(main[0] + main[1]);
}
}
public class Test {
public static void main(String[] args) {
Alpha main = new Alpha(args);
main.main();
}
}
在命令提示符当中执行如下代码
D、 在运行时引发异常
E、 由于运行时错误，程序无法执行
当执行到aVar为9 的时候，aVar++在括号当中返回的值为9，执行完括号后aVar的值递增为10
哪种说法是正确的？
A、 只有A.Java文件编译成功。
B、 只有B.java文件编译成功。
C、 只有C.java文件编译成功。
D、 Java和B.Java文件编译成功。
E、 B.java和C.java文件编译成功。
F、 Java和C.Java文件编译成功。
答：A
说明：在类B中，Java doStuff（）具有带有变量名的访问修改器，这是不允许的。
Java类名与文件名不同。
只有私有类可以有不同于文件名的名称
您必须确保maskcc方法返回一个字符串，该字符串隐藏信用卡号的所有数字，除了最后四个数字（以及分隔每组四个数字的连字符）。
您应该在n1行分别使用哪两个代码片段来实现这个需求？
内存运行时中创建了多少个对象？
说明：obj1和obj3。
当您执行e2=e1时，您复制的是对象引用—您没有复制对象—因此变量e1和e2都指向同一个对象
哪三条语句描述了Java语言的面向对象特性？
A、 对象不能重复使用。
B、 子类可以从超类继承。
C、 对象可以与其他对象共享行为。
D、 包必须包含多个类。
E、Object是所有其他对象的根类。
F、 必须在每个类中声明main方法。
回答：B，C，E。
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
list.add(“SE”);
list.add(“EE”);
list.add(“ME”);
list.add(“SE”);
list.add(“EE”);
list.remove(“SE”);
System.out.println("Values are: "+list);
}
当分别替换foo时，哪三个代码片段使程序能够编译？
当插入第2行时，哪个代码片段使代码能够编译？必须精确到那个包的所有类
A、 执行在第一个catch语句中终止，捕获的RuntimeException被打印到控制台。
B、 执行在第二个catch语句中终止，捕获的异常被打印到控制台。
C、 线程“main”中抛出运行时错误。
D、 执行正常完成，并将Ready to us@打印到控制台。
E、 代码无法编译，因为需要throws关键字
public class Test {
public static List data = new ArrayList();
//insert code here
{
for(String x : strs){
data.add(x);
}
return data;
}
public static void main(String[] args) {
String[] d = {“a”,“b”,“c”};
update(d);
for (String s : d){
System.out.println(s += " ");
}
}
}
当插入//insert code here时，哪个代码片段使代码能够编译和打印 a b c
正确答案选C
public class Test2 {
public static void main(String[] args) {
int b = 3;
if(!(b > 3)){
System.out.print(“square”);
}{
System.out.print(“circle”);
}
System.out.println(“…”);
}
}
正确答案选择A
int[] array={l，2，3，4，5}；
根据要求：
1、按输入顺序处理数组的所有元素。
2、按与输入相反的顺序处理数组的所有元素。
3、按输入顺序处理数组的交替元素。
哪两种说法是正确的？
A、 需求1、2和3可以通过使用增强的for循环来实现。
B、 需求1、2和3可以通过使用普通for循环来实现。
C、 要求2和3不能通过使用普通for循环标准来实现。
D、 需求1可以通过使用增强的for循环来实现。
E、 要求3不能通过使用增强for循环或标准for循环来实现
当在//insert code行独立插入时，哪两条语句使代码能够编译？
public class CharToStr {
public static void main(String[] args) {
String str1 = “Java”;
char str2[] = {‘J’,‘a’,‘v’,‘a’};
String str3 = null;
for (char c : str2){
str3 = str3 +c;
}
if(str1.equals(str3)){
System.out.print(“Successful”);
else
System.out.print(“Unsuccessful”);
}
}
else语句没有大括号所以是错误的，即使有括号选择B，因为str3最终为nullJava和str1不相同
对于二维数组，哪两种说法是正确的？
A、 它被实现为指定元素类型的数组。
B、 使用逐列惯例，二维数组的每一行必须具有相同的大小。
C、 在声明时，必须指定每个维度中数组的元素数。
D、 类对象的所有方法都可以在二维数组上调用。
class Caller{
private void init(){
System.out.println(“Initialized”);
}
public void start(){
init();
System.out.println(“Started”);
}
}
public class TestCall {
public static void main(String[] args) {
Caller c = new Caller();
c.start();
}
}
插入第11行的，将提供以下输出[21,13,11]
说明：
在输出中我们可以看到只有奇数存在，所以我们只需要删除偶数就可以得到预期的输出。
在JavaSE8中，有一个新的方法调用removelf，它接受谓词对象并删除满足谓词条件的元素。
谓词有函数方法调用take object并检查给定条件是否满足，
如果满足，则返回true，否则返回false。选项C我们传递了正确的lambda表达式来检查与谓词接口的函数方法匹配的数字是奇数还是偶数。
选项A不正确，因为它是无效的lambda表达式。选项B不正确，因为它删除了所有奇数。
选项D不正确，因为没有将谓词作为参数的remove方法
removelf 作用：删除集合中符合条件的成员
list.removeIf( e ->e%2 0);e是集合当中元素的值，如果值%20则返回true删除对应的值
What are the values of each element in intArr after this code has executed?
哪个命令集在控制台中打印Hello Duke？
class SpecialExecption extends Exception{
public SpecialExecption(String message){
System.out.println(message);
}
}
public class ExceptionTest {
public static void main(String[] args) {
try {
doSomething();
} catch (SpecialExecption e) {
System.out.println(e);
}
}
static void doSomething() throws SpecialExecption{
int[] ages = new int[4];
ages[4] = 17;
doSomethingElse();
}
static void doSomethingElse() throws SpecialExecption{
throw new SpecialExecption(“Thrown at end of doSomething() method”);
}
}
A) SpecialException: Thrown at end of dosomething() method
B) Error in thread “main” java. lang. ArrayIndexoutofboundserror
C) Exception in thread main" java. lang. ArrayInde xOutOf BoundsException:4
at ExceptionTest. dosomething (ExceptionTest. java: 13)
at Except ionTest . main (Excepti onTest.java: 4)
D) Special Exception: Thrown at end of doSomething() method
at Excepti onTest. dosomethingElse (ExceptionTest. java: 16)
at ExceptionTest. dosomething (Exceptiontest. java: 13)
at Excepti onTest。main (Except ionTest. Java: 4)
正确答案选择C
哪两个独立的修改使代码能够编译？
A、 公开第n1行的方法。
B、 公开第n2行的方法。
C、 公开n3行的方法。
D、 使第n3行的方法受到保护。
E、 公开n4行的方法
子类重写父类的方法要等于大于父类的权限
class Dog {
Dog(){
try {
throw new Exception();
} catch (Exception e) {
e.printStackTrace();
}
}
}
class Test {
public static void main(String[] args) {
Dog d1 = new Dog();
Dog d2 = new Dog();
Dog d3 = d2;
// do complex stuff
}
}
当到达行//do complex stuff时，创建了多少个对象？
两个Dog和两个Exception
哪三种说法是封装的好处？
A、 允许类实现在不更改客户端的情况下进行更改
B、 防止机密数据从对象中泄漏
C、 防止代码导致异常
D、 使类实现能够保护其不变量
E、 允许将类合并到同一个包中
F、 允许安全地创建同一类的多个实例
答：A、B、D
class Tours{
public static void main(String[] args) {
System.out.println("Happy Journey " + args[1]);
}
}
public class Traveler {
public static void main(String[] args) {
Tours.main(args);
}
}
D、 由于运行时错误，程序无法执行
运行时在内存中创建了多少个MarkList实例
public class Calculator {
public static void main(String[] args) {
int num = 5;
int sum;
do{
sum += num;
}while ((num–)>1);
System.out.println("The sum is " + sum + “.”);
}
}
sum需要赋予初值
答案：B
解释：==地址相等。
equals比较内容状态，而不是地址。
class X {
int x1,x2,x3;
}
class Y extends X{
int y1;
Y(){
x1 = 1;
x2 = 2;
y1 = 10;
}
}
class Z extends Y{
int z1;
Z(){
x1 = 3;
y1 = 20;
z1 = 100;
}
}
public class Test3 {
public static void main(String[] args) {
Z obj = new Z();
System.out.println(obj.x3 +“,” + obj.y1 + “,” +obj.z1);
}
}
哪个构造函数初始化变量x3？
A、 只有类X的默认构造函数
B、 只有类Y的无参数构造函数
C.类Z的无参数构造函数
D、 仅对象类的默认构造函数
答案：C
创建C对象后无参构造调用父类的无参构造
创建C对象后，赋值x3=0
哪个选项只列出那些属于未检查的异常类别的类？
说明：不是 B:lOError和IOException都是检查错误。
不是C，不是D，不是E:FileNotFoundException是一个选中的错误。
注：
检查异常：
*表示程序无法直接控制的区域中的无效条件（无效用户输入、数据库问题、网络中断、缺少文件）
*是异常的子类
*方法必须为其实现抛出的所有已检查异常建立策略（要么将已检查异常进一步传递到堆栈上，要么以某种方式进行处理）
注：
未检查的异常：
表示程序中的缺陷（bug）-通常传递给非私有方法的参数无效。
引用Gosling、Arnold和Holmes的Java编程语言：
未检查的运行时异常通常表示反映程序逻辑错误的情况，并且在运行时无法合理地从中恢复
*是RuntimeException的子类，通常使用llegalArgumentException、NullPointerException或llegalStateException实现
*方法没有义务为其实现抛出的未检查异常建立策略（而且它们几乎总是不这样做）
当插入到n1行时，哪个代码片段使App类能够打印相等的内容？
equalsIgnoreCase与equals区别是前者不区分大小写，而后者区分
以上说法哪个是正确的？
A、 变量数的值为808.1
B、 变量的值将是808
C、 变量数的值将为0。
D、 将抛出NumberFormatException。
E、 它不会编译。
说明：
Integer类值0返回给定字符串中的整数。
但我们需要传递整数格式正确的字符串，否则它将引发NumberFormatException。在本例中，我们传递的字符串不是整数值（因为传递的是小数），所以选项D是正确的
Integer. valueOf()可以将基本类型int转换为包装类型Integer，或者将String转换成Integer，String如果为Null或“”或者小数都会报错
interface DoInterface{
void m1(int n);
public void m2(int n);
}
public class DoClass implements DoInterface {
int x1,x2;
DoClass(){
this.x1=0;
this.x2=10;
}
public void m1(int p1) {
x1+=p1;
System.out.println(x1);
}
public void m2(int p1) {
x2+=p1;
System.out.println(x2);
}
}
class Test{
public static void main(String[] args) {
DoInterface doi = new DoClass();//line n3
doi.m1(100);
doi.m2(200);
}
}
正确答案选择A
多态性的两个好处是什么？
A、 运行时更快的代码
B、 运行时更高效的代码
C、 运行时更动态的代码
D、 更灵活和可重用的代码
E、 受其他类保护而不被扩展的代码
答案：C，D
polymorphism 多型现象，多态性 ; 多机组合形式
Faster 更快的 ; 快 ; 快速
dynamic 相互作用的方式，动态 ;
说明：
不正确：
非B:非法组合修饰符：protected和public
不是 C:setNum方法不能是私有的。
不是E:getNum方法不能是私有的
正确答案选D
我们要求您为购物应用程序开发一个程序，并向您提供以下信息：
应用程序必须包含Toy、EduToy和consToy类。
Toy类是其他两个类的超类。
int caicuiatePrice（Toy t）方法计算玩具的价格。
void printToy（Toy t）方法打印玩具的细节。
Toy类的哪个定义为类层次结构添加了有效的抽象层？
哪个语句将清空名为sb的StringBuilder变量的内容？
字符串以及数组的大小用length而集合的大小用size
下列哪一个可以填入此代码中的空白以使其编译？
D、 它不会用任何方法编译，因为接口不能有非抽象方法。
它将编译而不闪烁空白。
答案：C
说明：
在JavaSE8中，我们可以在接口中使用静态和/或默认方法，
但它们应该是非抽象的方法。所以在这种情况下，在空白处使用默认值是完全合法的。
因此，选项C是正确的。
选项A不正确，因为给定的方法不是抽象的，所以不能在那里使用抽象。
选项B和E是不正确的，因为如果它们不是默认的或静态的，我们就不能有非抽象方法接口。
public class Access {
private int x = 0;
private int y = 0;
public static void main(String[] args) {
Access accApp = new Access();
accApp.printThis(1,2);
accApp.printThat(3,4);
}
public void printThis(int x,int y){
x = x;
y = y;
System.out.println(“x:” + this.x + " y:" + this.y);
}
public void printThat(int x,int y){
this.x = x;
this.y = y;
System.out.println(“x:” + this.x + " y:" + this.y);
}
}
哪个答案不能编译？
说明：查看声明ArrayLIst（）的右侧，而不是ArrayLIst
public class TestLoop {
public static void main(String[] args) {
float myarray[] = {10.20f,20.30f,30.40f,50.60f};
int index = 0;
boolean isFound = false;
float key = 30.40f;
//insert code here
System.out.println(isFound);
}
}
插入第7行时，哪个代码片段使代码打印为真？
正确答案选择D
正确答案B
说明：
在第5行，我们通过传递120D创建了一个包装对象double，
它可以转换成双人的，所以不会有任何例外。
但如果仔细检查，可以看到变量号在try块中声明，
所以变量数的范围仅限于那个块，
因此尝试在外部访问它会导致编译时错误。
httpsy/文件。oracle.com/javase/tutorialiava/nutsandbolts/variables.html文件
不能是D：不能应用于给定类型。
expression1和expression2可以分别是什么来产生输出-8和16？
正确答案选择B
Which set modifications enable the code to compile and run?
哪些集合修改使代码能够编译和运行
public class MyFor3 {
public static void main(String[] args) {
int[] xx = null;
for (int ii: xx ) {
System.out.println(ii);
}
}
}
定义一个接受两个int值并将它们的和作为int值返回的方法的正确方法是什么？
A、 int sum（int first，int second）{first+second；}
B、 int sum（int first，second）{返回first+second；}
C、 {first，int+second；}
D、 int sum（int first，int second）{返回first+second；}
E、 空和（int first，int second）{返回first+second；}
答案：D
循环变量的作用域仅限于该封闭循环。所以在本例中，在第5行声明的循环变量X的作用域仅限于for loop。
试图访问第7行的变量，
它超出了变量X的范围，导致编译时错误。
由于第7行的错误，编译失败。
因此，选项D是正确的。
选项A和B不正确，因为代码无法编译。
public class Test {
public static void main(String[] args) {
Test ts = new Test();
System.out.print(isAvailable + " ");
isAvailable = ts.doStuff();
System.out.println(isAvailable);
}
public static boolean doStuff(){
return !isAvailable;
}
static boolean isAvailable = false;
}
正确答案选择C
循环将只运行一次，然后num==0将在循环的第一个周期后中断它
删除头尾空白符的字符串。
一、 默认构造函数只包含“super（）；”调用。
二。我们不能对构造函数使用任何访问修饰符。
三、 构造函数不应具有返回类型。
语句I是正确的，因为默认构造函数只包含super0调用
语句II是不正确的，因为我们可以将任何访问修饰符与构造函数一起使用。
语句三是正确的，因为构造函数不能有返回类型，甚至是void。
所以选项D是正确的。
public class TestA extends Root {
public static void main(String[] args) {
Root r = new TestA();
System.out.println(r.method1()); //line n1
System.out.println(r.method2()); //line n2
}
}
class Root{
private static final int MAX = 20000;
private int method1(){
int a = 100 + MAX; //line n3
return a;
}
protected int method2(){
int a = 200 + MAX; //line n4
return a;
}
}
最后
金三银四马上就到了，希望大家能好好学习一下这些技术点
学习视频：
大厂面试真题：
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！
mage/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NzU3MDM0,size_16,color_FFFFFF,t_70)
正确答案选择C
循环将只运行一次，然后num==0将在循环的第一个周期后中断它
删除头尾空白符的字符串。
一、 默认构造函数只包含“super（）；”调用。
二。我们不能对构造函数使用任何访问修饰符。
三、 构造函数不应具有返回类型。
语句I是正确的，因为默认构造函数只包含super0调用
语句II是不正确的，因为我们可以将任何访问修饰符与构造函数一起使用。
语句三是正确的，因为构造函数不能有返回类型，甚至是void。
所以选项D是正确的。
public class TestA extends Root {
public static void main(String[] args) {
Root r = new TestA();
System.out.println(r.method1()); //line n1
System.out.println(r.method2()); //line n2
}
}
class Root{
private static final int MAX = 20000;
private int method1(){
int a = 100 + MAX; //line n3
return a;
}
protected int method2(){
int a = 200 + MAX; //line n4
return a;
}
}
最后
金三银四马上就到了，希望大家能好好学习一下这些技术点
学习视频：
[外链图片转存中…(img-KLMsI0t5-1714736265074)]
大厂面试真题：
[外链图片转存中…(img-KzEiXgKY-1714736265074)]
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！
扫一扫
5657
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
