java5.面向对象编程(中)练习题
2021/6/12 14:51:28
本文主要是介绍java5.面向对象编程(中)练习题,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!
1.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();//父类方法show 则输出的结果如何? (2) 若在应用程序的main 方法中定义类B 的对象b: A b=new B();//多态;父类引用指向子类的对象 b.show();//首先调用父类的show,再调用子类的show方法 结果:Class A: a=1 d=2.0 Class B: a=3.0 d="Java program." 因为a,多态中虽然不可以访问子类中父类没有的属性,直接访问相同属性的话,得到的结果是父类中的,但是可以通过方法中来访问子类中父类没有的的属性
3.方法重写和重载的区别: 重载:在一个类中,在编译时就已经确定如何执行 重写:编译时看左边,运行时才会根据new的时那个对象来确定执行哪个; 方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现,重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法被重写 (Overriding)。子类的对象使用这个方法时,将调用子类中的定义,对它而言,父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法,它们或有不同的参数个数或有不同的参数类型,则称为方法的重载(Overloading)。
4.Overload的方法是否可以改变返回值的类型? 重载可以改变返回值类型
5.写出错误答案错误的原因 class Demo{ int show(int a,int b){return 0;}//返回值类型为缺省,所以重写方法的返回值类型只能为缺省或者public } 下面那些函数可以存在于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;}//不可以,静态只能覆盖静态。
6.写出程序结果 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()); } } //编译失败,因为int和long没有覆盖,所以子类中起始存在两个get方法,调用时不知道调用哪个,所以编译会失败
7.按要求实现下列问题:实现一个名为Person的类和它的子类Employee,Employee有两个子类Faculty和Staff。具体要求如下: 1)Person类中的属性有:姓名name(String类型),地址address(String类型), 电话号码telphone(String类型)和电子邮件地址email(String类型); 2)Employee类中的属性有:办公室office(String类型),工资wage(double 类型),受雇日期hiredate(String类型); 3)Faculty类中的属性有:学位degree(String类型),级别level(String类型); 4)Staff类中的属性有:职务称号duty(String类型)。 5)现有对象Person p1 =new Faculty()和Person p2 =new Staff (),请分别为p1的属性赋值“本科”和Staff类的duty赋值“职员” package classTest4; import java.security.PrivateKey; /** * describe: * * @author suoliang * @create 2021-06-11:39 */ public class use2 { public static void main(String[] args) { Person p1 = new Facutly(); Person p2 = new Staff(); if (p1 instanceof Facutly){ Facutly p11 = (Facutly) p1; p11.setDegree("本科"); System.out.println(p11.getDegree()); } if (p2 instanceof Staff){ Staff p22 = (Staff)p2; p22.setDuty("支援"); System.out.println(p22.getDuty()); } } } class Person{ private String name; private String address; private String telphone; private String email; } class Employee extends Person{ private String office; private double wage; private String hiredate; } class Facutly extends Employee{ private String degree; private String level; public String getDegree() { return degree; } public String getLevel() { return level; } public void setDegree(String degree) { this.degree = degree; } public void setLevel(String level) { this.level = level; } } class Staff extends Employee{ private String duty; public String getDuty() { return duty; } public void setDuty(String duty) { this.duty = duty; } }
8.object类的使用说明 8.1我比较两个String总是false,但是它们明明都是"abc" ! 因为如果使用==号比较的话,比较的是地址; 一定要使用equals,因为字符串中重写了equals,所以只会比较字面结果 8.2为什么要重写toString()方法? 不重写的话,tostring输出的是类名和地址值 8.3为什么要重写equals()方法? 不重写的话默认比较的是地址值 8.4定义一个person类,属性如下: (1)身份证号,性别,姓名,年龄,户籍,出生日期(Data类型,需要引用java.uitl.Data)功能: (2)自我介绍:介绍格式:(toString) 身份证号+姓名+户籍 (3)提供对象比较equals方法,只要身份证号+姓名相同就认为对象相等 package classTest4; import java.util.Date; /** * describe: * * @author suoliang * @create 2021-06-11:50 */ public class use3 { } class Person1{ private String name; private int id; private int age; private String place; private Date date; @Override public String toString() { return "Person1{" + "name='" + name + '\'' + ", id=" + id + ", place='" + place + '\'' + '}'; } public boolean equals(Object o){ if (o == this){return true;} if (o == null || o.getClass() != this.getClass()){ return false; } Person1 o1 = (Person1) o; return this.id == o1.id && this.name == o1.name; } }
9.写出“==”和equals的区别 类似:两个对象a和b,请问a==b和a.equals(b)有什么区别? ==比较的是地址值 equals是可以重写的,重写之后根据自己的意愿返回boolean
创建一个汽车类(Car) (1)为其定义两个属性:颜色和型号。每个属性都使用private进行封装,为每个属性设置set、get方法。 (2)为该类创建两个构造方法。第一个为无参的构造方法。第二个为带参构造方法 (3)重写toString方法,通过toString输出汽车信息。 (4)重写equals方法,如果汽车的颜色和型号相同就认为是同一辆车。 (5)实例化两个对象,输出两个对象的信息,比较两个对象是否是同一个对象。 package classTest4; /** * describe: * * @author suoliang * @create 2021-06-11:57 */ public class Car { private String color; private int id; public String getColor() { return color; } public int getId() { return id; } public void setColor(String color) { this.color = color; } public void setId(int id) { this.id = id; } public Car(String color, int id) { this.color = color; this.id = id; } @Override public String toString() { return "Car{" + "color='" + color + '\'' + ", id=" + id + '}'; } @Override public boolean equals(Object obj) { if (obj == this){ return true;} if (obj == null || obj.getClass() != this.getClass()){ return false; } Car obj1 = (Car) obj; return this.color == obj1.color && this.id == obj1.id; } } class test{ public static void main(String[] args) { Car car = new Car("12",12); Car car1 = new Car("12",12); System.out.println(car.equals(car1)); } }
定义员工类Employee,包含姓名、工号和工资,包含计算奖金方法bonus,普通员工和经理都是员工,计算奖金的方法为工资*奖金系数,普通员工的奖金系数为1.5(常量),经理为2(常量),分别实现bonus方法,创建对象测试。 package classTest4; /** * describe: * * @author suoliang * @create 2021-06-12:05 */ public class use4 { public void culWage(Employee1 employee1){ System.out.println(employee1.bonus()); } public static void main(String[] args) { //普通员工应该输出4500 use4 use4 = new use4(); use4.culWage(new CommonEmpl()); //经理一个输出6000 use4.culWage(new Manager()); } } class Employee1{ private String name; private int id; private double wage = 3000; public String getName() { return name; } public int getId() { return id; } public double getWage() { return wage; } public double bonus(){ return 0.0; } } class CommonEmpl extends Employee1{ @Override public double bonus() { return this.getWage() * 1.5; } } class Manager extends Employee1{ @Override public double bonus() { return this.getWage() * 2.0; } }
编写一个Java应用程序,设计一个汽车类Vehicle,包含的属性有车轮个数wheels和车重weight。小车类Car是Vehicle的子类,其中包含的属性有载人数loader。卡车类Truck是Car类的子类,其中包含的属性有载重量payload。 (1)每个类都有构造方法进行属性初识化 (2)每个类都输出相关数据的toString方法 (3)使用Test类中的main方法定义各类初始化数据后台打印相关数据 package classTest4; /** * describe: * * @author suoliang * @create 2021-06-12:13 */ public class use5 { public static void main(String[] args) { Vechile vechile = new Vechile(12, 12.5); System.out.println(vechile); } } class Vechile{ public Vechile(int wheels, double weight) { this.wheels = wheels; this.weight = weight; } private int wheels; private double weight; @Override public String toString() { return "Vechile{" + "wheels=" + wheels + ", weight=" + weight + '}'; } } class Car1 extends Vechile{ public Car1(int wheels, double weight, int loader) { super(wheels, weight); this.loader = loader; } private int loader; @Override public String toString() { return "Car1{" + "loader=" + loader + "} " + super.toString(); } } class Truck extends Car1{ public Truck(int wheels, double weight, int loader, double plaload) { super(wheels, weight, loader); this.plaload = plaload; } @Override public String toString() { return "Truck{" + "plaload=" + plaload + "} " + super.toString(); } private double plaload; }
定义一个交通工具类,并定义抽象方法,说明交通工具可以移动。继承交通工具而产生汽车、飞机、轮船类,并实现其移动方法。 package classTest4; import java.util.Scanner; /** * describe: * * @author suoliang * @create 2021-06-12:17 */ public class use6 { public void randomInput(Travel travel){ Scanner scanner = new Scanner(System.in); boolean isFlag = true; while (isFlag){ System.out.println("请输入一个1到3的整数:"); int num = scanner.nextInt(); if (num == 1){ travel = new Car2(); travel.Run(); } else if (num == 2){ travel = new Plane(); travel.Run(); } else if (num == 3){ travel = new Lunchaun(); travel.Run(); }else { isFlag = false; } } } public static void main(String[] args) { use6 use6 = new use6(); use6.randomInput(new Travel()); } } class Travel{ public void Run(){ System.out.println("交通工具可以移动"); } } class Car2 extends Travel{ @Override public void Run() { System.out.println("汽车可以移动"); } } class Plane extends Travel{ @Override public void Run() { System.out.println("飞机可以移动"); } } class Lunchaun extends Travel{ @Override public void Run() { System.out.println("轮船可以移动"); } }
写出8中基本数据类型的包装类 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 true Integer个范围,是新new的对象,不是常量对象的i1和i2是对象,他们==比较的是地址。如果-128~127范围,那么使用缓存的常量对象,如果超过比较地址
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);true基本数据类型比较值 System.out.println(c == d);false:引用数据类型比较地址 System.out.println(a == d);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();//Test new Test();//Test Demo } }
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); } 编译失败,父类没有无参构造器 }
package test; public class FatherClass{ public FatherClass(){ System.out.println("FatherClass Create"); } } 子类: package test; import test.FatherClass; public class ChildClass extends FatherClass{ public ChildClass(){ System.out.println("ChildClass Create"); } public static void main(String[] args) { FatherClass fc = new FatherClass(); ChildClass cc = new ChildClass(); } }
public class Test { public static void main(String[] args) { Base b1 = new Base(); Base b2 = new Sub(); } } class Base{ Base(){ method(100); } public void method(int i){ System.out.println("base : " + i); } } class Sub extends Base{ Sub(){ super.method(70); } public void method(int j){ System.out.println("sub : " + j); } } base : 100 sub : 100 base : 70
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; // }有了get方法以后得到的是5 } public class PersonTest { public static void main(String[] args) { A c = new B(); c.setA(5);//set的是B里面的5; System.out.println(c.getA());//输出的是A里面的0,因为子类中没有get方法 } }
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; } }//return 再for循环里可以用来终止循环,
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);//5 System.out.println(z.num);//5 f.show();//showZi z.show();//showZi } }
package classTest4; /** * describe: * * @author suoliang * @create 2021-06-13:01 */ public class use12 { public static void main(String[] args) { Per per = new stu(); per.show();//这里面的a和d是子类中的 System.out.println(per.a);//直接访问a和d是父类中的,不可以访问子类中的 System.out.println(per.d); } } class Per{ int a = 12; double d = 20.0; public void show(){ System.out.println(a+d); } } class stu extends Per{ int a = 20; String d = "爱我中华"; @Override public void show() { System.out.println(a + d); } }
这篇关于java5.面向对象编程(中)练习题的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!
- 2024-07-08如何在敏捷项目中实现高效测试?
- 2024-07-08用户故事一定要有 “So that...” 吗?
- 2024-07-04TiDB 资源管控的对撞测试以及最佳实践架构
- 2024-07-03万字长文聊聊Web3的组成架构
- 2024-07-02springboot项目无法注册到nacos-icode9专业技术文章分享
- 2024-06-26结对编程到底难不难?答案在这里
- 2024-06-19《2023版Java工程师》课程升级公告
- 2024-06-15matplotlib作图不显示3D图,怎么办?
- 2024-06-1503-Loki 日志监控
- 2024-06-1504-让LLM理解知识 -Prompt