JAVA基础（第9天 类，对象，抽象类，接口）

一、选择题（30分）

1.在Java中，关于注释，说法错误的是（C ）。
• A:单行注释使用“//”开头
• B:多行注释使用“/*”开头，“*/”结尾
• C:文档注释使用“//”开头, “*/”结尾
• D:如果说明的文字较多时（例如超过一行），一般使用多行注释
2.在Java中，Scanner类提供从控制台获取键盘输入的功能，已知正确实例化Scanner类的对象为input，则下列语句（D）能够获得键盘输入的int数据类型的数值。
• A:input.nextDouble();
• B:input.nextChar();
• C:input.nextBoolean();
• D:input.nextInt();
3.在以下Java的数据类型中，（ A）数据类型最适合存储年龄变量。
• A:int
• B:double
• C:char
• D:String
4.Java语言中异常的分类是哪项( B)。
• A:运行时异常和异常
• B:受检异常和非受检异常
• C:错误和异常
• D:错误和运行时异常
5.在Java中，使用文档注释的格式是（C）
• A:以//开头
• B:以/*开头，以*/结尾
• C:以/**开头，以*/结尾
• D:以/**开头，以**/结尾
6.下列关于修饰符混用的说法错误的是（ D ）。
• A:abstract不能与final同时修饰一个类
• B:接口中不可以有private的成员
• C:abstract方法必须在abstract类或接口中
• D:static方法中能直接处理非static的属性
7.在Java中，使用Eclipse进行代码调试时，步骤顺序为（A）。
(1) 设置断点
(2) 启动调试
(3) 跟踪程序，观察变量变化
(4) 单步调试执行
• A:①②④③
• B:②①③④
• C:①②③④
• D:④③②①
8.在Java中，已有public int sum(){return 0;}方法，在同一个类中以下不能与此方法构成重载的是（ C）。
• A:public int sum(int start,int end){ return 10;}
• B:public int sum(int start){ return 10;}
• C:public double sum(){return 10;}
• D:public int sum(double start){return 10;}
9.在Java中，Java源文件编译后的扩展名是（C）。
• A:.java
• B:.cla
• C:.class
• D:.cls
10.以下关于Java中的接口说法不正确的是（ BC ）。
• A:接口中可以定义常量，不能定义变量
• B:接口中所有方法都是抽象方法
• C:一个接口可以继承多个接口，也可以继承类
• D:一个类只能继承一个父类，但可以实现多个接口
11.在Java中，以下关于多态说法错误的是（ B）。
• A:实现多态的一个前提是要有继承关系
• B:将一个父类的引用指向一个子类对象，要进行强制类型转换
• C:父类引用变量指向其子类对象是实现多态的一个条件
• D:使用多态可以提高代码的可扩展性和可维护性
12.在Java中，以下关于包的描述正确的是（B ）。
• A:声明包使用package关键字，在声明时只要是在Java源文件中正式代码之前即可
• B:对于包的命名通常采用小写字母组成，同时不能以圆点作为开头和结尾
• C:要使用不在同一个包中的类，不需要将包显式地包括在Java程序中
• D:在一个Java源文件可以有多个包的声明语句
13.下列选项中，关于Java中方法描述正确的是（C）。
• A:方法中必须用return返回
• B:方法可以不定义在类中
• C:当方法没有返回值的时候，要用关键字void修饰
• D:一个类至少要定义一个方法
14.在JAVA中，while与do-while的区别是（A ）。
• A:do-while的循环体至少无条件执行一次
• B:在任何情况下，do-while和while都不可以互相转换
• C:while比do-while的控件条件更严格
• D:while是先执行循环体后判断控件条件，do-while则反之
15.在Java中，下列选项中关于封装说法错误的是（ D）。

