封装和继承作业
一、 选择题
1. | 使用权限修饰符( B )修饰的类的成员变量和成员方法,可以被当前包中所有类访问,也可以被它的子类(同一个包以及不同包中的子类)访问。(选择一项) | |
A | public | |
B. | protected | |
C. | 默认 | |
D. | private |
2. | 给出如下代码,如何使成员变量m被方法fun()直接访问( C )。(选择一项) | |
| class Test { private int m; public static void fun() { } } | |
A | 将private int m 改为protected int m | |
B. | 将private int m 改为public int m | |
C. | 将private int m 改为static int m | |
D. | 将private int m 改为int m |
3. | 以下关于继承条件下构造方法执行过程的代码的执行结果是( A )。(选择一项) | |
| class Person { public Person() { System.out.println("execute Person()"); } } class Student extends Person { public Student() { System.out.println("execute Student() "); } } class PostGraduate extends Student { public PostGraduate() { System.out.println("execute PostGraduate()"); } } public class TestInherit { public static void main(String[] args) { new PostGraduate(); } } | |
A. | execute Person() execute Student() execute PostGraduate() | |
B. | execute PostGraduate() | |
C. | execute PostGraduate() execute Student() execute Person() | |
D. | 没有结果输出 |
4. | 以下关于this和super关键字的说法错误的是( BD)。(选择二项) | |
A. | this关键字指向当前对象自身,super关键字指向当前对象的直接父类 | |
B. | 在main方法中可以存在this或super关键字,但不能同时存在。 | |
C. | this和super关键字都可以访问成员属性,成员方法和构造方法 | |
D. | 在一个类的构造方法中可以同时使用this和super来调用其他构造方法 |
5. | 给出下面的代码段,在代码说明//assignment x=a,y=b处写入如下( D )个代码是正确的。(选择一项) | |
| public class Base { int w, x, y, z; public Base(int a, int b) { x = a; y = b; } public Base(int a, int b, int c, int d) { // assignment x=a,y=b w = d; z = c; } } | |
A | Base(a,b); | |
B. | x=a,y=b; | |
C. | this(a),this(b); | |
D. | this(a,b) |
6. | 以下Java程序编译运行后的输出结果是(A )。(选择一项) | |||
| class HelloA { public HelloA( ) { System.out.println("HelloA"); } { System.out.println("I'm A class"); } static { System.out.println("static A"); } } public class HelloB extends HelloA { public HelloB( ) { System.out.println("HelloB"); } { System.out.println("I'm B class"); } static { System.out.println("static B"); } public static void main(String[] args) { new HelloB( ); } } | |||
A | static A static B I'm A class HelloA I'm B class HelloB | C. | static A I'm A class HelloA static B I'm B class HelloB | |
B. | static A static B I'm A class I'm B class HelloA HelloB | D | static A static B HelloA HelloB I'm A class I'm B class |
7. | 下列选项中关于Java中super关键字的说法正确的是( AD )。(选择二项) | |
A | super关键字是在子类对象内部指代其父类对象的引用 | |
B. | super关键字不仅可以指代子类的直接父类,还可以指代父类的父类 | |
C. | 子类通过super关键字只能调用父类的方法,而不能调用父类的属性 | |
D. | 子类通过super关键字可以调用父类的构造方法 |
二、 判断题
- 使用public修饰的成员属性和方法可以被当前项目中所有包的所有类访问。( T )
- 类的方法通常设为public,而类的实例变量一般也设为public。(F )
- 与未加访问控制符的缺省情况相比,public和protected修饰符扩大了类及其属性和方法的被访问范围,private修饰符则缩小了这种范围。( T )
- 访问权限是private的变量,只能在本类和与本类同一个包中的其他类使用。( F )
- 如果定义一个类时没有使用extends,则它的父类是java.lang.Object。( T )
- 对子类实例化对象需要调用超类的构造函数进行初始化工作,完成对子类中的超类实例变量的初始化,则子类可以继承超类的构造函数。(F )
- 在Java中任何一个子类的构造方法都必须调用其父类的构造方法(包括隐式调用),并且调用父类的构造方法的语句必须是子类构造方法的第一条语句。( F)
- Java中的类不允许多重继承,一个类只能有有一个直接父类。(T)
- Object类有一个public方法是toString( ),一个对象通过调用该方法可以获得该对象的字符串表示。( T )
- 运算符“==”用于比较引用时,如果两个引用指向内存同一个对象,则返回true。( T )
三、 简答题
1、private、默认、protected、public四个权限修饰符的作用.
答:访问修饰符:可以修饰变量,方法,类
修饰变量:四种修饰符都能使用
修饰方法:四种修饰符都能使用
修饰类:2种 public,default
2、方法重载和方法重写(覆盖)的区别。.
(1)方法重载:存在一个类中
方法名必须相同
参数列表不同(参数个数,类型,顺序不同)
与返回值无关
(2)方法重写:存在子父类中,子类把父类的方法重写一遍
返回值,方法名,参数列表必须一致
子类的访问修饰符要大于等于父类的访问修饰符
3、java.lang.Object类的六个常用方法的声明并说明其作用。
(1) Object类有一个默认构造方法pubilcObject(),在构造子类实例时,都会先调用这个默认构造 方法。
(2) equals()方法:用于测试某个对象是否同另一个对象相等。它在Object类中的实现是判断两个 对象是否指向同一块内存区域。
(3)toString():返回该对象的字符串表示。Object类中的toString()方法会打印出类名和对象的内 存位置。几乎每个类都会覆盖该方法,以便打印对该对象当前状态的表示。
(4) finalize
protected void finalize()
throws Throwable
当垃圾回收器确定不存在对该对象的更多引用时,由对象的垃圾回收器调用此方法。子类重 写 finalize 方法,以配置系统资源或执行其他清除。
(5)wait
public final void wait()
throws InterruptedException
导致当前的线程等待,直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。换句话说, 此方法的行为就好像它仅执行 wait(0) 调用一样。
(6)notify
public final void notify()
唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待,则会选择唤醒其中 一个线程。选择是任意性的,并在对实现做出决定时发生。线程通过调用其中一个 wait 方法, 在对象的监视器上等待。
4、继承条件下子类构造方法的执行过程
(1)子类的构造过程中必须调用其基类的构造方法。
(2)子类可以在自己的构造方法中使用super(argument_list)调用基类的构造方法
a、使用this(argument_list)调用本类的另外构造方法。
b、如果调用super,必须写在子类构造方法的第一行。
(3)如果子类的构造方法中没有显示的调用基类的构造方法,则系统默认调用基类的无参数构造 方法。
(4)如果子类构造方法中既没有显示调用基类构造方法,而基类又没有无参数的构造方法,则编 译出错。
5、super关键字的作用和使用
super子类可以通过它调用父类的方法 写在构造方法的第一行
6、==和equals()的联系和区别
(1)基本数据类型
也称原始数据类型。byte,short,char,int,long,float,double,boolean 他们之间的比较,应用双等 号(==),比较的是他们的值。
(2)复合数据类型(类)
当他们用(==)进行比较的时候,比较的是他们在内存中的存放地址,所以,除非是同一个 new出来的对象,他们的比较后的结果为true,否则比较后结果为false。 JAVA当中所有的类 都是继承于Object这个基类的,在Object中的基类中定义了一个equals的方法,这个方法的 初始行为是比较对象的内存地 址,但在一些类库当中这个方法被覆盖掉了,如 String,Integer,Date在这些类当中equals有其自身的实现,而不再是比较类在堆内存中的存放 地址了。
对于复合数据类型之间进行equals比较,在没有覆写equals方法的情况下,他们之间的比较 还是基于他们在内存中的存放位置的地址值的,因为Object的equals方法也是用双等号 (==)进行比较的,所以比较后的结果跟双等号(==)的结果相同。
四、 编程题
1. 使用面向对象的思想,编写自定义描述狗的信息。设定属性包括:品种,年龄,心情,名字;方法包括:叫,跑。
要求:
1) 设置属性的私有访问权限,通过公有的get,set方法实现对属性的访问
2) 限定心情只能有“心情好”和“心情不好”两种情况,如果无效输入进行提示,默认设置“心情好”。
3) 设置构造函数实现对属性赋值
4) 叫和跑的方法,需要根据心情好坏,描述不同的行为方式。
5) 编写测试类,测试狗类的对象及相关方法(测试数据信息自定义)
class Dog {
private String type;
private int age;
private String feeling="心情好";
private String name;
public Dog(String name,String type,int age,String feeling){
this.setAge(age);;
this.setFeeling(feeling);
this.setType(type);
this.setName(name);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getFeeling() {
return feeling;
}
public void setFeeling(String feeling) {
if(feeling.equals("心情好") || feeling.equals("心情不好")){
this.feeling = feeling;
System.out.println("输入信息正确,这只狗狗"+feeling);
}else{
System.out.println("输入信息错误,这只狗狗今天"+this.feeling);
}
}
public void shout(){
System.out.println("名字叫"+this.name+"的"+this.type+"呜呜的叫");
}
public void run(){
System.out.println("名字叫"+this.name+"的"+this.type+"快乐的奔跑");
}
}
public class Test1 {
public static void main(String[] args) {
Dog d=new Dog("旺财","泰迪",12,"不知道") ;
d.shout();
d.run();
System.out.println("=============================================");
Dog g=new Dog("大黄","阿拉斯加",8,"心情不好");
g.shout();
g.run();
}
}
2. 以面向对象的思想,编写自定义类描述IT从业者。设定属性包括:姓名,年龄,技术方向,工作年限, 工作单位和职务;方法包括:工作
要求:
1) 设置属性的私有访问权限,通过公有的get,set方法实现对属性的访问
2) 限定IT从业人员必须年满15岁,无效信息需提示,并设置默认年龄为15。
3) 限定“技术方向”是只读属性
4) 工作方法通过输入参数,接收工作单位和职务,输出个人工作信息
5) 编写测试类,测试IT从业者类的对象及相关方法(测试数据信息自定义)
class IT {
private String name;
private int age;
private String tend;
private int workAge;
private String workPlace;
private String job;
// 无参构造器
public IT() {
super();
// TODO Auto-generated constructor stub(指的是自动生成的构造函数)
}
// 有参构造器
public IT(String name, int age, String tend, int workAge, String workPlace, String job) {
super();
this.name = name;
this.age = age;
this.tend = tend;
this.workAge = workAge;
this.workPlace = workPlace;
this.job = job;
}
// get,set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age <= 15) {
this.age = 15;
System.out.println("年龄无效,默认值是15");
} else {
this.age = age;
}
}
public String getTend() {
return tend;
}
public void setTend(String tend) {
this.tend = tend;
}
public int getWorkAge() {
return workAge;
}
public void setWorkAge(int workAge) {
this.workAge = workAge;
}
public String getWorkPlace() {
return workPlace;
}
public void setWorkPlace(String workPlace) {
this.workPlace = workPlace;
}
public String getJob() {
return job;
}
public void setJob(String job) {
this.job = job;
}
// 工作方法
public void work() {
System.out.println("姓名:" +name);
System.out.println("年龄:" + age);
System.out.println("技术方向: " + tend);
System.out.println("工作年限: " + workAge);
System.out.println("工作单位: " + workPlace);
System.out.println("职务: " + job);
}
}
public class Test2 {
public static void main(String[] args) {
IT t = new IT("wade", 35, "数据库维护", 10, "腾讯实业", "数据库维护工程师");
t.work();
System.out.println("--------------------");
IT t1 = new IT();
t1.setName("阿杰");
t1.setAge(6);
t1.setTend("Java开发");
t1.setWorkAge(1);
t1.setWorkPlace("鼎盛科技");
t1.setJob("Java开发工程师");
t1.work();
}
}
五、 可选题
1. 以面向对象的思想,编写自定义类描述图书信息。设定属性包括:书名,作者,出版社名,价格;方法包括:信息介绍
要求:
1) 设置属性的私有访问权限,通过公有的get,set方法实现对属性的访问
2) 限定介格必须大于10,如果无效进行提示
3) 限定作者,书名境外为只读属性
4) 设计构造方法实现对属性赋值
5) 信息介绍方法描述图书所有信息
6) 编写测试类,测试图书类的对象及相关方法(测试数据信息自定)
class BookInformation {
private String name;
private String author;
private String publish;
private double price;
public String getName() {
return name;
}
public String getAuthor() {
return author;
}
public String getPublish() {
return publish;
}
public double getPrice() {
return price;
}
public void setName(String name) {
this.name = name;
}
public void setAuthor(String author) {
this.author = author;
}
public void setPublish(String publish) {
this.publish = publish;
}
public void setPrice(double price) {
this.price = price;
}
//书信息介绍
public void introduce() {
System.out.println("书名:" + getName());
System.out.println("作者:" + getAuthor());
System.out.println("出版社:" + getPublish());
System.out.println("价格:" + getPrice() + "元");
}
}
public class Test3 {
public static void main(String[] args) {
BookInformation b1 = new BookInformation();
b1.setName("鹿鼎记");
b1.setAuthor("金庸");
b1.setPublish("人民出版社");
b1.setPrice(120);
b1.introduce();
System.out.println("======================");
BookInformation b2 = new BookInformation();
b2.setName("绝代双骄");
b2.setAuthor("古龙");
b2.setPublish("中国长安出版社");
b2.setPrice(55);
b2.introduce();
}
}
2. 某公司要开发名为”我爱购物狂”的购物网站,请使用面向对象的思想设计描述商品信息
要求:
1) 分析商品类别和商品详细信息属性和方法,设计商品类别类和商品详细信息类
2) 在商品详细信息类中通过属性描述该商品所属类别
3) 设置属性的私有访问权限,通过公有的get,set方法实现对属性的访问
4) 编写测试类,测试商品类别类和商品详细信息类的对象及相关方法(测试数据信息自定)
5) 创建包info—存放商品类别类和商品详细信息类,创建包test—存放测试类
参考分析思路:
商品类别类:
属性:类别编号,类别名称
商品详细信息类:
属性:商品编号,商品名称,所属类别,商品数量(大于0),商品价格(大于0),
方法:盘点的方法,描述商品信息。内容包括商品名称,商品数量,商品价格,现在商品总价以及所属类别信息
//商品类别类
class GoodsType {
private String typeName;
private long typeNum;
public String getTypeName() {
return typeName;
}
public void setTypeName(String typeName) {
this.typeName = typeName;
}
public long getTypeNum() {
return typeNum;
}
public void setTypeNum(long typeNum) {
this.typeNum = typeNum;
}
}
//商品详细信息类
class GoodsInfo {
GoodsType gt=new GoodsType();
private String goodsName;
private double price;
private int inventory;
public GoodsInfo(GoodsType gt,String goodsName,double price,int inventory){
if(inventory>0 ){
this.inventory=inventory;
}else{
System.out.println("库存数量异常,请联系管理员");
}
this.gt=gt;
this.goodsName=goodsName;
this.price=price;
}
public GoodsType getGt() {
return gt;
}
public void setGt(GoodsType gt) {
this.gt = gt;
}
public String getGoodsName() {
return goodsName;
}
public void setGoodsName(String goodsName) {
this.goodsName = goodsName;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getInventory() {
return inventory;
}
public void setInventory(int inventory) {
this.inventory = inventory;
}
public void print(){
System.out.println("商品名称: "+this.goodsName);
System.out.println("所属类别: "+this.gt.getTypeName());
System.out.println("库存数量: "+this.inventory);
System.out.println("商品售价: "+this.price);
System.out.println("商品总价: "+this.price*this.inventory);
}
}
public class Test4 {
public static void main(String[] args) {
GoodsType gt=new GoodsType();
gt.setTypeName("洗发水");
GoodsInfo g=new GoodsInfo(gt,"潘婷洗发水400ml",40.5,16);
g.print();
System.out.println("##################################");
gt.setTypeName("洗发水");
GoodsInfo i=new GoodsInfo(gt,"蜂花洗发水250ml",11.1,0);
i.print();
}
}