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.0Class 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;@Overridepublic 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;}@Overridepublic String toString() {return "Car{" +"color='" + color + '\'' +", id=" + id +'}';}@Overridepublic 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) {//普通员工应该输出4500use4 use4 = new use4();use4.culWage(new CommonEmpl());//经理一个输出6000use4.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{@Overridepublic double bonus() {return this.getWage() * 1.5;}
}class Manager extends Employee1{@Overridepublic 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;@Overridepublic 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;@Overridepublic 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;}@Overridepublic 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{@Overridepublic void Run() {System.out.println("汽车可以移动");}
}class Plane extends Travel{@Overridepublic void Run() {System.out.println("飞机可以移动");}
}class Lunchaun extends Travel{@Overridepublic 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();//Testnew 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);//5System.out.println(z.num);//5f.show();//showZiz.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 = "爱我中华";@Overridepublic void show() {System.out.println(a + d);}
}

java5.面向对象编程(中)练习题相关推荐

java面向对象上机题库_Java面向对象编程上机-练习题汇总
Java面向对象编程上机-练习题汇总 [练习题1]类的成员变量: 猜数字游戏:一个类A有一个成员变量v,有一个初值100.定义一个类,对A类的成员变量v进行猜.如果大了则提示大了,小了则提示小了.等于 ...
c语言面向对象编程中的类_C ++中的面向对象编程
c语言面向对象编程中的类 Object oriented programming, OOP for short, aims to implement real world entities like ...
【小白学习C++ 教程】十二、C++面向对象编程中的构造函数和析构函数
@Author:Runsen 面向对象编程旨在:在编程中实现继承.隐藏.多态等现实世界的实体.OOP 的主要目的是将数据和对它们进行操作的函数绑定在一起. 我们可以说C++中的类,代表一组共享一些共同 ...
C＃中面向对象编程中的函数式编程
目录介绍面向对象编程中仿真的函数式编程技术粒度不匹配面向对象的函数式编程构造相互关系函数式编程/面向对象程序设计 C#中的函数式编程集成函数级别的代码抽象操作组合函数部分应用和局部套用 ...
在JavaScript面向对象编程中使用继承(5)
明天就要回老家去过年了,关于这个"在JavaScript面向对象编程中使用继承"的话题居然还没有说完.如果不完成,留下来一拖就拖到明年去了.所以还是抽空把它写完,今年的事情今年做, ...
C# 实例解释面向对象编程中的单一职责原则
在面向对象编程中,SOLID 是五个设计原则的首字母缩写,旨在使软件设计更易于理解.灵活和可维护.这些原则是由美国软件工程师和讲师罗伯特·C·马丁(Robert Cecil Martin)提出的许多原 ...
Objective-C向面向对象编程中添加了一个新概念：类别(categor)。
类别 Objective-C向面向对象编程中添加了一个新概念:类别(categor).类别被设计用于解决这样的问题:基类被认为是很脆弱的,即便是看似无害的改动也不能引入,否则可能会破坏更复杂的派生类. ...
C语言面向对象编程的类是指,c语言面向对象编程中的类_C ++中的面向对象编程...
c语言面向对象编程中的类 Object Oriented programming is a programming style that is associated with the concept ...
python面向对象编程中方法和属性_Python面向对象编程中关于类和方法的学习笔记...
Python面向对象编程中关于类和方法的学习笔记类与类方法是面向对象的编程语言中必不可少的特性,本文总结了Python面向对象编程中关于类和方法的学习笔记,需要的朋友可以参考下类和实例 pytho ...

java5.面向对象编程(中)练习题

java5.面向对象编程(中)练习题相关推荐

最新文章

热门文章