> 考试说明：本次测试卷一共25道测试题，共计100分。考试时间120分钟。
## 一、选择题（共 15 题，每题 2 分）
1. 关于 Java 语言 static 应用说法正确的是（C）
```
A 父类中的静态方法可以被子类重写
B 静态数据是属于对象的，可以通过某个对象来引用
C 父类和子类具有同名的静态方法时，当子类对象向上转型后，只能调用到父类原有的静态方法
D 静态的方法中可以通过方法名直接调用非静态的方法
```
2. 以下在 Java 中定义接口正确的是（B）
```
A public interface PersonDao { public int age; public int getAge(); }
B public interface PersonDao { public String getName(); public int getAge(); }
C public interface PersonDao { public String getName() {} pubic int getAge() {} }
D public interface PersonDao { private String getName() {} private int getAge() {} }
```
3. 以下关于 Java 语言继承的说法正确的是（C）
```
A Java 中的类可以有多个直接父类
B 抽象类不能有父类
C Java中的接口支持多继承
D 最终类可以作为其他类的父类
```
4. 对于构造方法，下列叙述不正确的是（C）
```
A 构造方法允许重载
B 子类默认调用父类的无参构造方法
C 子类不被允许调用父类的构造方法
D 在同一个类中定义的重载构造方法可以互相调用
```
5. 对于子类的构造方法说明，下列叙述中不正确的是（C）
```
A 子类默认调用父类的无参构造器
B 子类可以在自己的构造方法中使用super关键字来调用父类指定的构造方法
C 在创建子类对象的时，将先执行调用自父类的无参构造方法，然后再执行自己的构造方法
D 子类不但可以调用父类的无参构造方法，也可以调用父类的有参构造方法
```
6. 有关 Java 中的类和对象，以下说法错误的是（B）
```
A 同一类的所有对象都拥有相同的特征和行为
B 类和对象一样，只是说法不同
C 对象是具有属性和行为的实体
D 类规定了对象拥有的特征和行为
```
7. 在Java中，包的推荐命名规范不正确的是（BD）
```
A java 的包名都是小写单词组成的
B java 的包名首字母大写
C java 的包名采用的是域名的倒序
D java 的包名用圆括号包括
```
8. 如下Java代码的输出结果为（C）
```
public class Student {
public void Student() {
System.out.println("构造学生对象");
}
public static void main(String[] args) {
Student student = new Student();
}
}
```
```
A 输出：构造学生对象
B 编译错误
C 正确运行，但是什么也不输出
D 输出："构造学生对象"
```
9. 下面中哪两个可以在A的子类中使用（AC）
```
public class A {
protected int method1(int a, int b) {
return 0;
}
}
```
```
A public int method1(int a, int b) {return 0;}
B private int method1(int a, int b) {return 0;}
C private int method1(int a, long b) {return 0;}
D public short method1(int a, int b) {return 0;}
```
10. 在下方的代码中，BitUtils 和 SomeApp 分别放在不同的包中，当需要在 SomeApp 中的 main 方法中调用 BitUtils 中的 process方法时，即（1）处需要填写的代码是（C）
```java
package util;
public class BitUtils {
public static void process(byte[] b) {
// ... something ...
}
}
package app;
public class SomeApp {
public static void main(String[] args) {
byte[] bytes = new byte[256];
// (1)
}
}
```
```
A process(bytes);
B BitUtils.process(bytes);
C util.BitUtils.process(bytes);
D 在SomeApp中无法调用BitUtils中的方法;
```
11. 当类中的一个成员方法被下面哪个修饰符修饰后，该方法只能在本类中被访问（B）
```
A public B private C final D default
```
12. 在 Java 中，以下程序的运行结果是（A）
```
public class Person {
String name;
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);
}
}
```
```
A 输出：null
B 正常运行，但不会输出任何内容
C 编译出错，不能运行
D 能运行，但运行时会出现异常
```
13. 下列哪个不是单例模式的要点（B）
```
A 某个类只能有一个实例
B 某个类可以有一个实例
C 单例模式必须自行创建实例
D 必须自行向整个系统提供自行创建的实例
```
14. 下列关于 Java 中接口的说法不正确的是（C）
```
A 接口中方法的访问修饰符默认为 public
B 接口中的方法如果写成 void test(); 的形式，默认是抽象方法
C 实现接口的类中在重写接口中方法时访问修饰符可以为 protected
D 当类实现接口时，需要实现接口中所有的抽象方法，否则需要将该类设置为抽象类
```
15. 下列关于 instanceof 说法不正确的是（C）
```
A instanceof 的返回值为 true 和 false
B instanceof 可以用来判断对象是否可满足某个特定类型
C 可以通过"A instanceof B"表示 A 类可以转型为B类
D instanceof 可放在if语句的条件表达式中
```
## 二、阅读题（共 2 题，每题 5 分）
1. 下面 Java 代码的运行结果是（）
```
public class Penguin {
private String name; // 名字
private int health; // 健康值
private String sex; // 性别
public void Penguin() {
name = "QQ";
health = 10;
sex = "雄性";
}
public void print() {
System.out.println("名字是" + name);
System.out.println("健康值是" + health);
System.out.println("性别是" + sex);
}
public static void main(String[] args) {
Penguin pgn = new Penguin();
pgn.print();
}
}
```
```
名字是：null
健康值是：0
性别是：null
```
2. 下面 Java 代码的运行结果是（）
```
public class Father {
static {
System.out.println("父类静态构造");
}
{
System.out.println("父类构造块");
}
public Father () {
System.out.println("父类构造方法");
}
}
public class Son extends Father {
static {
System.out.println("子类静态构造");
}
{
System.out.println("子类构造块");
}
public Son () {
System.out.println("子类构造方法");
}
public static void main(String[] args) {
Son s1 = new Son();
Son s2 = new Son();
}
}
```
```
父类静态构造
子类静态构造
父类构造块
父类构造方法
子类构造块
子类构造方法
父类构造块
父类构造方法
子类构造块
子类构造方法
```
## 三、简述题（共 3 题，每题 10 分）
1. 请简述方法重载与方法重写的区别。
```
方法重载：满足以下条件的两个方法我们称之为方法重载（Overload）。
1. 在同一个类中
2. 方法名相同
3. 方法参数列表不同（参数类型不同、参数个数不同，参数顺序不同，与参数名称无关）
注意：方法重载与访问修饰符无关，与返回值类型无关。
方法重写：满足以下条件的方法我们称之为方法重写（Override）。
1. 在继承父类的子类中
2. 子类方法名与父类相同
3. 子类方法参数列表与父类相同
4. 子类方法访问修饰符必须比父类访问范围要大
5. 子类方法返回值类型如下：
基础数据类型必须保持一致
引用数据类型必须与父类返回值类型一致，或者是其的派生类
```
2. 请简述抽象类与接口的区别。
```
1. 声明
抽象类是类，使用 abstract + class 关键字来声明，接口使用 interface 关键字来声明
2. 构造方法
抽象类含有构造方法，接口没有构造方法。
抽象类里的构造方法并不能实例对象，而是提供给其子类在实例对象时调用，完成初始化操作。
3. 方法
接口在JDK1.7之前只能包含抽象方法，在JDK1.8之后可以包含静态方法和默认方法(default修饰)
接口所有方法访问修饰符只能为public，可以省略。抽象方法，可以省略abstract关键字。
抽象类中所有普通方法访问修饰符没有限制。
抽象类中抽象方法必须使用abstract修饰，不可省略，访问修饰符不能为private。
4. 属性
抽象类中可以包含成员变量与静态变量。
接口中只能包含静态常量，默认为 public static final 类型，必须初始赋值。
5. 继承与实现
一个类只能继承一个抽象类，重写抽象方法，使用extends关键字。
一个接口可以继承多个接口，使用extends关键字。
一个类可以实现多个接口，重写抽象方法，使用implements关键字。
```
3. 请写出任意一种单例设计模式的代码。
```
public class HungrySingleton {
private HungrySingleton () {}
private static HungrySingleton instance = new HungrySingleton();
public static HungrySingleton getInstance() {
return instance;
}
}
public class LazySingleton {
private LazySingleton() {}
private static LazySingleton instance;
public static LazySingleton getInstance() {
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
}
```
## 四、编程题（共 3 题，每题 10 分）
1. 定义图形 Shape 类、圆 Circle 类和矩形 Rectangle 类完成以下代码输出。
```
圆的面积为 38.465
矩形的面积为 30.0
```
```
public abstract class Shape {
public abstract double area();
}
public class Circle extends Shape {
private static final double PI = 3.14;
private double round;
public double area() {
return PI * this.getRound() * this.getRound();
}
// constructor
// getter/setter...
}
public class Rectangle extends Shape {
private double length;
private double width;
public double area() {
return this.getLength() * this.getWidth();
}
// constructor
// getter/setter...
}
public class Test {
public static void main(String[] args) {
Shape circle = new Circle(3.5);
Shape rectangle = new Rectangle(6.0, 5.0);
System.out.println("圆的面积为" + circle.area());
System.out.println("矩形面积为" + rectangle.area());
}
}
```
2. 定义教师 Teacher 类、学生 Student 类以及班级 Clazz 类完成以下代码输出。
```
30岁的张扬老师正在403教室给三年级二班的10名同学上数学课。
上课的同学有20岁的张三、21岁的李四、22岁的王五和23岁的赵六。
```
```
public class Teacher {
private String name;
private int age;
private String subject;
public void teaching(Clazz clazz) {
System.out.print(this.getAge() + "岁的" + this.getName() + "老师正在给");
System.out.print(clazz.getRoom() + clazz.getGrade() + clazz.getName() + "的");
System.out.print(clazz.getNum() + "名同学上" + this.getSubject() + "课" );
System.out.print("上课的同学有：" + clazz.studentInfo());
}
// constructor
// getter setter...
}
public class Student {
private String name; // 姓名
private int age; // 年龄
// constructor
// getter setter ...
}
public class Clazz {
private String room; // 教室
private String grade; // 年级
private String name; // 班级名称
private Student[] students = new Student[10]; // 学生们
private int num; // 实际学生数量
// 此方法不考虑学生排满溢出的情况
public void addStudent(Student student) {
for (int i = 0; i < students.length; i++) {
if (students[i] == null) {
students[i] = student;
num++;
break;
}
}
}
// constructor
// getter setter ...
public String studentsInfo() {
String info = "";
for (int i = 0; i < students.length; i++) {
info += students[i].getAge() + "的" + students[i].getName() + " ";
}
return info;
}
}
public class Test {
Teacher zhang = new Teacher(35, "张扬", "数学");
Clazz clazz = new Clazz("403教室", "三年级", "二班");
Student s1 = new Student(20, "张三");
Student s2 = new Student(21, "张四");
Student s3 = new Student(22, "张五");
Student s4 = new Student(23, "张六");
clazz.addStudent(s1);
clazz.addStudent(s2);
clazz.addStudent(s3);
clazz.addStudent(s4);
zhang.teaching(clazz);
}
```
3. 编写三个系别的学生类：英语系、计算机系以及文学系。定义一个可容纳 5 个学生类数组，初始学生成绩等信息，按照综合成绩从低到高排序输出。各系总分评测标准如下：
```
英语系：演讲 50%、期中考试 25%、期末考试 25%
计算机系：操作能力 40%、英语写作 20%、期中考试 20%、期末考试 20%
文学系：演讲 35%、作品 35%、期中考试 15%、期末考试 15%
```
```
public abstract class Student {
private int middle; // 期中
private int end; // 期末
public abstract int calcTotal();
// constructor
// getter setter
}
public class EnglishStudent extends Student {
private int speech; // 演讲
// constructor
// getter setter
@Override
public int calcTotal() {
return (int) (0.5 * this.getSpeech() + 0.25 * this.getMiddle() + 0.25 * this.getEnd());
}
@Override
public String toString() {
return "EnglishStudent{综合成绩=" + this.calcTotal() +
", 演讲=" + this.getSpeech() +
", 期中=" + this.getMiddle() +
", 期末=" + this.getEnd() +
'}';
}
}
public class ComputerStudent extends Student {
private int operate; // 操作
private int writing; // 写作
// constructor
// getter setter
@Override
public int calcTotal() {
return (int) (0.4 * this.getOperate() + 0.2 * this.getWriting()
+ 0.2 * this.getMiddle() + 0.2 * this.getEnd());
}
@Override
public String toString() {
return "ComputerStudent{综合成绩=" + this.calcTotal() +
", 操作=" + this.getOperate() +
", 写作=" + this.getWriting() +
", 期中=" + this.getMiddle() +
", 期末=" + this.getEnd() +
'}';
}
}
public class LiteratureStudent extends Student {
private int speech; // 演讲
private int works; // 作品
// constructor
// getter setter
@Override
public int calcTotal() {
return (int) (0.35 * this.getSpeech() + 0.35 * this.getWorks()
+ 0.15 * this.getMiddle() + 0.15 * this.getEnd());
}
@Override
public String toString() {
return "LiteratureStudent{综合成绩=" + this.calcTotal() +
", 演讲=" + this.getSpeech() +
", 作品=" + this.getWorks() +
", 期中=" + this.getMiddle() +
", 期末=" + this.getEnd() +
'}';
}
}
public class Test {
public static void main(String[] args) {
Student[] students = new Student[] {
new LiteratureStudent(70, 90, 100, 80),
new EnglishStudent(90, 70, 90),
new ComputerStudent(70, 70, 70, 70),
new ComputerStudent(80, 90, 90, 70),
new EnglishStudent(80, 80, 80)
};
Arrays.sort(students, Comparator.comparingInt(Student::calcTotal));
for (int i = 0; i < students.length; i++) {
System.out.println(students[i]);
}
}
}
```
- 阶段一 Java 零基础入门
- 步骤1：基础语法
- 第01课 初识
- 第02课 常量与变量
- 第03课 运算符
- 第04课 选择结构
- 第05课 循环结构
- 第06课 一维数组
- 第08课 方法
- 第09课 数组移位与统计
- 第10课 基础语法测试
- 第09课 基础语法测试（含答案）
- 步骤2：面向对象
- 第01课 类和对象
- 第02课 封装
- 第03课 学生信息管理
- 第04课 继承
- 第05课 单例模式
- 第06课 多态
- 第07课 抽象类
- 第08课 接口
- 第09课 内部类
- 第10课 面向对象测试
- 第10课 面向对象测试（含答案）
- 步骤3：常用工具类
- 第01课 异常
- 第02课 包装类
- 第03课 字符串
- 第04课 集合
- 第05课 集合排序
- 第06课 泛型
- 第07课 多线程
- 第08课 输入输出流
- 第09课 案例：播放器
- 第10课 常用工具测试（一）
- 第10课 常用工具测试（一）（答案）
- 第10课 常用工具测试（二）
- 第10课 常用工具测试（二）（答案）
- 阶段二 从网页搭建入门 JavaWeb
- 步骤1：HTML 与 CSS
- 第01课 HTML 入门
- 第01课 HTML 入门（作业）
- 第02课 CSS 入门
- 第02课 CSS 入门（作业）
- 第03课 CSS 布局
- 第03课 CSS 布局（作业）
- 步骤2：JavaScript 与前端案例
- 第01课 JavaScript 入门
- 第01课 JavaScript 入门（作业）
- 第02课 仿计算器
- 第03课 前端油画商城案例
- 第04课 轮播图
- 第05课 网页搭建测试
- 第05课 网页搭建测试（含答案）
- 步骤3：JavaScript 教程
- 入门
- 概述
- 基本语法
- 数据类型
- 概述
- 数值
- 字符串
- undefined, null 和布尔值
- 对象
- 函数
- 数组
- 运算符
- 算术运算符
- 比较运算符
- 布尔运算符
- 位运算符
- 运算顺序
- 语法专题
- 数据类型的转换
- 错误处理机制
- 标准库
- String
- Date
- Math
- DOM
- 概述
- Document 节点
- 事件
- EventTarget 接口
- 事件模型
- 常见事件
- 阶段三 数据库开发与实战
- 步骤1：初始数据库操作
- 第01课 数据类型
- 第02课 表的管理
- 第03课 数据管理
- 第04课 常用函数
- 第05课 JDBC 入门
- 第06课 Java 反射
- 第07课 油画商城
- 第08课 数据库基础测试
- 步骤2：MyBatis 从入门到进阶
- 第01课 IntelliJ IDEA 开发工具入门
- 第02课 Maven 入门
- 第03课 工厂模式
- 第04课 MyBatis 入门
- 第05课 MyBatis 进阶
- 第06课 商品信息管理
- 第07课 MyBatis 基础测试
- 步骤3：Redis 数据库与 Linux 下项目部署
- 第01课 Linux 基础
- 第02课 Linux 下 JDK 环境搭建及项目部署
- 第03课 Redis 入门
- 阶段四 SSM 到 Spring Boot 入门与综合实战
- 步骤1：Spring 从入门到进阶
- 第01课 Spring 入门
- 第02课 Spring Bean 管理
- 第03课 Spring AOP
- 第04课 基于 AspectJ 的 AOP 开发
- 第05课 JDBC Template
- 第06课 Spring 事务管理
- 第07课 人员管理系统开发
- 第08课 Spring 从入门到进阶测试
- 步骤2：Spring MVC 入门与 SSM 整合开发
- 第01课 Spring MVC 入门与数据绑定
- 第02课 Restful 风格的应用
- 第03课 SpringMVC 拦截器
- 第04课 办公系统核心模块
- 步骤3：Spring Boot 实战
- 第01课 Spring Boot 入门
- 第02课 校园商铺项目准备
- 第03课 校园商铺店铺管理
- 第04课 校园商铺商品管理及前台展示
- 第05课 校园商铺框架大换血
- 步骤4：Java 面试
- 第01课 面试准备
- 第02课 基础面试技巧
- 第03课 Web基础与数据处理
- 第04课 主流框架