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

麟-小白

已于 2023-03-20 13:21:06 修改

阅读量1.3k

点赞数 4

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

于 2022-10-22 19:15:02 首次发布

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

版权

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

13 篇文章 10 订阅

订阅专栏

写在前面

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

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

写在前面

继承性

java类是否可以多继承，怎么实现多继承？

继承练习

重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？

重载的方法是否可以改变返回值的类型？

写出错误答案错误的原因

写出程序结果

按要求实现下列问题：实现一个名为Person的类和它的子类Employee，Employee有两个子类Faculty和Staff。具体要求如下：

Object类的使用说明

比较两个String总是false，但是它们明明都是"abc" ！

类似：两个对象a和b，请问a==b和a.equals(b)有什么区别？

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

一文带你深入理解【Java基础】· 面向对象编程（中）③Object类和包装类的使用

一文带你深入理解【Java基础】· 面向对象编程（中）②子类对象实例化和多态

一文带你深入理解【Java基础】· 面向对象编程（中）①继承、方法的重写、权限修饰符和super

继承性

java类是否可以多继承，怎么实现多继承？

答：java没有多继承，但可以通过接口的形式来达到多继承的目地。

继承练习

定义类A 和类B 如下：

class A {
	int a = 1;
	double d = 2.0;

	void show() {
		System.out.println("Class A: a=" + a + "\td=" + d);
	}
}

class B extends A {
	float a = 3.0f;
	String d = "Java program.";

	void show() {
		super.show();
		System.out.println("Class B: a=" + a + "\td=" + d);
	}
}

(1) 若在应用程序的main 方法中有以下语句：

A a=new A();

a.show();

则输出的结果如何？

(2) 若在应用程序的main 方法中定义类B 的对象b：

A b=new B();

b.show();

则输出的结果如何？

答：输出结果为：

Class A: a=1 d=2.0

Class B: a=3.0 d=Java program。

重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？

答：方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。

重载的方法是否可以改变返回值的类型？

重载的方法是可以改变返回值的类型

写出错误答案错误的原因

class Demo{

int show(int a,int b){return 0;}

}

下面那些函数可以存在于Demo的子类中。

A.public int show(int a,int b){return 0;}//可以，覆盖。

B.private int show(int a,int b){return 0;}//不可以，权限不够。

C.private int show(int a,long b){return 0;}//可以，和父类不是一个函数。没有覆盖，相当于重载。

D.public short show(int a,int b){return 0;}//不可以，因为该函数不可以和给定函数出现在同一类中，或者子父类中。

E.static int show(int a,int b){return 0;}//不可以，静态只能覆盖静态。

写出程序结果

class Super {
	public int get() {
		return 4;
	}
}

class Demo15 extends Super {
	public long get() {
		return 5;
	}

	public static void main(String[] args) {
		Super s = new Demo15();
		System.out.println(s.get());
	}
}

编译失败，因为子类父类中的get方法没有覆盖。但是子类调用时候不能明确返回的值是什么类型。所以这样的函数不可以存在子父类中。

按要求实现下列问题：实现一个名为Person的类和它的子类Employee，Employee有两个子类Faculty和Staff。具体要求如下：

Person类中的属性有：姓名name（String类型），地址address（String类型），电话号码telephone（String类型）和电子邮件地址email（String类型）；
Employee类中的属性有：办公室office（String类型），工资wage（double类型），受雇日期hiredate（String类型）；
Faculty类中的属性有：学位degree（String类型），级别level（String类型）；
Staff类中的属性有：职务称号duty（String类型）。
现有对象Person p1 =new Faculty()和Person p2 =new Staff ()，请分别为p1的属性赋值“本科”和Staff类的duty赋值“职员”

public class PersonTest {
	public static void main(String[] args) {
		Person p1 = new Faculty("本科");
		Person p2 = new Staff("职员");
	}
}

public class Person {
	String name;
	String address;
	String telephone;
	String email;
}

public class Employee extends Person {
	String office;
	double wage;
	String hiredata;
}

public class Faculty extends Employee {
	String degree;
	String level;

	public Faculty(String degree) {
		super();
		this.degree = degree;
	}
}

public class Staff extends Employee {
	String duty;

	public Staff(String duty) {
		super();
		this.duty = duty;
	}
}

Object类的使用说明

比较两个String总是false，但是它们明明都是"abc" ！

答：比较String一定要使用equals或equalsIgnoreCase方法，不要使用 ==

==比较的是两个引用（变量）是否指向了同一个对象，而不是比较其内容。

为什么要重写toString()方法？

如果没有重写
重写toString()方法，在执行输出的时候，会自动调用自己写的toString()方法，利用重写的规则去打印

