javase阶段考试二（面向对象阶段）测试题及答案
一、 简答题（每题5分，共计40分）
1. 什么是类？什么是对象？类与对象的关系是什么？
类简单来说就是"分类"，是多个对象共性提取的抽象描述，在Java中是一种引用数据类型，里面包含了描述特征的成员变量，以及描述行为的成员方法。
类是一种抽象的概念，用于描述对象创建的模板，而对象是客观存在的实体，本质上就是内存空间中的一块区域，对象的数据结构取决于类。
2. 请写出类、属性、行为以及引用和对象声明的语法格式。
class 类名{
数据类型 成员变量名;
返回值类型 方法名称(形式参数列表){
方法体；
}
}
类类型 对象名 = new 类类型();
3. 简述构造方法的语法形式以及主要特点。
class 类名{
类名(形参列表){
构造方法体;
}
}
a构造方法的名称与类名完全相同；
b.构造方法没有返回值类型，连void都不能写；
c.构造方法用于在创建对象时被自动调用，从而实现该对象成员变量的初始化工作；
4. this关键字的基本概念和常见使用场合是什么？
在构造方法中，this代表当前正在构造的对象。
在普通方法中，this代表当前正在调用的对象，也就是调用对象。
当形参名/局部变量和属性同名时，需要使用this关键字通过.来明确表示属性变量，从而提高代码的可读性和正确性，也就是用于区分同名的成员变量和形参以及局部变量。
5. 简述封装的实现流程。
a.私有化成员变量，使用private关键字修饰；
b.提供公有的get成员变量和set成员变量方法，并在方法体中进行合理性的判断；
c.在构造方法中调用set成员变量的方法来确保合理性;
6. 方法重写的三大原则是什么？
a.要求方法名、参数列表、返回值类型相同，从jdk1.5开始允许返回子类类型；
b.要求访问权限不能变小，可以相同或者变大；
c.要求不能抛出更大的异常(异常机制)；
7. final关键字修饰类、方法以及属性各自的效果是什么？
final修饰的类表示该类不能被继承。
final修饰的方法不可以被重写，但可以被继承。
final修饰的成员变量必须被初始化，并且只能初始化一次。
8. 简述抽象类的实际意义。
抽象类的实际意义不在于创建对象而在于被继承，当一个类继承抽象类之后则必须要重写抽象方法，否则该类也要变成抽象类。
因此抽象类对子类具有强制性和规范性，通常叫做 模板设计模式。
二、 编程题（1~3每题10分，4~5每题15分，共计60分）
1. 提示用户输入班级的学生人数以及每个学生的信息，学生的信息有：学号、姓名、
年龄，最后分别打印出来，假定已提供Student类。
提示： Student[] arr = new Student[num]；
import java.util.Scanner;
public class TestStudent {
public static void main(String[] args) {
//1.提示用户输入班级人数并使用变量记录
System.out.println("请输入班级人数：");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
//2.根据用户输入的人数来声明一个数组 变长数组
Student[] arr = new Student[num];
//3.提示用户输入每个学生的信息并记录到数组中
for(int i = 0; i < num; i++){
System.out.println("请输入第" + (i+1) + "个学生的信息(学号 姓名 年龄)：");
arr[i] = new Student(sc.nextInt(), sc.next(), sc.nextInt());
}
System.out.println("--------------------------------------------");
//4.打印所有学生信息
for(int i = 0; i < num; i++){
System.out.println(arr[i].getName() + arr[i]. getAge() + arr[i].getId());
}
}
}
2. 分别使用递归和递推方式自定义成员方法计算参数n的阶乘并返回，要求写出方法即可。
//递推
int show(int n){
int res = 1;
for(int i = n; i >= 1; i--){
res = res * i;
}
return res;
}
//递归
int show1(int n){
if(1 == n){
return 1;
}
return n * show(n-1);
}
3. 编程实现Singleton类的封装，分别编写饿汉式和懒汉式。
/*
编程实现Singleton类的封装，饿汉式
*/
public class Singleton{
//2.提示本类类型的引用指向本类自己的对象
private static Singleton sin = new Singleton();
//1.私有化构造方法
private Singleton(){}
//3.提供公有的get成员变量方法将对象返回出去
public static Singleton getInstance(){
return sin;
}
}
/*
懒汉式
*/
public class Singleton{
//2.提示本类类型的引用指向本类自己的对象
private static Singleton sin = null; //懒汉式
//1.私有化构造方法
private Singleton(){}
//3.提供公有的get成员变量方法将对象返回出去
public static Singleton getInstance(){
if(null == sin){
sin = new Singleton();
}
return sin;
}
}
4. 编程实现以下需求：
自定义狗类，属性有：名字，牙齿数量，行为有：打印所有属性以及看家。
自定义猫类，属性有：名字、毛色，行为有：打印所有属性以及抓老鼠。
自定义动物类来描述上述类型的共性特征和行为。
/*
自定义狗类，属性有：名字，牙齿数量，行为有：打印所有属性以及看家
*/
public class Dog{
private String name;
private int tooth;
public Dog() {
super();
}
public Dog(String name, int tooth) {
setName(name);
setTooth(tooth);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getTooth() {
return tooth;
}
public void setTooth(int tooth) {
if(tooth > 0){
this.tooth = tooth;
}else{
System.out.println("牙齿数量不合理！！！");
}
}
public void show(){
System.out.println("name = " + getName() + "tooth = " + getTooth());
}
public void can(){
System.out.println("狗会看家");
}
}
/*
自定义猫类，属性有：名字、毛色，行为有：打印所有属性以及抓老鼠
*/
public class Cat{
private String name;
private String color;
public Cat() {
super();
}
public Cat(String name, String color) {
setName(name);
setColor(color);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void show(){
System.out.println("name = " + getName() + "color = " + getColor());
}
public void can(){
System.out.println("猫会抓老鼠");
}
}
/*
自定义动物类来描述上述类型的共性特征和行为
*/
public class Animal{
private String name;
public Animal() {
super();
}
public Animal(String name) {
super();
setName(name);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("name = " + getName());
}
}
5. 自定义Account类实现封装，特征有：账户余额，提供一个计算利息并返回的抽象方法。
自定义FixedAccount类继承Account类，在main()方法中使用多态的方式创建对象并指定账户余额，最后计算利息并打印出来。
/*
自定义Account类实现封装，特征有：账户余额，提供计算利息并返回的抽象方法
*/
public abstract class Account {
private int money;
public Account() {
super();
}
public Account(int money) {
super();
setMoney(money);
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
if(money > 0){
this.money = money;
}else{
System.out.println("金额不合理！！！");
}
}
//提供计算利息并返回的抽象方法
public abstract double getLixi();
}
/*
自定义FixedAccount类继承Account类，
在main()方法中使用多态的方式创建对象并指定账户余额，最后计算利息并打印出来
*/
public class FixedAccount extends Account {
public FixedAccount(int i) {
super(i);
}
@Override
public double getLixi() {
return getMoney() * 0.003;
}
public static void main(String[] args) {
//父类的引用指向子类的对象，形成了多态
Account acc = new FixedAccount(1000);
System.out.println("获取到的利息是：" + acc.getLixi()); //3.0
}
}