OCJP考试习题（1z0-808）答案+解析

Question No:1

Question No:2

解析：

public class Case {
    
    
    public static void main(String[] args) {
    
    
        String product = "Pen";
        product.toLowerCase();//toLowerCase() 方法将字符串转换为小写。
        product.concat("Box".toLowerCase());//concat合并多个字符串
        System.out.println(product.substring(4,6));//substring(4,6)该子字符串始于指定索引处的字符，一直到此字符串索引末尾
    }
}

Question No:3

Java异常机制有哪三个优点？
A、 改进了程序结构，因为错误处理代码与正常程序功能
B、 提供一组包含所有可能错误的标准异常
C、 改进了程序结构，因为程序员可以选择处理的位置例外情况
D、 改进了程序结构，因为必须在中的方法中处理异常他们发生了什么
E、 允许创建针对特定程序的新异常创建

Question No:4

B、 编译只在n1行失败
C、 编译仅在第n2行失败
D、 在n1行和n2行编译都失败
n1当中Java当中定义有参数构造后，无参构造就需要显示的定义，无参构造会消失
n2当在自己内部创建自己的对象的时候需要使用new关键字，当构造方法是静态的时候就不需要使用new关键字
及时改正了上面的，任然得不到A结果，因为在lin2的时候重新创建了一个Person对象所以不会输出Walter

下面是改正后的代码

package com.itzheng.ocjp1;
public class Person {
    
    
    String name;
    int age = 25;
    int number = 12;
    public Person(){
    
    
    }
    public Person(String name){
    
    
        this();
        setName(name);
    }
    public Person(String name,int age){
    
    
        new Person(name);
        setAge(age);
    }
    public String getName() {
    
    
        return name;
    }
    public void setName(String name) {
    
    
        this.name = name;
    }
    public int getAge() {
    
    
        return age;
    }
    public void setAge(int age) {
    
    
        this.age = age;
    }
    public String show(){
    
    
        return name + " " + age+ " " + number;
    }
    public static void main(String[] args) {
    
    
        Person p1 = new Person("Jesse");
        Person p2 = new Person("Walter",52);
        System.out.println(p1.show());
        System.out.println(p2.show());
    }
}

运行结果

Question No:5

在//insert code here插入时，哪两个代码片段使代码能够编译并打印12？
解析：

package com.itzheng.ocjp1;
class Mid{
    
    
    public int findMid(int n1,int n2){
    
    
        return (n1+n2)/2;
    }
}
public class Calc extends Mid{
    
    
    public static void main(String[] args) {
    
    
        int n1 = 22,n2 = 2;
        Calc c = new Calc();
        int n3 = c.findMid(n1,n2);//22+2=24 24/2=12
        System.out.println(n3);//输出12
    }
}

package com.itzheng.ocjp1;
class Mid{
    
    
    public int findMid(int n1,int n2){
    
    
        return (n1+n2)/2;
    }
}
public class Calc extends Mid{
    
    
    public static void main(String[] args) {
    
    
        int n1 = 22,n2 = 2;
        Mid m1 = new Mid();
        int n3 = m1.findMid(n1,n2);
        System.out.println(n3);
    }
}

B选项：静态方法不能直接调用非静态方法
C选项：子类不能作为父类的引用
E选项：findMid方法不是静态的不能直接调用

Question No:6

假设系统日期为2014年6月20日。结果是什么？
D选项：在运行时抛出日期解析Excpetion。

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
public class TestDate {
    
    
    public static void main(String[] args) {
    
    
        LocalDate date1 = LocalDate.now();//获取当前系统时间
        LocalDate date2 = LocalDate.of(2014,6,20);//向date2对象当中设置对应的时间
        LocalDate date3 = LocalDate.parse("2014-06-20", DateTimeFormatter.ISO_DATE);//向date2对象当中设置对应的时间
        System.out.println("date1 = "+date1);
        System.out.println("date2 = "+date2);
        System.out.println("date3 = "+date3);
    }
}

因此答案选A

Question No:7

package com.itzheng.ocjp1;
public class TestNumber {
    
    
    public static void main(String[] args) {
    
    
        int[] lst = {
    
    1,2,3,4,5,4,3,2,1};
        int sum = 0;
        for(int frnt = 0,rear = lst.length - 1;frnt < 5 && rear >= 5; frnt++,rear--){
    
    
            sum = sum + lst[frnt] + lst[rear];
        }
        System.out.println(sum);
    }
}

Question No:8

Given the code framgment

Question No:9

考虑到要求：
如果数量变量的值大于或等于90，则折扣=0.5
如果数量变量的值介于80和90之间，则折扣=0.2
哪两个代码片段可以独立地放在n1行以满足要求？

Question No:10

package com.itzheng.ocjp1;
public class Circls {
    
    
    double radius;
    public double area;
    public Circls(double r){
    
    
        radius = r;
    }
    public double getRadius() {
    
    
        return radius;
    }
    public void setRadius(double r){
    
    
        radius = r;
    }
    public double getArea(){
    
    
        return /*???*/;
    }
}
class App{
    
    
    public static void main(String[] args) {
    
    
        Circls c1 = new Circls(17.4);
        c1.area = Math.PI * c1.getRadius() * c1.getRadius();
    }
}

