zoukankan html css js c++ java

封装和继承作业

封装和继承作业

一、 选择题

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 ）

三、 简答题

private、默认、protected、public四个权限修饰符的作用.

　　　　访问修饰符:可以修饰变量，方法，类

　　修饰变量：四种修饰符都能使用

　　修饰方法：四种修饰符都能使用

　　修饰类：2种 public,default

方法重载和方法重写（覆盖）的区别。.

　　（1）方法重载：存在一个类中

方法名必须相同

参数列表不同（参数个数，类型，顺序不同）

与返回值无关

（2）方法重写：存在子父类中，子类把父类的方法重写一遍

返回值，方法名，参数列表必须一致

子类的访问修饰符要大于等于父类的访问修饰符

java.lang.Object类的六个常用方法的声明并说明其作用。

　　　　Object类有一个默认构造方法pubilcObject()，在构造子类实例时，都会先调用这个默认构造方法。

　　　　equals()方法：用于测试某个对象是否同另一个对象相等。它在Object类中的实现是判断两个对象是否指向同一块内存区域。

　　　　toString()：返回该对象的字符串表示。Object类中的toString()方法会打印出类名和对象的内存位置。几乎每个类都会覆盖该方法，以便打印对该对象当前状态的表示。

f　　　　inalize

　　　　protected void finalize()

　　　　 throws Throwable

　　　　当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。子类重写 finalize 方法，以配置系统资源或执行其他清除。

　　　　wait

　　　　public final void wait()

throws InterruptedException

　　　　导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。

　　　　notify

　　　　public final void notify()

　　　　唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。

继承条件下子类构造方法的执行过程

　　1、子类的构造过程中必须调用其基类的构造方法。

　　　　2、子类可以在自己的构造方法中使用super(argument_list）调用基类的构造方法

　　　　 2.1、使用this(argument_list)调用本类的另外构造方法。

　　　　 2.2、如果调用super，必须写在子类构造方法的第一行。

　　　　3、如果子类的构造方法中没有显示的调用基类的构造方法，则系统默认调用基类的无参数构造方法。

　　　　4、如果子类构造方法中既没有显示调用基类构造方法，而基类又没有无参数的构造方法，则编译出错。

super关键字的作用和使用

　　　　 super子类可以通过它调用父类的方法写在构造方法的第一行

==和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方法也是用双等号（==）进行比较的，所以比较后的结果跟双等号（==）的结果相同。

四、 编码题

以面向对象的思想，编写自定义类描述IT从业者。设定属性包括：姓名，年龄，技术方向，工作年限, 工作单位和职务；方法包括：工作

要求：

　　　　1) 设置属性的私有访问权限，通过公有的get,set方法实现对属性的访问

　　　　2) 限定IT从业人员必须年满15岁，无效信息需提示，并设置默认年龄为15。

　　　　3) 限定“技术方向”是只读属性

　　　　4) 工作方法通过输入参数，接收工作单位和职务，输出个人工作信息

