为了让期末考试通过QAQ
选择题/填空题
1、对于可以独立运行的java应用程序，下列（D）说法是正确的。
A、无须main方法 B、必须有两个main方法
C、可以有多个或零个main方法 D、只能有一个main方法
解析：没什么好说的，public static void main每个java程序都要有，所以必须也只能有一个main方法
2、Java#中程序的入口方法明是（B）
A Main B main C Begin D using
3、Java源文件和编译后的文件扩展名分别为（B）
A、.class和java B、.java和.class
C、.class和.class D、.java和.java
4、编译一个Java程序“MyJava”的方法是（D），运行程序的 方法是（C）
A、运行：“java MyJava.java” B、运行：”java Myjava.class”
C、运行：“java Myjava” D、运行：“javac MyJava.java”
5、要给Java源文件中只能有（B）个public类，且文件名和类名一致。
A、0 B、1 C、2 D、不确定
6、Java中数据类型有（B）
A、基本类型和调用类型 B、基本类型和引用类型
C、引用类型和关系类型 D、关系类型和调用类型
7、下列哪个是合法的Java标识符（B）？
A、Test&Glasses B、First_JavaApplet
C、5$theLastOne D、synchronized
解析：合法的Java标识符必须遵循以下规则：
标识符可以包含字母、数字、下划线（_）和美元符号（$）。
标识符不能以数字开头。
标识符不能是Java的保留字。
根据这些规则，我们可以分析给定的选项：
A、Test&Glasses - 包含非法字符”&”，不合法。
B、First_JavaApplet - 符合规则，合法。
C、5$theLastOne - 以数字开头，不合法。
D、synchronized - 是Java的保留字，不合法。
因此，正确答案是 B、First_JavaApplet。
8、下列变量定义与赋值正确的是（CDEF）（多选）
A、int a=”a”; B、float a =12.5;
C、double a =12 D、int a = ‘a’;
E、 char c =97 F、double d =1.2e3
这个B应该是对的吧？
解析：在Java中，变量定义和赋值需要遵循数据类型的规则。下面是对每个选项的分析：
A、int a=”a”; - 错误。int类型不能直接赋值为字符串。
B、float a =12.5; - 错误。float类型可以赋值为浮点数，但是后面得加个f即12.5f。
C、double a =12; - 正确。double类型可以赋值为整数，Java会自动将其转换为double类型。
D、int a = ‘a’; - 正确。int类型可以赋值为字符，因为字符在Java中会被隐式转换为其对应的ASCII值。
E、char c =97 - 正确。char类型可以赋值为整数，如果该整数是有效的Unicode字符的ASCII值。
F、double d =1.2e3 - 正确。double类型可以赋值为科学记数法表示的浮点数。
因此，正确的选项是C、D、E 和 F。
9、定义初始化一维数组的语句，其中不正确的 是（D）。
A. int a[]={1,2,3,4,5};
B. int[] a=new int[5]
C. int[] a =new int[]{1,2,3,4,5}
D. int[] a; a={1,2,3};
解析：A. int a[]={1,2,3,4,5}; - 正确。这是数组的声明和初始化的组合，数组a被初始化为包含元素1, 2, 3, 4, 5。
B. int[] a=new int[5] - 正确。这是声明一个名为a的整型数组，并使用new关键字分配了一个长度为5的数组，但此时数组元素尚未初始化，它们将被默认初始化为0。
C. int[] a =new int[]{1,2,3,4,5} - 正确。这是声明一个名为a的整型数组，并使用new关键字分配了一个数组，同时初始化了数组的元素。
D. int[] a; a={1,2,3}; - 不正确。在Java中，不能这样赋值数组。数组的初始化必须在声明时完成，或者使用new关键字后立即进行初始化。此外，即使在声明时初始化，也不能使用花括号{}，而是应该使用方括号[]。
因此，不正确的选项是 D。
10、有如下的语句：C
11、Java程序中如何获得数组的长度（D）。
A、利用全局函数getArrayLen（）
B、利用数组的getLength（）函数
C、利用数组的length（）函数
D、利用数组的length字段
解析：A. 利用全局函数 getArrayLen() - 错误。Java中没有这样的全局函数。
B. 利用数组的 getLength() 函数 - 错误。Java中数组没有名为 getLength 的方法。
C. 利用数组的 length() 函数 - 错误。虽然 length 是数组的一个属性，但它没有括号，不应该被当作函数调用。
D. 利用数组的 length 字段 - 正确。这是获取Java数组长度的正确方式。例如，如果你有一个数组 int[] myArray，你可以使用 myArray.length 来获取它的长度。
因此，正确答案是 D。
12、为Test类的一个无形式参数无返回值的方法method书写方法头，使得使用类名Test作为前缀就可以调用它，该方法头的形式为（A）
A. static void method() B. public void method()
C. final void method() D. abstract void method()
解析：A. static void method() - 正确。静态方法可以通过类名直接调用，不需要创建类的实例。
B. public void method() - 错误。这是一个公共方法，它需要通过类的实例来调用。
C. final void method() - 错误。尽管 final 关键字可以用来防止方法被子类覆盖，但这并不改变方法的调用方式，它仍然需要通过类的实例来调用。
D. abstract void method() - 错误。这是一个抽象方法，它必须在抽象类中定义，并且没有方法体。抽象方法也需要通过类的实例来调用，但因为抽象类不能实例化，所以不能直接调用。
因此，正确答案是 A。
13、对类进行实例化的时候，系统会自动调用（B）
A、main方法 B、构造方法 C、析构方法 D、都可以
解析：A. main方法 - 错误。main 方法是Java程序的入口点，但它不是在实例化类时自动调用的。
B. 构造方法 - 正确。构造方法在创建类的实例时被调用，用于初始化对象的状态。
C. 析构方法 - 错误。Java语言不支持析构方法。析构方法在其他一些语言中存在，用于在对象生命周期结束时执行清理工作，但Java使用垃圾回收机制来自动管理内存。
D. 都可以 - 错误。根据上述分析，只有构造方法在实例化类时被调用。
因此，正确答案是 B、构造方法。
14、当数据类型为引用类型，当引用类型的值为（B）时，表明没有引用任何对象。
A. Empty B. null C. Nothing D. 0
15、关于super（），下列叙述错误的是（D）。
A、super（）调用必须是方法第一条语句
B、当一个类没有构造方法时，默认调用super（）执行父类的无参构造方法
C、子类的构造方法中没有用super（）或this（），Java将默认执行super（）
D、什么时候都会自动调用super（）
emm，这个题目太脑残了，一看就选D
16、下面的是关于类及其修饰符的一些描述，错误的是（B）
A、abstract类只能用来派生子类，不能用来创建abstract类的对象
B、final类不但可以用来派生子类，也可以用来创建final类的对象
C、abstract不能与final同时修饰一个类
D、abstract方法必须在abstract类中声明，但abstract类定义中可以没有abstract方法
解析：A. abstract 类只能用来派生子类，不能用来创建 abstract 类的对象 - 正确。abstract 类不能被实例化，它必须被继承，并且它的子类需要提供所有抽象方法的实现。
B. final 类不但可以用来派生子类，也可以用来创建 final 类的对象 - 错误。final 类不能被继承，但可以被实例化。
C. abstract 不能与 final 同时修饰一个类 - 正确。abstract 类设计为可以被继承，而 final 类则不可以被继承，因此这两个修饰符不能同时应用于同一个类。
D. abstract 方法必须在 abstract 类中声明，但 abstract 类定义中可以没有 abstract 方法 - 正确。abstract 类可以包含抽象方法，也可以不包含。即使没有抽象方法，abstract 类仍然不能被实例化，它可能被设计为一个框架，强制要求其子类覆盖某些方法或实现某些行为。
17、以下哪一选项正确描述了synchronized关键字的作用（D）。
A、允许两个并行运行的进程相互通信
B、确保两个或多个线程同时启动或终止
C、确保两个或多个进程同时启动或终止
D、确保同一时间只有一个线程访问一个方法或对象
解析：synchronized 关键字在Java中用于控制多线程环境下对共享资源的访问，以确保在同一时间只有一个线程能够执行特定代码段。下面是对每个选项的分析：
A. 允许两个并行运行的进程相互通信 - 错误。synchronized 不是用来进行进程间通信的，而是用于同步线程。
B. 确保两个或多个线程同时启动或终止 - 错误。synchronized 不负责线程的启动或终止，它只确保线程在访问共享资源时的同步。
C. 确保两个或多个进程同时启动或终止 - 错误。synchronized 是Java中的关键字，用于线程同步，而不是用于进程同步。
D. 确保同一时间只有一个线程访问一个方法或对象 - 正确。synchronized 确保了当一个线程访问某个对象的同步方法或同步代码块时，其他线程不能访问该对象的任何其他同步方法或同步代码块。
因此，正确答案是 D。synchronized 关键字通常用于避免多线程环境下的竞态条件，确保线程安全。
18、以下字符串函数的描述中，错误的是（A）
A、charAt函数返回一个字符，如charAt（1）返回字符串中的第一个字符
B、indexof函数从前往后搜索字符第一次出现的位置
C、substring函数返回字符串的一个子串
D、String类和StringBuffer类都有length函数，它们的形式和功能是一致的
gpt貌似发癫了？A的错误地方我猜是charAt（1）会返回字符串的第二个字符吧。
19、下面哪个语句会发生编译错误（C）。
A、int[]a; B、int [] b=new int[10];
C、int c[]=new int[]; D、 int d=[]=null;
解析：C. int c[] = new int[]; - 编译错误。这个语句试图声明并初始化一个名为 c 的整型数组，但是没有指定数组的长度，这是不允许的。正确的初始化应该指定数组的长度，例如 int c[] = new int[10];。
20、关于异常处理，正确的 是（D）。
A、try，catch，finally三个子句必须同时出现，才能正确处理异常
B、catch子句只能出现一次
C、try子句中所抛出的异常一定能被catch子句捕获
D、无论异常是否抛出，finally子句中的内容都会被执行
这个finally子句在python中也是这样的 ，反正你只要写了这个他都是会执行的
21、实现一个继承接口Runnable的类需要实现下面的哪个方法（B）。
A、start B、run
C、wait D、paint
解析：
public interface Runnable {
void run();
}
A. start - 错误。start 是 Thread 类的一个方法，用于启动一个线程。
B. run - 正确。Runnable 接口只包含一个未实现的方法 run，任何实现 Runnable 接口的类都必须提供 run 方法的具体实现。
C. wait - 错误。wait 是 Object 类的一个方法，用于使当前线程等待，直到另一个线程调用了 notify 或 notifyAll 方法。
D. paint - 错误。paint 通常是 Component 类的一个方法，用于组件的绘制操作，与 Runnable 接口无关。
22、以下多线程程序的设计步骤，其中错误的是（C）。
A、在主程序中创建线程对象
B、调用线程对象的 start函数来启动线程
C、在Windows中注册一个线程
D、由Thread类派生出一个线程类
解析：A. 在主程序中创建线程对象 - 正确。首先，你需要创建一个线程对象。这可以通过继承 Thread 类或实现 Runnable 接口来完成。
B. 调用线程对象的 start() 函数来启动线程 - 正确。一旦线程对象被创建，你可以调用它的 start() 方法来启动线程。这将导致线程的 run() 方法被执行。
C. 在Windows中注册一个线程 - 错误。在Java中，线程的创建和管理是由Java运行时环境处理的，而不是在操作系统级别（如Windows）注册线程。Java提供了自己的线程调度和管理机制。
D. 由 Thread 类派生出一个线程类 - 正确。你可以通过继承 Thread 类并重写其 run() 方法来创建自定义线程类。
因此，错误的步骤是 C。在Java中，不需要在操作系统中注册线程。Java的线程是由Java虚拟机（JVM）管理的。
23、对于可以随着窗口的宽度变化而改变相应的控件的位置的布局对象是（A）
A、FlowLayout B、GridLayout
C、BordyLayout D、CardLayout
解析：A. FlowLayout - 流式布局管理器按照添加组件的顺序，从左到右，从上到下排列组件。它不会随着窗口宽度的变化而改变组件的位置。
B. GridLayout - 网格布局管理器将容器分割成大小相等的矩形网格，每个组件占据一个或多个网格。它也不会随着窗口宽度的变化而改变单个组件的位置，但整体网格会随着窗口大小的变化而缩放。
C. BorderLayout - 边界布局管理器将容器分为五个区域：北、南、东、西和中心。组件可以添加到这些区域之一，但它们的位置不会随着窗口宽度的变化而动态调整。
D. CardLayout - 卡片布局管理器允许在一个容器中堆叠组件，每次只能显示一个组件，类似于一系列卡片。它允许动态地在组件之间切换，但组件的位置不会随着窗口宽度的变化而改变。
没有一个选项是完全符合“随着窗口的宽度变化而改变相应控件的位置”的描述。然而，如果考虑到动态调整控件位置的能力，FlowLayout 是最接近这个描述的，因为它允许组件在窗口宽度变化时重新排列。但是，这种排列是线性的，而不是网格状或其他复杂的布局方式。
在Swing中，要实现更复杂的动态布局，通常会使用 LayoutManager 的子类或实现自定义的布局管理器。但根据给出的选项，最合适的答案是 A、FlowLayout，尽管它可能不是完美的解决方案
24、以下关于继承的叙述正确的是（B）。
A、在Java中一个类只能实现一个接口
B、在Java中类只允许单一继承
C、在Java中一个类不能同时继承一个类或实现一个接口
D、在Java中接口只允许单一继承
解析：在Java中，继承是面向对象编程的一个基本概念，它允许一个类（称为子类或派生类）继承另一个类（称为基类或父类）的属性和方法。以下是对每个选项的分析：
A. 在Java中一个类只能实现一个接口 - 错误。Java允许一个类实现多个接口。
B. 在Java中类只允许单一继承 - 正确。Java不支持多重类继承，即一个类不能直接继承多个类。
C. 在Java中一个类不能同时继承一个类或实现一个接口 - 错误。Java允许一个类继承一个类的同时实现多个接口。
D. 在Java中接口只允许单一继承 - 错误。Java中的接口可以多继承，即一个接口可以继承多个其他接口。
因此，正确答案是 B、在Java中类只允许单一继承。这是Java语言设计的一个关键特点，它避免了多重继承可能带来的复杂性和歧义。
25、关于方法重载的说法正确的是（C）。
A、如果两个方法名字不同，参数的数量不同，那么它们可以构成方法重载
B、如果两个方法名字相同，而返回值的 数据类型不同，那么它们可以构成方法重载
C、如果两个方法名字相同，而参数的数据类型或个数不同那么它们可以构成方法重载
D、如果两个方法名字不同，参数个数相同，那么它们可以构成方法重载
方法重载是Java中允许一个类中存在多个同名方法，但它们的参数列表必须不同的特性。下面是一个简单的例子来说明方法重载的概念：
假设我们有一个名为 Calculator 的类，它提供了几个重载的 add 方法来处理不同类型的参数：
public class Calculator {
// 第一个重载的 add 方法，接受两个 int 类型的参数
public int add(int a, int b) {
return a + b;
}
// 第二个重载的 add 方法，接受三个 int 类型的参数
public int add(int a, int b, int c) {
return a + b + c;
}
// 第三个重载的 add 方法，接受两个 double 类型的参数
public double add(double a, double b) {
return a + b;
}
}
在这个例子中，Calculator 类有三个 add 方法，它们的名字相同，但是参数列表不同：
第一个 add 方法接受两个 int 类型的参数。
第二个 add 方法接受三个 int 类型的参数。
第三个 add 方法接受两个 double 类型的参数。
由于参数列表不同，Java编译器能够区分这些方法调用。当你创建 Calculator 类的实例并调用 add 方法时，你需要提供正确数量和类型的参数，编译器会根据这些信息调用相应的重载方法。
例如：
Calculator calc = new Calculator();
// 调用第一个重载的 add 方法
int sum1 = calc.add(5, 10); // 返回 15
// 调用第二个重载的 add 方法
int sum2 = calc.add(5, 10, 15); // 返回 30
// 调用第三个重载的 add 方法
double sum3 = calc.add(5.5, 10.5); // 返回 16.0
每个 add 方法调用都根据提供的参数数量和类型被正确地解析到对应的方法实现。这就是方法重载的基本概念。
26、对于构造函数，下列叙述正确的是（D）。
A、构造函数不允许重载。
B、子类无条件地继承父类地构造函数。
C、子类不允许调用父类地构造函数。
D、在同一个类中定义地重载构造函数可以相互调用
27、以下正确地描述是（B）
A、构造函数名不必和类名相同
B、一个类可以声明多个构造函数
C、构造函数可以有返回值
D、编译器可以提供一个默认的带一个参数的构造函数
解析：A. 构造函数名不必和类名相同 - 错误。构造函数的名称必须与类名完全相同，包括大小写。
B. 一个类可以声明多个构造函数 - 正确。这是方法重载的概念，类可以有多个构造函数，只要它们的参数列表不同。
C. 构造函数可以有返回值 - 错误。构造函数不能有返回类型，即使是 void 也不可以。它们的主要目的是在创建对象时初始化对象的状态。
D. 编译器可以提供一个默认的带一个参数的构造函数 - 错误。如果类中没有定义任何构造函数，编译器会提供一个无参数的默认构造函数。如果类中定义了任何构造函数，即使是无参数的，编译器就不会提供默认构造函数。
因此，正确答案是 B。
名词解释-构造函数：
构造函数是一种特殊的方法，用于在创建对象时初始化对象的状态。以下是构造函数的一些关键特性：
名称：构造函数的名称必须与类名完全相同，包括大小写。
返回类型：构造函数没有返回类型，甚至不使用 void。它们的主要目的是初始化新创建的对象。
初始化：构造函数可以初始化对象的属性，设置初始值，分配资源，或者执行其他必要的启动任务。
重载：类可以有多个构造函数，只要它们的参数列表不同。这称为构造函数的重载。
自动调用：当使用 new 关键字创建类的实例时，构造函数会自动被调用。
继承：如果子类没有定义自己的构造函数，它将继承父类的一个构造函数（通常是无参数的构造函数）。如果父类没有无参数的构造函数，子类必须通过 super 关键字显式调用一个父类的构造函数。
不能被继承：虽然子类可以调用父类的构造函数，但构造函数本身不能被子类继承。每个类都有自己的构造函数。
不能被声明为 static：构造函数不是类的方法，因此不能被声明为 static。它们的作用是初始化类的对象。
调用顺序：在Java中，如果子类构造函数中没有显式地调用父类的构造函数，Java编译器会自动插入对父类无参数构造函数的调用（super()），这发生在子类构造函数的第一行。
下面是一个简单的构造函数示例：
public class Car {
private String model;
private int year;
// 构造函数
public Car(String model, int year) {
this.model = model;
this.year = year;
}
}
在这个例子中，Car 类有两个属性：model 和 year。构造函数接受两个参数，用于初始化这些属性。当你创建 Car 类的实例时，你需要提供模型和年份，构造函数会使用这些值来初始化新创建的对象。例如：
Car myCar = new Car(“Toyota Corolla”, 2021);
这行代码创建了一个 Car 对象，并调用了 Car 类的构造函数，传递了 “Toyota Corolla” 和 2021 作为参数。
28、在使用interface（接口）声明一个接口时，只可以使用（D）修饰符修饰该接口。
A、private B、protected C、private protected D、public
解析：在Java中，接口（interface）是一种特殊的抽象类型，它不能被实例化，但可以被类实现（implement）。接口的访问修饰符限制了其他类或接口访问接口的可见性。以下是对每个选项的分析：
A. private - 错误。接口不能声明为 private，因为 private 接口只能在定义它的顶层类或接口中被访问，这限制了接口的用途。
B. protected - 错误。接口可以声明为 protected，但这同样限制了接口的可见性，只能在同一个包中的类或不同包的子类中访问。
C. private protected - 错误。这不是Java中有效的访问修饰符组合。
D. public - 正确。接口默认的访问修饰符是 public，并且通常显式地声明为 public。声明为 public 的接口可以在任何地方被访问和实现。
因此，正确答案是 D、public。接口通常被声明为 public，以确保它们可以被不同的类实现，无论这些类位于哪个包中。
29、类Myclass中有下列方法定义：
class MyClass{
public void testParams(int... arr) {
System.out.print("使用不定长参数！");
}
public void testParams(int x, int y) {
System.out.print("使用两个整型参数！");
}
}
public class Test {
public static void main(String[] args) {
int a[]={1,2,3};
MyClass x = new MyClass();
x.testParams(a);
x.testParams(0,1);
x.testParams(0,1,2);
}
}
请问上述句的输出为（B）。
A、有语义二义性；
B、使用不定长参数！使用两个整型参数！使用不定长参数！
C、使用不定长参数！使用不定长参数！使用不定长参数！
D、使用不定长参数！使用两个整型参数！使用两个整型参数！
解析：在Java中，方法重载意味着可以在同一个类中拥有多个同名方法，只要它们的参数列表不同。参数列表的不同可以是参数的数量、类型不同，或者是参数数量和类型都不同。
在给出的代码中，MyClass 类有两个重载的 testParams 方法：
第一个 testParams 方法接受一个不定长参数（varargs），使用语法 int… arr 表示。
第二个 testParams 方法接受两个 int 类型的参数。
当调用 testParams 方法时，编译器会根据传递的参数数量和类型来确定调用哪个重载方法。
在 Test 类的 main 方法中，有三次调用 testParams：
x.testParams(a); 这里 a 是一个数组，传递给接受不定长参数的 testParams 方法，因为数组可以作为不定长参数的替代。
x.testParams(0,1); 这里传递了两个整型参数，匹配第二个 testParams 方法。
x.testParams(0,1,2); 这里传递了三个参数，根据Java的varargs语法规则，当传递的参数数量超过方法定义的固定参数数量时，多余的参数会被视为不定长参数数组的一部分。因此，这将调用第一个 testParams 方法。
所以，程序的输出将是：
使用不定长参数！使用两个整型参数！使用不定长参数！
30、 在JAVA中，com包中某类的方法使用下列（B）访问修饰符修饰后，可以被com.db包中的子类访问，但不能被com.db中其他类访问。
A、private
B、protected
C、public
D、friendly
解析：在Java中，访问修饰符控制了类、接口、方法和变量的可见性。以下是对每个选项的分析：
A. private - 错误。private 修饰的成员只能在定义它的类内部访问，不能被同一个包中的其他类或子类访问。
B. protected - 正确。protected 修饰的成员可以被同一个包中的其他类访问，也可以被不同包中的子类访问。但是，不能被不同包中的非子类访问。
C. public - 错误。public 修饰的成员可以被任何其他类访问，没有限制。
D. friendly - 错误。Java中没有 friendly 这个访问修饰符。
因此，正确答案是 B、protected。使用 protected 访问修饰符，可以确保 com 包中的类的方法可以被子类（即使子类在不同的包中，如 com.db）访问，但不能被 com.db 包中的其他非子类访问。
31、下列程序的运行结果是（D）
public static void main(String[] args) {
int[] num = new int[]{1,2,3,4,5};
ArrayList arr = new ArrayList();
for(int i = 0 ; i<num.length ; i++){
arr.add(num[i]);
}
arr.remove(2);
System.out.println(arr.get(2));
}
A. 1 B. 2 C. 3 D.4
32、一个异常对象可以由Java虚拟机抛出，也可以由程序主动抛出。Java提供给程序主动抛出异常的语句是（C）。
A、catch B、throws C、throw D、try
只能死记硬背，貌似这题没有别的办法
33、JFrame缺省搭配是什么布局管理器（A），Jpanel默认的 布局管理器是（D）？
A、边界布局管理器
B、盒式布局管理器
C、表格型布局管理器
D、流式布局管理器
JF 边界 JP 流式
34、下列哪一个容器不属于顶级容器（C）。
A、Frame B、JDialog C、JPanel D、Applet
死记硬背
35、以下哪条语句可以将面板的布局管理器设置为网格式布局（B）：
A. setLayoutManager(new GridLayout());
B. setLayout(new GridLayout(2,2));
C. setGridLayout(2,2);
D.setBorderLayout();
解析：在Java的Swing图形用户界面编程中，GridLayout 类是用来创建网格布局管理器的。以下是对每个选项的分析：
A. setLayoutManager(new GridLayout()); - 这个语句创建了一个新的 GridLayout 对象，但没有指定行数和列数，因此它将创建一个默认的网格布局，其中所有组件都会放在一个单一的行和列中。
B. setLayout(new GridLayout(2,2)); - 这个语句正确地创建了一个具有指定行数和列数的网格布局管理器，这里是2行2列。这是设置面板为网格式布局的正确方式。
C. setGridLayout(2,2); - 这个语句是错误的，因为 setGridLayout 方法不存在。正确的方法是 setLayout，它接受一个布局管理器作为参数。
D. setBorderLayout(); - 这个语句是错误的，因为它尝试调用一个不存在的方法 setBorderLayout。正确的方法应该是 setLayout，并且需要传递一个 BorderLayout 对象作为参数。
因此，正确答案是 B. setLayout(new GridLayout(2,2));。这条语句将面板的布局管理器设置为2行2列的网格式布局。
36、要实现集合中里的元素进行自定义排序，要实现哪个接口（B）。
A. Serializable（可序列化） B. Comparator（比较器） C. Runnable（可运行的） D. Cloneable（可克隆的）
只要看这些单词的意思就行了，比较器说明他会将元素进行比较再排序所以肯定选B
37、如果希望一个类不能被继承，应该用下面的（A）关键字定义类。
A. final B. static C.abstract D. protected
这题我在课上听到过，所以我是会做的
38、如果希望一个方法不能被重写，应该用下面的（A）关键字定义方法。
A. final B. static C.abstract D. protected
39、下面类中属于字节输入抽象类的 是（C)，属于字符输入抽象类的是（D）。
A、FileInputStream B、ObjectInputStream C、InputStream D、Reader
40、下面（A）事件监听器是用来处理动作事件的，（B）事件监听器是用来处理键盘时间的，（C）事件监听器是用来处理鼠标时间的。
A、ActionListener B、KeyListener C、MouseListener D、WindowListener
这题也是的，看看单词的意思就很容易做出来了
41、写出下面表达式的 执行结果：
System,out.println(“1”+”2”); //12
System,out.println(“1”+ 2); //12
System,out.println(1+2+”a”); //3a
System,out.println(“a”+1+2); //a12
System,out.println(‘a’+2);; //99
System,out.println(1+2); //3
42、写出下面的表达式a≤x≤b a<=x && x <= b
非常简单的操作，和c语言一样的
43、在默认情况下，equals方法是比较两个对象的地址是否相等，如果要比较两个对象的 属性是否相等，应该重写（equals）方法。
44、下面程序运行后，i的值为（0）
int a = 50, i =0;
if(a>60) , i=1;
if(a>70) , i=2;
if(a>80) , i=3;
if(a>90) , i=4;
纯纯送分题，走人。
45、下面程序运行后，i的值为（1）
int a=75,i=0;
if(a>60);
i=1;
else if(a>70)
i=2;
else if(a>80)
i=3;
else if(a>90)
i=4;
还是送分题，就是一个if的简单知识，从上往下运行程序，只要有一个分支为true，下面的分支就不会再运行了，所以这题在第一个分支就停掉了，i=1.
46、判断题：一个类文件中，有import语句，也有package语句，则（package）语句写在第一行。 //对
47、有如下程序 注：这题貌似有点难，先放一放，等会研究
class A{
public A() {
System.out.println("类A无参构造函数")：
}
public A(String s){
System.out.println("类A带有1一个参数的构造函数");
}
}
class B extends A {
public B() {
System.out.pringln("类B无参构造函数");
}
public B(String s) {
System.out.println("类B带有1个参数的构造函数");
}
}
class C extends A {
public C() {
System.out.println("类C无参构造函数");
}
public C(String s) {
super(s);
System.out.println("类C带有1个参数的构造函数");
}
}
public class Test{
public static void main(Sting[] args) {
new B();//语句1
}
}
则程序的执行结果是：
类A无参构造函数
类B无参构造函数
如果把语句1换成new B(“hello”);则运行结果为：
类A无参构造函数
类B带有1个参数的构造函数
如果把语句1换成new C(“hello”);则运行结果为：
类A带有1个参数的构造函数
类C带有1个参数的构造函数
48、下面程序的运行结果是（7）。
public static void main(String[] args) {
int a=2;
switch(a){
case 1:
a+=1;
break;
case 2:
a+=2;
case 3:
a+=3;
break
}
System,out.println(a);
}
解析：因为a的初始值是2，所以执行case 2，2+2=4，由于case2不存在break语句，所以继续运行case 3，4+3等于7，所以最终的结果是7。
49、
for(int i = 1;i<=3;i++){
if(i==2)
return;
System.out.println("i="+i);
}
System.out.println("hello");
上面程序的运行 结果是（i=1)
如果把return换成break，则程序的运行结果是（i=1 hello）
如果把return换成continue，则程序的运行结果是（i=1 i=3 hello)
编程题
50、定义个抽象类Student，通过Student类的基础上派生出小学生类Pupil，要求：
1）Student 类有学号啥图ID（string）和姓名stuName（string）；
2）Student类提供抽象方法totalScore（）来获得学生的总成绩；
3）Pupil类还有语文chinese（double）和数学math（double）这两门课的成绩；
4）体现字段的封装性；
5）通过构造方法对所有字段赋值，通过重写toString（）方法显示字段的值；
6）并提供Test类进行测试，测试时使用自己的学号和姓名。
abstract class Student {
private String stuID;
private String stuName;
public String getStuID() {
return stuID;
}
public void setStuID(String stuID) {
this.stuID = stuID;
}
public String getStuName() {
return stuName;
}
public void setStuName(String stuName) {
this.stuName = stuName;
}
public Student(){
}
public Student(String stuID, String stuName) {
setStuID(stuID);
setStuName(stuName);
}
public abstract double totalScore();
@Override
public String toString() {
return "stuID=" + stuID+", stuName=" + stuName;"
}
}
class Pupil extends Student {
private double chinese, math;
public double getChinese() {
return chinese;
}
public void setChinese(double chinese) {
this.chinese =chinese;
}
public double getMath() {
return math;
}
public void setMath(double math) {
this.math = math;
}
public Pupil() {
}
public Pupil(String stuID, String stuName, double chinese ,double math){
super(stuID,stuName);
setChinese(chinese);
setMath(math)；
}
@Override
public double totalScore(){
return this.chinese + this.math;
}
@Override
public String toString() {
return super.toString()+"chinese="+chinese+",math="+math;
}
}
class Test {
public static void main(String[] args) {
Student student = new Pupil("1001","jack",90,95);
System.out.println(student+",totalScore="+student.totalScore());
}
}
51、假设售票厅有3个窗口（窗口A，窗口B，窗口C），可以发售某日某列车的20张车票，请用3个线程模拟这3个窗口的售票情况，需要保证不能售出同号车票，输出各个售票点的售票情况（要求：提供Test类，测试并显示各个售票窗口的售票情况。
public class Test5 {
public static void main(String[] args) {
TicketWindow tw = new TicketWindow();
new Thread(tw,"窗口A").start();
new Thread(tw,"窗口B").start();
new Thread(tw,"窗口C").start();
}
}
class TicketWindow implements Runnable {
private static int ticketNumber = 20;
@Override
public void run() {
while (true) {
synchronized(this) {
if(ticketNumber>0) {
Thread thread = Thread.currentThread();
String threadName = thread.getName();
System.out.println(threadName + "正在售出第" + (ticketNumber--)+ "张票");
}else{
break;
}
try{
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
52、求100之内的素数
public class PrimeNumber {
public static void main(String[] args) {
for(int m=2;m<=100;m++)
{
boolean flag=true;
for(int i=2;i<=m-1;i++){
if(m%i==0)
{
flag=false;
break;
}
}
if(flag==true)
{
System.out.println(m);
}
}
}
}
53、求两个数的最大公约数
public class gongyueshu {
public static void main(String[] args) {
int a=100,b=28,r;
r=a%b;
while( r!=0) {
a=b;
b=r;
r=a%b;
}
System.out.println(b);
}
}
54、定义一个教师类Teacher，包含如下属性：工号（private String id)、姓名（private String name)、薪水(private int salary)。
创建若干个教师类的对象，将其加入List集合中。将教师对象按照如下规则输出：
1）按照薪水从大到小排列;
2)若薪水相同，按照姓名字典从A-Z，a-z排列；
3)若前面的属性均相同，按照工号从小到大顺序。
public class Teacher {
private String id,name;
int salary;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name=name;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public Teacher(String id,String name,int salary) {
super();
this.id = id;
this.name = name;
this.salary = salary;
}
@Override
public String toString() {
return "id=" + id + ",name=" + name+ ",salary=" + salary;
}
}
import java.util.ArrayList;
import java.util.Comparator;
public class Test {
public static void main(String[] args) {
ArrayList<Teacher>list=new ArrayList<Teacher>();
list.add(new Teacher("1001","Caoyue",6900));
list.add(new Teacher("1002","zhansa",8900));
list.add(new Teacher("1003","wangli",9000));
list.add(new Teacher("1004","Katefd",8900));
list.add(new Teacher("1005","Caoyue",6900));
list.sort(new Comparator<Teacher>(){
@Override
public int compare(Teacher o1,Teacher o2){
if(o1.getSalary()!=o2.getSalary())
return o2.getSalary()-o1.getSalary();
else if(!(o1.getName().equals(o2.getName())))
return o1.getName().compareTo(o2.getName());
else{
return o1.getId().compareTo(o2.getId());
}
}
});
for (Teacher teacher:list) {
System.out.println(teacher);
}
}
}
55、定义个抽象类Shape，再构造派生类Circle，要求：
1）在Shape类中有形状的名称name（string）；
2）在Shape类中提供抽象方法area（），用来输出不同图形的面积。
3）Circle类中增加字段圆的半径r（double）；
4）体现字段的封装性；
5）通过构造方法对所有字段赋值；
6）通过构造方法对所有字段赋值，通过重写toSring（）方法显示图形的名称和图形的面积。
7）并提供Test类进行测试。
abstract class Shap {
String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Shap() {
}
public Shap(String name){
setName(name);
}
@Override
public String toString() {
return "Shap [name="+ name + "]";
}
public abstract double area();
}
class Circle extends Shap{
double r;
public double getR() {
return r;
}
public void setR(double r) {
this.r = r;
}
public Circle() {
}
public Circle(String name, double r) {
super(name);
setR(r);
}
@Override
public String toString() {
return super.toString()+" [r=" + r + "]";
}
@Override
public double area() {
return 3.14*r*r;
}
}
public class Test {
public static void main(String[] args) {
Shap shap = new Circle("circle",4);
System.out.println(shap);
System.out.println("面积为："+shap.area());
}
}
56、题目要求：
1）新建类WriteDemo从键盘上输入自己的学号，姓名，保存到src目录下的myinfo.config文件中，文件内容参考格式如下：
id=*** （你的学号）
name=*** （你的姓名首字母速写）
2）新建类ReadDemo，从键盘上输入id和name，读取学号和姓名，并显示出来。
import java.util.Scanner;
import java.io.FileWriter;
import java.io.IOException;
public class WriteDemo {
public static void main(String[] args) throws IOException {
Scanner in =new Scanner(System.in);
System.out.print("请输入学号：");
String id = in.nextLine();
System.out.print("请输入姓名：");
String name = in.nextLine();
FileWriter fw = new FileWriter("src/myInfo.config");
fw.write("id="+id);
fw.write('\n');
fw.write("name="+name);
fw.close();
}
}
import java.io.IOException;
import java.io.FileReader;
import java.util.Properties;
public class ReadDemo {
public static void main(String[] args) throws IOException{
Properties properties = new Properties();
properties.load(new FileReader("src/myInfo.config"));
String id=properties.getProperty("id");
String name=properties.getProperty("name");
System.out.println("学号="+id+",姓名="+name);
}
}
57、编写一个类Student，要求：
1）在Student类中，包含私有字段(String name， int age);
2）体现字段的封装
3）提供构造方法，对字段赋值
4）重写toString方法 ，输出学生的信息
5）重写equals方法，比较两个对象的内容是否相等（name和age是否相等）
public class Student {
private String name;
private int age;
public String getNmae(){
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge(){
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student() {
}
public Student(String name, int age) {
setName(name);
setAge(age);
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
@Override
public boolean equals(Object obj) {
if(this == obj)
return true;
if(obj instanceof Student) {
Student student = (Student) obj;
return this.name.equals(student.name) && this.age == student.age;
}
return false;
}
}
public class Test {
public static void main(String[] args) {
Student stu1 = new Student("zs", 18);
Student stu2 = new Student("zs", 18);
System.out.println(stu1.equals(stu2));
Student stu3 = new Student("zs", 18);
Student stu4 = new Student("ls", 18);
System.out.println(stu3.equals(stu4));
}
}