[Java知识库]Java复习

判断题

1.java

1. 编译当前路径下的HelloWorld.java文件，使用的命令是：javac HelloWorld.java 。T
2. 运行类路径下的HelloWorld.class文件，使用的命令是：java HelloWorld.class 。F

正确命令是：java HelloWorld。

3. Java虚拟机可以将类文件（.class）在不同的操作系统上运行，从而实现跨平台特性。T
4. 一个Java源文件的名称可以随便取，不受任何限制。F

Java 程序源文件的命名不是随意的，Java 文件的命名必须满足如下规则。
1、Java 程序源文件的后缀必须是 .java，不能是其他文件后缀名。
2、如果 Java 程序源代码里定义了一个 public 类，则该源文件的主文件名必须与该 public 类（也就是该类定义使用了 public 关键字修饰）的类名相同。
3、如果 Java 程序源代码里没有定义任何 public 类，那么 Java 程序源程序的主文件名可以是任意的。
由于 Java 程序源文件的文件名必须与 public 类的类名相同，因此，一个 Java 源文件虽然包含多个类定义，但最多只能定义一个 public 类。
推荐：

1. 一个 Java 源文件只定义一个类，不同的类使用不同的源文件定义。
2. 让 Java 源文件的主文件名与该源文件中定义 的 public 类同名。

5. 一个Java源文件中可以有多个类，但只能有一个类是public的。T
6. 在Windows操作系统和Linux操作系统运行的JAVA虚拟机没有什么差别。F

JAVA虚拟机：虚拟机指通过软件模拟的具有完整硬件系统功能的、运行在一个完全隔离环境中的完整计算机系统。java虚拟机是软件模拟的计算机可以在任何处理器上安全并且兼容的执行保存在.class文件中的字节码。

2.编程基础

1. 一个数组可以存放不同类型的数值。（ F ）

数组本身定义就是用来存放相同类型的集合。
Object[] objs可以存放所有类型的Object，但是此时都是作为Object类型存入的，所以不能说是不同类型。

2. 程序运行中可以改变数组的大小。（ F ）

数组一旦生成后，数组的大小在运行之中就无法改变

3. Java允许创建不规则数组，即Java多维数组中各行的列数可以不同。（ T ）
4. Java语言中不用区分字母的大写小写。（ F ）
5. Java中，boolean基本类型的变量取值为0、1，也可取值true或false。（ F ）

boolean 只能取值true、和false。

6. Java基本数据类型的变量所占存储空间大小是固定的，与平台（操作系统）无关。这样方便程序的移植。（ T ）
7. 在Java中，&&、||和 &、|都表示逻辑的与、或运算，二者使用起来没有什么差异。( F )

&：按位与，也叫逻辑与。必须两个语句都判断完毕才判断是否对错。
&&：短路与。两个语句中只要第一个不符合条件，就会直接标错，跳出判断。
|：逻辑或，必须两个语句都判断完毕才判断是否至少有一个是对的。
||：短路或，是两个语句中只要第一个符合条件，就会直接标对，跳出判断。

8. 在如下代码中，两个变量str和i都是基本数据类型的变量。（ F ）

String str="sdutcs”; 
int i =100;

基本数据（8种）：byte（位）、short（短整数）、int（整数）、long（长整数）、float（单精度）、double（双精度）、char（字符）和boolean（布尔值）
String是一个对象

9. Java中的switch-case分支结构中，一旦控制表达式的计算结果与某个case值匹配成功，就执行完该case对应的语句块，即结束switch-case语句。（ F ）

会继续执行后面的case模块，直到遇到break或者switch-case正常结束

10. 使用break语句可以跳出一次循环。（ F ）

break会直接终止循环，continue则可以跳过一次循环，执行下一次循环

11. Java中continue语句的作用是结束本次循环，开始下一次循环。（ T ）
12. Java中数组的元素只能是简单数据类型。（ F ）

数组也可以是Object类型

13. 数组作为方法的参数时，必须加在数组名后加方括号。（ T ）
14. 数组中有length()这个方法，如array.length()表示数组array中元素的个数（ F ）

array.length的功能是获取数组array的长度，返回的是数组的长度，而不是数组的实际有效大小。

15. 制造（new）数组时，要指定数组长度，以便为数组分配内存。（ T ）

3.类与对象

1. package语句必须放到java程序的最开始。（ T ）
2. 类及其属性、方法可以同时有一个以上的修饰符来修饰。（ T ）
3. 在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对象程序的特性称为重载。（ T ）
4. 在实例方法或构造器中，this用来引用当前对象，通过使用this可引用当前对象的任何成员。（ T ）
5. 有的类定义时可以不定义构造函数，所以构造函数不是必需的。（ F ）

不定义构造函数的话，编译器会使用默认构造函数，并不代表构造函数不存在。

6. 非静态的成员变量（实例变量）能被静态方法（类方法）和非静态方法（实例方法）所直接使用。( F )

关键字static修饰的方法称为静态方法。
访问变量:
非静态方法可以访问类中的任何成员
静态方法只能访问静态成员
被调用区别:
非静态方法必须由实例对象来调用
静态方法除了可由实例对象调用外，还可以由类名直接调用。
super,this:
非静态方法中可以使用super、this关键字
静态方法中不能使用super、this关键字

7. 实例变量只能通过对象名访问，类变量既可以通过某个对象名也可以通过类名来访问。( T )
8. 实例变量是属于对象的。一个类的多个对象对实例变量可以设置不同的值。( T )
9. 有如下类的定义：

public class Rectangle {   
 public Rectangle(int l) {  //构造方法1
  if (l > 0) {
   w = l;
   h = l;
  }
 }
 public Rectangle(int w1, int h1) {  //构造方法2
  if (w1 > 0 && h1 > 0) {
   w = w1;
   h = h1;
  }
 }
}

下面使用Rectangle类创建一个对象，是否正确？( F )
Rectangle rect=new Rectangle();

因为有了自定义构造函数，所以就不会生成默认的构造函数，所以构造函数时，必须有1个参数或者2个参数。

10. 在定义一个类的时候，如果类的成员被private所修饰，该成员不能在类的外部被直接访问。（ T ）

属性	Class	Package	Subclass	World
public公共属性	Yes	Yes	Yes	Yes
protected保护属性	Yes	Yes	Yes	No
no modifier默认属性	Yes	Yes	No	No
private私有属性	Yes	No	No	No

class：类本身是否有权访问由级别定义的成员。一个类，总是有权访问自己的成员变量。
Package：表示该类（不管其父级），相同的包中类是否具由对成员的访问权限
Subclass：在此包外部声明的该类的子类是否有权访问成员。
World：是否所有类都具有对成员的访问权限

4.继承与多态

1. 如果一个类的声明中没有使用extends关键字，这个类被系统默认为是继承Object类。（ T ）

使用关键字extends来声明一个类的子类
格式：class 子类名 extends 父类名{
}
Object是java.lang包中的类。

2. 覆盖只能在不同的类中完成。（ T ）

在类继承中，子类可以修改从父类继承来的方法，即子类可以创建一个与父类方法有不同功能的方法，但具有相同的名称、返回值类型、参数列表。
如果在新类中定义一个方法，其名称、返回值类型和参数列表正好与父类中的相同，那么，新方法被称做覆盖旧方法。
参数列表又叫参数签名，包括参数的类型、参数的个数和参数的顺序，只要有一个不同就叫做参数列表不同。
被覆盖的方法在子类中只能通过super调用。覆盖不会删除父类中的方法，而是对子类的实例隐藏，暂时不使用。
方法覆盖的原则：

1. 覆盖方法的返回类型、方法名称、参数列表必须与原方法的相同。
2. 覆盖方法不能比原方法访问性差（即访问权限不允许缩小）。
3. 覆盖方法不能比原方法抛出更多的异常。
4. 被覆盖的方法不能是final类型，因为final修饰的方法是无法覆盖的。
5. 被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
6. 被覆盖的方法不能为static。如果父类中的方法为静态的，而子类中的方法不是静态的，但是两个方法除了这一点外其他都满足覆盖条件，那么会发生编译错误；反之亦然。即使父类和子类中的方法都是静态的，并且满足覆盖条件，但是仍然不会发生覆盖，因为静态方法是在编译的时候把静态方法和类的引用类型进行匹配。

3. 可以使用protected修饰符来防止方法和数据被不同包的非子类访问。（ T ）

访问权限	private（私有）	friendly（默认）	protected（保护）	public（公共）
同一个类中	可	可	可	可
同一个包的不同类	不可	可	可	可
不同包的子类	不可	不可	可	可
不同包的非子类	不可	不可	不可	可

4. 子类不继承父类的构造方法。（ T ）

1. 子类不能继承父类的构造函数，但是可以调用父类的构造函数super()
2. 先调用父亲的构造方法，然后再执行子类的构造方法
3. 父类有有参构造函数，则子类必须在自己的构造函数中显示的调用父类的构造函数即super
4. 子类的某个构造函数想要调用父类的其他带参构造函数，在构造函数第一行添加super(args1,args2…)
   注意：方法是没有继承一说的，只有覆写或者重载，类和类之间才能叫继承。

5. 可以覆盖在父类中定义的私有方法。（F）

私有方法只有在同一个类中才可使用，无法被子类继承

6. 在方法重写时，子类方法不能比父类方法的访问权限更严格。（T）
7. 一个Java类可以有多个父类，这称作多继承。（F）

Java只支持单继承，Python支持多继承

8. 在程序中this和super调用构造方法时可以同时出现。（ F）

Java语言规定，在执行该类构造前必须先执行父类的构造，直到Object类的构造
简单解释:构造函数中调用其他构造函数的代码要写在第一行，如果同时写super()和this()，两个语句都需要放在第一行，这样冲突
原理解释:

1. 如果显式调用了构造函数（无论是父类还是子类的构造函数），则只按顺序执行被调用的构造函数
2. 如果没有显式调用构造函数，则程序在运行时会自动在构造函数的第一行加上调用父类无参构造函数（上一条的情况就不会加），一直向上调用到Object的构造函数为止

即无论有没有super,都会执行父类的构造,而this在构造本身的同时,也需要先构造父类,所以此时父类的构造行为发生在代码的第二行,所以不能用
所以:
this()和super()不能同时出现在构造函数中
super作为父类、this作为子类的代指时可以同时出现

9. 子类对象不能访问父类的私有成员变量，因此也没有任何办法可以修改父类的私有成员变量。(F)

子类可以继承父类所有的成员变量和函数,虽然子类能继承父类的私有成员变量,但是不能直接访问父类的私有成员变量,但是可以通过父类的public类型的成员函数来访问父类的私有成员变量

10. final声明的类可以有子类。(F)

final方法：
不允许任何从此类继承的类来覆写这个方法，继承仍然可以继承这个方法
final类：
一个final类是无法被任何人继承的，那也就意味着此类在一个继承树中是一个叶子类
final类中的成员，你可以定义其为final，也可以不是final。
对于方法，由于所属类为final的关系，自然也就成了final型的

11. 子类和父类必须在一个包中。（F）

子类和父类不一定在一个包内

12. 使用类的继承，目的是把多种对象间的共同的属性和共同行为抽取到父类中，因此子类对象和父类的关系表示是is-a的关系。（T）
13. 所谓上转型，是指可以将父类的一个实例赋给子类的引用。（ F）

向上转型：用父类的引用变量去引用子类的实例
当向上转型之后，父类引用变量可以访问子类中属于父类的属性和方法，但是不能访问子类独有的属性和方法。
向下转型：只有当这个对象原本就是子类对象通过向上转型得到的时候才能够成功转型。