类的封装不好。你需要换个圈来计算 而是返回该区域。
哪两个修改是必要的，以确保类是正确的封装的？

A、 删除区域字段。
B、 更改getArea（）方法，如下所示：
public double getArea（）{return Math.PIradiusradius；}
C、 添加以下方法：
public double getArea（）{area=Math.PIradiusradius；}
D、 更改要保护的setRadius（）方法的修饰符为protected

Question No:11

		int row = 10;
        for (;row > 0;){
    
    
            int col = row;
            while (col > 0){
    
    
                System.out.print(col + " ");//10 8 6 4 2
                col -= 2;
            }
            row = row/col;//10/0抛出异常
        }

Question No:12

class Patient{
    
    
    String name;
    public Patient(String name){
    
    
        this.name=name;
    }
}
public class Test {
    
    
    public static void main(String[] args) {
    
    
        List ps = new ArrayList();
        Patient p2 = new Patient("Mike");
        ps.add(p2);
        //insert code here
        if(f >= 0){
    
    
            System.out.println("Mike Found");
        }
    }
}

当插入第14行时，哪个代码片段可以打印Mike找到的代码？

Question No:13

class CD {
    
    
    int r;
    CD(int r){
    
    
        this.r=r;
    }
}
public class DVD extends CD {
    
    
    int c;
    DVD(int r,int c) {
    
    
        //line n1
    }
}

Question No:14

哪两种说法是正确的？

A、 这不是唯一有效的for循环构造；存在另一种形式的for循环方式
B、 表达式expr1是可选的。它初始化循环并作为循环计算一次开始。
C、 当expr2的计算结果为false时，循环终止。仅在每次之后进行评估循环。
D、 表达式expr3必须存在。它在每次迭代后通过循环。（错表达三可以放在for循环内部）

说明：翻译
for语句的格式如下：
for（初始值 stmt；条件；下一个值 stmt）{
执行的内容（body）
}
for语句中有三个子句。
初始值 stmt语句在循环开始之前完成，通常是为了初始化迭代变量。
每次循环完成之前都要测试条件表达式。循环不是如果布尔表达式为false（与while循环相同）则执行。下一个值的stmt语句在执行body之后完成。它通常会增加迭代变量。

Question No:15

关于Java类的结构，哪三种说法是正确的？
A、 一个类只能有一个私有构造函数。
B、 方法可以与字段（成员变量）同名。
C、 类可以具有重载的静态方法。
D、 公共类必须有一个main方法。
E、 方法是类的必需组件。
F、 字段（成员变量）在使用前不需要初始化。

说明：A:私有构造函数阻止类被其显式实例化
如果程序员没有为类提供构造函数，那么系统将始终提供默认的公共无参数构造函数。
要禁用此默认构造函数，只需向类添加一个私有的无参数构造函数。这个私有构造函数可能是空的。
B： 以下操作很好：
int cake（）{
int cake=0；
返回（1）；
C： 我们可以在Java中重载静态方法。关于方法重载静态方法
与普通方法一样，为了重载静态方法，您需要提供
另一个具有相同名称但方法签名不同的静态方法。

Question No:16

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 {
    
    
5.    public static void main(String[] args){
    
    
6.        Candidate c = new Candidate("James",20);
7.        Candidate c1 = new Candidate("Willams",32);
8.        System.out.println(c);
9.        System.out.println(c1);
10.    }
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}

Question No:17

Question No:18

进行的哪两个修改使代码能够编译和运行？

A、 在每个print语句后添加break语句
B、 在switch代码块中添加默认部分
C、 将每个大小写标签中的字符串文本更改为整数
D、 将变量day的类型更改为String
E、 按升序排列箱子标签

Question No:19

==比较地址值是否一致
equals比较的内容是否一致

Question No:20

s变量是static修饰的
static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本【存放在方法区】，它当且仅当在类初次加载时会被初始化【加final和不加final的static变量初始化的位置不一样】。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

static成员变量的初始化顺序按照定义的顺序进行初始化。

Question No:21

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?

Question No:22

下面哪一项与上面的代码片段等价？

Question No:23

第一个元素arr[0]尚未定义，值为空

Question No:24

语句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");
    }
}

Question No:25

循环当中的if语句判断当前是否有偶数，如果有偶数就讲isChecked=true

Question No:26

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 ，所以为死循环

Question No:27

哪两个是Java异常类？
SecurityException是一个运行时异常
IllegalArgumentException不合法的参数异常

Question No:28

Question No:29

为了使代码成功编译，您应该做哪两个修改？

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();
    }
}

Question No:30

一个方法声明为接受三个参数。
程序调用此方法并传递只有两个参数。结果如何？

A、 编译失败。
B、 第三个参数的值为null。
C、 第三个参数的值是void。
D、 第三个参数的值为零。
E、 第三个参数为其声明的类型提供了适当的falsy值。
F） 方法尝试访问第三个参数时发生异常