　　　　5) 编写测试类，测试IT从业者类的对象及相关方法（测试数据信息自定义）

  1 public class IT {
  2     private String name;
  3     private int age;
  4     private String tend;
  5     private int workAge;
  6     private String workPlace;
  7     private String job;
  8 
  9     // 无参构造器
 10     public IT() {
 11         super();
 12         // TODO Auto-generated constructor stub
 13     }
 14 
 15     // 有参构造器
 16     public IT(String name, int age, String tend, int workAge, String workPlace, String job) {
 17         super();
 18         this.name = name;
 19         this.age = age;
 20         this.tend = tend;
 21         this.workAge = workAge;
 22         this.workPlace = workPlace;
 23         this.job = job;
 24     }
 25 
 26     // get,set方法
 27     public String getName() {
 28         return name;
 29     }
 30 
 31     public void setName(String name) {
 32         this.name = name;
 33     }
 34 
 35     public int getAge() {
 36         return age;
 37     }
 38 
 39     public void setAge(int age) {
 40         if (age <= 15) {
 41             this.age = 15;
 42             System.out.println("年龄无效，默认值是15");
 43         } else {
 44             this.age = age;
 45         }
 46     }
 47 
 48     public String getTend() {
 49         return tend;
 50     }
 51 
 52     public void setTend(String tend) {
 53         this.tend = tend;
 54     }
 55 
 56     public int getWorkAge() {
 57         return workAge;
 58     }
 59 
 60     public void setWorkAge(int workAge) {
 61         this.workAge = workAge;
 62     }
 63 
 64     public String getWorkPlace() {
 65         return workPlace;
 66     }
 67 
 68     public void setWorkPlace(String workPlace) {
 69         this.workPlace = workPlace;
 70     }
 71 
 72     public String getJob() {
 73         return job;
 74     }
 75 
 76     public void setJob(String job) {
 77         this.job = job;
 78     }
 79 
 80     // 工作方法
 81     public void work() {
 82         System.out.println("姓名：" +name);
 83         System.out.println("年龄：" + age);
 84         System.out.println("技术方向: " + tend);
 85         System.out.println("工作年限: " + workAge);
 86         System.out.println("工作单位: " + workPlace);
 87         System.out.println("职务: " + job);
 88     }
 89 
 90 }
 91 public class test {
 92     public static void main(String[] args) {
 93         IT t = new IT("马未龙", 35, "数据库维护", 10, "腾讯实业", "数据库维护工程师");
 94         t.work();
 95         System.out.println("--------------------");
 96         IT t1 = new IT();
 97         t1.setName("张凯");
 98         t1.setAge(6);
 99         t1.setTend("Java开发");
100         t1.setWorkAge(1);
101         t1.setWorkPlace("鼎盛科技");
102         t1.setJob("Java开发工程师");
103         t1.work();
104     }
105 }

　　2.编写应用程序，创建类的对象，分别设置圆的半径、圆柱体的高，计算并分别显示圆半径、圆面积、圆周长，圆柱体的体积。（7分）

　　提示:（1）编写一个圆类Circle，该类拥有：

　　1) 一个成员变量，radius（私有，浮点型）;//存放圆的半径；

　　2) 两个构造方法

　　Circle（） //将半径设为0

　　Circle（double r ） //创建Circle对象时将半径初始化为r

　　3) 三个成员方法

　　double getArea（） //获取圆的面积

　　double getPerimeter（） //获取圆的周长

　　void show（） //将圆的关径、周长、面积输出到屏幕

（2）编写一个圆柱体类Cylinder，它继承于上面的Circle类。还拥有：

　　1) 一个成员变量，double hight （私有，浮点型）; //圆柱体的高；

　　2) 构造方法

　　//创建Cylinder对象时将半径初始化为r,高度初始化为h

　　Cylinder（double r,double h）

　　3) 成员方法

　　double getVolume（） //获取圆柱体的体积

　　void showVolume（） //将圆柱体的体积输出到屏幕

 1 public class Circle {
 2     double radius;
 3 
 4     // 无参构造器
 5     public Circle() {
 6        this.radius=0;
 7     }
 8 
 9     // 有参构造器
10     public Circle(double r) {
11         this.radius = r;
12     }
13     
14     //获取圆的面积
15     public double getArea(){
16         double s = Math.PI*this.radius*this.radius;
17         return s;
18     }
19     
20     //获取圆的周长
21     public double getPerimeter(){
22         double c = 2*Math.PI*this.radius;
23         return c;
24     }
25     
26   //将圆的半径、周长、面积输出到屏幕
27     public void show(){
28       System.out.println("圆的半径是:"+this.radius);
29       System.out.print("圆的周长是：");
30       System.out.printf("%.2f",getPerimeter());
31       System.out.print("
圆的面积是：");
32       System.out.printf("%.2f",getArea());
33     }
34 }
35 public class Cylinder extends Circle {
36     double hight;// 圆柱体的高
37 
38     public Cylinder(double r, double h) {
39         super(r);
40         this.hight = h;
41     }
42 
43     // 获取圆柱体的体积
44     public double getVolume() {
45         double s = super.getArea();
46         double v =s*this.hight;
47         return v;
48     }
49     
50     //将圆柱体的体积输出到屏幕
51     public void showVolume(){
52         System.out.print("
圆柱的体积是：");
53         System.out.printf("%.2f",getVolume());
54     }
55 }
56 public class test {
57     public static void main(String[] args) {
58         Cylinder c = new Cylinder(3, 6);
59         Circle ci = new Circle(5);
60         ci.show();
61         c.showVolume();
62     }
63 }

　　3.某公司要开发新游戏，请用面向对象的思想，设计游戏中的蛇怪和蜈蚣精

　　设定

　　1) 蛇怪类:

　　属性包括：怪物名字，生命值，攻击力

　　方法包括：攻击，移动（曲线移动），补血（当生命值<10时，可以补加20生命值）

　　2) 蜈蚣精类：