14. 抽象类能实例化一个对象。如：
    abstract class A(){}
    可以调用如下语句创建对象a:A a=new A(); (F)

抽象类不能实例化！
抽象类不能直接通过new去实例化一个对象，那它就是不能实例化，要获取抽象类的对象， 需要先用一个类继承抽象类， 然后去实例化子类。也可以用匿名内部类，在抽象类中创建一个匿名的子类，继承抽象类，通过特殊的语法实例化子类的对象 。
抽象类：

1. 普通类是一个完善的功能类，可以直接产生实例化对象，并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。
2. 所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰。
3. 拥有抽象方法的类就是抽象类，抽象类要使用abstract关键字声明。

抽象类的使用方法：

1. 抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public；
2. 抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；
3. 抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；
4. 子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）；
5. 抽象类继承子类里面有明确的方法覆写要求，而普通类可以有选择性的来决定是否需要覆写；
6. 抽象类实际上就比普通类多了一些抽象方法而已，其他组成部分和普通类完全一样
7. 普通类对象可以直接实例化，但抽象类的对象必须经过向上转型之后才可以得到。

使用限制：

1. 由于抽象类里会存在一些属性，那么抽象类中一定存在构造方法，其存在目的是为了属性的初始化。
2. 抽象类不可以用final声明，因为抽象类必须有子类，而final定义的类不能有子类；
3. 外部抽象类不允许使用static声明，而内部的抽象类运行使用static声明。使用static声明的内部抽象类相当于一个外部抽象类，继承的时候使用“外部类.内部类”的形式表示类名称。
4. 可以直接调用抽象类中用static声明的方法
5. 由于抽象类中只需要一个特定的系统子类操作，所以可以忽略掉外部子类。

15. 抽象方法必须定义在抽象类中，所以抽象类中的方法都是抽象方法。（ F）

抽象类中，有抽象方法，也有普通方法，还有构造方法。

5.接口与实现

1. 类在实现接口方法时必须给出方法体，并且一定要用public来修饰。（ T ）
2. 一个Java源文件就是由类和接口组成的。（ T ）
3. 如果一个类声明实现一个接口，但没有实现接口中的所有方法，那么这个类必须是abstract类。（ T ）

子类是非抽象类，则必须实现接口中的所有方法；
子类是抽象类，则可以不实现接口中的所有方法，因为抽象类中允许有抽象方法的存在！

4. 一个接口可以继承其他接口。（T）
5. 接口中的属性，都是静态常量。(T)

接口的成员特点：
1:成员变量 只能是常量。默认修饰符 public static final
2:成员方法 只能是抽象方法。默认修饰符 public abstract
成员属性最终都是公共静态常量

6. 接口是特殊的类型，所以接口也可以继承，子接口将继承父接口的所有常量和抽象方法。( T )

java中的接口是一种特殊的抽象类，接口里面的所有方法都是抽象方法，接口里面的所有属性都是常量

7. 为了克服单继承的缺点，Java使用了接口，一个类可以实现多个接口。( T )

6.异常处理

1. 异常也是一个对象。（T）
2. 用户可以自定义自己的异常类。（T）
3. 可以使用throws语句来指明方法有异常抛出。（T）

throws:

1. 跟在方法声明后面，后面跟的是异常类名
2. 可以跟多个异常类名，用逗号隔开
3. 表示抛出异常，由该方法的调用者来处理
4. throws表示有出现异常的可能性，并不一定出现这些异常

throw:

1. 用在方法体内，后面跟的是异常类对象名
2. 只能抛出一个异常对象名
3. 表示抛出异常，由该方法体内的语句来处理
4. throw则是抛出了异常，执行throw一定出现了某种异常

4. 程序运行时所产生的系统定义的异常将自动被抛出。（T）
5. Java程序执行时出现异常，也不一定是程序本身的错。（T）
6. 一个异常处理中fianlly语句块只能有一个或者可以没有。（T）
7. Java语言中所有异常类都是java.lang.Throwable的子类。（T）
8. 在异常处理中，若try中的代码可能产生多种异常则可以对应多个catch语句，若catch中的参数类型有父类子类关系，此时应该将父类放在前面，子类放在后面。（F）

catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓，如果异常类型满足子父类的关系，则要求子类一定要声明在父类的上面，否则报错。

9. 一个异常处理中 finally语句块可以不出现，也可以出现一次。（T）
10. 非运行时异常（受检异常或编译异常），指的是RuntimeException以外的异常，如：IOException、SQLException等以及用户自定义的Exception异常，类型上属于Exception类及其子类。从语法上是必须进行处理的异常，需要使用try-catch（try-catch-finally）结构进行处理或者利用throws向上层抛出。如果不处理，程序就不能编译通过。（T）

异常：在Java语言中， 将程序执行中发生的不正常情况称为“异常” 。
异常事件可分为两类：

1. Error： Java虚拟机无法解决的严重问题。 如： JVM系统内部错误、 资源耗尽等严重情况。
   比如： StackOverflowError和OOM。 一般不编写针对性的代码进行处理。
2. Exception: 其它因编程错误或偶然的外在因素导致的一般性问题， 可以使用针对性的代码进行处理。 例如：
   1. 空指针访问
   2. 试图读取不存在的文件
   3. 网络连接中断
   4. 数组角标越界

两种解决方法：

1. 遇到错误就终止程序的运行。
2. 由程序员在编写程序时， 就考虑到错误的检测、 错误消息的提示， 以及错误的处理。

异常处理机制

1. try-catch-finally
2. throws + 异常类型
   
   try
   用try{…}语句块选定捕获异常的范围,将可能出现异常的代码放在try语句块中try中的异常对象匹配到某一个catch时，就进入catch中进行异常处理，一旦处理完成就跳出当前的try-catch结构（在没有写finally的情况下）。继续执行其后的代码。在try结构中声明的变量，出了try结构之后，就不能被调用。
   catch (Exceptiontype e)
   catch (Exceptiontype e)。每个try语句块可以伴随一个或多个catch语句， 用于处理可能产生的不同类型的异常对象。catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓，如果异常类型满足子父类的关系，则要求子类一定要声明在父类的上面，否则报错。
   finally
   1. 捕获异常的最后一步是通过finally语句为异常处理提供一个统一的出口，使得在控制流转到程序的其它部分以前，能够对程序的状态作统一的管理。
   2. 不论在try代码块中是否发生了异常事件， catch语句是否执行， catch语句是否有异常， catch语句中是否有return，finally块中的语句都会被执行。
   3. finaly中声明的是一定会被执行的代码，即使catch中出现了异常，try中有return语句，catch中有return语句等情况。
   4. finally语句和catch语句是任选的。

用户自定义异常类
1. 一般，用户自定义异常类都是RuntimeException的子类。
2. 自定义异常类通常需要编写几个重载的构造器。
3. 自定义异常需要提供全局常量：serialVersionUID
4. 自定义的异常通过throw抛出。
5. 自定义异常最重要的是异常类的名字，当异常出现时，可以根据名字判断异常类型。

7.常用类

1. 设String对象s="Hello “，运行语句System.out.println(s.concat(“World!”));后String对象s的内容为"Hello world!”，所以语句输出为Hello world!。（F）

s.concat(“World!”)会返回"Hello World!",但无法改变s的内容，所以s的内容还是"Hello "

String表示字符串，引用数据类型，用双引号括起来的都是String对象
String类之间的比较用String.equals
CharSequence
描述字符串结构的接口，在这个接口里面一般发现有三种常用的子类：String、StringBuffer、StringBuilder
常用方法：

方法名	作用
char charAt(int index)	返回指定位置的字符
int compareTo(String str)	比较两个字符串。相等返回0；前大后小返回1；前小后大返回-1
boolean contains(CharSequence s)	判断字符串是否包含s
boolean endsWith(String str)	判断字符串是否以str结尾
boolean equals(Object obj)	判断两个串是否相等
boolean equalsIgnoreCase(String str)	忽略大小写判断两个串是否相等
byte[] getBytes()	将字符串串变成字节数组返回
int indexOf(String str)	返回str在字符串第一次出现的位置
boolean isEmpty()	字符串是否为空
int length()	字符串长度
int lastIndexOf(String str)	返回str最后一次出现的位置
String replace(CharSequence str1, CharSequence str2)	用str2替换字符串str1的字符
String[] split(String str)	将字符串以str分割
boolean startsWith(String str)	判断字符串是否以str开始
String substring(int index)	从index开始截取字串
String substring(int statr, int end)	截取statr到end- 1的字符串
char[] toCharArray()	将字符串转换乘char数组
String toLowerCase()	字符串转小写
String toUpperCase()	字符串转大写
String trim()	去除字符串两边空格
concat()	连接两个或更多字符串，并返回新的字符串。
静态方法	作用
static String valueOf(int i)	将 i 转换成字符串

2. String对象可以使用==进行内容的比较。(F)

使用equals方法进行比较，==会判断两个变量的地址

3. String实例一旦创建完毕，就不能再修改其内容。（T）
4. 利于Scanner类的对象进行输入字符串时，使用next()或者nextLine()方法都能取得字符串，二者没有什么差别。（F）

nextLine的输入会忽略空格，遇到回车结束输入

5. java.lang.Math类是一个最终类。其中包含许多用来进行科学计算的类方法和常量，它们都是Math类的静态成员。（T）

8. 组件与事件处理

1. JPanel的缺省布局管理器是FlowLayout。(T)
2. 事件适配器应用的目的就是避免让程序员去实现接口中的每一个抽象方法，而只需要实现自己所需要的方法。(T)
3. 内部类被定义于某一个类内部的类，往往应用在Java的事件处理过程中。(T)
4. 匿名类是定义于某个方法内部，且没有名称的类，匿名类是一种创建事件监视器类的有效方法。(T)

选择题

1.java

1. 关于Java语言的描述，错误的是（ A ）。
   A. 每一个.java文件编译后对应一个.class文件。
   B. .java文件编译后，每一个class对应一个.class文件
   C. Java源代码编译后产生的.class是字节码文件
   D. .class文件在JVM上运行

如果这个.java文件内包含多个类，那么就会生成多个.class文件

2. 某Java源文件代码如下，该源文件应如何命名？（ D ）

class A {
int a;
}
class B {
  int b;
}
class C {
   public static void main(String[] args) {
       System.out.print("HELLO!");
   } 
}

A. 一定是A.java
B.一定是B.java
C.一定是C.java
D.后缀是.java，文件名可以任意取，符合标识符规范即可。

因为代码里面没有public类，所以对于类的文件名可以任意取，符合标识符规范即可。

3. 下面不属于Java语言特点的是：( C )。
   A.平台无关
   B.面向对象
   C.支持指针类型
   D.垃圾回收机制

C：C、C++支持指针类型，JAVA并不支持
JAVA语言的特点：

1. 简单性：不使用指针，并提供了垃圾回收机制
2. 跨平台性：java自带虚拟机实现了跨平台性，不受计算机硬件和操作系统的约束而在任意计算机环境下都可以正常运行。
3. 面向对象：使程序的开发更加简单易用。比如具有代码扩展、代码复用等功能。
4. 安全：因为指针和内存等功能删除，避免了非法内存操作。当Java用来创建浏览器时，语言功能和浏览器本身提供的功能结合起来，使它更安全。
5. 多线程：允许一个应用程序同时存在两个或两个以上的线程，用于支持事务并发和多任务处理。
6. 分布性：Java语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口，它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocket等。Java的RMI(远程方法激活)机制也是开发分布式应用的重要手段。
7. 可移植性：Java编译器是用Java实现的，Java的运行环境是用ANSI C实现的，另外Java还严格规定了各个基本数据类型的长度。
8. 解释性：Java解释器能直接运行目标代码指令，链接程序通常比编译程序所需资源少，所以程序员可以在创建源程序上花上更多的时间。
9. 高性能：Java可以在运行时直接将目标代码翻译成机器指令，翻译目标代码的速度与C/C++的性能没什么区别。
10. 动态性：适应于动态变化的环境，Java程序需要的类能够动态地被载入到运行环境，也可以通过网络来载入所需要的类。这也有利于软件的升级。