Question No:31

哪两个操作将改进类的封装？
A、 将字段的访问修饰符从public更改为private
B、 从类声明中删除公共修饰符
C、 将方法的返回类型更改为void
D、 返回数组或ArrayList内容的副本，而不是直接引用

Question No:32

哪三个成员必须有私人访问修饰符以确保保持这种不变性？

此类需要保护sum字段上的不变量。
哪三个成员必须具有私有访问修饰符才能确保保持不变？
A. x字段
B. y栏位
C.sum字段
D. ComputerSum（）构造函数
E. setX（）方法
F. setY（）方法
答案：C，E，F
说明：sum字段和两个用于更新sum字段的方法（setX和SetY）。

Question No:33

Question No:34

哪个语句最能描述封装？
A、 封装确保了类的设计，使得只能从其他对象访问对象的某些字段和方法。
B、 封装确保了类的设计，使它们的方法是可继承的。
C、 封装确保类可以使用声明为抽象的字段和方法进行设计。
D、 封装确保可以设计类，以便在方法具有参数mytypex时，MyType的任何子类都可以传递给该方法。

Question No:35

哪两个类正确地使用了shape类？


说明：当一个抽象类是子类时，子类通常为其父类（E）中的所有抽象方法提供实现。但是，如果没有，那么子类也必须声明为抽象（B）。注意：抽象类是声明为抽象的类–它可以包含也可以不包含抽象方法。抽象类不能实例化，但可以子类化

Question No:36

Question No:37

Question No:38

说明：代码加倍（iObj++，iVar++）；将两个变量从10增加到11。

Question No:39

Question No:40

Question No:41

public class MyFor1 {
    
    
    public static void main(String[] args) {
    
    
        int[] x = {
    
    6,7,8};
        for (int i : x){
    
    
            System.out.print(i+" ");
            i++;
        }
    }
}

Question No:42

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<Alpha> strs = new ArrayList<Alpha>();
        strs.add(new Alpha());
        strs.add(new Beta());
        strs.add(new Gamma());
        for (Alpha t: strs) {
    
    
            System.out.println(t.doStuff("Java"));
        }
    }
}

Question No:43

Question No:44

说明：选项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行，填写“扔新”

Question No:45

A、 Reading Card
Checking Card
B、 编译只在n1行失败。
C、 编译只在n2行失败。
D、 编译只在n3行失败。
E、 编译在第n2行和第n3行都失败。

Question No:46

实际测试结果是D

Question No:47

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);
    }
}

Question No:48

Question No:49

Stirng中的trim()方法的作用就是去掉字符串前面和后面的空格.
isEmpty() 方法用于判断字符串是否为空。

str在去除空格后没有将值赋给str所以str当中的值不变

Question No:50

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

Question No:51

强制转换类型是不会影响其值的变化的

Question No:52

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。

Question No:53

Question No:54

Question No:55

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

Question No:56

Question No:57

Question No:58

Question No:59

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

Question No:60

哪三个是foo的有效替换，以便程序编译和运行？

Question No:61

说明：
不正确：
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();
    }
}

Question No:62

public class X {
    
    
    public static void main(String[] args) {
    
    
        String theString = "Hello World";
        System.out.println(theString.charAt(11));
    }
}

Question No:63

关于Java字节码，哪种说法是正确的？
A、 它可以在任何平台上运行。
B、 它只能在任何平台上运行，只要它是为那个平台编译的。
C、 它可以在任何具有Java运行时环境的平台上运行。
D、 它可以在任何有Java编译器的平台上运行。
E、 它可以在任何平台上运行，前提是该平台同时具有Java运行时环境和Java编译器。
run on 继续
only if 只有当
compiled 编写 ; 编纂 ; 编译 ; compile的过去分词和过去式
the Java 渣华道98号
compiler 编纂者 ; 汇编者 ; 编著者 ; 编译程序

Environment(影响个体或事物行为或发展的)环境; 客观环境; 自然环境; 生态环境; (运行)环境; 工作平台; 软件包;

Question No:64

选项D是正确答案。
代码无法编译，因为我们不能对集合类型使用基元，所以在这段代码中，第7行尝试使用int，
导致编译错误。
我们应该用包类Integer。整数在那里。所以选项D是正确的

Question No:65

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

Question No:66

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());
        }
    }
}

Question No:67

您应该如何在第n1行的ElectricAccount类中编写方法，以便成员
可变账单总是等于成员变量kwh乘以成员可变利率的值？
客户使用的任何电量（由customer类的实例表示）
必须通过useElectricity方法向客户账单（由会员变量账单表示）缴款。
customer类的实例永远不能篡改或减少成员变量bill的值。

Question No:68

Question No:69

Question No:70

公共类中字段声明的受保护修饰符意味着该字段
A、 无法修改
B、 可以在课外读，但不能写
C、 只能从这个类及其子类中读取和写入包裹
D、 可以从这个类及其在任何包中定义的子类进行读写

Question No:71

