java面向对象周测带答案
一、简答题（每题5分，共计40分）
1.什么是类？什么是对象？类与对象的关系是什么？
类本质上就是分类的意思，也就是具有相同共性的一类事物的抽象描述。
类就是一种用户可以自定义的引用数据类型，用于包装描述属性的成员变量，和用于描述行为的成员方法，换句话说，类可以用于描述多个不同类型的数据。
类是一种抽象的概念，用于描述对象创建的模板，而对象是客观存在的实体，本质上就是内存空间中的一块区域，对象的数据结构取决于类。
2.请写出类、属性、行为的定义格式，以及引用和对象的定义格式。
class 类名{
数据类型 成员变量名;
返回值类型 方法名称(形式参数列表){
方法体；
}
}
类类型 对象名 = new 类类型();
3.简述方法重载的概念、体现形式以及作用。
当同一个类中方法名相同，参数列表不同的方法之间 构成重载关系。 参数列表的体现形式有：参数个数的不同、参数类型不同、参数顺序不同。
方法的重载与返回值类型和形参变量名无关，但是建议尽量相同。
作用： 对于调用者来说，只需要记忆一个方法名就可以实现所有形式的调用。
4.this关键字的基本概念和常见使用方式是什么？
在构造方法中，this代表当前正在构造的对象。
在普通方法中，this代表当前正在调用的对象，也就是调用对象。
当形参名/局部变量和属性同名时，需要使用this关键字通过.来明确表示属性变量，从而提高代码的可读性和正确性，也就是用于区分同名的成员变量和形参以及局部变量。
5.基本数据类型和引用数据类型分别作为方法参数的效果是什么？。
当基本数据类型作为参数传递时，传递数据内容本身，因此形参改变不会影响到实参；
当引用数据类型作为参数传递时，传递的是引用记录的地址，因此形参指向的内容发生改变时，会直接对实参产生影响。
当引用数据类型作为参数传递后，若形参改变了指向再去改内容，则对实参无影响。。
6.简述封装的实现流程。
a.私有化成员变量，使用private关键字修饰；
b.提供公有的get成员变量和set成员变量方法，并在方法体中进行合理性的判断；
c.在构造方法中调用set成员变量的方法来确保合理性;
7.final关键字修饰类、方法以及属性各自的效果是什么？
final修饰的类表示该类不能被继承。
final修饰的方法不可以被重写，但可以被继承。
final修饰的成员变量必须被初始化，并且只能初始化一次。
8.简述多态的效果。
a.父类引用只能访问父类中的属性和方法。
b.父类引用不能直接访问子类中的属性和方法。
c.父类引用若想访问子类中的属性和方法，则进行强制类型转换，转换为子类变量调用
d.父类引用调用非静态的重写方法时，则调用子类中的版本；
调用静态的重写方法时，则调用父类中的版本。
二、编程题（13题每题10分，45题15分，共计60分）
1．自定义方法将一整数逆序后放入一数组中（要求递归实现）如：1234 变为 {4,3,2,1}。
public void NO1(int num,int[] arr,int i) {
if(num>0) {
arr[i] = num%10;
i++;
NO1(num/10,arr,i);
}else {
return;
}
}
2．编程实现两种形式（饿汉式和懒汉式）的单例模式。
//懒汉式单例模式
public class text {
//设立静态变量
private static text tt = null;
private text(){
//私有化构造函数
System.out.println("懒汉式单例模式");
}
//开放一个公有方法，判断是否已经存在实例，有返回，没有新建一个在返回
public static text getInstance(){
System.out.println("懒汉式单例模式");
if(tt == null){
System.out.println("懒汉式构造函数的实例当前并没有被创建");
tt = new text();
}else{
System.out.println("懒汉式构造函数的实例已经被创建");
}
System.out.println("方法调用结束，返回单例");
return tt;
}
}
//饿汉式单例模式
public class text2 {
//设立静态变量，直接创建实例
private static text2 tt = new text2();
private text2(){
//私有化构造函数
System.out.println("饿汉式单例模式");
}
//开放一个公有方法，判断是否已经存在实例，有返回，没有新建一个在返回
public static text2 getInstance(){
System.out.println("饿汉式单例模式");
return tt;
}
}
3．编程实现以下需求：
自定义狗类，属性有：名字、牙齿数量，行为有：吃食物、看家。
自定义猫类，属性有：名字、颜色，行为有：吃食物、抓老鼠。
自定义测试类，自定义成员方法实现既能打印狗又能打印猫的所有特征，在main()方法中调用即可。
package text;
public class an {
private String name;
public an() {
}
public an(String name) {
setName(name);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show() {
System.out.println("名字： "+getName()+"吃食物");
}
}
package text;
public class cat extends an{
private String color;
public cat(String name,String color) {
super(name);
setColor(color);
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void show() {
System.out.println("名字： "+getName()+"颜色: "+getColor()+"吃食物");
}
public void work() {
System.out.println("抓老鼠");
}
}
package text;
public class dog extends an{
private int ya;
public dog(String name,int ya) {
super(name);
setYa(ya);
}
public int getYa() {
return ya;
}
public void setYa(int ya) {
this.ya = ya;
}
public void show() {
System.out.println("名字： "+getName()+"牙齿： "+getYa()+"吃食物");
}
public void work() {
System.out.println("看家");
}
}
package text;
public class text {
public static void print(an an) {
an.show();
if(an instanceof cat) {
cat cc= (cat)an;
cc.work();
}else if (an instanceof dog) {
dog dd=(dog)an;
dd.work();
}
}
public static void main(String[] args) {
print(new cat("猫","白色"));
print(new dog("狗", 18));
}
}
4．编程实现以下需求：
自定义Accout类实现封装，特征有：账户余额，要求提供计算利息兵返回的抽象方法。
自定义FixedAccount类继承Account类并重写抽象方法，在main()方法中使用多态方式构造对象并设置账户余额为2000，最后计算利息并打印出来。
package t;ext
public abstract class Accout {
private int money;
public Accout() {
}
public Accout(int money) {
setMoney(money);
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
public abstract double getLi();
}
package text;
public class FixedAccount extends Accout{
public FixedAccount(int i) {
super(i);
}
@Override
public double getLi() {
return getMoney()*0.03;
}
public static void main(String[] args) {
Accout ac = new FixedAccount(2000);
double as = ac.getLi();
System.out.println("利息： "+as);
}
}
5．编程实现以下需求：
自定义TestInterfaceA接口，提供一个打印1~20之间所有奇数的抽象方法。
自定义TestInterfaceB接口，提供一个打印1~20之间所有偶数的抽象方法。
自定义SubAB类实现上述两个接口并重写抽象方法，在main方法中使用多态语法 格式创建对象并调用两个方法实现打印。
package text;
public interface A {
public abstract void show();
}
package text;
public interface B {
public abstract void print();
}
package text;
public class AB {
public static void text(A a) {
a.show();
}
public static void text1(B b) {
b.print();
}
public static void main(String[] args) {
AB.text(new A() {
@Override
public void show() {
for (int i = 0; i < 20; i++) {
if(i%2==1) {
System.out.println(i);
}
}
}
});
AB.text1(new B() {
@Override
public void print() {
for (int i = 1; i < 20; i++) {
if(i%2==0) {
System.out.println(i);
}
}
}
});
}
}
原文地址：https://www.cnblogs.com/kindsong/p/9759613.html