4. 如果JDK的安装路径为d:\jdk，若想在DOS命令窗口中任何当前路径下，都可以直接使用javac和java命令，需要将环境变量path设置为以下哪个选项？（ B ）
   A.d:\jdk;
   B.d:\jdk\bin;
   C.d:\jre\bin;
   D.d:\jre;
5. 下面关于main方法声明正确的是（ B ）。
   A.public main(String args[ ])
   B.public static void main(String args[ ])
   C.private static void main(String args[ ])
   D.void main()
6. 下列有关Java语言的叙述中，正确的是( B )
   A.Java是不区分大小写的
   B.源文件名与public类型的类名必须相同
   C.源文件名的扩展名为.jar
   D.源文件中public类的数目不限
7. 某Java源文件代码如下，该源文件经过编译后，如何执行？( C )

public class A {
 int a;
}
class B {
 int b;
}
class C {
 public static void main(String[] args) {
  System.out.print("HELLO!");
 }
}

因为main执行函数存放在C类中，所以要通过java C来执行。

2.编程基础

1. 整型数据类型中，需要内存空间最少的是（ D ）
   A.short
   B.long
   C.int
   D.byte

byte: 8位 1字节
char: 16位 2字节
short 16位 2字节
int 32位 4字节
float: 32位 4字节
long: 64位 8字节
double: 64位 8字节
boolean: 32位 4字节,在数组中时 8位 1字节

2. 若int型变量a的值为3，则执行b=++a后，a和b的值分别为？（ B ）
   A.3,4
   B.4,4
   C.4,3
   D.3,3

b=++a,先执行++a，a从3变为4，++a结束后，返回a，此时a的值为4，然后b=a。a和b的值为4，4

3. 下面哪项不是合法的标识符？（ A ）
   A.2variable
   B.variable2
   C.what$
   D.__3

标识符不能以数字开头

4. 下面的方法，当输入为2的时候返回值是多少?（ B ）

public int getValue(int i) {
         int result = 0;
         switch (i) {
            case 1:
                result = result + i;
            case 2:
                result = result + i * 2;
            case 3:
                result = result + i * 3;
        }
        return result;
 }

A.0 B.2 C.4 D.10

输入2后，执行case2模块，result此时等于i*2，i输入为2，所以result为4。因为没有遇到break，继续执行case3模块，result又加上了i*3，所以result为10

5. 有如下程序代码，执行的结果是：( A )

public class Main {
    public static void main(String[] args) {
        int x=10,y=20,z=30;
        if(x<y)
            z=x;
        else
            x=y;
        y=z;
        System.out.println("x="+x+",y="+y+",z="+z);
    }
}

A.x=10,y=10,z=10
B.x=20,y=30,z=10
C.x=20,y=20,z=20
D.x=20,y=30,z=20

首先判断，x小于y，执行if部分，z被赋值为x，if-else模块结束。此时xyz的值是10，20，10。执行y=z语句，y的值被赋为z，然后正常输出xyz的值为10，10，10

6. 在Java中，以下程序段的输出结果是（ B ）。

 int n=9;
 while(n>6){
     n--;
     System.out.print(n);
 }

A.987
B.876
C.8765
D.9876

n为9，进入while模块，n减去1，输出n为8。此时n大于6，输出7时，n为7，输出6时，n为6，6不大于6，结束whil模块。
所以输出的内容为876

7. 下面关于数组声明和初始化的语句那个有语法错误？（ C ）
   A.int a1[]={3,4,5};
   B.String a2[]={“string1”,“string1”,“string1”};
   C.String a3[]=new String(3);
   D.int[][] a4=new int[3][3];

String a3[]=new String(3);把（3）换成[3]
数组声明：类型 数组名[] = new 类型[数组个数]

8. 下列语句会造成数组new int[10]越界是（ D ）。
   A.a[0] += 9;
   B.a[9]=10;
   C.a[9]
   D.for(int i=0;i<=10;i++) a[i]++;

在for循环中，i的值会经历从0到11，当i变为11时，会访问数组的[11]号位置，造成数据越界。

9. 若int a[][]={{123,345,334},{1,2},{3,4}}; 则 a[2][1]=（ D ）。
   A.1
   B.3
   C.2
   D.4

把a以二维数组表示：
123、345、334
1 、2
3 、4
a[2][1]代表横二纵一，从0开始数，得出结果为4

10. 执行完以下代码int[ ] x = new int[25]；后，以下哪项说明是正确的（ A ）。
    A.x[24]为0
    B.x[25]为0
    C.x[0]为空
    D.x[24]未定义

B->x数组个数为25个即从0到24，一共25个元素，x[25]属于未定义
C->x[0]为0
D->x[24]为0

3.类与对象

1. 关于被私有访问控制符private修饰的成员变量，以下说法正确的是（ C ）
   A.可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类
   B.可以被两种类访问和引用：该类本身、该类的所有子类
   C.只能被该类自身所访问和修改
   D.只能被同一个包中的类访问

详情，看上方判断题3.类与对象的第10个

2. 下面关于缺省构造方法的描述中正确的是（ A ）。
   A.当类中没有定义任何构造方法时，Java编译器将为这个类创建缺省构造方法
   B.缺省构造方法可以初始化其他方法中定义的变量
   C.Java编译器会为所有的类创建缺省构造方法。
   D.如果在一个类中定义的构造方法都声明了参数，Java编译器将为这个类创建一个缺省构造方法

Java构造方法的特点：

1. 构造方法可以被重载，一个构造方法可以通过this关键字调用另一个构造方法，this语句必须位于构造方法的第一行；
2. 方法的重载(overload)：重载构成的条件：方法的名称相同，但参数类型或参数个数不同，才能构成方法的重载。
3. 当一个类中没有定义任何构造方法，Java将自动提供一个缺省构造方法；
4. 子类通过super关键字调用父类的一个构造方法；
5. 当子类的某个构造方法没有通过super关键字调用父类的构造方法，通过这个构造方法创建子类对象时，会自动先调用父类的缺省构造方法
6. 构造方法不能被static、final、synchronized、abstract、native修饰，但可以被public、private、protected修饰；
7. 构造方法不是类的成员方法；
8. 构造方法不能被继承。

3. 为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为（ A ）。
   A.static void method( )
   B.public void method( )
   C.final void method( )
   D.abstract void method( )

静态方法不用实例化就可以调用它的成员方法

4. 已知name，age是Person类的成员属性，关于构造方法，下面哪个描述是正确的？（ D ）
   A.

public void Person(String name){
    this.name=name;
} //这是Person类中的构造方法

B.

public Person(){
    name="";
    age=10;
}
public Person(String name){
    Person();
    this.name=name;
} //这是Person类中两个构造方法

C.

public Person(String name){
    this();
    this.name=name;
} //这是Person类中唯一的构造方法

D.

public Person(){
    name="";
    age=10;
}
public Person(String name){
    this();
    this.name=name;
} //这是Person类中两个构造方法

A.不符合构造方法的书写要求，应该去掉public void
B.构造方法不是成员方法，所以B的第二个构造方法使用错误
C.中的this(),代表它含有无参构造方法
this（），this（实参）必须在构造方法的第一行
在有参数构造方法中调用无参数构造方法this（）；在无参数的构造方法中调用有参数的构造方法this（实参）

5. 一个*.java文件中可以包含多少个public类？（ A ）
   A.最多1个
   B.最少1个
   C.只能0个
   D.不限制

一个java文件可以有多个类，但只能有一个是public类

6. 对于下列Dog类，哪个叙述是错误的？（ C ）

class Dog{
	Dog(int m){ }
	Dog(double m){ }
	int Dog(int m){return 23; }
	void Dog(double m){ }
}

A.Dog(int m)和Dog(double m)是互为重载的构造方法
B.int Dog(int m)和void Dog(double m)是互为重载的非构造方法
C.Dog类有三个构造方法
D.Dog类有两个构造方法，而且没有无参的构造方法

构造方法没有函数类型，所以只有第一个和第二个是构造方法。

7. 分析如下代码：（C）

public class Test {
  private int t;
  public static void main(String[] args) {
    int x;
    System.out.println(t);
  }
}

A.变量t没有初始化，所以会引起错误。
B.变量t是私有的，因此不能在main方法中访问。
C.t是非静态的，不能在静态的main方法中引用。
D.变量x没有初始化，所以会引起错误。

在静态方法中，只能使用静态的函数和变量

8. 类ABC定义如下：

public  class  ABC{
   public int max( int  a, int  b) {   }   
   //行3
}    

将以下哪个方法插入行3是不合法的。( B )
A.public float max(float a, float b, float c){ }
B.public int max(int c, int d){ }
C.public float max(float a, float b){ }
D.private int max(int a, int b, int c){ }

Duplicate method max(int, int) in type Main
报出如上错误，表示有两个相同的方法在一个类中
B本质上和行2是一样的

9. 关于类和对象的关系，下列说法哪种说法是错误的？（ A）
   A.类和对象都是具体的。
   B.类是抽象的，对象是具体的。
   C.一般情况下，在定义类之后，能创建无数个对象，可以说，类能化身千万。
   D.类是引用型数据类型。

对象：万物皆对象，包括现实中客观存在的事物，具有状态、行为和标识。
类：具有相同特征和行为的对象组成的集合就是类，类在JAVA中是引用型数据类型
Java的数据类型只有两大类，一类是基本类型（8个基本数据类型）、其他都是引用数据类型，例如：类（class）、接口（interface）、数组（ [ ] ）

10. 已知：Student类的定义如下：

class Student{
 int age;
}

在主方法中，有如下两段程序代码A和B：

 int a;        //变量a是局部变量
 System.out.println(a);    //A段代码
------------------------------------------------------
 Student student=new Student();
 System.out.println(student.age);   //B段代码

关于A和B两段代码的合法性，说法正确的是：（ D ）。
A.都不合法
B.都合法，将输出0和0
C.A段合法，输出0；B段不合法
D.A段不合法；B段合法，输出0

在主方法内，变量都需要经过初始化或者实例化，才可以使用
当实例化对象时，会执行它的构造方法，如果类中未写他的构造方法，则会执行它的缺省构造方法，int变量赋值为0

11. 关于构造方法定义与作用，下列说法错误的是：（ C ）。
    A.用来创建类的实例时调用的方法
    B.调用该方法时，对实例变量赋值
    C.定义时，方法名称与类名相同，返回值类型可以不写，也可以写成void
    D.一个类的构造方法可以定义多个，多个构造方法的参数有明显区别。

构造方法不可以加返回值类型
构造方法：

1. 不写返回值类型
2. 名称与类名称必须完全相同
3. 不能有return
4. 自己如果没有写构造方法的话，默认存在一个空的构造方法
5. 一旦写了至少一个构造方法后，默认的空的构造方法就不存在了
6. 构造方法可以重载

12. 关于以下代码的说明，正确的是（ C ）。

class Main {
    static int x = 10;
    static {
        x += 5;
        System.out.println("x=" + x);
    }
    public static void main(String args[ ])
    {
        System.out.println("x=" + x);
    }
    static {
        x /= 3;
        System.out.println("x=" + x);
    }
}