　　属性包括：怪物名字，生命值，攻击力

　　方法包括：攻击，移动（飞行移动）

　　要求

　　1) 分析蛇怪和蜈蚣精的公共成员，提取出父类—怪物类

　　2) 利用继承机制，实现蛇怪类和蜈蚣精类

　　3) 攻击方法，描述攻击状态。内容包括怪物名字，生命值，攻击力

　　4) 编写测试类，分别测试蛇怪和蜈蚣精的对象及相关方法

　　5) 定义名为mon的包存怪物类，蛇怪类，蜈蚣精类和测试类

 1 public class Monster {
 2     String name;
 3     int healthpoint;// 生命值
 4     int Attack;// 攻击力
 5 
 6     public String getName() {
 7         return name;
 8     }
 9 
10     public int getHealthpoint() {
11         return healthpoint;
12     }
13 
14     public int getAttack() {
15         return Attack;
16     }
17 
18     public void setName(String name) {
19         this.name = name;
20     }
21 
22     public void setHealthpoint(int healthpoint) {
23         this.healthpoint = healthpoint;
24     }
25 
26     public void setAttack(int attack) {
27         this.Attack = attack;
28     }
29     
30     //攻击
31     public void attack(){
32         System.out.println("怪物"+getName()+"展开攻击");
33         System.out.println("当前的生命值是："+getHealthpoint());
34         System.out.println("攻击力是："+getAttack());
35     }
36      //移动
37     public void move(){}
38     
39 
40 }
41 public class Snake extends Monster {
42     //补血（当生命值<10时，可以补加20生命值）
43     public void addHP(){
44         if(getHealthpoint()<10){//当生命值<10时，可以补加20生命值
45             healthpoint = getHealthpoint()+20;
46             System.out.println("施展大蛇补血术。。。。。当前的生命值是："+healthpoint);
47         }
48         
49     }
50     
51     //方法重写-重写父类move();
52     public void move(){
53         System.out.println("我是蛇怪，我走S行线路！");
54     }
55     
56     
57 }
58 public class Centipede extends Monster {
59     // 方法重写-重写父类move();
60     public void move() {
61         System.out.println("我是蜈蚣精，我御风飞行！");
62     }
63 }
64 public class test {
65     public static void main(String[] args) 
66         // 创建蛇对象
67         Snake s = new Snake();
68         s.setName("金蛇怪");
69         s.setHealthpoint(1);
70         s.addHP();
71         s.setAttack(100);
72         s.attack();
73         s.move();
74         // 创建蜈蚣对象
75         System.out.println();
76         Centipede ce = new Centipede();
77         ce.setName("紫衣蜈蚣");
78         ce.setHealthpoint(30);
79         ce.setAttack(70);
80         ce.attack();
81         ce.move();
82     }
83 }

五、 可选题

以面向对象的思想，编写自定义类描述图书信息。设定属性包括：书名，作者，出版社名，价格；方法包括：信息介绍

　　要求：

　　1) 设置属性的私有访问权限，通过公有的get,set方法实现对属性的访问

　　2) 限定介格必须大于10，如果无效进行提示

　　3) 设计构造方法实现对属性赋值

　　4) 信息介绍方法描述图书所有信息

　　5) 编写测试类，测试图书类的对象及相关方法（测试数据信息自定）

ublic 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 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) 分析演员和运动员的公共成员，提取出父类—人类

　　4) 利用继承机制，实现演员类和运动员类

