【Java基础】· 面向对象编程（下）习题详解

麟-小白

已于 2023-03-20 12:19:03 修改

阅读量1.6k

点赞数 4

分类专栏： Java基础习题精练文章标签： java 开发语言软件工程 eclipse

于 2022-10-30 11:54:33 首次发布

本文链接：https://blog.csdn.net/qq_34025246/article/details/127589563

版权

Java基础习题精练专栏收录该内容

13 篇文章 10 订阅

订阅专栏

写在前面

Hello大家好，我是【麟-小白】，一位软件工程专业的学生，喜好计算机知识。希望大家能够一起学习进步呀！本人是一名在读大学生，专业水平有限，如发现错误或不足之处，请多多指正！谢谢大家！！！

如果小哥哥小姐姐们对我的文章感兴趣，请不要吝啬你们的小手，多多点赞加关注呀！❤❤❤ 爱你们！！！

1)下面关于接口的说法中不正确的是（C）。

2)Java语言接口间的继承关系是（B）。

3)一个类实现接口的情况是（A）。

填空题

abstract class 和interface 有什么区别?

接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?

是否能通过编译？

写出程序结果

编一个程序，包含以下文件

鸭嘴兽属于脊椎动物中的哺乳动物，太阳花属于植物中的种子植物，而鸭嘴兽和太阳花都属于生物。完成如下要求（共50分，每小题10分）：

如下代码是否可以编译通过，如果可以，运行结果是什么？

内部类

选择题

Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)

Static Nested Class 和 Inner Class的不同

写出程序结果

编一个类A，在类中定义局部类B，B中有一个常量name，有一个方法show()打印常量name。进行测试

设计公司类（Lenovo）,有一个接口类Works,里面有接口work()，下面有2个部门（开发部和销售部）,使用内部类分别实现开发部和销售部的工作。

抽象类与抽象方法

abstract 的method 是否可同时是static，是否可同时是native，是否可同时是synchronized？

是否可以从一个static方法内部发出对非static方法的调用？

谈谈final, finally, finalize的区别(后面异常中讲finally)

【面向对象编程（下）知识详解】

一文带你深入理解【Java基础】· 面向对象编程（下）③接口和内部类

一文带你深入理解【Java基础】· 面向对象编程（下）②代码块、final和abstract

一文带你深入理解【Java基础】· 面向对象编程（下）①static和main方法

main()方法

选择题

class Test {
	public static void main(String[] args) {
		String foo = args[1];
		String bar = args[2];
		String baz = args[3];
	}
}

d:\>java Test Red Green Blue

what is the value of baz?

A. baz has value of ""

B. baz has value of null

C. baz has value of "Red"

D. baz has value of "Blue"

E. baz has value of "Green"

F. the code does not compile

G. the program throw an exception

答：G执行时抛出数组下标越界异常。

解析：
命令行执行java的字节码文件，
java是命令
Test是字节码文件的名称
Red Green Blue是执行Test字节码文件的参数，各个参数中间用空格间隔，
字符串”Red“是对应main方法的参数数组args[0]
字符串”Green“是对应main方法的参数数组args[1]
字符串”Blue“是对应main方法的参数数组args[2]

接口

选择题:

1)下面关于接口的说法中不正确的是（C）。

A．接口中所有的方法都是抽象的

B．接口中所有的方法都是public访问权限

C．子接口继承父接口所用的关键字是implements

D．接口是Java中的特殊类，包含常量和抽象方法

解析：

用于定义接口的关键字是interface，而实现接口的关键字是implements。

2)Java语言接口间的继承关系是（B）。

A．单继承 B．多重继承 C．不能继承 D．不一定

解析：

Java类可以实现多个接口 --->弥补了Java单继承性的局限性

接口与接口之间可以继承，而且可以多继承

3)一个类实现接口的情况是（A）。

A．一次可以实现多个接口

B．一次只能实现一个接口

C．不能实现接口

D．不一定

解析：

同上

填空题

1)_____是声明接口的关键字，可以把它看成一个特殊类。接口中的数据成员默认的修饰符是_____，接口中的成员方法默认的修饰符是_____。

答：

interface

public static final

public abstract

abstract class 和interface 有什么区别?

答：声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。但可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法

接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口

接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?

答案是：接口可以继承接口。抽象类可以实现(implements)接口，

抽象类可继承实体类，但实体类必须不能是如下两种情况之一：

1，final修饰符修饰的类是不能的

2，如果此实体类有且仅有私有的构造函数也是不能的。

是否能通过编译？

interface A {
	int x = 0;
}

class B {
	int x = 1;
}

class C extends B implements A {
	public void pX() {
		System.out.println(x); // super.x A.x
	}

	public static void main(String[] args) {
		new C().pX();
	}
}