A.不能通过编译，因为缺少方法名和返回类型
B.不能通过编译，因为只能有一个静态初始化器
C.编译通过，执行结果为：
x=15
x=5
x=5
D.编译通过，执行结果为：
x=3
x=8
x=8

首先明确Java初始化类的步骤

1. 假如这个类还没有被加载和连接, 则程序先加载并连接该类
2. 假如该类的直接父类还没有被初始化, 则先初始化其直接父类
3. 假如类中有初始化语句, 则系统依次执行这些初始化语句

静态块（static{}）

1. 优化程序性能
2. 可以放置于类中的任何地方、类中有多个static块
3. 在类初次被加载的时候执行且仅会被执行一次，会按照static块的顺序来执行每个static块，一般用来初始化静态变量和调用静态方法

所以这里，先会执行Main类中的静态块，第一步输出10+5->15，第二部输出主方法下面的static块，15/3->5、最后输出main函数的输出语句，5；

13. 在Java中，针对类和成员提供了4种访问级别，以下控制级别由小到大的顺序是：（ A ）。
    A.private< 默认 < protected < public
    B.默认 < private< protected < public
    C.protected < 默认 < private < public
    D.protected < private< 默认 < public

private->私有
默认->默认
protected->保护
public->公共

14. 构造方法中调用其他构造方法时，this(,…)须放在代码的第（ B ）行。
    A.可以不出现
    B.1
    C.末
    D.无限制

this.关键字
指的是访问类中的成员变量，用来区分成员变量和局部变量（重名问题）
this()；
访问本类的构造方法
()中可以有参数的 如果有参数 就是调用指定的有参构造
注意：

1. this() 不能使用在普通方法中 只能写在构造方法中
2. 必须是构造方法中的第一条语句

4. 继承与多态

1. 以下关于继承的叙述正确的是（ A ）。
   A.在Java中类只允许单一继承
   B.在Java中一个类只能实现一个接口
   C.在Java中一个类不能同时继承一个类和实现一个接口
   D.在Java中接口只允许单一继承

A:Java只支出单一继承，多继承会产生钻石问题
B&D:Java支持类实现多接口和继承多接口

2. 下面是People和Child类的定义和构造方法，每个构造方法都输出编号。在执行new Child(“mike”)的时候都有哪些构造方法被顺序调用？请选择输出结果 ( D )

class People {
        String name;
        public People() {
               System.out.print(1);
        }
        public People(String name) {
               System.out.print(2);
               this.name = name;
        }
}
class Child extends People {
       People father;
       public Child(String name) {
              System.out.print(3);
              this.name = name;
              father = new People(name + ":F");
       }
       public Child(){
             System.out.print(4);
       }
}

A.312
B.32
C.432
D.132

执行new Child（“mike”），因为Child继承People，所以先实例化People类，在进行Child类，之后进入构造器内，这里使用的是有参构造，子类构造器会默认有一个super（）方法在第一行，所以先执行People类的无参构造方法输出“1”，然后执行子类的有参构造输出“3”，输出之后，在子类有参构造器中，又实例化了一个People类对象，使用了有参构造，所以又输出一个“2”，最后结束。总共过程中输出132。

3. 给定如下一个Java源文件Child.java，编译并运行Child.java，以下结果正确的是？（ B）
   
   A.编译错误：没有找到构造器Child()
   B.编译错误：没有找到构造器Parent1()
   C.正确运行，没有输出值
   D.正确运行，输出结果为：parent2

调用子类的构造方法时，无论是否使用super关键字，系统都会自动调用父类的构造方法。
而无论子类的构造方法是什么形式，只要没有用super关键字，都会默认调用父类的无参构造方法。
这里父类的默认构造方法被覆盖了，且没有写无参构造方法。

4. 如果任何包中的子类都能访问超类中的成员，那么应使用哪个限定词:( C)
   A.public
   B.private
   C.protected
   D.transient(序列化)
5. 关于下面的类，哪句是最准确的？ （ B ）

class A {
  private int i;
  protected int j;
}
class B extends A {
  private int k;
  protected int m;

  // some methods omitted
}

A.在类B中，一个实例方法只能访问i，j，k，m。
B.在类B中，一个实例方法只能访问j，k，m。
C.在类B中，一个实例方法只能访问j，m。
D.在类B中，一个实例方法只能访问k，m。

私有属性的变量，只能在本类中访问

6. 有如下代码:（A）

class A {              
    double f(double x, double y) {                  
    return x * y;              
   }     
}
class B extends A {              
    double f(double x, double y) {                  
    return x + y;              
    }     
}     

A.重写
B.重载
C.扩展
D.扩充

重载：
同一个类中，只要方法的方法名相同，那么这几个方法就构成重载。
重写：
重写方法只能发
生在父类和子类之间。

1. 重写方法的方法名和方法参数必须完全一致。
2. 重写方法的返回值必须和原方法的返回值类型完全一样
3. 重写方法的返回值类型比原方法的返回值类型小
4. 重写方法抛出的异常，不能大于原方法抛出的异常
5. 重写方法的权限不能小于原方法的权限
6. 重写方法只能发生在父类和子类之间

重写和重载的方便：

1. 重写发生在父类和子类之间，重载发生在同一个类中。
2. 重写方法的权限必须大于等于原方法的权限，重载方法的权限可以是任意的。
3. 重写方法的返回值类型必须小于原方法的返回值类型，重载方法的返回值类型是任意的。
4. 重写方法的方法名和方法参数必须完全一致，重载方法的方法名要相同，而方法参数要不同。
5. 静态方法不可以重写，但是静态方法可以被重载。
6. 前者实现的是运行时的多态性，而后者实现的是编译时的多态性

7. 在使用super 和this关键字时，以下描述正确的是( A)
   A.在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过
   B.this（）和super（）可以同时出现在一个构造函数中
   C.super（）和this（）不一定要放在构造方法内第一行
   D.this（）和super（）可以在static环境中使用，包括static方法和static语句块

详情见上

8. 在同一个源文件中定义了两个类，在子类横线处填入重写方法，下面选项错误的是（ B）：

class Father{
 void run() {}
}
class Child extends Father{
 @Override
——————————;

A.void run() {}
B.public void run() {}
C.protected void run() {}
D.private run() {}

重写必须要与原先方法有差异，所以排除A，其次重写后的方法的权限不能比原方法小，所以选B

9. Java关于方法的重写，哪个说法是错误的？（ C）
   A.对一个方法的重写必须发生在具有继承关系的两个类中，即子类对父类方法的重写。
   B.方法的重写在一般意义上要求：两个方法的参数个数和类型以及返回值类型都一致。
   C.方法的重写是一个类的两个方法，方法的名称相同，但参数不同。
   D.子类对象调用子类重写了父类的方法时，优先调用子类的方法。

重写的方法的名称和参数必须完全一致

10. Java中（ C ） 。
    A.一个子类可以有多个父类，一个父类也可以有多个子类
    B.一个子类可以有多个父类，但一个父类只可以有一个子类
    C.一个子类可以有一个父类，但一个父类可以有多个子类
    D.上述说法都不对
11. A派生出子类B，B派生出子类C，对于如下Java源代码正确的说法是（D）。

12.    A  a0 =new  A();
13.    A  a1 =new  B();
14.    A  a2 =new  C();

A.只有第1行能通过编译
B.第1、2行能通过编译，但第3行编译出错
C.第1、2、3行能通过编译，但第2、3行运行时出错
D.第1行、第2行和第3行的声明都是正确的

向上转型

12. 下面说法不正确的是( C )
    A.一个子类的对象可以接收父类对象能接收的消息；
    B.当子类对象和父类对象能接收同样的消息时，它们针对消息产生的行为可能不同；
    C.父类比它的子类的方法更多；
    D.子类在构造函数中可以使用super( )来调用父类的构造函数；

子类会继承父类的所有方法，所以父类只会小等于子类的方法数量

13. 类Teacher和Student是类Person的子类,下面的代码中最后一句语句的运行结果是( C ).

Person p;
Teacher t;
Student s;
//p,t and s are all non-null.
if(t instanceof Person)  {s=(Student)t;}

A.编译时正确，但运行时错误
B.将构造一个Student对象
C.表达式是错误的
D.表达式是合法的

类型强制转换不能向这样转,只能在一个继承层次上向下强制转型.

14. 给出如下代码段:( C )

class A{
	static int i;
	int j,k;
	public void fun() {
		for(int j=0;j<20;j++) {
			i++;
		}
	}
	public void f() {
		fun();
	}
}
class B extends A {
	static int k;
	public void fun() {
		for(j=0;j<10;j++) {
			k+=3;
		}
	}
}
public class Main{
	public static void main(String[] args) throws Exception {
		A a = new B();
		a.f();
		System.out.println(a.k);
		System.out.println(a.j);
	}
}

A.30 0
B.0 0
C.0 10
D.30 10

这里是实例化B类的对象，然后向上转型为A类，B类把fun函数进行了重写，所以这时，a有一个B类的fun方法和A类的f方法，所以执行B类的fun方法，k值变为30，这里的k是B类的static k，但是输出的A类的int k，所以a.k是0。for循环里面的j使用的是A类中的j，会对a.j产生影响，所以最后输出0，10
变量的调用，默认情况下使用就近原则

15. 下面的概念，哪个不是关于对象的多态性的体现（B）
    A.方法的重载
    B.方法的继承
    C.方法的覆盖
    D.对象的上、下转型

方法多态性，体现在方法的重载和覆写上
对象多态性，体现在父、子对象之间的转型上
向上转型（Upcast)、向下转型（Downcast）

16. 已知类的继承关系如下：( A )

class Employee;
class Manager extends Employee;
class Director extends Employee;

则以下语句哪个能通过编译？ ( A )。
A.Employee e = new Manager();
B.Director d = new Manager();
C.Director d = new Employee();
D.Manager m = new Director();

B：不是父子类型，不能转型
C：子类不能直接实例化父类
D：不是父子类型，不能转型

17. 下列哪些定义抽象类的语句是合法的（C ）。
    A.public class Test{ abstract void enjoy();}
    B.public abstract Test{abstract void enjoy();}
    C.public abstract class Test{abstract void enjoy();}
    D.public class abstract Test{abstract void enjoy();}

A：缺少关键字abstract
B：少class关键字
D：位置错误

18. 运行类C的输出是（ B ）

class A {
  public A() {
    System.out.println("The default constructor of A is invoked");
  }
}

class B extends A {
  public B() {
    System.out.println("The default constructor of B is invoked");
  }
}

public class C  {
  public static void main(String[] args) {
    B b = new B();
  }
}

A.没有输出。
B.输出 “The default constructor of B is invoked”
C.输出"The default constructor of B is invoked"，然后是"The default constructor of A is invoked"
D.输出"The default constructor of A is invoked"，然后是"The default constructor of B is invoked"

子类构造方法，会首先执行父类的默认的构造方法

19. 在下面的代码中，若要在子child类中对父类的addvalue方法进行重写，下面对于child类中的addvalue方法的声明哪个是正确的：（A ）。

class father {
 public int addvalue(int a, int b) {
  int s = a + b;
  return s;
 }
}
class child extends father {

}

A.public int addvalue(int i,int j)
B.void addvalue(int a,int b)
C.void addvalue(double i)
D.int addvalue(int a)

B和C和D，比父类的方法权限小，所以错误并且重写方法的方法名和方法参数必须完全一致。

20. 有如下代码，程序执行的结果是：（ A ）。

class A {
 int v1 = 10;
 int v2 = 10;

 public void m1() {
  System.out.println("A m1");
 }

 public void m2() {
  System.out.println("A m2");
 }
}

