提示:内容已经过期谨慎付费，点击上方查看最新答案
面向对象程序设计（JAVA）
- 根据语句Word w = new Word(“Java”);可知Word类一定申明了下面的构造方法（ ）。
- 给定语句Person p2=p1;，下面说法一定错误的是（ ）。
- 已知Person类中有形如Person addFriend(Person p)的方法，下面选项中一定存在语法错误的是（ ）。
- 下面选项中创建对象数最多的语句是（ ）。
- 用于申明子类的关键字是（ ）。
- 已知抽象类Document，根据语句Document doc=new Paper();可以判断（ ）。
已知Point类的申明如下，下面选项中正确的是（ ）。
public class Point{
public void Point(Point p){}
public void Point(int x, int y){}
}
根据以下程序可知一个Student对象有（ ）个属性变量。
class Person{
private int age;
private String name;
}
class Student extends Person{
private String school;
}
- 程序文件Document.java中最可能的内容是选项（ ）。
- 下面选项中属于运行时异常的是（ ）。
- 下面关于自定义异常的申明中属于非运行时异常的选项是（ ）。
- 属于java.io包内预定义类的选项是（ ）。
根据Student类的申明推断Person类的申明最为可能的是选项（ ）。
public class Student extends Person{
public Student(String school){}
}
- 运行Java程序的入口方法是（ ）。
- 下面说法中错误的是（ ）。
- 遍译Person.java文件后将生成（ ）。
- 下面选项中一定存在语法错误的是（ ）。
根据以下程序可以判断选项（ ）没有语法错误。
public class Person{
public Person(int id, String name)throws Exception{}
}
class MyException extends Exception{}
运行下面程序最可能输出的结果是（ ）。
import java.util.*;
public class Test{
public static void main(String[] args){
ArrayList list = new ArrayList();
list.add(“John”);
list.add(3);
list.add(null);
list.add(null);
System.out.println(list)；
}
}
- 已知News类是Document类的一个子类，根据语句n = new News();可以判断变量n的语法类型是（ ）。
- 关于方法申明下面选项中没有语法错误的是（ ）。
运行下面程序将输出结果（ ）。
public class Point{
int x=10;
int y = 10;
public Point(){
this.x = 30;
this.y = 30;
}
public String getInfo(){
return “(”+ x + “,” + y +“)”;
}
public static void main(String[] args){
System.out.println(“Point：” + new Point().getInfo());
}
}
关于下面程序的说法正确的是（ ）。
class Person{
public Person(String name){}
}
class Student extends Person{}
- 根据语句int a=b.length;推测变量b的数据类型可能是（ ）。
运行下面程序产生的异常类型是（ ）。
public class Person{
int age;
public String getInfo(){
if(age<1) throw new ArithmetricException();
return “Person”;
}
public static void main(String[] args){
Person [] persons = new Person[10];
for(int i=0; i<12; i++) System.out.println(persons[i].getInfo());
}
}
- 在Paper类中覆盖equals方法的正确形式是（ ）。
- 下面关于import语句用法错误的选项是（ ）。
请为以下NamedBean类的申明选择一个必须的构造方法（ ）。
public class NamedBean{
public NamedBean(){this(0, “Unknown”);}
}
下面的程序运行后将输出结果（ ）。
public class Point{
int x=10, y=10;
public String getInfo(){
return “(”+ x + “,” + y +“)”;
}
public static void main(String[] args){
Point p1 = new Point();
Point p2 = p1;
p2.x = -10;
System.out.println(p1.getInfo() + “\t” + p2.getInfo());
}
}
关于下面一段程序说法正确的是（ ）。
public class Test{
public static void main(String[] args){
String name;
String hello = “Hello,” + name；
System.out.println(hello);
}
}
根据如下程序选择正确的说法（ ）。
public class Book{
String title;
double price;
public Book(){}
public Book(String title){this.title = title;}
public static void main(String[] args){
Book a = new Book();
Book b = new Book(“Java Programming”);
}
}
- 属于java.util包内预定义类的选项是（ ）。
- 语句int a = Integer.parseInt(“hello”);在语法上是正确的，但是在运行时将产生异常。（ ）
- 运行语句Exception e = new Exception();将人为制造一个异常并终止程序运行。（ ）
- 任何一个Java类都一定有toString方法。（ ）
- 语句Person[] friends = new Person[10];执行后内存中将增加11个新对象。（ ）
- 任何一个Java类都至少有一个构造方法。（ ）
- 语句System.out.println(10 + 10 +“hello”+ 10 + 10);运行后将输出1010hello1010。（ ）
- 表达式new Person()==new Person()的值一定为false。（ ）
- 任何方法在执行时一定有一个当前对象。（ ）
- 即使一个抽象类中没有申明任何抽象方法，我们也不可以使用new调用其构造方法来创建对象。（ ）
- 只要安装了JDK我们就可以开发Java程序了。（ ）
- 如果p instanceof Object的值为false，可以断定p的值一定为null。（ ）
- 在集成开发环境中运行一个Java程序时，不需要对源程序进行编译就可以直接运行。（ ）
- 根据语句Record[] data = new Record[10];可以断定Record一定是具体类。（ ）
- 语句int a = new Integer(10);在语法上是错误的。（ ）
- 使用BufferedReader可以用一行字符串一行字符串的方式读取输入内容。（ ）
A:public void Word(String w){} B:public Word(String w){} C:public word(String w){} D:public word(){}
答案:public Word(String w){}
A:执行该语句后变量p2的值可能为null B:p1是Person类型的变量 C:执行该语句后内存中增加一个新的Person对象 D:执行该语句后变量p1和p2引用同一个Person对象
AI参考:根据给定的语句“Person p2=p1;”，可以得出以下结论：B：p1是Person类型的变量 —— 这个选项是正确的，因为p1的类型被声明为Person。D：执行该语句后变量p1和p2引用同一个Person对象 —— 这个选项也是正确的，因为语句创建了一个新的Person对象，并将p1的引用赋值给了p2，所以p1和p2都引用了同一个Person对象。然而，A选项“执行该语句后变量p2的值可能为null”是不一定正确的。虽然Java中的基本类型（如int、float等）在赋值时，如果左侧为null，则右侧赋值为null，但是对于引用类型（如Person），赋值时不会检查左侧是否为null。因此，即使p1为null，p2的值也可能不是null。因此，选项A一定错误。所以答案是：A:执行该语句后变量p2的值可能为null。'
A:this.addFriend(null).addFriend(new Person()); B:this.addFriend(null); C:没有 D:this.addFriend(new Person(“John”)).addFriend(new Person(“Mary”));
答案:s1.older(s2)_p.older(s1)_s1.older(p)AI参考:根据题目给出的信息，选项中只有 A 有语法错误。这是因为在一个对象的方法中调用该对象的另一个方法时，如果使用 null 作为参数，可能会导致空指针异常（NullPointerException）。具体来说，对于 A 选项，我们试图在名为 this 的对象上调用了 addFriend 方法两次，第一次传入了 null 参数，第二次传入了新的 Person 对象。由于 null 不能作为任何对象的实例，因此会导致空指针异常。而其他选项中的语法都是正确的。因此，正确答案是 A: this.addFriend(null).addFriend(new Person());。'
A:String[] data = new String[3]; B:Integer[] data = new Integer[10]; C:String[] data = {“John”, ”Mary”, “Alice”}; D:int[] data = new int[10];
答案:ta =new int[10];
A:Object B:extends C:implements D:public
答案:extends
A:都正确 B:Paper类是Document类的直接或间接子类 C:语句Object obj = new Paper();在语法上一定是正确的 D:Paper类一定是具体类
AI参考:根据题目给出的语句 `Document doc = new Paper();`，我们可以推断出 `Paper` 类是 `Document` 类的子类或者具有与 `Document` 类相似的行为。但并没有提供足够的信息来断定 `Paper` 类是否是直接或间接的子类，因此选项 B 不正确。另一方面，抽象类是不能被实例化的，因此选项 C 不正确。而 `Paper` 类可能是抽象类或者是具体类，但在给定的语句中并没有给出足够的线索来确定它是否是具体类，因此选项 D 不正确。所以，正确答案是选项 A：因为 `Paper` 类继承自 `Document` 类或者具有与 `Document` 类相似的行为，所以可以推断出 `Paper` 类可能具有与 `Document` 类相同的属性或方法。这并不意味着 `Paper` 类一定是具体类，因为抽象类也可以有非抽象的方法和属性。因此，答案为：都正确。'
A:Point p = new Point(2, 10); B:Point p = new Point(); C:Point p = new Point(null); D:都正确
答案:distance方法执行时有可能产生空指针异常;Point类只有一个构造方法;语句Point p = new Point().copy();在语法上是正确的
A:0 B:1 C:3 D:2
AI参考:正确答案是 D:2。根据题目给出的代码，Student类继承了Person类，所以Student对象有Person类的两个属性变量，即age和name，还有Student类特有的一个属性变量school，所以共有三个属性变量，但是题目中要求选择一个答案，所以正确答案是D：2。'
A:public class News extends Document{} B:都可能 C:public class Document{}public class News extends Document{} D:public class Document{}
AI参考:正确选项是C:public class Document{}public class News extends Document{}。程序文件Document.java中应该包含一个公共类Document和一个继承自Document的类News。选项A和D都是正确的Java类声明，但它们并没有明确说明News类继承自Document类，因此不符合题目要求。选项B没有提供任何内容，所以不符合题意。因此，最可能的内容是选项C：一个公共类Document和一个继承自该类的另一个公共类News。'
A:都是 B:ClassCastException C:ArithmetricException D:NullPointerException
A:public class MyException extends Exception{} B:public class MyException extends String{} C:public class MyException extends NullPointerException{} D:public class MyException extends RuntimeException{}
A:FileReader B:都是 C:IOException D:File
AI参考:正确选项是：B:都是。java.io包内预定义类包括：FileInputStream、FileOutputStream、FileReader、FileWriter、BufferedReader、BufferedWriter、InputStreamReader、OutputStreamWriter等。其中，FileReader和BufferedReader都属于java.io包内预定义类。因此，选项B“都是”是正确答案。选项C和D不属于java.io包内预定义类。选项A是FileReader类的实例化对象，不属于预定义类。'
A:public class Person{public Person(int age){}} B:public class Person{public Person(int age, String name){}} C:public class Person{public Person(String name){}} D:public class Person{}
A:public static void Main(){} B:public static void main(String[] params){} C:public static void Main(String[] params){} D:public static void main(String args){}
A:除Object类外任何一个Java类都有一个父类 B:任何一个Java类都可以作为父类来申明子类 C:Object类是所有Java类的祖先 D:任何一个Java类最多只可能有一个父类
A:person.exe B:Person.exe C:Person.class D:person.class
A:Object obj = new Person(“John”); B:String info = new Person(“John”); C:Object obj = “Hello,” + new Person(“John”); D:String info = “Hello,” + new Person(“John”);
AI参考:正确选项是：C:Object obj = “Hello,” + new Person(“John”);。该选项存在语法错误，原因在于字符串和对象不能直接相加。在Java中，字符串和对象需要使用特定的方法进行连接，例如使用加号（+）连接字符串和对象时，需要使用toString()方法将对象转换为字符串。因此，正确的代码应该是Object obj = new Person("John").toString();。其他选项中，A和B选项中存在语法错误，因为Object和String类型不能直接赋值给String类型的变量；D选项中存在逻辑错误，因为“Hello, ”后面应该接的是字符串而不是Person对象。'
A:public class Test{public static void main(String[] args){System.out.println(new Person(20, “John”).toString());}} B:public class Test{public static void main(String[] args)throws MyException{System.out.println(new Person(20, “John”).toString());}} C:public class Test{public static void main(String[] args)throws Exception{System.out.println(new Person(20, “John”).toString());}} D:public class Test{public static void main(String[] args){System.out.println(new Person(20, “John”));}}
AI参考:正确选项是C:public class Test{public static void main(String[] args)throws Exception{System.out.println(new Person(20, “John”).toString());}}。解释如下：* 程序中定义的Person类有一个构造函数，该构造函数声明抛出异常，但并未在方法体中处理该异常。* 在选项C中，main方法声明了抛出Exception异常，这是正确的，因为main方法可以声明任何类型的异常。* 在选项A、B和D中，main方法并没有声明抛出异常，这是不正确的。* 在选项C中，程序调用了Person类的构造函数并打印了结果，而Person类的构造函数声明了抛出异常，因此main方法需要声明抛出Exception异常以避免编译错误。因此，选项C是语法正确的选项。'
A:0x38dd B:[John, 3, null] C:[John, 3] D:[John, 3, null, null]
AI参考:运行下面程序最可能输出的结果是【D:[John, 3, null, null]】。程序中首先创建了一个ArrayList对象，然后依次添加了"John"，3，和两个null。输出该ArrayList时，因为ArrayList是按照元素顺序添加的，所以最终输出为"[John, 3, null, null]"。选项B与输出结果相同。选项A为字符串形式，不符合程序输出的列表格式；选项C和选项D少一个元素。因此，最可能的输出结果为选项D。'
A:News B:都可能 C:Object D:Document
AI参考:根据题目中的语句“n = new News();”可以判断变量n的语法类型是News，因此选项A是正确答案。这个语句创建了一个新的News对象，并将其引用赋值给变量n，因此变量n的类型就是News类。'
A:public int[] next(){return null;} B:public int next(){return null;} C:public int[] next(){return {2, 3};} D:public void next(){return null;}
AI参考:正确选项是：B: public int next() { return null; }。在Java中，方法声明需要遵循一些基本规则，包括语法和命名约定。首先，方法声明必须以public修饰符开始，选项A中没有public修饰符是错误的。其次，方法的返回类型应该与实际返回的值相匹配。在选项B中，方法的返回类型是int[]，这没有问题。同时，选项B的方法体内使用了return null;来返回null，这也是符合Java语法规则的。所以，只有选项B符合Java的语法规则。其他选项都存在或多或少的错误。选项C中的int[]没有明确给出是一个数组类型，选项D中的next()方法没有明确的返回类型，且next通常用于表示迭代或下一个元素，与题目中的方法名不符。因此，正确答案是B。'
A:Point：null B:Point：(30,30) C:Point： D:Point：(10,10)
AI参考:运行该程序将输出结果为 `Point：(30,30)`。程序中定义了一个 `Point` 类，包含两个成员变量 `x` 和 `y`，初始值分别为 10。在 `Point` 类中定义了一个构造函数，用于初始化 `x` 和 `y` 的值为 30。在 `main` 方法中，创建了一个 `Point` 对象，并调用了其 `getInfo` 方法，返回值为 `(30,30)`，并将其输出到控制台。因此，输出结果为 `Point：(30,30)`。'
A:Person类和Student类都存在语法错误 B:Person类存在语法错误 C:Student类存在语法错误 D:Person类和Student类都不存在语法错误
A:int B:Integer C:int[] D:String
A:ArithmetricException B:ArrayIndexOutOfBoundsException C:NullPointerException D:其他三个都对
AI参考:运行下面程序产生的异常类型是：B:ArrayIndexOutOfBoundsException解释：在程序中，我们创建了一个Person数组，并尝试访问索引为12的元素，而实际上该数组只有10个元素，因此数组越界，抛出了ArrayIndexOutOfBoundsException异常。在主函数中，我们通过循环访问了数组中的所有元素，但是由于数组长度限制，超出了索引范围，所以会抛出此异常。'
A:public boolean equals(Paper obj) B:public boolean equals(Object obj) C:都正确 D:public boolean equals()
AI参考:正确答案是A:public boolean equals(Paper obj)。在Java中，覆盖equals方法时，需要确保传入的参数与当前对象是同一类型，因此应该使用Paper obj作为参数类型。此外，equals方法应该返回一个布尔值，表示当前对象是否与传入的对象相等。因此，选项A是正确的形式。B选项虽然语法上正确，但Object类中的equals方法接收Object类型的参数，而题目要求是Paper类型，因此不够准确。D选项则是不正确的空方法返回，不能用于覆盖equals方法。'
A:import java.lang.Boolean; B:import java.util.Scanner; C:import java.util.*; D:import java.lang;
A:public NamedBean(int id, String name){} B:public NamedBean(int id){} C:public NamedBean(String name){} D:public NamedBean(NamedBean copy){}
AI参考:正确答案是：A:public NamedBean(int id, String name){}给出的类中明确给出了一个构造方法声明，需要符合类声明时的格式要求，该方法应该具有与类声明相同的访问修饰符（即公共公开的），且方法名必须与类名相同，同时该方法应该接收两个参数，第一个参数是int类型的id，第二个参数是String类型的name。所以正确答案是A选项。'
A:(10,10) (10,10) B:(-10,10) (10,10) C:(-10,10) (-10,10) D:(10,10) (-10,10)
A:程序运行输出结果Hello, B:程序运行输出结果Hello,null C:程序运行产生空指针异常 D:程序存在语法错误无法运行
A:两个Book对象在内存中的结构是一样的 B:程序存在语法错误 C:运行程序会输出结果Java Programming D:使用new Book()创建的Book对象，其title属性值为null
A:ArrayList B:Scanner C:System D:Calendar
AI参考:正确选项是：A:ArrayList B:ScannerJava.util包内预定义类的选项包括：* ArrayList：一个动态数组实现类，用于存储对象。* Scanner：用于从控制台读取输入的类。* System：Java标准库中的核心类之一，提供了一些常用的系统属性访问方法。* Calendar：Java中的一个日期时间类，用于处理日期和时间相关的操作。因此，属于java.util包内预定义类的选项是A:ArrayList和B:Scanner。C:System属于核心类库，而D:Calendar则是Java标准库中的日期时间类。'
A:对 B:错
A:错 B:对
A:对 B:错
A:错 B:对
AI参考:正确答案是B：对。语句Person[] friends = new Person[10];创建了一个Person类型的数组，并初始化了10个Person对象。在内存中，除了这10个对象外，还需要额外分配数组元素和数组头部的空间，总共需要增加11个新对象。因此，这个判断题是正确的。'
A:对 B:错
A:错 B:对
A:错 B:对
AI参考:答案是B：对。在Java中，对象比较运算符“==”用于比较两个对象的引用是否相等，而不是比较它们的内容是否相等。因此，对于两个不同的Person对象实例，即使它们具有相同的属性值，使用“==”运算符比较它们的引用仍然会返回false。因此，表达式new Person() == new Person()的值一定为false。'
A:对 B:错
AI参考:正确答案为B：错。在面向对象编程中，方法通常需要一个当前对象作为参数或作为方法的执行上下文。但是，并不是任何方法在执行时都有当前对象，因此这个说法是错误的。'
A:对 B:错
A:对 B:错
AI参考:正确选项为A：对。虽然JDK（Java Development Kit）是开发Java程序所必需的，但是要开发Java程序还需要其他的工具和环境，如文本编辑器、集成开发环境（IDE）等。此外，还需要了解Java编程语言的基本语法和概念。因此，仅仅安装了JDK并不意味着可以直接开发Java程序。'
A:对 B:错
A:错 B:对
A:错 B:对
AI参考:答案：B。根据语句Record[] data = new Record[10];可以断定Record一定是具体类，因为Record[] data表示Record类的一个数组，数组中的元素必须是具体类。'
A:对 B:错
A:错 B:对
温馨提示支付 ￥1.70 元后可查看付费内容,请先翻页预览!