周期类的ofDays()方法用于从给定的天数中获取一个周期作为参数。该参数以整数形式接受。此方法返回具有给定天数的Period。

说明：
为了创建，我们在LocalDate类中使用了以下方法：
public static LocalDate of（intyear，int month，int dayOfMonth）
在这里，我们需要记住的是，这个月不是以零为基础的，所以如果你通过了一个月，那么
这个月是一月。
然后我们使用了1天的period对象，并将其添加到date对象中，使之成为当前日期
所以最终产量是2015-03-27。因此，方案A是正确的。

Question No:72

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

Question No:73

关于顶级类的默认构造函数，哪个语句是正确的？
A、 它可以接受争论。
B、 它的声明中有私有访问修饰符。
C、 它可能过载。
D、 子类的默认构造函数总是调用其超类的无参数构造函数。
答案：D
说明：在Java和C中，“default constructor”都是指一个空构造函数，如果没有为类定义构造函数，编译器会自动生成该构造函数。默认构造函数也是空的，这意味着它什么也不做。程序员定义的不带参数的构造函数也称为默认构造函数。

Question No:74

Question No:75

哪两个修改，当独立进行时，允许代码打印joe:true:100.0？

Question No:76

变量没有赋予初值

Question No:77

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

Question No:78

Question No:79

Question No:80

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
    }
}

Question No:81

以下哪项将打印当前时间？

LocalTime是一个接口，因此我们不能对它们使用new关键字。所以选项A和C是不正确的。
为了获得当前时间，我们可以在LocalTime接口上调用now方法。所以选项C是正确的。
选项D不正确，因为在LocalTime接口中今天没有调用方法

Question No:82

哪两个语句正确地描述了检查异常？
A、 这些都是编写良好的应用程序应该预料到并从中恢复的特殊情况。
B、 这些是应用程序外部的异常情况，应用程序通常无法预料或从中恢复。
C、 这些是应用程序内部的异常情况，应用程序通常无法预料到或无法从中恢复。
D、 作为RuntimeException和Error的子类的每个类都被归类为checked异常。
E、 作为异常子类的每个类（不包括RuntimeException及其子类）都被归类为checked Exception。

答案：B，D

说明：勾选异常：
（B） 表示程序直接控制范围之外的无效条件
（无效的用户输入、数据库问题、网络中断、缺少文件） 是异常的子类
这有点令人困惑，但也要注意RuntimeException（unchecked）本身就是Exception（checked）的一个子类。
方法必须为其引发的所有已检查异常建立一个策略
实现（或者将检查的异常传递到堆栈的更高层，或者以某种方式处理它）

Question No:83

int float double 前面的可以赋值给后面的，但是后面的不能赋值给前面的

Question No:84

答案：B
说明：循环（对于（intpos=0；pos<=4；pos++）{），它应该是pos<=3，原因是一个异常，被捕获。然后打印正确的总和。

Question No:85

Question No:86

哪个选项可以替换XXX以使代码打印135？

Question No:87

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、 程序没有打印任何内容

Question No:88

Question No:89

正确答案：C

Question No:90

12/10=1

Question No:91

哪行代码初始化学生实例？

Question No:92

子类继承父类后自动在子类的无参的构造方法当中调用父类的无参构造

Question No:93

当在“l/在此处插入代码片段行插入哪个代码片段时，启用该代码要成功地将arra元素更改为大写？



A虽然正确但是重复定义了上面的内容
不正确：不是B:阵列长度是3，但子阵列有2、3和4个元素。索引将越界。
不是B：子阵列的长度不同。索引将越界。
not D：编译错误
E编译错误

Question No:94

Question No:95

Question No:96

哪两个选项放在main方法的n1行时编译失败

Question No:97

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行必须插入哪个代码片段才能编译代码？

Question No:98

答案：B

说明：while语句不正确。它具有for语句的语法。
while语句在特定条件为真时连续执行一个语句块。
其语法可表示为：
while（表达式）{
报表
}
while语句计算表达式，该表达式必须返回布尔值。
如果表达式的计算结果为true，
while语句执行while块中的语句。
while语句继续测试表达式并执行其块，直到表达式的计算结果为false。
引用：while和do while语句

Question No:99

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");
        }
    }
}

Question No:100

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);
        }
    }
}

Question No:101

Question No:102

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、 由于运行时错误，程序无法执行

Question No:103

当执行到aVar为9 的时候，aVar++在括号当中返回的值为9，执行完括号后aVar的值递增为10

Question No:104

哪种说法是正确的？
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类名与文件名不同。
只有私有类可以有不同于文件名的名称

Question No:105

您必须确保maskcc方法返回一个字符串，该字符串隐藏信用卡号的所有数字，除了最后四个数字（以及分隔每组四个数字的连字符）。
您应该在n1行分别使用哪两个代码片段来实现这个需求？

Question No:106

Question No:107

内存运行时中创建了多少个对象？

说明：obj1和obj3。

当您执行e2=e1时，您复制的是对象引用—您没有复制对象—因此变量e1和e2都指向同一个对象

Question No:108

哪三条语句描述了Java语言的面向对象特性？