class B extends A {
 int v2 = 20;
 int v3 = 20;

 public void m2() {
  System.out.println("B m2");
 }

 public void m3() {
  System.out.println("B m3");
 }
}

public class Main {
 public static void main(String[] args) {
  A a = new B();
  a.m1();
  a.m2();
  System.out.println(a.v1);
  System.out.println(a.v2);
 }
}

A.

A m1
B m2
10
10

B.

B m1
B m2
20
20

C.

A m1
A m2
10
10

D.

A m1
B m2
10
20

实例化B类，并向上转型赋值给a，此时调用a的m1方法，因为B类没有m1方法，所以此时调用的是A类的m1方法、之后调用m2方法，因为B类中讲m2方法进行了重写，所以此时a调用的是m2的方法。因为向上转型，父类无法调用子类的变量，所以此时输出的是A类的v1和v2。

5.接口与实现

1. 若A1、A2为已定义的接口 ,以下接口定义中没有语法错误的是（ D ） 。
   A.interface B { void print() { } }
   B.abstract interface B { void print() }
   C.abstract interface B extends A1,A2 { abstract void print(){ };}
   D.interface B { void print();}

接口用abstract修饰与否都没有区别
A：方法去掉{}，方法只需要写声明，不要写方法体。
B：缺少；号
C：也包含了方法体

2. 欲构造ArrayList类的一个实例，此类继承了List接口，下列哪个方法是正确的？（ B ）
   A.ArrayList myList=new Object（）；
   B.List myList=new ArrayList（）；
   C.ArrayList myList=new List（）；
   D.List myList=new List（）；

A:只是实例化了一个ArrayList类的对象myList，而没有实现接口
B:用List来声明MyList实现接口，并用ArrayList构造出一个实例
C:List并不是一个类，不能用new关键字
D:接口不能实例化一个接口

3. 如下哪个是正确的接口？( D )
   A.interface A { void print() { }; }
   B.abstract interface A { print(); }
   C.abstract interface A { abstract void print() { };}
   D.interface A { void print();}

A:包含了方法体
B:缺少返回值类型
C:也包含了方法体

4. 下列选项中，用于实现接口的关键字是 （ B ）。
   A.interface
   B.implements
   C.abstract
   D.class

interface定义接口，implements实现接口、abstract抽象、class类

5. 关于接口，下面的叙述错误的是（ D）。
   A.一个接口可以多继承多个接口
   B.一个类可以实现多个接口
   C.抽象类在实现接口时，可以不实现该接口中声明的所有方法
   D.抽象类在实现接口时，必须实现该接口中声明的所有方法

接口和抽象类配合起来使用,这样的抽象类称为便利类。开发者觉得哪个方便就选用哪个。

6. 以下代码，描述正确的有( A )

interface IDemo{
    public static final String name;1
    void print();2
    public void getInfo();3
}
abstract class Person implements IDemo{4
    public void print(){
    }
}

A.第1行错误，没有给变量赋值
B.第4行错误，没有实现接口的全部方法
C.第2行错误，方法没有修饰符
D.第3行错误，没有方法的实现

A：被public static final修饰的变量，必须初始化，在后面的代码中，该成员变量也无法发生改变
B：抽象类实现接口，不需要实现全部的方法
C：有默认的修饰符
D：接口内的方法不需要实现

7. 如下程序的运行结果为：（ D ）。

interface A {
}

class C {
}

class B extends D implements A {
}

public class Test {
  public static void main(String[] args) {
    B b = new B();
    if (b instanceof A)
      System.out.println("b is an instance of A");
    if (b instanceof C)
      System.out.println("b is an instance of C");
  }
}

class D extends C {
}

A.没有输出
B.b is an instance of A.
C.b is an instance of C.
D.输出b is an instance of A，然后是b is an instance of C.

B继承D实现接口A，D继承C，所以B可以向上转型为D、A、C，所以两个if判断均成立

8. 给定以下代码，请问下列选项中哪个是正确的？（ D）

public interface Top{
  void twiddle(String s);
}

A.

public abstract class Sub implements Top{
  public abstract void twiddle(String s){ }
}

B.

public class Sub implements Top{
  public void twiddle(Integer i){ }
}

C.

public class Sub implements Top{
  void twiddle(String s){ }
}

D.

public class Sub implements Top{
  public void twiddle(String s){ }
  public void twiddle(Integer i){ }
}

D：继承实现了Top的接口的方法，还重载了该方法
A：不应该有abstract修饰符
B：没有实现Top的接口方法
C：缺少访问修饰符
接口中的方法默认都是 public 和 abstract 的。所以在实现接口的类中，实现方法时都要在方法前加上 public 修饰符。

6. 异常处理

1. 假设方法unsafe() 将抛出IOException, 可以填入如下代码段第1行的选项是（ D ）。

1)
2) { if(unsafe()){//do something…}
3)   else if(safe()){//do the other…}
4) }

A.public IOException methodName()
B.public void methodName()
C.public void methodName() throw IOException
D.public void methodName() throws IOException

throws方法
跟在方法声明后面，后面跟的是异常类名

2. 下列哪种异常是检查型异常，需要在编写程序时声明 （ C ）.
   A.NullPointerException
   B.ClassCastException
   C.FileNotFoundException
   D.IndexOutOfBoundsException

非检查型异常:
□ ArithmeticException：数学计算异常。
□ NullPointerException：空指针异常。
□ NegativeArraySizeException：负数组长度异常。
□ ArrayOutOfBoundsException：数组索引越界异常。
□ ClassNotFoundException：类文件未找到异常。
□ ClassCastException：类型强制转换异常。
□ SecurityException：违背安全原则异常。
检查型异常
□ NoSuchMethodException：方法未找到异常。
□ IOException：输入输出异常。
□ EOFException：文件已结束异常。
□ FileNotFoundException：文件未找到异常。
□ NumberFormatException：字符串转换为数字异常。
□ SQLException：操作数据库异常

3. getCustomerInfo()方法如下，try中可以捕获三种类型的异常，如果在该方法运行中产生了一个IOException，将会输出什么结果（ A ）。

public void getCustomerInfo() {
            try {
              // do something that may cause an Exception
            } catch (java.io.FileNotFoundException  ex){
                  System.out.print("FileNotFoundException!");
            } catch (java.io.IOException  ex){
                System.out.print("IOException!");
            } catch (java.lang.Exception  ex){
                 System.out.print("Exception!");
            }
}

A.IOException!
B.IOException!Exception!
C.FileNotFoundException!IOException!
D.FileNotFoundException!IOException!Exception!

4. 以下描述不正确的有(D)
   A.try块不可以省略
   B.可以使用多重catch块
   C.finally块可以省略
   D.catch块和finally块可以同时省略
5. 如下程序会抛出（A ）类型的异常？

public class Test {
  public static void main(String[] args) {
    System.out.println(1 / 0);
  }
}

A.ArithmeticException
B.ArrayIndexOutOfBoundsException
C.StringIndexOutOfBoundsException
D.ClassCastException

A计算异常

7.常用类

1. 要产生[20，999]之间的随机整数使用哪个表达式？（C）
   A.(int)(20+Math.random()*97)
   B.(int)Math.random()*999
   C.20+(int)(Math.random()*980)
   D.20+(int)Math.random()*980