为什么要重写equals()方法？

默认equals在比较两个对象时，是看他们是否指向同一个地址。
但有时，我们希望两个对象只要是某些属性相同就认为他们的quals为true。比如：
Student s1 = new Student(1,"name1");
Student s2 = new Student(1,"name1");
如果不重写equals的话，他们是不相同的，所以我们要重写equals，判断只要他们的id和名字相同equals就为true，在一些集合里有时也这样用，集合里的contain也是用equals来比较

定义一个person类，属性如下：

（1）身份证号，性别，姓名，年龄，户籍，出生日期（Data类型，需要引用java.uitl.Data）功能：

（2）自我介绍：介绍格式：（toString）

身份证号+姓名+户籍

（3）提供对象比较equals方法，只要身份证号+姓名相同就认为对象相等

import java.util.Date;
public class Person {
	String id;
	String gender;
	String name;
	int age;
	String adress;
	Date date;

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

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (id == null) {
			if (other.id != null)
				return false;
		} else if (!id.equals(other.id))
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

}

写出“==”和equals的区别

== 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址
equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是==;
具体要看自定义类里有没有重写Object的equals方法来判断。
通常情况下，重写equals方法，会比较类中的相应属性是否都相等。

类似：两个对象a和b，请问a==b和a.equals(b)有什么区别？

如果 a 和 b 都是对象，则 a==b 是比较两个对象的引用，只有当 a 和 b 指向的是堆中的同一个对象才会返回 true，而 a.equals(b) 是进行逻辑比较，所以通常需要重写该方法来提供逻辑一致性的比较。例如，String 类重写 equals() 方法，所以可以用于两个不同对象之间内容的比较。如果内容相同，返回true

创建一个汽车类（Car）

（1）为其定义两个属性：颜色和型号。每个属性都使用private进行封装，为每个属性设置set、get方法。

（2）为该类创建两个构造方法。第一个为无参的构造方法。第二个为带参构造方法

（3）重写toString方法，通过toString输出汽车信息。

（4）重写equals方法，如果汽车的颜色和型号相同就认为是同一辆车。

（5）实例化两个对象，输出两个对象的信息，比较两个对象是否是同一个对象。

public class CarTest {
	public static void main(String[] args) {
		Car car1 = new Car("black", "BMW");
		Car car2 = new Car("black", "BMW");
		System.out.println(car1.toString());
		System.out.println(car2.toString());
		System.out.println(car1.equals(car2));
	}
}

public class Car {
	private String color;
	private String band;

	public Car() {
		super();
	}

	public Car(String color, String band) {
		super();
		this.color = color;
		this.band = band;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public String getBand() {
		return band;
	}

	public void setBand(String band) {
		this.band = band;
	}

	@Override
	public String toString() {
		return "Car [color=" + color + ", band=" + band + "]";
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Car other = (Car) obj;
		if (band == null) {
			if (other.band != null)
				return false;
		} else if (!band.equals(other.band))
			return false;
		if (color == null) {
			if (other.color != null)
				return false;
		} else if (!color.equals(other.color))
			return false;
		return true;
	}

}

按要求实现下列问题：

封装一个西游记人物类Person：包含私有属性：姓名（name）、身高（height）、武（weapon）、种族（race），并提供访问器（get方法）和修改器（set方法）

在测试类中实例化三个对象：tangseng（唐僧）、sunwukong（孙悟空）、baigujing（白骨精），分别设置他们的种族为：人族、仙族、妖族
在打印对象时，按照例如：“姓名：孙悟空；种族：仙族”的格式在控制台输出信息。
提供一个技能方法void skill()，这个方法根据当前对象name属性判断技能，如果是孙悟空，就打印“七十二变”，如果是唐僧，就打印“紧箍咒”，如果是白骨精，就打印“九阴白骨爪”，在测试类中调用这个方法。
重写equals方法进行判断，如果种族属性是人族或者仙族，则返回true，如果是妖族，则返回false，在测试类中对孙悟空和唐僧进行比较，打印结果，对唐僧和白骨精进行比较，并打印结果。

public class PersonTest {
	public static void main(String[] args) {
		Person tangseng = new Person("唐僧");
		Person sunwukong = new Person("孙悟空");
		Person baigujing = new Person("白骨精");
		
		tangseng.setRace("人族");
		sunwukong.setRace("仙族");
		baigujing.setRace("妖族");
		System.out.println(tangseng.toString());
		System.out.println(sunwukong.toString());
		System.out.println(baigujing.toString());
		
		tangseng.skill();
		sunwukong.skill();
		baigujing.skill();
		System.out.println(sunwukong.equals(tangseng));
		System.out.println(tangseng.equals(baigujing));
	}
}

public class Person {
	private String name;
	private double height;
	private String weapon;
	private String race;