• A:封装就是隐藏类的实现细节，提供程序规定的方法来访问数据，还可以在这些方法中加入存取控制语句，限制不合理操作
• B:封装的过程就是将属性的访问权限设置为private，并为每个属性创建一对getter()和setter()方法
• C:封装时会用到多个权限控制符来修饰成员变量和方法
• D:在封装时，对属性的赋值控制语句是放在getter()方法中(也可以是在构造方法里)
16.在Java程序设计语言中，使用类的步骤包括（D ）。
• A:使用关键字class定义类
• B:使用关键字new创建类的对象
• C:使用点运算符“.”访问类的属性和方法
• D:以上全部
17.某Java类的main方法如下所示，则编译运行该类的输出结果是（D ）。
public static void main(String[] args) {
for(int i=0;i<10;i++){
if(i%2!=0)
return;
System.out.print(i);
}
}
• A:13578
• B:02468
• C:0123456789
• D:0
18.以下关于abstract的说法，正确的是（ D ）。
• A:abstract只能修饰类
• B:abstract只能修饰方法
• C:abstract类中必须有abstract方法
• D:abstarct方法所在的类必须用abstract修饰
19.在Java中，以下关于抽象类和接口的说法错误的是（ D）。
• A:Java中的类只能继承一个父类，但可以实现多个接口
• B:一个类如果实现了一个接口，则必须实现接口中的全部方法，除非其本身也是抽象的
• C:Java中通过实现接口达到了多重继承的效果
• D:抽象类不可以实现接口
20.下面Java程序的输出结果为True的是（BD）。
String s=”ADD”;
String t=”ADD”;
• A:System.out.println(s=t);
• B:System.out.println(s==t);
• C:System.out.println(s.equal(t));
• D:System.out.println(s.equals(t));
21.有三个Java类，分别是Person.java、Student.java、Test.java，代码如下：
Person.java
public class Person {
protected String name;
public void study(String name){
this.name=name;
System.out.println(this.name+“正在学习”);
}
}
Student.java
public class Student extends Person{
public void study(String name){
super.name=name;
System.out.println(“学生”+super.name+“正在学习”);
}
}
Test.java
public class Test {
public static void main(String[] args) {
Person p = new Student();
p.study(“李立”);
}
}
请问，Test.java的执行结果是（A）。
• A:学生李立正在学习
• B:李立正在学习
• C:李立正在学习
• 学生李立正在学习
• D:代码编译错误
22.在Java中，使用static关键字可以修饰方法和属性，下面选项中关于静态方法描述正确的是（ AC）。
• A:在静态方法中不能直接调用非静态方法
• B:在非静态方法中不能直接调用静态方法
• C:使用类名可以直接调用非私有的静态方法
• D:在静态方法中可以使用this关键字
23.现有程序：
class Birds {
public static void main(String[] args) {
try {
throw new Exception();
} catch (Exception e) {
try {
throw new Exception();
} catch (Exception e2) {
System.out.print(“inner”);
}
System.out.print(“middle”);
}
System.out.print(“outer”);
}
}
程序执行的结果：（C）
• A:inner outer;
• B:middle outer;
• C:inner middle outer;
• D:编译失败;
24.下面Java程序的描述正确的是（）。
class HelloWorld{
public static void main(String[]args){
system.in.println(‘Hello World!’);
}
}
• A:没有错误
• B:有1处错误
• C:有2处错误
• D:有3处错误
25.下列有关抽象类与接口的叙述中正确的是（ C ）。

• A:抽象类中必须有抽象方法，接口中也必须有抽象方法
• B:抽象类中可以有非抽象方法，接口中也可以有非抽象方法
• C:含有抽象方法的类必须是抽象类，接口中的方法必须是抽象方法
• D:抽象类中的变量定义时必须初始化，而接口中不是。
26.在Java中，某Java类中包含如下main函数，则编译运行此类的结果是（D ）。
public static void main(String args[]) {
double a = 32.587; //第1行
int b = (int)a; //第2行
System.out.println(“b=” + b); //第3行
}
• A:第1行出现编译错误
• B:第2行出现编译错误
• C:第3行出现编译错误
• D:程序正确运行，输出结果为：b=32
27.下列属于非受检异常的是哪项（ D）。
• A:SQLException
• B:IOException
• C:NullPointerException
• D:OutOfMemoryError
28.给定如下Java代码，下列横线处填入（C ）选项，可以实现divide()方法的重写，并且能够编译正确。
class Arithmetic{
public int divide(int a,int b){
return a/b;
}
}
public class Demo extends Arithmetic{

---

}
• A:private int divide(int a,int b){
• return a/b+1;
• }
• B:public double divide(int a,int b){
• return a/b+1;
• }
• C:public int divide(int a,int b){
• return a/b+1;
• }
• D:public int divide(int a){
• return a/b+1;
• }
29.分析如下Java代码程序，如果运行程序后输出的结果是1-10之间的偶数和，则在下划线处应填入的代码是（ D）。
public class HelloAccp {
public static void main(String[] args){
int sum=0;
for (i=1;i<=10;i++){
if ( _______ )
continue;
sum=sum+i;
}
System.out.println(“1-10之间的偶数和为：”+sum);
}
}
• A:i%2=1
• B:i/2=1
• C:i/21
• D:i%21
30.在Java中，执行如下代码后，输出结果描述正确的是（C ）。
public class Animal{
int age=9;
public Animal(int age){
this.age=age;
}
public static void main(String[] args) {
Animal animal=new Animal();
System.out.println(animal.age);
}
}
• A:9
• B:0
• C:编译错误
• D:null
二、简答题（48分，每题6分）