Math.random()可以随机产生一个[0，1）的数
A:Math.random()*97可以随机产生一个[0，97）的数，然后再加20，就可以产生[20，117）的数
B:生成[0，999)的整数
C和D:C会首先执行括号内的，生成[0，980）之间的数，D会首先执行(int)Math.random()，生成一个0。

2. 对于下列代码：以下表达式的值为true的是？"（A）

String str1="java";
String str2="java";
String str3=new String("java");
StringBuffer str4=new StringBuffer("java");

A.str1= =str2;
B.str1= =str4;
C.str2= =str3;
D.str3= =str4;

选项内是==，所以这里看的是这些变量的地址，str1和str2都引用了"java"变量的地址，所以相等，str3实例化了一个"java"变量，是一个新的变量，所以地址肯定和str1、str2不一样，str4同理

3. 关于字符串的构造方法，如下代码执行结果是（B ）。

String str="ABCDEFG";
char[] chars=str.toCharArray(); 
System.out.println(new String(chars,1,3));

A.ABC
B.BCD
C.AB
D.BC

建立str变量，然后将str转化为char类型，建立chars中从1到3的字符生成一个字符串输出，ABCDEFG，从0开始数，输出索引为123的元素即BCD

4. 定义字符串：String str=“abcdefg”,则str.indexOf(‘d’)的结果是？
   A.‘d’
   B.true
   C.3
   D.4

indexOf会输出查找字符或字符串出现在str的第一次位置，从0开始数，d在str的第3位

5. 下列哪个表达式是正确的？（B）
   A.int m=Float.parseFloat(“567”);
   B.int m=Short.parseShort(“567”);
   C.byte m=Integer.parseInt(“2”);
   D.float m=Float.parseDouble(“2.9”);

A:不能把浮点型赋值给int型
B:short变量可以赋值给int
C:int不能赋值给byte，只能小范围赋值大范围
D:如上同理

8.组件与事件处理

1. 下列哪一项不属于布局管理器? ( D )
   A.GridLayout
   B.CardLayout
   C.BorderLayout
   D.BagLayout
2. 如果容器组件p的布局是BorderLayout，则在p的下部添加一个按钮b，应该使用的语句是（ C ）
   A.p.add(b);
   B.p.add(b,“North”);
   C.p.add(b,“South”);
   D.b.add(p,“North”);
3. 声明并创建一个按钮对象b，应该使用的语句是（ A ）
   A.Button b=new Button( );
   B.button b=new button( );
   C.Button b=new b( );
   D.b.setLabel(“确定”);
4. 在类中若要处理ActionEvent事件，则该类需要实现的接口是( C )
   A.Runnable
   B.Serializable
   C.ActionListener
   D.Event
5. 向JComboBox中添加一个选项，可用以下哪个方法：(B)
   A.add()
   B.addItem()
   C.InsertItem()
   D.addItemAt()
6. 下面不是JComponent的子类的是：(D)
   A.JLabel
   B.JPanel
   C.JTree
   D.JFrame
7. 要实现多个单选按钮的互斥效果需要用到的类是：(B)
   A.JPanel
   B.ButtonGroup
   C.JFrame
   D.JDialog
8. 下列ABCD注释标注的哪行代码没有编译错误，但触发运行异常？(B)
   
   A.A
   B.B
   C.C
   D.D
9. 当单击鼠标或拖动鼠标时，触发的事件是：(D)
   A.KeyEvent
   B.ActionEvent
   C.ItemEvent
   D.MouseEvent
10. 以下不属于Swing中的组件的是：?
    A.JPanel
    B.JTable
    C.Menu
    D.JFrame

程序填空

3.类与对象

1. 题目要求:
   1.使用this调用已有的有参构造方法，将width与length分别设置为5和6。
   2.在Rectangle类中覆盖toString方法。按照width=实际宽度值,length=实际长度值的格式返回。

public Rectangle(){ 
	this(5,6); //空1
}
public Rectangle(int width, int length) {
    this.width = width;
    this.length = length;
}
public 
String toString()//空2
{
	return "width="+this.width+",length="+this.length;//空3
}    

2. this在构造方法的使用

 class Base {
    int x, y, z, w;
    public Base(int a, int b) {
        x = a;
        y = b;
    }
    public Base(int a, int b, int c, int d) {
 		this(a,b);// 换一种办法实现赋值 x=a, y=b   空1
        z = c;
        w = d;
    }
}
public class Main {
    public static void main(String[] args) {
        Base base = new Base(1, 1, 1, 1);//空2
        System.out.println(base.x + " " + base.y + " " + base.z + " " + base.w);
    }
}

7.常用类

1. 给出以下代码：

public class Main {
    int i=0;
    Main(int ii) { i = ii; }
    Main(String s) { this(s.length()); }
    public String toString() { return String.format("%02X",i); }
    public static void main(String[] args) {
        Main m = new Main("hello world");
        System.out.println(m);
    }
}

程序运行输出结果是：（0B）

首先从main函数开始分析，实例化一个Main变量，并调用了参数为String的构造器，构造器中的this（）方法又会调用另一个构造器，参数为字符串的长度，Main的成员变量就等于这个字符串的长度。之后使用println输出，println会调用自带的toString方法，输出这个长度按16进制输出，并前补0。
x代表输出为16进制，o代表输出8进制

2. 当编译并运行下列代码时，其运行结果是什么？

public class Main{
   public static void main(String args[]){
     String s="Hello";
     methodA(s);
     s=s.replace('e', 'a');
     System.out.println(s);
   }
   public static void methodA(String str){
     str+="World";
   }
}

上述代码的运行结果为：（Hallo）

首先从main开始分析，s赋值，调用methodA方法，方法里面str后面加了一个"world"字符串，但是这里str是形参，不影响main函数里面的s变量，所以main函数里面的s还是"Hello"，之后执行replace方法，会把字符串里面的第二个形参替换为第一个形参，s变为"Hallo"，最后输出Hallo

3. Java中所有类都是类（Object）的子类

常识

8组件与事件处理

1. （BorderLayout）布局包括五个明显的区域：东、南、西、北、中。
2. JPanel的缺省布局管理器是（FlowLayout）
3. 在GUI编程中，采用了基于事件的处理机制，由（事件）、（事件源）、事件处理程序三个部分组成
4. 对话框分为（模式）对话框和（无模式）对话框两种。

函数题

6.异常处理

1. 异常-finally
   代码中向系统申请资源，到最后都要将资源释放。
   现有一Resource类代表资源类，包含方法：
   1. open(String str)打开资源，声明为抛出Exception(包含出错信息)。
   2. close()方法释放资源，声明为抛出RuntimeException(包含出错信息)

现在根据open(String str)中str的不同，打印不同的信息。str的内容分为4种情况：

1. fail fail，代表open和close均会出现异常。打印open的出错信息与close的出错信息。
2. fail success，代表open抛出异常，打印open出错信息。close正常执行，打印resource release success
3. success fail ,代表open正常执行，打印resource open success。close抛出异常，打印close出错信息。
4. success success，代表open正常执行，打印resource open success，close正常执行打印resource release success。
   注1：你不用编写打印出错信息的代码。
   注2：捕获异常后使用System.out.println(e)输出异常信息，e是所产生的异常。

裁判测试程序：

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    Resource resource = null;
    try{
        resource = new Resource();
        resource.open(sc.nextLine());
         /*这里放置你的答案*/

       sc.close();

}

以下输入样例代表输入success success。
输入样例
success success
输出样例

resource open success
resource release success

编程代码：

	        System.out.println("resource open success");
	    }catch (Exception e){
	    	System.out.println(e);
	    }
	    try {
	    	resource.close();
	    	System.out.println("resource release success");
	    }catch(Exception e){
	    	System.out.println(e);
	    }

2. 异常-多种类型异常的捕获
   如果try块中的代码有可能抛出多种异常，且这些异常之间可能存在继承关系，那么在捕获异常的时候需要注意捕获顺序。
   补全下列代码，使得程序正常运行。
   裁判测试程序：

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    while (sc.hasNext()) {
        String choice = sc.next();
        try {
            if (choice.equals("number"))
                throw new NumberFormatException();
            else if (choice.equals("illegal")) {
                throw new IllegalArgumentException();
            } else if (choice.equals("except")) {
                throw new Exception();
            } else
            break;
        }
        /*这里放置你的答案*/
    }//end while
    sc.close();
}

输出说明
在catch块中要输出两行信息：
第1行：要输出自定义信息。如下面输出样例的number format exception
第2行：使用System.out.println(e)输出异常信息，e是所产生的异常。
输入样例

number illegal except quit

输出样例

number format exception
java.lang.NumberFormatException
illegal argument exception
java.lang.IllegalArgumentException
other exception
java.lang.Exception

编程代码：

	        catch(NumberFormatException e){
	        	System.out.println("number format exception");
	        	System.out.println(e);
	        }catch(IllegalArgumentException e) {
	        	System.out.println("illegal argument exception");
	        	System.out.println(e);
	        }catch(Exception e) {
	        	System.out.println("other exception");
	        	System.out.println(e);
	        }

编程题

2.编程基础

1. 计算工资数
   某公司标准上班时间是120小时，每小时工钱是20元, 如果上班时间超出了120小时，超出部分每小时按2倍工资发放。请编写程序计算员工月工资。
   输入格式:
   输入一个员工的工作小时数
   输出格式:
   输出这个员工的工资数
   输入样例:
   在这里给出一组输入。例如：
   40
   输出样例:
   在这里给出相应的输出。例如：
   800
   编程代码：

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {solver();}
	public static void solver() {
		Scanner sc = new Scanner(System.in);
		int num = sc.nextInt();
		if(num>120) {
		System.out.println(num*20+(num-120)*20);
		}else if(num > 0){
		System.out.println(num*20);
		}else{
        System.out.println("0");
        }
	}
}

输入这个时间后，判断是否满足双倍工资要求，然后输出对应的工资，注意的是，需要判断输入为负数的情况，这个有点理解不了，上班时间怎么可能有负。

2. JAVA-求整数序列中出现次数最多的数
   要求统计一个整型序列中出现次数最多的整数及其出现次数。
   输入格式:
   在一行中给出序列中整数个数N（0<N≤1000），依次给出N个整数，每个整数占一行。
   输出格式:
   在一行中输出出现次数最多的整数及其出现次数，数字间以空格分隔。题目保证这样的数字是唯一的。
   输入样例:
   在这里给出一组输入。例如：
   10 3 2 -1 5 3 4 3 0 3 2
   输出样例:
   在这里给出相应的输出。例如：
   3 4
   编程代码：

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {solver();}
	public static void solver() {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		int nums[] = new int[N];
		int count1=0;
		int count = 0;
		int num1[] = new int[N];
		int num2[] = new int[N];
		for(int i=0;i<N;i++) {
			int temp = sc.nextInt();
			nums[i] = temp;
		}
		Arrays.sort(nums);
		for(int i=0;i<N-1;i++) {
			if(nums[i]==nums[i+1]) {
				count1++;
			}else if(nums[i]!=nums[i+1]){
				num1[count] = nums[i];
				num2[count] = count1;
				count++;
				count1 = 1;
			}
		}
		int max = 0;
		int select = 0;
		for(int i=0;i<num1.length;i++) {
			if(max < num2[i]) {
				select = i;
				max = num2[i];
			}
		}
		System.out.println(num1[select]+" "+max);
	}
}

这里应该还有更简单的方法，但是这里选则一个比较简单好理解的方法，首先把数据输入到一个数组里面，之后进行操作处理。
编程思考：调用Java的排序方法，方便操作，之后在排序的基础上进行遍历，通过前后判断前后的元素是否相等来计算该元素的个数。每当前后两个元素不一样的时候，就把当前元素和元素的个数存入数组。在存入元素和元素个数的数组内进行遍历，获取个数最多的个数和元素的下标，之后输入即可。

3. sdut-九九乘法表
   九九乘法表是数学学习的基础，今天我们就来看看乘法表的相关问题。《九九乘法歌诀》，又常称为“小九九”,如下图所示。你的任务是写一个程序，对于给定的一个正整数 n ，输出“九九乘法表”的前 n 行。例如，输入 n 为 9，你的程序的输出将为下图：
   输入格式:
   输入包含多组测试数据，以 EOF 结束。每组测试数据只包含一个正整数 n (0 < n < 10)。
   输出格式:
   对于每组测试数据，输出上图所示“九九乘法表”的前 n 行。
   输入样例:

2 3

输出样例:
在这里给出相应的输出。例如：

1*1=1
1*2=2 2*2=4
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9

编程代码：

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		solver();
		}
	 static void solver() {
		Scanner sc = new Scanner(System.in);
		while(sc.hasNext()) {
			int num = sc.nextInt();
			for(int i=1;i<=num;i++) {
				for(int j=1;j<=num;j++) {
					if(j<=i)
					System.out.printf("%d*%d=%d",j,i,i*j);
					if(j<i)
					System.out.printf(" ");
				}
				System.out.println();
			}			
		}
	}
}

难点就是以EOF结束，这里需要用sc.hasNext()方法。
这个乘法表，用双重循环，内层循环进行一些简单的限制，限制的规律从两个数的变化中得出，最后需要注意这个输出的格式，保证两个式子之间的空格正常。

• 评委打分
  班级里要搞智力竞赛啦!同学们都踊跃参加。进入最后决赛的是10个同学，随着一道道题目的出示，有时是1号选手得分，有时是5号选手得分，每次答对者得10分，最后结果如何呢?
  输入格式:
  第一行有十个整数，表示十位同学的初始分。第二行一个整数n，表示有n道题竞赛。
  接下去有n行，每行有一个数字x，x表示本次可以加分的选手序号（每次答对者得10分）。
  输出格式:
  10个同学最终的得分值，每两位同学之间有一个空格。
  输入样例:

10 0 0 0 10 10 0 0 0 10
3
1
10
1

输出样例:

30 0 0 0 10 10 0 0 0 20

解题代码：

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		solver();
		}
	 static void solver() {
		Scanner sc = new Scanner(System.in);
		int score[] = new int[10];
		for(int i=0;i<10;i++) {
			score[i] = sc.nextInt();
		}
		int problem_num = sc.nextInt();
		for(int i=0;i<problem_num;i++) {
			int select = sc.nextInt();
			score[select-1]+=10;
		}
		for(int i=0;i<score.length;i++) {
			if(i==0) {
				System.out.printf(""+score[i]);
			}else {
				System.out.printf(" "+score[i]);
			}
		}
	}
}

首先输入初始分，然后设置循环，根据下标给对应选手加分，最后输出。

• 666
  中国人非常喜欢6这个数字，因为大家总爱说66大顺啊。数学狂人李某人喜欢把什么都数字化，于是她把顺利这个词也定义了数量级，6代表1级顺利，66代表2级顺利，666代表3级顺利，以此类推。你看，数学狂人的世界总是让人无法理解。今天，李某人决定将数学进行到底，现在她设前n级顺利的和是sn。
  sn=6+66+666+...+66..66(n个6)。
  假设你已经知道了数字n，那么，你能帮李某人求出sn么?
  输入格式:
  输入一个正整数n，n的范围是[0,10)。
  输出格式:
  输出Sn的值。
  输入样例:
  2
  输出样例:
  72
  编程代码：

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		solver();
		}
	 static void solver() {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int num = 6;
		int sum = 0;
		for(int i=0;i<n;i++) {
			sum+=num;
			num += Math.pow(10, i+1)*6;
		}
		System.out.println(sum);
	}
}

设置循环，在循环内控制每次加的数字的变化，难点为找到每次加的数字的规律。

3.类与对象

1. 构造函数与toString
   定义一个有关人的Person类，内含属性：
   String name、int age、boolean gender、int id，所有的变量必须为私有(private)。
   注意：属性顺序请严格按照上述顺序依次出现。
   1.编写无参构造函数：

   • 打印"This is constructor"。
   • 将name,age,gender,id按照name,age,gender,id格式输出

   2.编写有参构造函数
   依次对name,age,gender赋值。
   3.覆盖toString函数：
   按照格式：类名 [name=, age=, gender=, id=]输出。建议使用Eclipse自动生成.
   4.对每个属性生成setter/getter方法
   5.main方法中