答案：错误。在编译时会发生错误(错误描述不同的JVM有不同的信息，意思就是未明确的x调用）对于父类的变量,可以用super.x来明确，

而接口的属性默认隐含为 public static final.所以可以通过A.x来明确。

写出程序结果

interface A {
}

class B implements A {
	public String func() {
		return "func";
	}
}

class Demo {
	public static void main(String[] args) {
		A a = new B();
		System.out.println(a.func());
	}
}

编译失败：因为A接口中并未定义func方法。

编一个程序，包含以下文件

（1）Shape.java文件，在该文件中定义接口类Shape，该接口在shape包中。

属性：PI。

接口：求面积的方法area()。

（2）Circle.java文件，在该文件中定义圆类Circle，该类在circle包中，实现Shape接口类。

属性：圆半径radius。

方法：构造器；实现求面积方法area()；求周长方法perimeter()。

（3）Cylinder.java文件，在该文件中定义圆柱体类Cylinder，该类在cylinder包中，继承圆类。

属性：圆柱体高度height。

方法：构造器；求表面积方法area()；求体积方法volume()。

（4）X5_3_6.java文件，在该文件中定义主类X5_3_6，该类在默认包中，其中包含主方法main()，在主方法中创建两个圆类对象cir1和cir2，具体尺寸自己确定，并显示圆的面积和周长；再创建两个圆柱体类的对象cy1和cy2，具体尺寸自己确定，然后分别显示圆柱体cy1和cy2的底圆的体积和表面积。

【编程分析】本题主要考察接口、包、继承、封装等问题。

public interface Shape {
	double PI = 3.1415926535;

	double area();
}

public class Circle implements Shape {

	private double radius;

	public Circle() {
		super();
	}

	public Circle(double radius) {
		super();
		this.radius = radius;
	}

	public double getRadius() {
		return radius;
	}

	public void setRadius(double radius) {
		this.radius = radius;
	}

	@Override
	public double area() {
		return PI * radius * radius;
	}

	public double perimeter() {
		return 2.0 * PI * radius;
	}
}

public class Cylinder extends Circle {
	private double height;

	public Cylinder() {
		super();
	}

	public Cylinder(double radius, double height) {
		super(radius);
		this.height = height;
	}

	public double getHeight() {
		return height;
	}

	public void setHeight(double height) {
		this.height = height;
	}

	public double area() {
		return 2.0 * super.area() + super.perimeter() * height;
	}

	public double volume() {
		return super.area() * height;
	}
}

public class X5_3_6 {
	public static void main(String[] args) {
		Circle cir1 = new Circle(3);
		Circle cir2 = new Circle(4);
		System.out.println(cir1.area());
		System.out.println(cir1.perimeter());
		System.out.println(cir2.area());
		System.out.println(cir2.perimeter());
		
		Cylinder cy1 = new Cylinder(3.0,4.0);
		Cylinder cy2 = new Cylinder(5.0,6.0);
		System.out.println(cy1.area());
		System.out.println(cy1.perimeter());
		System.out.println(cy2.area());
		System.out.println(cy2.perimeter());
	}
}

鸭嘴兽属于脊椎动物中的哺乳动物，太阳花属于植物中的种子植物，而鸭嘴兽和太阳花都属于生物。完成如下要求（共50分，每小题10分）：

1）设计一系列的接口来表示这些规范：生物ß动物ß脊椎动物ß哺乳动物；生物ß植物ß种子植物，并且按照箭头要求来继承；

2）生物都有呼吸方式，只有一个方法声明：void respirations();设计两个类，分别是鸭嘴兽和太阳花，分别实现生物接口的respirations方法，执行方法可以分别输出：“鸭嘴兽是动物，需要呼吸氧气”，“太阳花是植物，可以吸收二氧化碳，呼出氧气”；

3）动物接口拥有方法声明：void run(),鸭嘴兽类可以实现方法，输出信息：“鸭嘴兽只有两只脚，它可以用两只脚奔跑”

4）植物接口都有繁殖方法声明 void reproduction(),太阳花在实现reproduction方法时输出信息“太阳花可以用种子繁殖，也可以用枝条繁殖”

5)声明一个Test类作为测试，执行上述声明的所有方法；

public interface Creature {
	void respirations();
}
public interface Animal extends Creature {
	void run();
}
public interface Vertebrate extends Animal {

}
public interface Mammals extends Vertebrate {

}
public interface Plant extends Creature {
	void reproduction();
}
public interface SeedPlant extends Plant {

}
public class YaZuiShou implements Creature, Animal {

	@Override
	public void respirations() {
		System.out.println("鸭嘴兽是动物，需要呼吸氧气");
	}

	@Override
	public void run() {
		System.out.println("鸭嘴兽只有两只脚，它可以用两只脚奔跑");
	}

}
public class TaiYangHua implements Creature, Plant {