A、 对象不能重复使用。
B、 子类可以从超类继承。
C、 对象可以与其他对象共享行为。
D、 包必须包含多个类。
E、Object是所有其他对象的根类。
F、 必须在每个类中声明main方法。
回答：B，C，E。

Question No:109

public static void main(String[] args) {
    
    
        ArrayList<String> 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);
    }

Question No:110

Question No:111

当分别替换foo时，哪三个代码片段使程序能够编译？

Question No:112

当插入第2行时，哪个代码片段使代码能够编译？必须精确到那个包的所有类

Question No:113

A、 执行在第一个catch语句中终止，捕获的RuntimeException被打印到控制台。
B、 执行在第二个catch语句中终止，捕获的异常被打印到控制台。
C、 线程“main”中抛出运行时错误。
D、 执行正常完成，并将Ready to us@打印到控制台。
E、 代码无法编译，因为需要throws关键字

Question No:114

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

Question No:115

Question No:116

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("...");
    }
}

Question No:117

正确答案选择A

Question No:118

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循环来实现

Question No:119

当在//insert code行独立插入时，哪两条语句使代码能够编译？

Question No:120

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不相同

Question No:121

对于二维数组，哪两种说法是正确的？
A、 它被实现为指定元素类型的数组。
B、 使用逐列惯例，二维数组的每一行必须具有相同的大小。
C、 在声明时，必须指定每个维度中数组的元素数。
D、 类对象的所有方法都可以在二维数组上调用。

Question No:122

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();
    }
}

Question No:123

插入第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删除对应的值

Question No:124

What are the values of each element in intArr after this code has executed?

Question No:125

哪个命令集在控制台中打印Hello Duke？

Question No:126

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

Question No:127

哪两个独立的修改使代码能够编译？

A、 公开第n1行的方法。
B、 公开第n2行的方法。
C、 公开n3行的方法。
D、 使第n3行的方法受到保护。
E、 公开n4行的方法
子类重写父类的方法要等于大于父类的权限

Question No:128

Question No:129

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

Question No:130

Question No:131

哪三种说法是封装的好处？

A、 允许类实现在不更改客户端的情况下进行更改
B、 防止机密数据从对象中泄漏
C、 防止代码导致异常
D、 使类实现能够保护其不变量
E、 允许将类合并到同一个包中
F、 允许安全地创建同一类的多个实例
答：A、B、D

Question No:132

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、 由于运行时错误，程序无法执行

Question No:133

运行时在内存中创建了多少个MarkList实例

Question No:134

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需要赋予初值

Question No:135

Question No:136

答案：B
解释：==地址相等。
equals比较内容状态，而不是地址。

Question No:137

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

Question No:138

哪个选项只列出那些属于未检查的异常类别的类？



说明：不是 B:lOError和IOException都是检查错误。
不是C，不是D，不是E:FileNotFoundException是一个选中的错误。
注：
检查异常：
*表示程序无法直接控制的区域中的无效条件（无效用户输入、数据库问题、网络中断、缺少文件）
*是异常的子类
*方法必须为其实现抛出的所有已检查异常建立策略（要么将已检查异常进一步传递到堆栈上，要么以某种方式进行处理）
注：
未检查的异常：
表示程序中的缺陷（bug）-通常传递给非私有方法的参数无效。
引用Gosling、Arnold和Holmes的Java编程语言：
未检查的运行时异常通常表示反映程序逻辑错误的情况，并且在运行时无法合理地从中恢复
*是RuntimeException的子类，通常使用llegalArgumentException、NullPointerException或llegalStateException实现
*方法没有义务为其实现抛出的未检查异常建立策略（而且它们几乎总是不这样做）

Question No:139

当插入到n1行时，哪个代码片段使App类能够打印相等的内容？

equalsIgnoreCase与equals区别是前者不区分大小写，而后者区分

Question No:140

以上说法哪个是正确的？

A、 变量数的值为808.1
B、 变量的值将是808
C、 变量数的值将为0。
D、 将抛出NumberFormatException。
E、 它不会编译。

说明：

Integer类值0返回给定字符串中的整数。

但我们需要传递整数格式正确的字符串，否则它将引发NumberFormatException。在本例中，我们传递的字符串不是整数值（因为传递的是小数），所以选项D是正确的

Integer. valueOf()可以将基本类型int转换为包装类型Integer，或者将String转换成Integer，String如果为Null或“”或者小数都会报错

Question No:141

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

Question No:142

多态性的两个好处是什么？

A、 运行时更快的代码
B、 运行时更高效的代码
C、 运行时更动态的代码
D、 更灵活和可重用的代码
E、 受其他类保护而不被扩展的代码
答案：C，D
polymorphism 多型现象，多态性 ; 多机组合形式
Faster 更快的 ; 快 ; 快速
dynamic 相互作用的方式，动态 ;

Question No:143

Question No:144

说明：
不正确：
非B:非法组合修饰符：protected和public
不是 C:setNum方法不能是私有的。
不是E:getNum方法不能是私有的

Question No:145

正确答案选D