1. 简要回答一下重写（Overriding）和重载（OverLoading）的区别
   方法的重写Overriding和重载Overloading是Java多态性的不同表现。
   重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。二者多态的差别在于，重载的编译时多态，重写是运行时多态。重写(Overriding)是父类与子类之间多态性的一种表现，而重载(Overloading)是一个类中多态性的一种表现。
   如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding) 。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。
   如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型或有不同的参数次序，则称为方法的重载(Overloading)。不能通过访问权限、返回类型、抛出的异常进行重载.
   重写（override) 特点 ：
   1、 override的子类的方法名称、参数类型必须要和父类方法的完全匹配，才能达到重写的效果；
   2、override的子类的方法的返回值类型必须和 父类方法的一致，其modifier可以扩大，不可以缩小；
   3、override的子类的方法所抛出的异常只能是父类方法抛出异常的子异常；
   4、被private、final等关键字修饰的方法是不能被override的；
   5、一个不是用abstract标识的方法不可以override成abstract方法。

重载（Overload） 特点 ：
1、在使用重载时只能通过不同的参数样式（例如，不同的参数类型，不同的参数个数，不同的参数顺序）；
2、方法的异常类型和数目不会对重载造成影响；
3、不能通过访问权限、返回类型、抛出的异常进行重载（例如，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果）。

2. 简述Java 实现动态多态的手段。
   Java 多态主要体现为父类引用变量可以指向子类对象：
   父类类型 变量名 = new 子类类型();
   1、多态的前提是必须有子父类关系或者类实现接口关系，否则无法完成多态。
   2、在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。
   多态主要有三种形式:
   1.普通类多态定义的格式
   父类 变量名 = new 子类();
   2、 抽象类多态定义的格式
   abstract class Parent{
   public abstract void m1();
   }
   class Child extends Parent{
   @Override
   public void m1(){
   System.out.println(“重写父类抽象方法”);
   }
   }
   //类的多态使用
   Parent fu= new Child ();
   3、接口多态定义的格式
   interface InterfaceA{
   public abstract void m1();
   }
   class ClassA implements InterfaceA {
   public void m1(){
   System.out.println(“重写接口抽象方法”);
   }
   }
   InterfaceA obj =new ClassA();
   另外，java的多态还表现在同类中，同样的动作，接收的数据不同其处理方式也不同。这个就是重载。

3. 简述this和super的区别
   关键字this:
   　　this是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指针。
   　　this的用法在java中大体可以分为3种：
   　　1、普通的直接引用
   　　this相当于是指向当前对象本身。
   2、形参与成员名字重名，用this来区分。
   3、引用本类的构造函数。
   关键字super:
   可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。
   　　super也有三种用法：
   　　1、普通的直接引用
   　　与this类似，super相当于是指向当前对象的父类的引用，这样就可以用super.xxx来引用父类的成员。
   　　2、子类中的成员变量或方法与父类中的成员变量或方法同名时，用super进行区分.
   3、引用父类构造函数
   　　super（参数）：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。
   this（参数）：调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）。
   注意：在调用构造方法时，两个不能同时使用。
   super和this的异同：
   • super:　它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名、super.成员函数据名（实参）。
   • this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）
   • super()和this()类似,区别是，super()在子类中调用父类的构造方法，this()在本类内调用本类的其它构造方法。
   • super()和this()均需放在构造方法内第一行。
   • 尽管可以用this调用一个构造器，但却不能调用两个。
   • this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
   • this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
   • 从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