　　5) 编写测试类，分别测试人类，演员类和运动员类对象及相关方法

　　6) 定义名为act的包存人类，演员类，运动员类和测试类

  1 public class People {
  2     private String name;
  3     private int age;
  4     private String sex;
  5 
  6     public String getName() {
  7         return name;
  8     }
  9 
 10     public int getAge() {
 11         return age;
 12     }
 13 
 14     public String getSex() {
 15         return sex;
 16     }
 17 
 18     public void setName(String name) {
 19         this.name = name;
 20     }
 21 
 22     public void setAge(int age) {
 23         this.age = age;
 24     }
 25 
 26     public void setSex(String sex) {
 27         this.sex = sex;
 28     }
 29     
 30     //公共方法-自我介绍
 31     public void introduce(){
 32         System.out.println("大家好！我是："+getName());
 33         System.out.println("今年"+getAge() +"岁");
 34         System.out.println("我是一个"+getSex()+"生");
 35     }
 36 }
 37 
 38 public class Sportsman extends People {
 39     private String project;
 40     private String grade;
 41 
 42     public String getProject() {
 43         return project;
 44     }
 45 
 46     public String getGrade() {
 47         return grade;
 48     }
 49 
 50     public void setProject(String project) {
 51         this.project = project;
 52     }
 53 
 54     public void setGrade(String grade) {
 55         this.grade = grade;
 56     }
 57     
 58     public void title(){
 59         System.out.println("我是一个普通的小老百姓");
 60         System.out.println("=====================");
 61     }
 62     //运动员介绍-运动项目，历史最好成绩
 63     public void infor(){
 64         System.out.println("我最擅长的运动项目是："+getProject()+"短跑");
 65         System.out.println("历史最好的成绩是："+getGrade());
 66     }
 67 
 68 }
 69 public class Actor extends People{
 70     private String graduate;
 71     private String representative;
 72 
 73     public String getGraduate() {
 74         return graduate;
 75     }
 76 
 77     public String getRepresentative() {
 78         return representative;
 79     }
 80 
 81     public void setGraduate(String graduate) {
 82         this.graduate = graduate;
 83     }
 84 
 85     public void setRepresentative(String representative) {
 86         this.representative = representative;
 87     }
 88     
 89     //演员介绍-毕业院校，代表作
 90     public void info() {
 91         System.out.println("毕业院校："+getGraduate());
 92         System.out.println("代表作："+getRepresentative());
 93     }
 94     
 95     public void title1(){
 96         System.out.println("=====================");
 97     }
 98 }
 99 
100 public class test {
101     public static void main(String[] args) {
102         //运动员对象
103         Sportsman s = new Sportsman();
104         s.setName("刘小翔");
105         s.setAge(23);
106         s.setSex("男");
107         s.setProject("200");
108         s.setGrade("22秒30");
109         s.title();
110         s.introduce();
111         s.infor();
112         
113         //演员对象
114         Actor a = new Actor();
115         a.setName("章衣");
116         a.setAge(27);
117         a.setSex("女");
118         a.setGraduate("北京电影学院");
119         a.setRepresentative("《寄往天国的家书》");
120         a.title1();
121         a.introduce();
122         a.info();
123     }
124    
125   
126 }

查看全文

相关阅读:
2017-2018-20155336 《信息安全系统设计基础》第八周学习总结
 2017-2018-20155336 《信息安全系统设计基础》第七周学习总结
 2017-2018-20155336 《信息安全系统设计基础》第六周学习总结
 2017-2018-1 20155336 《信息安全系统设计基础》第五周学习总结
 2017-2018-1 20155336 《信息安全系统设计基础》第四周学习总结
 20155336 2017-2018 1 《信息安全系统设计基础》第3周学习总结
 2017-2018-1 20155310 《信息安全系统设计基础》第九周学习总结
 《信息安全技术》实验三数字证书应用
 2017-2018-1 20155310 《信息安全系统设计基础》第七周学习总结
 2017-2018-1 20155310 20155337 实验二固件程序设计

原文地址：https://www.cnblogs.com/topshark/p/10251886.html