我们要求您为购物应用程序开发一个程序，并向您提供以下信息：
应用程序必须包含Toy、EduToy和consToy类。
Toy类是其他两个类的超类。
int caicuiatePrice（Toy t）方法计算玩具的价格。
void printToy（Toy t）方法打印玩具的细节。

Toy类的哪个定义为类层次结构添加了有效的抽象层？

Question No:146

Question No:147

Question No:148

哪个语句将清空名为sb的StringBuilder变量的内容？
字符串以及数组的大小用length而集合的大小用size

Question No:149

Question No:150

下列哪一个可以填入此代码中的空白以使其编译？


D、 它不会用任何方法编译，因为接口不能有非抽象方法。
它将编译而不闪烁空白。
答案：C
说明：
在JavaSE8中，我们可以在接口中使用静态和/或默认方法，
但它们应该是非抽象的方法。所以在这种情况下，在空白处使用默认值是完全合法的。
因此，选项C是正确的。
选项A不正确，因为给定的方法不是抽象的，所以不能在那里使用抽象。
选项B和E是不正确的，因为如果它们不是默认的或静态的，我们就不能有非抽象方法接口。

Question No:151

Question No:152

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);
    }
}

Question No:153

哪个答案不能编译？


说明：查看声明ArrayLIst（）的右侧，而不是ArrayLIst

Question No:154

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

Question No:155

Question No:156

正确答案B

Question No:157

说明：
在第5行，我们通过传递120D创建了一个包装对象double，
它可以转换成双人的，所以不会有任何例外。
但如果仔细检查，可以看到变量号在try块中声明，
所以变量数的范围仅限于那个块，
因此尝试在外部访问它会导致编译时错误。
httpsy/文件。oracle.com/javase/tutorialiava/nutsandbolts/variables.html文件

Question No:158

不能是D：不能应用于给定类型。

Question No:159

Question No:160

expression1和expression2可以分别是什么来产生输出-8和16？
正确答案选择B

Question No:161

Question No:162

Which set modifications enable the code to compile and run?

哪些集合修改使代码能够编译和运行

Question No:163

public class MyFor3 {
    
    
    public static void main(String[] args) {
    
    
        int[] xx = null;
        for (int ii: xx  ) {
    
    
            System.out.println(ii);
        }
    }
}

Question No:164

定义一个接受两个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

Question No:165

循环变量的作用域仅限于该封闭循环。所以在本例中，在第5行声明的循环变量X的作用域仅限于for loop。
试图访问第7行的变量，
它超出了变量X的范围，导致编译时错误。
由于第7行的错误，编译失败。
因此，选项D是正确的。
选项A和B不正确，因为代码无法编译。

Question No:166

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

Question No:167

循环将只运行一次，然后num==0将在循环的第一个周期后中断它

Question No:168

Question No:169

Question No:170

删除头尾空白符的字符串。

Question No:171

Question No:172

一、 默认构造函数只包含“super（）；”调用。
二。我们不能对构造函数使用任何访问修饰符。
三、 构造函数不应具有返回类型。

语句I是正确的，因为默认构造函数只包含super0调用
语句II是不正确的，因为我们可以将任何访问修饰符与构造函数一起使用。
语句三是正确的，因为构造函数不能有返回类型，甚至是void。
所以选项D是正确的。

Question No:173

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;
    }
}

Question No:174

A、 此方法无效。
B、 此方法只能在接口中使用。
C、 这个方法可以返回任何东西。
D、 此方法只能在接口或抽象类中使用。
E、 以上都不是。

给定的方法被声明为默认方法，因此我们只能在接口内部使用它。
因此，选项B是正确的，选项D是不正确的。
选项A不正确，因为它是有效方法。选项C不正确，因为返回类型为void，这意味着我们不能返回任何内容。

Question No:175

Question No:176

Question No:177

Question No:178

哪三个是有效的？

不正确：
不是B，不是C:Pet是抽象的，不能实例化。
不是F:不兼容的类型。需要小猎犬，找到狗。

Question No:179

public class Test {
    
    
    public static void main(String[] args) {
    
    
        Integer num = Integer.parseInt(args[1]);
        System.out.println("Number is :" + num);
    }
}

Question No:180

答案：C
说明：if（c.length（）>=4）{
则永远达不到该行。
这会导致编译错误。
注：
continue语句跳过for、while或do while循环的当前迭代。
未标记的break语句终止最内部的switch、for、while或do while语句，
但标记的break语句终止外部语句。

Question No:181

public class Jump {
    
    
    static String aegs[] = {
    
    "lazy","lion","is","always"};
    public static void main(String[] args) {
    
    
        System.out.println(
            args[1] + " " + args[2] + " "
                + args[3] + "jumping"
        );
    }
}

Question No:182

public class Vowe1 {
    
    
    private char var;
    public static void main(String[] args) {
    
    
        char var1 = 'a';
        char var2 = var1;
        var2 = 'e';

        Vowe1 obj1 = new Vowe1();
        Vowe1 obj2 = obj1;
        obj1.var = 'i';
        obj2.var = 'o';

        System.out.println(var1 + ", " +var2);
        System.out.println(obj1.var + ", " + obj2.var);
    }
}

Question No:183

Question No:184

说明：值104将导致MarketOutOfBoundsException

Question No:185

Question No:186

public class Test2 {
    
    
    public static void doChange(int[] arr){
    
    
        for (int pos = 0; pos < arr.length; pos++){
    
    
            arr[pos] = arr[pos] + 1;
        }
    }
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    10,20,30};
        doChange(arr);
        for(int x:arr){
    
    
            System.out.print(x + ", ");
        }
        doChange(arr[0],arr[1],arr[2]);
        System.out.println(arr[0] + ", " + arr[1] + ", " + arr[2]);
    }
}