	@Override
	public void respirations() {
		System.out.println("太阳花是植物，可以吸收二氧化碳，呼出氧气");
	}

	@Override
	public void reproduction() {
		System.out.println("太阳花可以用种子繁殖，也可以用枝条繁殖");
	}

}
public class Test {
	public static void main(String[] args) {
		YaZuiShou yaZuiShou = new YaZuiShou();
		TaiYangHua taiYangHua = new TaiYangHua();
		yaZuiShou.respirations();
		yaZuiShou.run();
		taiYangHua.respirations();
		taiYangHua.reproduction();
	}
}

如下代码是否可以编译通过，如果可以，运行结果是什么？

interface A {
	int x = 0;
}

class B {
	int x = 1;
}

class C extends B implements A {

	public void printX() {
		System.out.println(x);
	}

	public static void main(String[] args) {
		new C().printX();
	}
}

答案：编译错误

System.out.println(x);报错，x有歧义

内部类

选择题

public class OuterClass { 
  private double d1 = 1.0; 
    //插入代码 
}

您需要在第3行插入一个声明有效的内部类（选择两个。）

A. class InnerOne{
     public static double methoda() {return d1;}
   }

B. public class InnerOne{
     static double methoda() {return d1;}
   }

C. private class InnerOne{
     double methoda() {return d1;}
   }

D. static class InnerOne{
     protected double methoda() {return d1;}
   }

E. abstract class InnerOne{
     public abstract double methoda();
   }

说明如下：

一.静态内部类可以有静态成员，而非静态内部类则不能有静态成员。故 A、B 错

二.静态内部类的非静态成员可以访问外部类的静态变量，而不可访问外部类的非静态变量；return d1 出错。故 D 错

三.非静态内部类的非静态成员可以访问外部类的非静态变量。故 C 正确

四.答案为C、E

Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)

答：匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现

Static Nested Class 和 Inner Class的不同