4. 简述抽象类和接口的区别
   1.语法层面上的区别：
   1）定义不同，抽象类：abstract class 类名{}；接口 interface 接口名{}。
   抽象类可以有普通成员方法，接口只能有抽象方法，jdk8开始支持默认方法和静态方法。
   2）抽象类中的变量可以是任意的，但是接口中的变量只能是public static final来修饰的。
   3）抽象类中可以有静态方法和静态代码块，但是接口中不能有静态代码块或者是静态方法。
   4）抽象类是单继承的但是接口是多实现的。
   2.设计层面上的区别：
   抽象类是对事务整体的抽象，而接口只是对行为的抽象。比如说汽车和火车都能抽象为一个类，他们都有行驶的功能，我们可以把行驶作为一个接口，用汽车和货车来实现这个接口。抽象类描述的是”是不是“，而接口描述的是”有没有“。
   如果一个类A继承了抽象类B，但是又对B中的方法不满意，那么我们可以在B中修改抽象方法（所有子类的公共方法），但是A中的代码却不需要改动。如果一个接口C中的方法做了更改，那么所有实现这个接口的非抽象方法都必须做出相应的改动。抽象类是一种模板式的定义，而接口则是一种规范的定义。

5. 简述子类的构造方法和其对象创建的过程
   1.首先，初始化父类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；
   2.然后，初始化子类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化。
   3.其次，初始化父类的普通成员变量和代码块，在执行父类的构造方法；
   4.最后，初始化子类的普通成员变量和代码块，在执行子类的构造方法；
   以上是一般过程，首先一开始先初始化的是静态成员变量和静态代码块是因为这些代码在类加载的时候就加载进内存了，这些内容只执行一次，需要特别注意！！！！

6. 如何定义包、使用包，以及使用时应该注意哪些事项。
   包是Java语言提供的一种区别类名字命名空间的机制，它是类的一种文件组织和管理方式、是一组功能相似或相关的类或接口的集合。Java package提供了访问权限和命名的管理机制，它是Java中很基础却又非常重要的一个概念。
   一、包的作用
   1 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
   2 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
   3 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
   二、包的定义
   在一个.java文件中可以一个public类和多个非public类，如果要将这些类组织在一个包当中，则在.java文件中除注释以外的第一行使用关键字package即可实现。当需要调用此包中的类时，就可以使用关键字import进行导入。在定义包的时候，应该注意几点:
   1 为了尽量使包名保持唯一性，包名通常采用小写、按倒写互联网址的形式进行定义。如:com.hank.www表示包文件放置的文件路径为com/hank/www。
   2 在进行命名包时，应该避免使用与系统发生冲突的名字，如java.lang、java.swing等。
   三、包的使用：
   1、创建类的时候，在java源码第一行使用 package 关键字标志本类所在的包。
   2、如果某个类调用不同包类时，使用 import进行导入，如果使用import包名.*；表示导入包中所有的类。
   3、如果本包中有某个类，而这时必须导入另外一个包相同名字的类时，使用import导入时会出现问题，为了避免出现歧义，一般使用全类名访问。