	public Person(String name) {
		super();
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public double getHeight() {
		return height;
	}

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

	public String getWeapon() {
		return weapon;
	}

	public void setWeapon(String weapon) {
		this.weapon = weapon;
	}

	public String getRace() {
		return race;
	}

	public void setRace(String race) {
		this.race = race;
	}

	@Override
	public String toString() {
		return "姓名：" + getName() + ";" + "种族：" + getRace();
	}

	public void skill() {
		if (this.name.equals("孙悟空")) {
			System.out.println("七十二变");
		}
		if (this.name.equals("唐僧")) {
			System.out.println("紧箍咒");
		}
		if (this.name.equals("白骨精")) {
			System.out.println("九阴白骨爪");
		}
	}

	@Override
	public boolean equals(Object obj) {
		Person s = (Person) obj;
		if (s.race.equals("妖族")) {
			return false;
		}
		return true;
	}

}

包装类的使用

写出8种基本数据类型的包装类

Byte Short Integer Long Float Double Character

int 和 Integer 有什么区别

答：Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。

int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。

原始类型封装类型及其对应的包装类：boolean Boolean,char Character,byte Byte,short Short,int Integer,long Long,float Float,doubl Double

引用类型和原始类型的行为完全不同，并且它们具有不同的语义。

引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。

以下代码的运行结果是：

public static void main(String[] args) {
		Integer i1 = 128;
		Integer i2 = 128;
		int i3 = 128;
		int i4 = 128;
		System.out.println(i1 == i2);
		System.out.println(i3 == i4);
		System.out.println(i1 == i3);
	}

答案：

false

true

Integer的i1和i2是对象，他们==比较的是地址。如果-128~127范围，那么使用缓存的常量对象，如果超过这个范围，是新new的对象，不是常量对象

以下代码的运行结果

public static void main(String[] args) {
		double a = 2.0;
		double b = 2.0;
		Double c = 2.0;
		Double d = 2.0;
		System.out.println(a == b);
		System.out.println(c == d);
		System.out.println(a == d);
	}

答案：

true

false

true

super关键字

写出程序结果

class Test {
	Test() {
		System.out.println("Test");
	}
}

class Demo extends Test {
	Demo() {
		// super();
		System.out.println("Demo");
	}

	public static void main(String[] args) {
		new Demo();
		new Test();
	}
}

Test

Demo

Test

写出程序结果

class Super {
	int i = 0;

	public Super(String a) {
		System.out.println("A");
		i = 1;
	}

	public Super() {
		System.out.println("B");
		i += 2;
	}
}

class Demo extends Super {
	public Demo(String a) {
		// super();
		System.out.println("C");
		i = 5;
	}

	public static void main(String[] args) {
		int i = 4;
		Super d = new Demo("A");
		System.out.println(d.i);
	}
}

B C 5

写出程序结果

class Super {
	int i = 0;

	public Super(String s) {
		i = 1;
	}
}

class Demo extends Super {
	public Demo(String s) {

		i = 2;
	}

	public static void main(String[] args) {
		Demo d = new Demo("yes");
		System.out.println(d.i);
	}
}

//编译失败，因为父类中缺少空参数的构造器。

//或者子类应该通过super语句指定要调用的父类中的构造器。

多态性

写出程序结果

class A {
	private int a;

	public void setA(int a) {
		this.a = a;
	}

	public int getA() {
		return a;
	}
}

class B extends A {
	private int a;

	public void setA(int a) {
		this.a = a;
	}
	// public int getA(){
	// return a;
	// }
}

public class PersonTest {

	public static void main(String[] args) {
		A c = new B();

		c.setA(5);

		System.out.println(c.getA());
	}
}

class Fu {
	boolean show(char a) {
		System.out.println(a);
		return true;
	}
}

class Demo extends Fu {
	public static void main(String[] args) {
		int i = 0;
		Fu f = new Demo();
		Demo d = new Demo();
		for (f.show('A'); f.show('B') && (i < 2); f.show('C')) {
			i++;
			d.show('D');
		}
	}

	boolean show(char a) {
		System.out.println(a);
		return false;
	}
}

class Fu {
	int num = 4;

	void show() {
		System.out.println("showFu");
	}
}

class Zi extends Fu {
	int num = 5;

	void show() {
		System.out.println("showZi");
	}
}

class T {
	public static void main(String[] args) {
		Fu f = new Zi();
		Zi z = new Zi();
		System.out.println(f.num);
		System.out.println(z.num);
		f.show();
		z.show();
	}
}

showZi

结语

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

麟-小白

关注

4
点赞
踩
5

收藏

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

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

扫一扫