答：Nested Class （一般是C++的说法），Inner Class (一般是JAVA的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。注：静态内部类（Inner Class）意味着

1创建一个static内部类的对象，不需要一个外部类对象

2不能从一个static内部类的一个对象访问一个外部类对象

写出程序结果

class TD {
	int y = 6;

	class Inner {
		static int y = 3;

		void show() {
			System.out.println(y);
		}
	}
}

class TC {
	public static void main(String[] args) {
		TD.Inner ti = new TD().new Inner();
		ti.show();
	}
}

编译失败，非静态内部类中不可以定义静态成员。

内部类中如果定义了静态成员，该内部类必须被静态修饰。

编一个类A，在类中定义局部类B，B中有一个常量name，有一个方法show()打印常量name。进行测试

class A {
	public void show() {
		class B {
			private final String NAME = "人";

			void show() {
				System.out.println(NAME);
			}
		}
		B b = new B();
		b.show();
	}
}

class Test {
	public static void main(String[] args) {
		A a = new A();
		a.show();
	}
}

设计公司类（Lenovo）,有一个接口类Works,里面有接口work()，下面有2个部门（开发部和销售部）,使用内部类分别实现开发部和销售部的工作。

public interface Works {
	void work();
}

public class Lenovo {
	class k implements Works {

		@Override
		public void work() {
			System.out.println("开发产品");
		}

	}

	class x implements Works {

		@Override
		public void work() {
			System.out.println("销售产品");
		}

	}
}

抽象类与抽象方法

abstract 的method 是否可同时是static，是否可同时是native，是否可同时是synchronized？

答：都不能

抽象类和抽象方法之间的关系

定义抽象类和抽象方法的关键字是（abstract）。抽象类中（可以）有抽象方法，（可以）有普通方法（可以）有属性；一个类中定义了抽象方法，那这个类（必须）用abstract修饰，即抽象类。

判断题

abstract class Name {
	private String name;

	public abstract boolean isStupidName(String name) {}
}

这有何错误?

答案: 错。abstract method必须以分号结尾，且不带花括号。

是否可以通过编译？

abstract class Something {
   private abstract String doSomething ();
}

答案: 错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的，怎么可以用private把abstract method封锁起来呢? (同理，abstract method前不能加final)。

编程

定义一个抽象类Person，有name,age,sex三个属性，创建构造函数，给这三个属性赋值，重写打印描述信息方法，打印三个属性值；这个类中有两个抽象方法work和hello；定义两个子类Teacher，Student；教师的work实现是：教书育人，hello实现是：“同学好”；学生的work实现是：认真学习，hello实现是“老师好”。

public abstract class Person {
	private String name;
	private int age;
	private String gender;

	public Person() {
		super();
	}

	public Person(String name, int age, String gender) {
		super();
		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 String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}

	public abstract void work();

	public abstract void hello();
}

public class Student extends Person {

	@Override
	public void work() {
		System.out.println("认真学习");
	}

	@Override
	public void hello() {
		System.out.println("老师好");
	}
	
}

public class Teacher extends Person {

	@Override
	public void work() {
		System.out.println("教书育人");
	}

	@Override
	public void hello() {
		System.out.println("同学好");
	}

}

static的使用

是否可以从一个static方法内部发出对非static方法的调用？

答：不可以,如果其中包含对象的method()；不能保证对象初始化.

写一个Singleton出来

Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

一般Singleton模式通常有几种形式:

第一种形式: 饿汉式。定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例化，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。

public class Singleton {
	private Singleton() {

	}

	private static Singleton instance = new Singleton();

	public static Singleton getInstance() {
		return instance;
	}
}

第二种形式：懒汉式。

public class Singleton {
	private Singleton() {

	}

	private static Singleton instance = null;

	public Singleton getInstance() {
		if (instance == null) {
			instance = new Singleton();
		}
		return instance;
	}
}

编译是否通过？

public class Something {
	public static void main(String[] args) {
		Something s = new Something();
		System.out.println("s.doSomething() returns " + doSomething());
	}

	public String doSomething() {
		return "Do something ...";
	}
}

看上去很完美。

答案: 错。看上去在main里call doSomething没有什么问题，毕竟两个methods都在同一个class里。

但仔细看，main是static的。static method不能直接call non-static methods。

可改成"System.out.println("s.doSomething() returns " + s.doSomething());"。

同理，static method不能访问non-static instant variable。

写出程序结果

public class Demo {
	private static int j = 0;

	private static boolean methodB(int k) {
		j += k;
		return true;
	}

	public static void methodA(int i) {
		boolean b;
		b = i < 10 | methodB(4);
		b = i < 10 || methodB(8);
	}

	public static void main(String args[]) {
		methodA(0);
		System.out.println(j);
	}
}

答：4

final关键字

谈谈final, finally, finalize的区别(后面异常中讲finally)

答：final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载

finally—在异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）

finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的

如下程序是否可通过编译？

public class Something {
   public int addOne(final int x) {
       return ++x;
   }
}

这个比较明显。

答案: 错。int x被修饰成final，意味着x不能在addOne method中被修改。

如下程序是否可通过编译？

public class Something {
	public static void main(String[] args) {
		Other o = new Other();
		new Something().addOne(o);
	}

	public void addOne(final Other o) {
		o.i++;
	}
}

class Other {
	public int i;
}

和上面的很相似，都是关于final的问题，这有错吗?

答案: 正确。在addOne method中，参数o被修饰成final。如果在addOne method里我们修改了o的reference(比如: o = new Other();)，那么如同上例这题也是错的。但这里修改的是o的member vairable(成员变量)，而o的reference并没有改变。

是否可以通过编译？

class Something {
	int i;

	public void doSomething() {
		System.out.println("i = " + i);
	}
}

答案: 正确。输出的是"i = 0"。int i属于instant variable (实例变量，或叫成员变量)。instant variable有default value。

int的default value是0。

是否可以通过编译？

class Something {
    final int i;

    public void doSomething() {
        System.out.println("i = " + i);
    }
}

和上面一题只有一个地方不同，就是多了一个final。这难道就错了吗?

答案: 错。final int i是个final的instant variable (实例变量，或叫成员变量)。final的instant variable没有default value，必须在constructor (构造器)结束之前被赋予一个明确的值。可以修改为"final int i = 0;"。

代码块

以下代码的运行结果是？

public class Test {
	static int x, y, z;

	static {
		int x = 5;
		x--;
	}

	static {
		x--;
	}

	public static void main(String[] args) {
		System.out.println("x=" + x);
		z--;
		method();
		System.out.println("result:" + (z + y + ++z));
	}

	public static void method() {
		y = z++ + ++z;
	}
}

答案：

x=-1

result:3

结语

本人会持续更新文章的哦！希望大家一键三连，你们的鼓励就是作者不断更新的动力

麟-小白

关注

4
点赞
踩
8

收藏

觉得还不错? 一键收藏
打赏
0
评论
【Java基础】· 面向对象编程（下）习题详解

Hello大家好，我是【麟-小白】，一位软件工程专业的学生，喜好计算机知识。希望大家能够一起学习进步呀！本人是一名在读大学生，专业水平有限，如发现错误或不足之处，请多多指正！！！如果小哥哥小姐姐们对我的文章感兴趣，请不要吝啬你们的小手，多多呀！❤❤❤爱你们！！！目录【面向对象编程（下）知识详解】【Java基础】· 第6章 · 面向对象编程（下）③接口和内部类【Java基础】· 第6章 · 面向对象编程（下）②代码块、final和abstract。
复制链接

扫一扫