7. try-catch-finally的执行过程。
   1、finally语句块一定执行吗？当try中有System.exit(0)时，会强制退出，就不会执行finally中的语句了。
   2、当try、catch中有return时，finally中的代码依然会继续执行
   3、finally是在return后面的表达式运算之后执行的，此时并没有返回运算之后的值，而是把值保存起来，不管finally对该值做任何的改变，返回的值都不会改变，依然返回保存起来的值。也就是说方法的返回值是在finally运算之前就确定了的。
   4、finally代码中最好不要包含return，程序会提前退出，也就是说返回的值不是try或catch中的值
   主要分为分六种情况：
   情况1：try{}catch{}finally{} return;
   程序正常进行
   情况2：try{return;}catch{}finally{} return;
   a、先执行try中的语句，包括return后面的表达式，b、然后执行finally中的语句，c、最后执行try中的return 。
   ps：返回值是try中的return后面的表达式的值，finally后面的return语句不会被执行。
   情况3：try{} catch{return;} finally{} return;
   　　先执行try中的代码块
   　　有异常：a、先执行catch中的语句，包括return后面的表达式，b、然后执行finally中的语句，c、最后执行catch中的return，finally后面的return不会被执行
   　　无异常：执行finally中的代码块，然后执行return语句　
   情况4：try{return;} catch{} finally{return;}
   　　a、先执行try中的语句，包括return后面的表达式，b、然后执行finally中的语句，c、最后执行finally中的return
   　　ps：返回的值是finally中return后面的表达式的值，因为finally中有return语句，所以会提前退出
   情况5：try{} catch{return} finally{return};
   　　先执行try中的代码块
   　　有异常：a、先执行catch中的语句，包括return后面的表达式，b、然后执行finally中的语句，c、最后执行finally中的return，因为finally中有return语句，所以会提前退出
   　　无异常：执行finally中的代码块，然后执行finally中的return
   情况6：try{return;} catch{return;} finally{return;}
   　　先执行try中的代码块，包括return后面的表达式
   　　有异常：a、先执行catch中的语句，包括return后面的表达式；b、然后执行finally中的语句；c、最后执行finally中的return，因为finally中有return语句，所以会提前退出。
   　　无异常：执行finally中的代码块，然后执行finally中的return。
   总结论：在执行try、catch中的return之前一定会执行finally中的代码（如果finally存在），如果finally中有return语句，就会直接执行finally中的return方法，所以finally中的return语句一定会被执行的。编译器把finally中的return语句标识为一个warning。

8. 运行时异常与一般异常有何异同？
   相同点：都是直接或继承于Exception;
   不同点：
   1.定义不同，运行时异常都是RuntimeException类及其子类异常，如NullPointerException、IndexOutOfBoundsException等。一般异常是RuntimeException以外的异常，类型上都属于Exception类及其子类。
   2.处理方法不同，运行时异常是不检查异常，程序中可以选择捕获处理，也可以不处理。对于一般异常，JAVA编译器强制要求用户必需对出现的这些异常进行try-catch并处理，否则程序就不能编译通过。
   3.发生原因不同，运行时异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。面对这种异常不管我们是否愿意，只能自己去写一大堆catch块去处理可能的异常。

四、编程题（32分）

1. 求1！+2！+3！+…+10! (12分)

package app17;

public class Test {
	 
	public static void main(String[] args) {
		//a为某一项的值，sum为前几项的总和;
		int a=1,sum=0;
		for (int i = 1; i <= 10; i++) {
			a*=i;
			sum+=a;
			System.out.println(i+"!="+a);
		}
		System.out.println("1!+2!+3!+...+10!="+sum);
	}
}

2. 定义一个类，完成一个动态数组，可以存取任意类型的对象，当数组空间全部存入元素，空间应扩大原来的一半。（20分）

package app17;

public class ArrayAdd {

	private Object[] obj;// object数组

	private int index;// 数组下标

	public Object[] getObj() {
		return obj;
	}

	public void setObj(Object[] obj) {
		this.obj = obj;
	}

	public int getIndex() {
		return index;
	}

	public void setIndex(int index) {
		this.index = index;
	}

	public ArrayAdd() {// 默认构造函数
		init();
	}

	private void init() {// 数组的初始化
		this.index = 0;
		this.obj = new Object[10];
	}

	public void addLength(Object ele) {// 添加元素

		obj[index] = ele;
		index++;
		// 如果数组下标达到数组长度就开始扩容
		if (index == obj.length) {
			Object[] temp = new Object[obj.length * 2];
			System.arraycopy(obj, 0, temp, 0, obj.length);
			obj = temp;
		}

	}

	// 通过下标获取数组里的元素

	public Object getEle(int index) {
		return obj[index];
	}

	public static void main(String[] args) {
		ArrayAdd a = new ArrayAdd();
		int sum = 0;
		for (int i = 0; i < 20; i++) {
			a.addLength(i);
		}

		// 下面做一个简单验证
		for (int i = 0; i < a.getIndex(); i++) {
			sum += (int) a.getEle(i);
		}

		System.out.println(a.getIndex()); // 20
		System.out.println(sum); // 190

	}

}