Question No:187

使用访问修饰符保护变量并将其隐藏在类中的Java概念的名称是什么？
A、 封装
B、 继承
C、 抽象
D、 实例化
E、 多态性
答：A

Question No:188

Question No:189

Question No:190

哪种说法是正确的？
A、 obj可以访问p和s。
B、 obj只能访问s。
C、 obj可以访问r和s。
D、 对象可以访问p、r和s。
只有公共的才可以访问

Question No:191

答案：C
说明：FLOWING行不编译：
系统打印（“在“+位置找到”+键+）；
变量pos在此行未定义，因为其作用域仅在for循环中有效。
在循环内创建的任何变量都是循环的局部变量。

Question No:192

public class TestTry {
    
    
    public static void main(String[] args) {
    
    
        StringBuilder message = new StringBuilder("hello java!");
        int pos = 0;
        try
        {
    
    
            for (pos = 0; pos < 12; pos++){
    
    
                switch (message.charAt(pos)){
    
    
                    case 'a':
                    case 'e':
                    case 'o':
                        String uc = Character.toString(message.charAt(pos)).toUpperCase();
                        message.replace(pos,pos+1,uc);
                }
            }
        }catch (Exception e){
    
    
            System.out.println("Out of limits");
        }
        System.out.println(message);
    }
}

Question No:193

对于原始数据类型的二维数组，哪两条语句是正确的？
A、 它不能包含不同类型的元素。
B、 每个尺寸的长度必须相同。
C、 在声明时，必须指定每个维度中数组的元素数。
D、 类对象的所有方法都可以在二维数组上调用。
答案：C，D

Question No:194

外层循环运行了6次

Question No:195

Question No:196

abstract class X {
    
    
    public abstract void methodX();
}
interface Y{
    
    
    public void  methodY();
}

Answer: B,C
Explanation: When an abstract class is subclassed, the subclass usually provides
implementations for all of the abstract methods in its parent class ©.
However, if it does not, then the subclass must also be declared abstract (B).
Note: An abstract class is a class that is declared abstract- -it may or may not include abstract methods.
Abstract classes cannot be instantiated, but they can be subclassed.

答案：B，C
说明：当抽象类是子类时，子类通常提供
父类（C）中所有抽象方法的实现
但是，如果没有，那么子类也必须声明为抽象（B）。
注意：抽象类是一个声明为抽象的类–它可能包括也可能不包括抽象方法。
抽象类不能被实例化，但它们可以被子类化

Question No:197

Question No:198

Question No:199

以下哪种数据类型允许编译以下代码段？

Answer: B,D
Explanation:
Option B and D are the correct answer.
Since the variables I and j are floats, resultant will be float type too.
So we have to use float or primitive type which can hold float, such a primitive type is double,
it has wider range and also can hold floating point numbers,
hence we can use double or foat for the blank.
As explained above options B and D are correct.
long and int can’t be used with floating point numbers so option A is incorrect.
Option E is incorrect as it have smaller range and also can’t be used with floating point numbers.

答案：B，D
说明：
选项B和D是正确答案。
因为变量i和j是浮点数，所以结果也将是浮点数类型。
所以我们必须使用float或者可以容纳float的基元类型，这样的基元类型是double，
它的范围更广，还可以容纳浮点数

Question No:200

Question No:201

哪两项可以合法地包含在java类声明中？

哪两项可以合法地包含在java类声明中？
A、 导入语句
B、 字段声明
C、 包声明
D、 方法声明

Question No:202

哪行代码打印的数字最高

Question No:203

Question No:204

Question No:205

Question No:206

Question No:207

Question No:208

Question No:209

Question No:210

Question No:211

哪个选项使代码能够编译？

Question No:212

Question No:213

Question No:214

答案：C

说明：
name和pass变量都是实例变量，
我们没有给他们任何值
所以它们取默认值。For Boolean默认值为false，For string默认值为null
不是基元类型，默认值为null，所以在第7行，
null将作为变量名的值打印，在第8行将打印false。因此，选项C是正确的。
如上所述，选项A、B和D不正确。
代码编译得很好，所以选项E不正确

Question No:215