• 首先从屏幕读取n，代表要创建的对象个数。
• 然后输入n行name age gender , 调用上面2编写的有参构造函数新建对象。
• 然后将刚才创建的所有对象逆序输出。
• 接下来使用无参构造函数新建一个Person对象，并直接打印该对象。
  输入样例:

3
a 11 false
b 12 true
c 10 false

输出样例:

Person [name=c, age=10, gender=false, id=0]
Person [name=b, age=12, gender=true, id=0]
Person [name=a, age=11, gender=false, id=0]
This is constructor
null,0,false,0
Person [name=null, age=0, gender=false, id=0]

编程代码：

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int num = sc.nextInt();
		Person people[] = new Person[num];
		for(int i=0;i<num;i++) {
			String name = sc.next();
			int age = sc.nextInt();
			boolean gender = sc.nextBoolean();
			people[i] = new Person(name,age,gender);
		}
		for(int i=people.length-1;i>=0;i--) {
			System.out.println(people[i].toString());
		}
		Person temp = new Person();
		System.out.println(temp.toString());
	}
}
class Person{
	private String name;
	private int age;
	private boolean gender;
	private int id;
	
	Person(){//无参构造
		System.out.println("This is constructor");
		this.name=null;
		this.age=0;
		this.gender=false;
		this.id=0;
		System.out.println(getName()+","+getAge()+","+isGender()+","+getId());
	}
//	有参构造
	Person(String name,int age,boolean gender){
		this.name=name;
		this.age=age;
		this.gender=gender;
	}
	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 boolean isGender() {
		return gender;
	}
	public void setGender(boolean gender) {
		this.gender = gender;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", gender=" + gender + ", id=" + id + "]";
	}
}

快捷键：生成setter、getter方法、构造方法、toString方法等
Alt+Shift+S—eclipse
Alt+Shift+Insert—IDEA

• 形状
• 定义长方形类与圆形类Circle
  长方形类-类名：Rectangle，private属性：int width,length
  圆形类-类名：Circle，private属性:int radius
  编写构造函数：
  带参构造函数:Rectangle(width, length),Circle(radius)
  编写方法：
  public int getPerimeter()，求周长。
  public int getArea()，求面积。
  toString方法，使用Eclipse自动生成。
  注意：
  计算圆形的面积与周长，使用Math.PI。
  求周长和面积时，应先计算出其值(带小数位)，然后强制转换为int再返回。
• main方法
  • 输入2行长与宽，创建两个Rectangle对象放入相应的数组。
  • 输入2行半径，创建两个Circle对象放入相应的数组。
  • 输出1：上面2个数组中的所有对象的周长加总。
  • 输出2：上面2个数组中的所有对象的面积加总。
  • 最后需使用Arrays.deepToString分别输出上面建立的Rectangle数组与Circle数组

思考：如果初次做该题会发现代码冗余严重。使用继承、多态思想可以大幅简化上述代码。
输入样例:

1 2
3 4
7
1

输出样例:

69
170
[Rectangle [width=1, length=2], Rectangle [width=3, length=4]]
[Circle [radius=7], Circle [radius=1]]

编程代码：

import java.util.Arrays;
import java.util.Scanner;
import java.lang.Math;
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int L1 = sc.nextInt();
		int W1 = sc.nextInt();
		int L2 = sc.nextInt();
		int W2 = sc.nextInt();
		Rectangle a[] = new Rectangle[2];
		a[0] = new Rectangle(L1, W1);
		a[1] = new Rectangle(L2, W2);
		int R1 = sc.nextInt();
		int R2 = sc.nextInt();
		Circle b[] = new Circle[2];
		b[0] = new Circle(R1);
		b[1] = new Circle(R2);
		System.out.println((int)(a[0].getPerimeter()+a[1].getPerimeter()+b[0].getPerimeter()+b[1].getPerimeter()));
		System.out.println((int)(a[0].getArea()+a[1].getArea()+b[0].getArea()+b[1].getArea()));
		System.out.println(Arrays.deepToString(a));
		System.out.println(Arrays.deepToString(b));
	}
}
class Rectangle{//长方形
	private int width;
	private int length;
	
	public Rectangle(int width, int length) {
		super();
		this.width = width;
		this.length = length;
	}
	public int getPerimeter() {//长方形周长
		return 2*(this.length+this.width);
	}
	public int getArea() {//长方形面积
		return this.length*this.width;
	}
	@Override
	public String toString() {
		return "Rectangle [width=" + width + ", length=" + length + "]";
	}
}
class Circle{//圆形
	private int radius;
	public Circle(int radius) {
		super();
		this.radius = radius;
	}
	public double getPerimeter() {//圆周长
		return (int)(Math.PI*2*this.radius);
	}
	public double getArea() {//圆面积
		return (int)(Math.PI*this.radius*this.radius);
	}
	@Override
	public String toString() {
		return "Circle [radius=" + radius + "]";
	}
}

• 计算年龄
  定义一个Birthday类，其成员变量有3个整形变量（出生的年月日）：year,month,day；提供构造方法对这3个成员变量进行初始化；提供成员变量的get、set方法；成员函数有getAge(),功能是实现计算到2017年12月25日时该Birthday对象的年龄。编写程序测试这个类。
  输入格式:
  输入出生的年、月、日（注：输入的年月日以换行隔开）
  输出格式:
  计算得到年龄
  输入样例:
  在这里给出一组输入。例如：

1995
12
23

输出样例:
在这里给出相应的输出。例如：

age=22

编程代码：

import java.util.Arrays;
import java.util.Scanner;
import java.lang.Math;
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int year = sc.nextInt();
		int month = sc.nextInt();
		int day = sc.nextInt();
		Birthday people = new Birthday(year, month, day);
		System.out.printf("age=");
		System.out.println(people.getAge());
	}
}
class Birthday{
	private int year;
	private int month;
	private int day;
	
	public Birthday(int year, int month, int day) {
		super();
		this.year = year;
		this.month = month;
		this.day = day;
	}

	public int getYear() {
		return year;
	}

	public void setYear(int year) {
		this.year = year;
	}

	public int getMonth() {
		return month;
	}

	public void setMonth(int month) {
		this.month = month;
	}

	public int getDay() {
		return day;
	}

	public void setDay(int day) {
		this.day = day;
	}

	public int getAge() {
		int year = 2017,month = 12,day = 25;
		return year-this.year;
	}
}

• 圆柱体类设计
• 定义一个圆柱类Cylinder
  1. 里面包含私有属性 private int radius（半径）,height(高）
  2. 为属性完成其setter getter方法
  3. 完成带参构造方法Cylinder(int radius,height),该方法中包含一句System.out.println(“Constructor with para”);
  4. 完成无参构造方法Cylinder()，在无参构造方法中调用有参构造方法，为半径和高赋值为2,1,该方法包含一句System.out.println(“Constructor no para”);
  5. 完成求体积方法 public int getVolumn(){} 求圆柱体积,π使用Math.PI
• 定义测试类Main，在main方法中，按照顺序要求完成下列操作
• 从键盘接收两个数，第一个为半径，第二个为高，并利用刚才输出两个数创建圆柱体对象c1,求c1的体积并输出。
• 使用无参构造方法 创建第二个圆柱体对象c2，求c2的体积并输出。
  输入格式:
  在一行中输入半径 和高。
  输出格式:
  对每一个圆柱体输出它的体积
  输入样例:
  在这里给出一组输入。例如：

2   3

输出样例:
在这里给出相应的输出。例如：

Constructor with para
37
Constructor with para
Constructor no para
12

编程代码：

import java.util.Scanner;
import java.lang.Math;
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int r = sc.nextInt();
		int h = sc.nextInt();
		Cylinder cylinder1 = new Cylinder(r,h);
		System.out.println((int)cylinder1.getVolumn());
		Cylinder cylinder2 = new Cylinder();
		System.out.println((int)cylinder2.getVolumn());
	}
}
class Cylinder{
	private int radius;
	private int height;
//	带参构造方法
	public Cylinder(int radius, int height) {
		this.radius = radius;
		this.height = height;
		System.out.println("Constructor with para");
	}
	public Cylinder() {
		this(2,1);
		System.out.println("Constructor no para");
	}
	public int getRadius() {
		return radius;
	}
	public void setRadius(int radius) {
		this.radius = radius;
	}
	public int getHeight() {
		return height;
	}
	public void setHeight(int height) {
		this.height = height;
	}
	 public double getVolumn(){//圆柱体积
		return Math.PI*getRadius()*getRadius()*getHeight();
	 }
}

• 统计商品总价
  消费者购买超市5件商品，输入商品名和价格，输出购买的商品信息，并输出应付的总价。
  要求：定义Goods类及其成员变量和方法。
  （1）定义Goods类：成员变量有 name, price
  （2）定义Goods类的带两个参数的构造方法。
  （3）定义Goods类的toString()方法，getPrice()方法。
  输入格式:
  输入5行数据，每行一个商品信息，包括商品名和价格，以一个空格分隔。
  输出格式:
  输出商品信息，格式：商品名,价格
  最后输出总价，格式：should pay:总价
  裁判程序如下：

class Main{
    public static void main(String args[]){
        Goods ga[] =new Goods[5];
        Scanner sc = new Scanner(System.in);
        for(int i =0;i<5;i++){
            ga[i]= new Goods(sc.next(),sc.nextDouble());
        }        
        double  shouldPay = 0;
        for(Goods g:ga){
            shouldPay += g.getPrice();
            System.out.println(g.toString());
        }
        System.out.println("should pay:"+shouldPay);            
    }
}

输入样例:

book 5.5 
pencil 1.2 
pen 8.0 
ruler 2.5 
eraser 1.0

输出样例:

book,5.5
pencil,1.2
pen,8.0
ruler,2.5
eraser,1.0
should pay:18.2

代码编程：

import java.util.Scanner;
import java.lang.Math;
class Main{
    public static void main(String args[]){
        Goods ga[] =new Goods[5];
        Scanner sc = new Scanner(System.in);
        
        for(int i =0;i<5;i++){
            ga[i]= new Goods(sc.next(),sc.nextDouble());
        }        
        
        double  shouldPay = 0;
        for(Goods g:ga){
            shouldPay += g.getPrice();
            System.out.println(g.toString());
        }
        
        System.out.println("should pay:"+shouldPay);            
    }
}
class Goods{
	private String name;
	private double price;
	public Goods(String name, double price) {
		super();
		this.name = name;
		this.price = price;
	}
	@Override
	public String toString() {
		return name + "," + price;
	}
	public double getPrice() {
		return this.price;
	}
}

• 构造函数与初始化块
  1. 定义一个Person类
     属性：String name, boolean gender, int age, int id ,所有的变量必须为私有(private)。
     无参构造函数:Person(), 功能：打印This is constructor 。
     有参构造函数:Person(name, gender, age) ，功能：给属性赋值。
     建议：使用Eclipse自动生成toString方法
  2. 定义类的初始化块
     为Person类加入初始化块，在初始化块中对id属性赋值，并且要保证每次的值比上次创建的对象的值+1。然后在下一行打印This is initialization block, id is … 其中…是id的值。
     提示：可为Person类定义一个static属性来记录所创建的对象个数
  3. 编写静态初始化块
     打印This is static initialization block
  4. 编写main方法
     • 首先输入n，代表要创建的对象数量。
     • 然后从控制台分别读取n行的name, gender, age, 并调用有参构造函数Person(name, age, gender)新建对象 。
     • 将创建好的n个对象逆序输出(即输出toString()方法)。
     • 使用无参构造函数新建一个Person对象，然后直接打印该对象。

思考
初始化类与对象有几种方法，构造函数、初始化块、静态初始化块。这三种方法执行的先后顺序是什么？各执行几次。
输入样例:

3
a 11 false
b 12 true
c 10 false

输出样例:

This is static initialization block
This is initialization block, id is 0
This is initialization block, id is 1
This is initialization block, id is 2
Person [name=c, age=10, gender=false, id=2]
Person [name=b, age=12, gender=true, id=1]
Person [name=a, age=11, gender=false, id=0]
This is initialization block, id is 3
This is constructor
null,0,false,3
Person [name=null, age=0, gender=false, id=3]

代码编程

import java.util.Scanner;
import java.lang.Math;
class Main{
    public static void main(String args[]){
    	Scanner sc = new Scanner(System.in);
    	int n = sc.nextInt();
    	Person people[] = new Person[n];
    	for(int i=0;i<n;i++) {
    		String name = sc.next();
    		int age = sc.nextInt();
    		boolean gender = sc.nextBoolean();
    		people[i] = new Person(name,gender,age);
    	}
    	for(int i = n-1;i>=0;i--) {
    		System.out.println(people[i].toString());
    	}
    	Person temp = new Person();
    	System.out.println(temp.getName()+","+temp.getAge()+","+temp.isGender()+","+temp.getId());
    	System.out.println(temp.toString());
    }
}
class Person{
	private String name;
	private boolean gender;
	private int age;
	private int id;
	private static int nums=-1;
	Person(){
		System.out.println("This is initialization block, id is "+nums);
		System.out.println("This is constructor");
		this.name = null;
		this.gender = false;
		this.age = 0;
		this.id = nums;
	}
	public Person(String name, boolean gender, int age) {

		this.name = name;
		this.gender = gender;
		this.age = age;
		this.id = nums;
		System.out.println("This is initialization block, id is "+nums);
	}
	static{
		System.out.println("This is static initialization block");
	}
	{
		nums++;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", gender=" + gender + ", id=" + id + "]";
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public boolean isGender() {
		return gender;
	}
	public void setGender(boolean gender) {
		this.gender = gender;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

4. 继承与多态

1. 教师类
   设计一个教师类Teacher,要求：
   属性有编号（int no）、姓名（String name）、年龄（int age）、所属学院（String seminary），为这些属性设置相应的get和set方法。
   为Teacher类重写equals方法，要求：当两个教师对象的no相同时返回true。
   重写Teacher类的toString方法，通过该方法可以返回“no: , name:, age: **, seminary: **”形式的字符串。
   输入格式:
   两个教师对象的编号，姓名，年龄，学院
   输出格式:
   教师的信息
   两个教师是否相等
   输入样例:
   在这里给出一组输入。例如：

1 Linda 38 SoftwareEngineering
2 Mindy 27 ComputerScience

输出样例:
在这里给出相应的输出。例如：

no: 1, name:Linda, age: 38, seminary: SoftwareEngineering
no: 2, name:Mindy, age: 27, seminary: ComputerScience
false

编程代码：

import java.util.Objects;
import java.util.Scanner;
import java.lang.Math;
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		Teacher teacher[] = new Teacher[2];
		for(int i=0;i<teacher.length;i++) {
			int id = sc.nextInt();
			String name = sc.next();
			int age = sc.nextInt();
			String seminary = sc.next();
			teacher[i] = new Teacher(id,name,age,seminary);
			System.out.println(teacher[i].toString());
		}
		System.out.println(teacher[0].equals(teacher[1]));
	}
}
class Teacher{
	private int no;
	private String name;
	private int age;
	private String seminary;
	
	
	public Teacher(int no, String name, int age, String seminary) {
		super();
		this.no = no;
		this.name = name;
		this.age = age;
		this.seminary = seminary;
	}
	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	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 getSeminary() {
		return seminary;
	}
	public void setSeminary(String seminary) {
		this.seminary = seminary;
	}

	
	@Override
	public boolean equals(Object obj) {
		if (obj == null)
			return false;
		Teacher other = (Teacher) obj;
		return no == other.no;
	}
	@Override
	public String toString() {
		return "no: " + no + ", name:" + name + ", age: " + age + ", seminary: " + seminary;
	}
}

2. 覆盖
   Java每个对象都继承自Object,都有equals、toString等方法。
   现在需要定义PersonOverride类并覆盖其toString与equals方法。
   1. 新建PersonOverride类
   • 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。
   • 有参构造方法，参数为name, age, gender
   • 无参构造方法，使用this(name, age,gender)调用有参构造函数。参数值分别为"default",1,true
   • toString()方法返回格式为：name-age-gender
   • equals方法需比较name、age、gender，这三者内容都相同，才返回true.

2. main方法
2.1 输入n1，使用无参构造函数创建n1个对象，放入数组persons1。
2.2 输入n2，然后指定name age gender。每创建一个对象都使用equals方法比较该对象是否已经在数组中存在，如果不存在，才将该对象放入数组persons2。
2.3 输出persons1数组中的所有对象
2.4 输出persons2数组中的所有对象
2.5 输出persons2中实际包含的对象的数量
2.5 使用System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));输出PersonOverride的所有构造函数。
**提示：**使用ArrayList代替数组大幅复简化代码，请尝试重构你的代码。
输入样例:

1
3
zhang 10 true
zhang 10 true
zhang 10 false

输出样例:

default-1-true
zhang-10-true
zhang-10-false
2
[public PersonOverride(), public PersonOverride(java.lang.String,int,boolean)]

编程代码：

import java.util.Arrays;
import java.util.Objects;
import java.util.Scanner;
import java.lang.Math;
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n1 = sc.nextInt();
		PersonOverride PO1[] = new PersonOverride[n1];
		for(int i=0;i<n1;i++) {
			PO1[i] = new PersonOverride();
		}
		int n2 = sc.nextInt();
		PersonOverride PO2[] = new PersonOverride[n2];
		int count2 = 0;
		for(int i=0;i<n2;i++) {
			boolean flag = true;
			String name = sc.next();
			int age = sc.nextInt();
			Boolean gender = sc.nextBoolean();
			PersonOverride temp = new PersonOverride(name,age,gender);
			for(int j=0;j<count2;j++) {
				if(PO2[j].equals(temp)) {
					flag = false;
					break;
					}
				}
			if(flag) {
				PO2[count2] = new PersonOverride(name,age,gender);
				count2++;
			}
		}
		for(int i=0;i<n1;i++) {
			System.out.println(PO1[i].toString());
		}
		for(int i=0;i<count2;i++) {
			System.out.println(PO2[i].toString());
		}
		System.out.println(count2);
		System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
	}
}
class PersonOverride{
	private String name;
	private int age;
	private boolean gender;
	
	public PersonOverride(){
		this("default",1,true);
	}
	
	public PersonOverride(String name, int age, boolean gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}

	@Override
	public String toString() {
		return name + "-" + age + "-" + gender;
	}

	@Override
	public boolean equals(Object obj) {
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		PersonOverride other = (PersonOverride) obj;
		return age == other.age && gender == other.gender && Objects.equals(name, other.name);
	}
}

3. 校园角色类设计
   学校需要构建综合系统，使用者包含多种角色。角色Role分两类：学生Student和雇员Employee；雇员又分为教员Faculty和职员Staff。
   每个角色都有姓名、性别。学生有学号、班级。一个雇员有工号、入职日期。教员有职称。职员有职位称号。
   请以如下Main类为基础，构建各个角色类，将代码补充完整。

public class Main {
    public static void main(String[] args) {
        Faculty fac = new Faculty("张三",32,"33006","2019","10","25","讲师");
        Student stu=new Student("李四",19,"20201103","202011");
        Staff sta = new Staff("王五",27,"32011","2015","06","17","教务员");        
        fac.show();
        sta.show();
        stu.show();
    }
}

输入格式:
无
输出格式:
我是张三，年龄32岁。工号是33006，2019年10月25日入职。是一名教师，讲师职称。
我是王五，年龄27岁。工号是32011，2015年6月17日入职。是一名教务员。
我是李四，年龄19岁。学号是20201103，来自202011班。
输入样例:
在这里给出一组输入。例如：

输出样例:
在这里给出相应的输出。例如：

我是张三，年龄32岁。工号是33006，2019年10月25日入职。是一名教师，讲师职称。
我是王五，年龄27岁。工号是32011，2015年6月17日入职。是一名教务员。
我是李四，年龄19岁。学号是20201103，来自202011班。

编程代码：

public class Main {
    public static void main(String[] args) {
        Faculty fac = new Faculty("张三",32,"33006","2019","10","25","讲师");
        Student stu=new Student("李四",19,"20201103","202011");
        Staff sta = new Staff("王五",27,"32011","2015","06","17","教务员");        
        fac.show();
        sta.show();
        stu.show();
    }
}
class Role{
	private String name;
	private int age;
	private String id;
	public Role(String name, int age, String id) {
		this.name = name;
		this.age = age;
		this.id = id;
	}
	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 getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
}
class Student extends Role{//学生类
	private String grend;

	public Student(String name, int age, String id, String grend) {
		super(name, age, id);
		this.grend = grend;
	}

	public String getGrend() {
		return grend;
	}

	public void setGrend(String grend) {
		this.grend = grend;
	}

	@Override
	public String toString() {
		return "我是"+super.getName()+"，年龄"+super.getAge()+"岁。学号是"+super.getId()+"，来自"+getGrend()+"班。";
	}
	public void show() {
		System.out.println(toString());
	}
}
class Employee extends Role{//雇员类
	private String year;
	private String month;
	private String day;
	private String professional;
	public Employee(String name, int age, String id, String year, String month, String day, String professional) {
		super(name, age, id);
		this.year = year;
		this.month = month;
		this.day = day;
		this.professional = professional;
	}
	public String getYear() {
		return year;
	}
	public void setYear(String year) {
		this.year = year;
	}
	public String getMonth() {
		return month;
	}
	public void setMonth(String month) {
		this.month = month;
	}
	public String getDay() {
		return day;
	}
	public void setDay(String day) {
		this.day = day;
	}
	public String getProfessional() {
		return professional;
	}
	public void setProfessional(String professional) {
		this.professional = professional;
	}
	
}
class Faculty extends Employee{//教员-->讲师
	public Faculty(String name, int age, String id, String year, String month, String day, String professional) {
		super(name,age,id,year,month,day,professional);
	}

	@Override
	public String toString() {
		return "我是"+super.getName()+"，年龄"+super.getAge()+"岁。工号是"+super.getId()+"，"+Integer.parseInt(super.getYear()) +"年"+Integer.parseInt(super.getMonth())+
				"月"+Integer.parseInt(super.getDay())+"日入职。是一名教师，"+super.getProfessional()+"职称。";
	}
	public void show() {
		System.out.println(toString());
	}
}
class Staff extends Employee{//职员-->教务员
	public Staff(String name, int age, String id, String year, String month, String day, String professional) {
		super(name,age,id,year,month,day,professional);
	}
	@Override
	public String toString() {
		return "我是"+super.getName()+"，年龄"+super.getAge()+"岁。工号是"+super.getId()+"，"+Integer.parseInt(super.getYear())+"年"+Integer.parseInt(super.getMonth())+
				"月"+Integer.parseInt(super.getDay())+"日入职。是一名"+super.getProfessional()+"。";
	}
	public void show() {
		System.out.println(toString());
	}
}