public class X implements Z{
    
    
    public String toString(){
    
    
        return "X ";
    }
    public static void main(String[] args) {
    
    
        Y myY = new Y();
        X myX = myY;
        Z myZ = myX;
        System.out.print(myX);
        System.out.print((Y)myX);
        System.out.print(myZ);
    }
}
class Y extends X{
    
    
    public String toString() {
    
    
        return "Y";
    }
}

Question No:216

下列哪一个可以填入此代码中的空白以使其编译？

答案：C
说明：
在JavaSE8中，我们可以在接口中使用静态和/或默认方法，但它们应该是
非抽象方法。所以在这种情况下，在空白处使用默认值是完全合法的。
因此，选项C是正确的。
选项A不正确，因为给定的方法不是抽象的，所以不能在那里使用抽象。
选项B和E是不正确的，因为如果它们不是默认的或静态的，我们就不能有非抽象方法接口。

Question No:217

Question No:218

哪项更改将使代码能够编译？

哪项更改将使代码能够编译？
A、 将public修饰符添加到第n1行method1的声明中
B、 从第n2行method1的定义中删除public修饰符
C、 在第n3行更改方法2 public声明private修饰符
D、 更改n4 DoClass doi=new DoClass（）行；
答案：C
说明：私有成员（字段和方法）只能在
类，它们被声明或在内部类中。
private关键字是四种访问方式之一
由Java提供的修饰符，在public、default（package）、protected和private这四个修饰符中是限制性最强的。

Question No:219

class Student{
    
    
    String name;
    int age;
}
1.public class Test {
    
    
2.    public static void main(String[] args) {
    
    
3.        Student s1 = new Student();
4.        Student s2 = new Student();
5.        Student s3 = new Student();
6.        s1=s3;
7.        s3=s2;
8.        s2=null;
9.    }
10.}

哪种说法是正确的？
A、 在第8行之后，有三个对象可以进行垃圾收集
B、 在第8行之后，有两个对象可以进行垃圾收集
C、 在第8行之后，一个对象有资格进行垃圾收集
D、 在第8行之后，没有一个对象符合垃圾收集的条件

Question No:220

Question No:221

在给定的语句中，我们可以看到，我们为创建int数组传递了负值，
结果是除离子外的负离子。因此，选项B是正确的。
选项A不正确，因为在需要对象的情况下，当应用程序尝试使用null时抛出该选项。
选项D不正确，因为引发了IndexOutOfBoundsException，以指示某种索引（例如数组、字符串或向量）超出范围。
java.lang.Object
java.lang.Throwable
java.lang.Exception
java.lang.RuntimeException
java.lang.NegativeArraySizeException

如果应用程序试图创建大小为负的数组，则抛出该异常。

Question No:222

缺少对参数化构造函数的n1行隐式调用，n2 this（）必须是第一行。

Question No:223

Question No:224

哪个选项表示成功完成外循环后num数组的状态？

Question No:225

public class Alpha {
    
    
    int ns;
    static int s;
    Alpha(int ns){
    
    
        if(s < ns){
    
    
            s = ns;
            this.ns = ns;
        }
    }
    void doPrint(){
    
    
        System.out.println("ns = " + ns + " s = " +s);
    }
}
class TestA{
    
    
    public static void main(String[] args) {
    
    
        Alpha ref1 = new Alpha(50);
        Alpha ref2 = new Alpha(125);
        Alpha ref3 = new Alpha(100);
        ref1.doPrint();
        ref2.doPrint();
        ref3.doPrint();
    }
}

正确答案选择D

Question No:226

public class Palindrome {
    
    
    public static int main(String[] args) {
    
    
        System.out.print(args[1]);
        return 0;
    }
}

And the commands
javac Palindromds.java
java Palindrome Wow Mom

代码可以编译，但不执行。

Question No:227

public class Test2 {
    
    
    public static void main(String[] args) {
    
    
        int ar1[] = {
    
    2,4,6,8};
        int ar2[] = {
    
    1,3,5,7,9};
        ar2 = ar1;
        for (int e2 : ar2){
    
    
            System.out.print(" "+e2);
        }
    }
}

正确答案选择A

Question No:228

可以在
//insert code-here行插入哪个代码片段来编译代码？

答：A
说明：
不正确：
不是C，不是D：对super的调用必须是构造函数中的第一个语句。

Question No:229

哪个用法表示编译名为“Main”的java源文件的有效方法？

说明：编译器由javac命令调用。编译Java类时，
必须包含文件名，其中包含主要类（包括Java扩展名）。
所以要运行Mainjava文件，我们必须使用选项A中的命令。
为了执行Java程序，我们可以使用Java命令，但不能使用它进行编译。

Question No:230

Question No:231

哪两个是有效的数组声明？
声明数组的时候不需要指定大小，初始化的时候才需要指定大小

Question No:232

Question No:233

选项E是正确答案。
代码未能编译，因为StringBuilder类中没有名为concert的方法。
concert方法在String类中。
因此，选项E在这里是正确的，我们应该使用StringBuilder类的append方法，在这种情况下选项B是正确的

Question No:234

它将把StringBuilder的字符串内容与string对象进行比较

Question No:235

哪三行在n1行独立插入时，导致程序打印0余额？

Question No:236