java继承习题
（一）选择题
1）若在某一个类定义中定义有如下的方法：final void workDial( )该方法属于
A.本地方法
B.最终方法
C.静态方法
D.抽象方法
2）下面哪个方法与题目中的不是重载方法public int max(int x,int y)
A.public double max(double x,double y)
B.publicintmax(intn,int k)
C.publicintmax(intx,int y, int z)
D.public double max(double n,double k)
3）为了区分类中重载的同名的不同方法，要求
A.参数列表不同
B.调用时用类名或对象名做前缀
C.参数名不同
D.返回值类型不同
4）某个类中存在一个方法：void getSort(int x),以下能作为该方法的重载的声明的是？
A.publicgetSort(float x)
B.doublegetSort(intx,int y)
C.int getSort(int y)
D.voidget(intx,int y)
5）A派生出子类B ，B派生出子类C，并且在Java源代码中有如下声明：
A a0=new A();
A a1 =new B();
A a2=new C();
问以下哪个说法是正确的？
}
A.只有第1行能通过编译
B.第1、2行能通过编译，但第3行编译出错
C.第1、2、3行能通过编译，但第2、3行运行时出错
D.第1行、第2行和第3行的声明都是正确的
6）设有下面两个类的定义。
class Person {
long id; // 身份证号
String name; // 姓名
}
class Student extends Person {
int score; // 入学总分}
intgetScore() {
return score;
}
}
则类Person和类Student的关系是？
}
A.包含关系
B.继承关系
C.关联关系
D.上述类定义有语法错误
7）下列叙述中，正确的是?
A.子类继承父类的所有属性和方法
B.子类可以继承父类的私有的属性和方法
C.子类可以继承父类的公有的属性和方法
D.创建子类对象时，父类的构造方法都要被执行
8）现有两个类A、B，以下描述中表示B继承自A的是?
A.class A extends B
B.class B implements A
C.classA implements B
D.classB extends A
9）下列叙述中错误的是？
A.一个子类可有多个父类
B.父类派生出子类
C.子类继承父类
D.子类只能有一个父类
10）关于继承下面说法正确的是
A.子类能够继承父类私有的属性;
B.子类可以重写父类的final方法;
C.子类能够继承不同包父类的protected属性;
D.子类能够继承不同包父类的缺省属性;
11）有名字为A的包和名为B的类，下面的语句正确的是
A.package A.B;
B.package B;
C.import A.* ;
D.import B;
12）声明一个名字为P的包，下面的语句正确的是
A.packagePkg;
B.Package P;
C.package P;
D.package "p";
13）导入包A中的类AA应该使用下面哪条语句?
A.import A.AA ;
B.import AA.A；
C.package A；
D.package AA；
14）下列针对int类型的私有属性age的访问器方法格式正确的是？
A.voidgetAge(int age)
B.int getAge(int age)
C.voidsetAge(int age)
D.int setAge()
15）下列关于访问器方法说法正确的是？
A.get方法可以读取属性的值
B.set方法用来读取属性的值
C.必须为每个private属性提供访问器方法
D.public属性不能有访问器方法
16）表示数据或方法可以只能被定义它的类访问的是
A.public
B.默认的
C.private
D.protected
17）表示数据或方法只能被其它包中的子类访问的是
A.public
B.默认的
C.private
D.protected
18）对于子类的构造函数说明，下列叙述中不正确的是?
A.子类无条件地继承父类的无参构造函数
B.子类可以在自己的构造函数中使用super关键字来调用父类的含参数构造函数，但这个调用语句必须是子类构造函数的第一个可执行语句
C.在创建子类的对象时，将先执行继承自父类的无参构造函数，然后再执行自己的构造函数
D.子类不但可以自动执行父类的无参构造函数，也可以自动执行父类的有参构造函数
19）当你编译运行下列程序代码，会得到什么结果?
private class Base{
Base(){
int i = 100;
System.out.println(i);
}
}
public class Pri extends Base{
staticint i = 200;
public static void main(String argv[]){
Pri p = new Pri();
System.out.println(i);
}
}
A.这段代码不能通过编译
B.输出200
C.输出100和200
D.输出100
（二）简答题
1）简述修饰类的可见性修饰符有哪些及其作用？
2）简述修饰类的成员的可见性修饰符有哪些及其作用？
3）导入包时可导入其他包中哪些类？如何导入包p中的全部可以使用的类，请写出语句？4）包的作用是什么？如何声明一个包？
5）写出set和get方法定义的格式。
6）简述this和super的区别？
7）super的作用有哪些？
8）final修饰符都能用来修饰程序中哪些成员？
9）请写出下列输出结果。
classFatherClass {
publicFatherClass() {
System.out.println("FatherClass Create"); }
}
classChildClass extends FatherClass {
publicChildClass() {
System.out.println("ChildClass Create"); }
public static void main(String[] args) {
FatherClass fc = new FatherClass();
ChildClass cc = new ChildClass(); }
FatherClass Create
FatherClass Create
ChildClass Create
10）下面是一个类的定义,填写程序空白处。
class B {
privateint x;
private char y;
public B( int x, char y , char j) {
x = i;
y = j; }
publicintgetX()
{ return x;}
public void setX(int x)
{ this.x=x}
public char getY()
{ return y;}
public void setY( char y)
{ this.y=y;}
}
11）定义类A和类B如下.：
class A{
intm=1;
double n=2.0;
void print( ) {
System.out.println("Class A: m="+m +"，n="+n); }
}
class B extends A{
float m=3.0f;
String n="Good .";
void print( ) {
super.print( );
System.out.println("Class B: m="+m +"，n="+n); }
}
问题：(1)若在应用程序的main方法中有以下语句：
A a=new A();
a.print();
则输出的结果如何？
Class A: m=1,n=2.0
(2)若在应用程序的main方法中定义类B的对象b：
Bb=new B();
b.print();
则输出的结果如何？
Class A: m=1，n=2.0
Class B: m=3.0，n=Good
12）请写出下列输出结果。
class Parent {
voidprintMe() {
System.out.println("parent");
}
}
class Child extends Parent {
voidprintMe() {
System.out.println("child");
}
voidprintAll() {
super.printMe();
this.printMe();
printMe();
}
}
class Class1 {
public static void main(String[] args) {
Child myC = new Child();
myC.printAll();
}
}
parent
child
child
（三）编程题
1）定义一个学生类，包括属性：学号（ID），姓名（name），成绩（score）；构造方法（带三个参数）；每个属性的访问器方法。
2）创建类A1，实现构造方法中输出This is A;创建A1的子类B1，实现构造方法中输出This is B;创建B1的子类C1，实现构造方法中输出This is C。
3）定义一个人类（Person），它包含属性：姓名（name）,性别（sex）;带两个参数的构造方法；属性的访问器方法。定义上面人类的子类学生类（Student），包括属性：学号（ID），带参数的构造方法；属性的访问器方法。
JAVA类的继承实验报告
《面向对象程序设计》实验报告 实验六、类的继承 课程代码：1H10500学分：6 实验类型：实践型实验学时：4个学时 实验时间：2017.11.23 实验地点：5407 班级：计算机164 专业：计算机科学与技术专业学号：2016011147 姓名：林文辉 一、实验目的 （1）学习JAVA继承的思想 （2）了解JAVA语言继承的实现 二、实验内容及步骤 内容：在圆柱体类Cylinder里，用一个构造方法调用另一个构造方法 步骤：方案的设计与分析（类结构图。。。。。。） （1）找出对象的共同属性和行为 （2）设计代表共同状态与行为的类 （3）决定子类是否需要让某项行为有特定的不同的运行方式 （4）寻找更多抽象化的机会 （5）完成类的继承层次 三、实验过程及结果 实验1代码： abstract class Graphics { abstract void parameter(); abstract void area(); } class Rectangle extends Graphics{ double h,w; Rectangle(double u,double v){h=u;w=v;} void parameter() { S ystem.out.println("矩形高度为:"+h+",矩形宽度为:"+w); } void area() { S ystem.out.println("矩形面积为："+(h*w)); } }
class Circle extends Graphics{ double r; String c; Circle(double u,String v){r=u;c=v;} void parameter() { System.out.println("圆半径为:"+r+",圆颜色为:"+c); } void area() { System.out.println("圆面积为:"+(Math.PI*r*r)); } } class ExamAbs{ public static void main(String args[]) { Rectangle rec=new Rectangle(2.0, 3.0); Circle cir=new Circle(4.0, "Red"); Graphics[]g= {rec,cir}; for(int i=0;i 1,定义一个接口Assaultable(可攻击的)，该接口有一个抽象方法attack()。 2,定义一个接口Mobile（可移动的）,该接口有一个抽象方法move()。 3,定义一个抽象类Weapon,实现Assaultable接口和Mobile接口，但并没有给出具体的 实现方法。 4,定义3个类：Tank,Flighter,WarShip都继承自Weapon,分别用不同的方式实现Weapon 类中的抽象方法。 5,写一个类Army,代表一支军队，这个类有一个属性是Weapon数组w（用来存储该军队所拥有的所有武器）；该类还提供一个构造方法，在构造方法里通过传一个int类型的参数来限定该类所能拥有的最大武器数量,并用这一大小来初始化数组w。该类还提供一个方法addWeapon(Weapon wa),表示把参数wa所代表的武器加入到数组w中。在这个类中还定义两个方法attackAll()和moveAll()，让w数组中的所有武器攻击和移动。 6，写一个主方法去测试以上程序。 interface Assaultable{//可攻击的 void attack(); } interface Mobile{//可移动的 void move(); } abstractclass Weapon implements Assaultable,Mobile { publicvoid attack(){} publicvoid move(){} } class Tank extends Weapon{ publicvoid attack(){ System.out.println("坦克攻击！！！"); } publicvoid move(){ System.out.println("坦克移动！！！"); } } class Flighter extends Weapon{ publicvoid attack(){ System.out.println("战斗机攻击！！！"); } publicvoid move(){ System.out.println("战斗机移动！！！"); 实验项目名称：继承和多态 （所属课程：Java语言程序设计） 院系：专业班级：姓名： 学号：实验地点：指导老师： 本实验项目成绩：教师签字：日期： 1．实验目的 （1）掌握类的继承机制。 （2）熟悉类中成员变量和方法的访问控制。 （3）熟悉方法或构造方法多态性。 2.实验内容 （1）模拟编写程序，理解类的继承、多态、继承和多态规则。 （2）独立编程，实现类的继承和多态。 3.实验作业 设计一个类Shape（图形）包含求面积和周长的area()方法和perimeter()方法以及设置颜色的方法SetColor()，并利用Java多态技术设计其子类Circle（圆形）类、Rectangle （矩形）类和Triangle（三角形）类，并分别实现相应的求面积和求周长的方法。每个类都要覆盖toString方法。 海伦公式：三角形的面积等于s(s-a)(s-b)(s-c)的开方，其中s=(a+b+c)/2 程序代码为： Class包 package Class; public class Shape { private String color = "while"; public Shape(String color){ this.color = color; } public void setColor(String color){ this.color = color; } public String getColor(){ return color; } public double getArea(){ return 0; } public double getPerimeter(){ return 0; } public String toString(){ return"color:" + color; } } package Class; public class Circle extends Shape { private double radius; public Circle(String color,double radius) { super(color); this.radius = radius; } public void setRadius(double radius){ this.radius = radius; } public double getRadius(){ return radius; } public double getCircleArea(){ return 3.14*radius*radius; } public double getCirclePerimeter(){ return 3.14*2*radius; } public String toString(){ 实验三类的继承 实验目的：掌握类的继承、抽象类的定义和使用、对象的向上转型。实验内容：已知若干图形，求以该图形为底的锥体的体积。 实验要求：用面向抽象的思想实现 实验步骤： 1、程序总体框架 2、在shape包中创建抽象类Shape，代码如下： 3、在centrun包中创建一个类Centrun,代码如下： Centrun这个类为核心类，在之后的代码编写中可以不做更改，getVolume函数用来求椎体的体积，即利用抽象类getArea进行适应性计算。 4、创建一个包myshape，在其中先创建一个Circle类，代码如下： Circle是对抽象类shape的继承（记得导入shape包），在Circle类中，利用对getArea 函数代码的重写操作，具体实现了求圆的面积这一操作。【此处的具体实现应该放入该图形的具体面积求法。】 5、创建一个包Test，对以上三个包中的代码进行具体实现，代码如下： 导入myshape包，在main函数中通过向上转型，实例化shape包中的抽象类Shape，然后调用函数输出圆锥的体积。 6、在求出实验结果1，即调试好shape、myshape、centrun这三个包后，不再更改shape、centrun包，而是在myshape包下新建所需的类，如本次实验所需的三角形、矩形； 7、在myshape包下创建一个类Rectangular，代码如下： 8、在myshape包下创建一个类Triangle，需注意的是，求三角形的面积需要判断三角形的三边能否构成三角形（不能构成时返回0），代码如下： 实验结果： 1、Test测试包最终代码： 西安邮电大学 （计算机学院） 课内实验报告 实验名称：继承与多态 专业名称：计算机科学与技术 班级：计科1405班 学生姓名：高宏伟 学号：04141152 指导教师：刘霞林 实验日期：2016.10.13 一、实验目的 通过编程和上机实验理解Java 语言的继承和多态特性，掌握变量的隐藏、方法的覆盖、重载，掌握抽象类和接口的使用。 二、实验要求 1.编写体现类的继承性（成员变量、成员方法、成员变量隐藏）的程序。 2.编写体现类的多态性（成员方法重载）的程序。 3.编写体现类的多态性（构造方法重载）的程序。 4.编写使用接口的程序。 三、实验内容 （一）类的继承 1.创建公共类Student. （1）编写程序文件Student.java，源代码如下: public class Student { protected String name; //具有保护修饰符的成员变量 protected int number; void setData(String m,int h) //设置数据的方法 { name =m; number= h; } public void print() //输出数据的方法 { System.out.println(name+", "+number); } } （2）编译Student.java，产生类文件Student.class。 2．创建继承的类Undergraduate （1）程序功能：通过Student 类产生子类undergraduate，其不仅具有父类的成员变量name（）、number（学号），还定义了新成员变量academy（学院）、department （系）。在程序中调用父类的print 方法。 （2）编写Undergraduate 程序: class Undergraduate extends Student { 【代码1】//定义成员变量academy 【代码2】//定义成员变量department public static void main(String args[]) { 【代码3】//创建一个学生对象s 【代码4】//用父类的setData方法初始化对象s 【代码5】//对象s调用print方法 【代码6】//创建一个大学生对象u 【代码7】//调用父类的成员方法setData初始化对象u 【代码8】//设置对象u的成员变量academy 【代码9】//设置对象u的成员变量department System.out.print(https://www.wendangku.net/doc/2a7433297.html,+", "+u.number+", "+u.academy+", "+u.department); } } （3）编译并运行程序 注意：公共类Student 与undergraduate 类要在同一文件夹（路径）。 (二)方法的重载 （1）程序功能：对不同的数进行排序输出。在IntSort 类中定义3 个同名的方法sort。 （2）编写Sort.java 文件，源代码如下。 import java.awt.Graphics; import java.applet.Applet; class IntSort { public String sort(int a, int b) { if (a>b) return a+""+b; else return b+""+a; } public String sort(int a, int b, int c) { int swap; if (a JAVA中继承的总结 一、继承概念： 把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系， 这多个类就具备了这些内容。这个关系叫继承。 二、何时实现继承 A:继承体现的是：is a的关系。 B:采用假设法 三、怎么实现继承 A:用关键字extends表示 B:格式： class 子类名 extends 父类名 {} C:子类 public class 子类 extends 父类 { //增加自己属性 //重写父类的属性 //增加自己的方法 //重写父类的方法 } 四、继承的好处： A:提高了代码的复用性 B:提高了代码的维护性 C:让类与类产生了一个关系，是多态的前提 继承的弊端： A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。 原则：低耦合，高内聚。 耦合：类与类的关系 内聚：自己完成某件事情的能力 B:打破了封装性 五、Java中继承的特点 A:Java中类只支持单继承，只能一个直接父类，Object 根类 B:Java中可以多层(重)继承(继承体系) 六、继承的注意事项： A:子类能继承父类的私有成员,但不是都能访问 B:子类不能继承父类的构造方法，但是可以通过super去访问 C:不要为了部分功能而去继承 七、继承中static用法 A:static:子类可以继承父类的静态方法,但不能重写 B:static 的属性和方法都是不能覆盖的，因为static修饰的部分都是与对象无关的，只与类有关 八、Java继承中的成员关系 A:成员变量 a:子类的成员变量名称和父类中的成员变量名称不一样，这个太简单 b:子类的成员变量名称和父类中的成员变量名称一样，这个怎么访问呢? 第四章 面向对象的概念和 Java 实现-2 回顾 ?类是具有相同属性和行为的一组对象的集合 , 对象是类的实例 ?封装是隐藏对象实现细节的过程，以便不让用户看到实现的细节 ?类可用Class 来定义，类的变量和方法可被该类的实例访问, 圆点符号用于访问对象的成员，构造函数在创建对象时初始化对象 ?包可用package 来申明，可用import 来导入包 目标 ?理解继承及其特点 ?运用JAVA程序实现继承 ?理解多态及其特点设计 ?运用JAVA程序实现多态 ?掌握访问修饰符和方法修饰符 继承 继承的特点 继承的优点 继承的JAVA实现 子类构造方法 2-1 子类构造方法 2-2 ?调用父类构造方法的语法为： super() 或 super(参数列表) ; ?super () 方法始终指向调用类的父类 调用父类构造方法 演示：示例 3 多态性 2-1 ?多态性是指?°多种形式?± ?它使用不同的实例而执行不同操作 ?多态包括方法重写和方法重载 多态性 2-2 方法重载 2-1 方法重载 2-2 演示：示例 4 方法重写 2-1 方法重写 2-2 访问修饰符 3-1 ?信息隐藏是 OOP 最重要的功能之一，也是使用访问修饰符的原因 ?信息隐藏的原因包括： ?对任何实现细节所作的更改不会影响使用该类的代码 ?防止用户意外删除数据 ?此类易于使用 访问修饰符 3-2访问修饰符 3-3 ?访问修饰符可访问性 方法修饰符 static 修饰符 3-1 ?static修饰符修饰的方法叫静态方法 ?目的 ?使该方法独立于类的实例，使用类去访问，而不是类实例，所以也叫类方法 static 修饰符 3-2 ?调用静态方法的语法为： classname.methodname( ); static 修饰符 3-3 演示：示例 6 final 修饰符 abstract 修饰符 3-1 ?由abstract修饰的方法叫抽象方法；由abstract修饰的类叫抽象类 ?抽象方法必须声明在抽象类中 ?抽象方法语法： abstract type method_name(parameter_list); ?声明抽象类语法： abstract class{…… } ?使用：父类中的某些抽象不包含任何逻辑，并需要在子类中重写，子类提供这种抽象方法的实现细节 abstract 修饰符 3-2 ?抽象类可以具有指向子类对象的对象引用 abstract 修饰符 3-3 演示：示例 7 接口 ?接口就是某个事物对外提供的一些功能的申明 ?可以利用接口实现多态，同时接口也弥补了Java单一继承的弱点 ?使用interface关键字定义接口 ?一般使用接口声明方法或常量，接口中的方法只能是声明，不能是具体的实现 创建接口的步骤 2-1 // 定义方法的接口 public interface myinterface { public void add(int x, int y); public void volume(int x,int y, int z); } // 定义程序使用的常量的接口 public interface myconstants { public static final double price = 1450.00; public static final int counter = 5; } 创建接口的步骤 2-2 接口使用示例 class shap2D { static double getArea; //面积 static double getPerimeter; //周长 } class circle extends shap2D { double r; double getRadius(){return r=2;} double getArea() {return Math.PI*r*r;} double getPerimeter() {return 2*Math.PI*r;} public String toString() { String s; return s="周长："+getPerimeter()+"面积:"+getArea(); } } class Triangle extends circle { double a,b,c; Triangle (double x,double y,double z) {a=x; b=y;c=z;} void setA(double x){a=x;} double getA(){return a;} public double getPerimeter() {return a+b+c;} public double getArea() { double s=(a+b+c)/2; return Math.sqrt(s*(s-a)*(s-b)*(s-c)); } public boolean isTriangle() { boolean flag=false; if(a>0&&b>0&&c>0&&a+b>c&&a+c>b&&c+b>a) flag=true; return flag; } } class rectangle extends circle { double a,b; 为什么要继承、封装和多态 1,为什么要继承 继承的好处是代码重用.哲学上讲事物都是有共性和特性的.把共性函数代码放入到父类中,把特性函数代码放入到子类中,当然是否共性要以参照点的标准.OO中所谓的抽象我自己理解为哲学中的共性在同一个行业中,他们各业务流程往往有很大的相似性,但往往我们都是到一个项目中就重新写一套流程代码,或者粘贴以前的代码.可能有很多代码都是以前写过的重复代码.造成重复劳动.如果采用继承应该这样,首先在父类中做一个基本上大部分行业项目都必要的简洁的主流程.在子类中针对具体项目的特殊性做主流程充分的完善的补充.这样在每个项目中,只针对项目的特殊性编写代码,大大降低重复劳动.当然根据具体流程的复杂多可以划分多的继承层次,呈现一种继承的树结构,但一定的要保证层次一定要有实际的意义. 2,为什么要封装 高内聚低偶合的思想简单的理解同一模块内的提高内聚,不同模块降低偶合.如果说一个类代表一个模块或是一个业务流,那么A类内部要提高内聚,类的属性可以看成是内的局部变量.提高数据的重用.公共函数尽量能被其他主函数,尽量达到功能内聚.如果说是A类和B类,并且是不同模块(也许是同一个模块下的两个子模块),那么B 是不能使用A的函数和属性的,紧进行数据偶合.封装的作用就体现在这里. 再现实中就项目中经常遇到这种情况,某项业务增加或修改一种类型的业务流,自己本身调试成功了,但是缺影响了此业务下其他的业务流,不得不测试所有得其他原本正常的业务流并不得不针对此做类型判断的补丁,这种补丁很肯能导致程序结构的不合理. 3.为什么要多态 个人认为多态的好处体现在代码的可扩充性,比如一个业务有多个业务流,为了区别不同的类型就的使用判断,那么新添加一个流程就得在过程执行主流程(往往是final,必然是面向过程的)中添加一个”if then”或是重载一个函数 在目前项目中mvc得控制器就是典型的多态.想想如果我们不使用多态那么怎么办?因为对PO对象是新添加的,那么必须针对新的PO 对象在代码中做IF判断,才能用他本身的对象类型指向他.造成过程执行主流程不断的要变更自己的代码. 总结: OO中继承和多态互相依赖又互相矛盾,没有继承就不可能有多态,多态的使用往往又在面向过程的代码中.继承是使子类可以使用父类的功能,而多态使父类能使用子类的功能. OO并非只是在编码阶段来处理,实际上在概要设计,详细设计,数据库设计的时候就应该OO的思想来设计.提高软件可重用性和可扩充性.对于想对一个行业做标准化产品软件而言,很重要. 20XX级java语言实验3指导(面向对象程序设计(继承、封装、多态)) 上机实验三：面向对象程序设计(继承、封装、多态) 类是面向对象程序设计的基础，是Java的核心和本质所在，在Java中，所有的语言元素都封装在类中。编写java 程序的过程就是从现实世界中抽象出java可实现的类，并用合适的语句定义它们的过程，本节将学习类的应用，以及如何创建类的实例，通过类的继承更有效的组织程序结构，明确类之间的关系。掌握本节所讲的内容后，读者就可以使用面向对象技术编写java程序了。 接口是特殊的抽象类，只包含常量和方法的定义，而没有方法的实现，也就是说接口是方法定义和常量值的集合。 包是Java语言中有效管理类的一个机制。通过关键字package声明包语句，package语句作为Java源文件的第一条语句，指明该源文件定义的类所在的包。使用import语句可以引入包中的类。 一、实验目的 1) 2) 3) 4) 5) 6) 7) 掌握类的定义和使用掌握对象的声明和使用 了解构造函数的概念和使用掌握类的继承关系和派生方法掌握多态的概念与使用掌握接口的定义和使用掌握 Java中包的应用 二、实验内容 1) 2) 3) 4) 5) 6) 7) 类的声明 定义类成员变量以及成员方法 实例化类、创建类对象以及类方法的调用类的继承 通过实例理解接口的定义通过实例熟悉接口的应用 正确应用Java中包和import语句 三、实验步骤 1) 类和类的实例化 一个类的实现包括两部分：类声明和类体。、类声明[public][abstract][final] class className [extends superclassName] [implements interfaceNameList] {……} 期中修饰符[public][abstract][final]说明类的属性className为类名 superclassName为父类的名字 interfaceNameList为类实现的接口列表、类体类体定义如下 class className { [public|protected|private] [static] [final] [transient] [volatile] Type variableName; //成员变量 一.extends和super的使用和方法的重写 1.定义一个人的类（属性有名字，年龄。写一个能输出各个属性值 的方法showInfo（）），定义一个学生类（属性有性别），学生继承人类 要求：（1）父类的属性赋值用构造方法来实现（分别用有参数构造方法和无参数构造方法实现） （2）子类的属性也用构造方法来赋值。 （3）在子类中重写父类的showInfo（）方法 （4）声明学生类的对象，调用学生的显示信息的方法。 2 定义Animal父类，含有属性name，sex，age，方法sleep，run，编写一个子类Person，继承Animal类，然后调用父类的属性和方法二． 1、试编写三个具有继承关系的类，A、B、C（B继承A，C继承B）。 要求A中包含方法a1()、a2()，B类中的方法b1()访问了a1() 和a2()，C类中的方法c1()访问了a1()、a2()、b1()。 提示：（a1(),a2(),b1(),c1()这些方法体除了实现题目要求之外，其余内容可以任意编写。） 2、请编码实现动物世界的继承关系： 动物（Animal）具有行为：吃（eat）、睡觉（sleep） 动物包括：兔子（Rabbit），老虎（Tiger） 这些动物吃的行为各不相同（兔子吃草，老虎吃肉）；但睡 觉的行为是一致的。 请通过继承实现以上需求，并编写测试类AnimalTest进行测试。3、父类Person 包含like（）方法子类Son 重写父类方法并打印输出 4、(选做)父类Employee 属性：name、sex ，带一个构造方法Employee(String n, char s) 子类Worker继承自Employee 属性：char category;法（）可以调用父类 的所有非私有方法 B) super（）可以调用父类的所有非私有构造函数 C) super.属性可以调用父类的所有非私有属性 D) this和super关键字可以出现在同一个构造函数中 8．以下关于final关键字说法错误的是（A,C）（两项） A) final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性 B) final修饰的类肯定不能被继承 C) final修饰的方法不能被重载 D) final修饰的变量不允许被再次赋值 9．访问修饰符作用范围由大到小是（D） A) private-default-protected-public B) public-default-protected-private C) private-protected-default-public D) public-protected-default-private 10．以下（D）不是Object类的方法 A) clone（） B) finalize（） C) toString（） D) hasNext（） 11．多态的表现形式有（A） A) 重写 B) 抽象 C) 继承 D) 封装 12．以下对重载描述错误的是（B） Java中类的继承 1、方法重载 重载方法必须满足以下条件: ＃方法名相问. ＃方法的参数类型、个数、顺序至少有一项不相同。 ＃方法的返回类型可以不相同。 ＃方法的修饰符可以不相同. 方法覆盖 (1)子类方法的名称、参数签名和返回类型必须与父类方法的名称、参数签名和返回类型一致. (2)子类方法不能缩小父类方法的访问权限. (3)子类方法不能抛出比父类方法史多的异常， (4)方法覆盖只存在于子类和父类(包括直接父类和间接父类)之间.在同一个 类中方法只能被重载，不能被扭盖。 (5)父类的静态方法不能被子类覆盖为非静态方法。 (6)子类可以定义与父类的静态方法同名的静态方法，以便在子类中隐藏父类的静态方法.在编译时，子类定义的静态方法也必须满足与方法覆盖类似的约束。 (7)父类的非静态方法不能被了类覆盖为静态方法。 (8)父类的私有方法不能被子类覆盖。 (9)父类的抽象方法可以被子类通过两种途径覆盖:一是子类实现父类的抽象方法:二是子类重新声明父类的抽象方法。 (10)父类的非抽象方法可以被覆盖为抽象方法. 方法覆盖与方法重载的异同 方法覆盖和方法重载具有以下相同点: ＃都要求方法同名. ＃都可以用于抽象方法和非抽象方法之间. 方法筱盖和方法重载具有以下不同点: ＃.方法覆盖要求参数签名必须一致.而方法重载要求参数签名必须不一致. ＃.方法覆盖要求返回类型必须一致，而方法重载对此不做限制. ＃.方法覆盖只能用于子类覆盖父类的方法，方法重载用于同一个类的所有方d (包括从父类中继承而来的方法)。 ＃.方法覆盖对方法的访问权限和抛出的异常有特殊的要求，而方法重载在这力面没有任何限制。 ＃.父类的一个方法只能被子类覆盖一次，而一个方法在所在的类中可以被重载多次。 super关键字 super和this关键字都可以用来履盖Java语言的默认作用域.使被屏蔽的方法或变 盆变为可见。在以下场合会出现方法或变量被屏蔽的现象. .场合一:在一个方法内.当局部变量和类的成员变量同名，或者局部变量和父类的成员变量同名时，按照变量的作用域规则，只有局部变量在方法内可 见。 .场合二:当子类的某个方法覆盖了父类的一个方法。在子类的范围内，父类 的方法不可见. .场合三:当子类中定义了和父类同名的成员变量时，在子类的范围内，父类 的成员变量不可见。 在程序中，在以下情况下会使用super关键字: ＃在类的构造方法中，通过super语句调用这个类的父类的构造方法。 ＃在子类中访问父类的被屏蔽的方法和属性。 多态性 它是指当系统A访问系统B的服务时，系统B可以通过多种实现方式来提供服务， 而这一切对系统A是透明的. 多态的各种特性 (1)对于一个引用类型的变量，Java编译器按照它声明的类型来处理. (2)对于一个引用类型的变盆.运行时Java虚拟机按照它实际引用的对象来处理.例如以下代码虽然编译可以通过，但运行时会抛出ClassCastException运行时异常. Sub sub=new Sub(); 类的继承习题 一、选择题 1. Java语言的类间的继承关系是( B )。 A) 多重的B) 单重的C) 线程的D) 不能继承 2. 以下关于Java语言继承的说法正确的是( C )。 A)Java中的类可以有多个直接父类B)抽象类不能有子类 C)Java中的接口支持多继承D)最终类可以作为其它类的父类 3. 现有两个类A、B，以下描述中表示B继承自A的是(D)。 A) class A extends B B) class B implements A C) class A implements B D) class B extends A 4. A） 5. A） 6. Java 7. A)Java C)Java 8. A) class C) class 9. 现有类 A) class C) class 10. A） 11. A） 12. A） 13. java A） 14. 饰符是（ A） 15. A） 16. A）public B) protected C) private D) final 17. 下列选项中，表示终极方法的修饰符是：（B） A）interface B) final C) abstract D) implements 18. 下列选项中，定义接口MyInterface的语句正确的是：（A） A）interface MyInterface{ } B) implements MyInterface { } C) class MyInterface{ } D) implements interface My{ } 19. 如果子类中的方法mymethod()覆盖了父类中的方法mymethod()，假设父类方法头部定义如下：void mymethod(int a)，则子类方法的定义不合法的是：（C） A）public void mymethod(int a) B) protected void mymethod(int a) C) private void mymethod(int a) D) void mymethod(int a) 二、填空题 1. 如果子类中的某个变量的变量名与它的父类中的某个变量完全一样，则称子类中的这个变量________了父类 实验五继承与多态 一、实验目的 1.掌握抽象类的声明； 2.掌握多态的执行机理； 3.掌握上转型的使用； 4.掌握构造方法的执行机理； 5.面向抽象的编程； 二、实验内容 1.假定根据学生的3门学位课程的分数决定其是否可以拿到学位，对于本科生， 如果3门课程的平均分数超过60分即表示通过，而对于研究生，则需要平均超过80分才能够通过。根据上述要求，请完成以下Java类的设计： （1）设计一个基类Student描述学生的共同特征。 （2）设计一个描述本科生的类Undergraduate，该类继承并扩展Student类。 （3）设计一个描述研究生的类Graduate，该类继承并扩展Student类。 （4）设计一个测试类StudentDemo，分别创建本科生和研究生这两个类的对象，并输出相关信息。 2.假定要为某个公司编写雇员(40个雇员)工资支付程序，这个公司有各种类型 的雇员（Employee），不同类型的雇员按不同的方式支付工资： （1）经理（Manager）——每月获得一份固定的工资 （2）销售人员（Salesman）——在基本工资的基础上每月还有销售提成。（3）一般工人（Worker）——则按他每月工作的天数计算工资。 根据上述要求试用类的继承和相关机制描述这些功能，并编写一个Java Application程序，演示这些类的用法。（提示：应设计一个雇员类（Employee）描述所有雇员的共图特性，这个类应该提供一个计算工资的抽象方法ComputeSalary( )，使得可以通过这个类计算所有雇员的工资。经理、销售人员和一般工人对应的类都应该继承这个类，并重新定义计算工资的方法，进而给出它的具体实现。（用对象数组） 三、实验报告涉及以下内容 1.继承中父子构造方法的执行关系 2.重写 3.super的应用 4.上转型 5.多态 第4章继承与多态一．选择题 1、编译与运行以下两文件结果就是( D )。 //文件P1、java package MyPackage; class P1{ void afancymethod(){ System、out、println("What a fancy method"); } } //文件P2、java package YourPackage; import MyPackage、*; public class P2 extends P1{ public static void main(String argv[]){ P2 p2 = new P2(); p2、afancymethod(); } } A.两个均通过编译,P2运行时输出What a fancy method B.没一个通过编译 C.两个均通过编译,但P2运行时出错 D.P1 通过编译,但P2出现编译错误 2.下列程序运行的结果就是( A )。 package a; package b; public class D{ public static void main(String args[]) { System、out、println("^_^,今天心情不错！"); } } A.出现编译错误 B.^_^,今天心情不错！ C.通过编译,运行时出错 D.以上都不对 3.Java的核心类库中哪个包,Java系统能自动引入( B )。 A.java、io B.java、lang C.java、net D.java、util 4.下列程序运行结果就是( A )。 private class Base{ Base(){ int i = 100; System、out、println(i); } JAVA课程设计——员工工资管理 import java.util.Scanner; class Employee{ private String name; privateint birthmonth; public String getName() { return name; } publicvoid setName(String name) { https://www.wendangku.net/doc/2a7433297.html, = name; } publicint getBirthmonth() { return birthmonth; } publicvoid setBirthmonth(int birthmonth) { this.birthmonth = birthmonth; } publicdouble getSalary(int thismonth){ if(birthmonth==thismonth){ return 100; } else return 0; } publicvoid print(){ System.out.print("员工信息：\n姓名:"+name+"，出生月份："+birthmonth+"，"); } public Employee(String name,int birthmonth){ setName(name); setBirthmonth(birthmonth); } } //固定工资 class SalariedEmployee extends Employee{ privateint salary; public SalariedEmployee(String name, int birthmonth,int salary) { super(name, birthmonth); this.salary=salary; } publicdouble getSalary(int thismonth) { return salary+super.getSalary(thismonth); } publicint basesalary(){return salary;} } //小时工 class HourlyEmployee extends Employee{ privateint hoursalary; privateint monthhour; privateint salary; public HourlyEmployee(String name, int birthmonth,int hoursalary,int monthhour) { super(name, birthmonth); 福建农林大学计算机与信息学院实验报告 实验（四）继承和多态 一、实验目的和要求 1.掌握面向对象的继承关系 2.理解面向对象的多态 3.掌握方法的重写 4.掌握接口的实现 二、实验内容和原理 设计一个抽象类Shape，包括2个抽象方法，分别是计算形状的周长和面积。设计具体类Rectangle和Circle，分别表示矩形和圆，它们都是Shapes的子类。使Rectangle和Circle都实现Comparable接口（根据面积比较大小），编写一个通用的排序程序和一个通用的二分查找程序（自己写代码实现），能对这二种类型的数组进行排序并查找指定的对象。 三、实验环境 1.硬件环境： 2.软件环境：JDK1.5 四、算法描述及实验步骤 1.算法描述（可以用类图、流程图、伪代码或源程序描述） … 对实现了Comparable接口的对象数组data进行排序 public static void sort(Comparable[] data) 在实现了Comparable接口的对象数组data中查找元素element public int binarySearch(Comparable[] data, Comparable element) 2.实验步骤 ●创建一个UML项目，并设计类Shape、Rectangle和Circle，并建立 描述Shape、Rectangle、Circle和Comparable间关系的类图 ●创建一个Java应用项目 ●把UML项目中的类自动生成代码到Java应用项目中 ●实现类中的方法及通用的排序和检索程序 ●进行编译 ●进行测试，使用的测试用例： 输入：预期输出： … 五、调试过程 1.编译过程 上一次跟别人解答，没想到没提交上去，又不想删了，所以做成文档，才入这行朋友可以看下 Question 1. 编码实现动物世界的继承关系： a) 动物（Animal）具有行为：吃（eat）、睡觉（sleep） b) 受保护得物件（接口）具有得行为：beProtected（）; c) 有价值得物件（接口）具有得行为：getMoney（） d) 老虎是动物，同时是有价值且受保护得动物类型。 e) 熊猫是动物，同时是有价值且受保护得动物类型。 f) 这些动物吃的行为各不相同（熊猫吃竹子，老虎吃肉）；但睡觉的行为是一致的；受保护得级别不一致，价值也不一致。 g) 请通过继承，接口实现以上需求，并编写测试类AnimalTest进行测试。 Animail.java父类-动物类 package com; /** * @author Administrator * */ public class Animal { private String name; private String food; //吃的一个行为 public void eat() throws Exception{ System.out.println(https://www.wendangku.net/doc/2a7433297.html,+"吃"+this.food+"!"); } //睡觉的一个行为 public void sleep(){ System.out.println(https://www.wendangku.net/doc/2a7433297.html,+"在睡觉!"); } public String getName() { return name; } public void setName(String name) { https://www.wendangku.net/doc/2a7433297.html, = name; } public String getFood() { return food; } public void setFood(String food) { this.food = food; } } AnimalInterface.Java 接口 package com; public interface AnimalInterface { //默认为public,因为接口要被实现，并被广范使用， //所以最好是public因为如果不是公开的就没有必要做接口了void beProtected(); void getMoney(); } AnimalTest.java 测试类 package com; public class AnimalTest { /**Java 接口与类之间继承例题
JAVA继承和多态实验报告
java 类的继承 实验报告(含代码)
Java继承与多态实验报告
java中继承的相关知识总结
《java面向对象程序设计-继承和多态》教案
JAVA继承类求几何图形面积周长代码
Java为什么要继承、封装和多态
20XX级java语言实验3指导(面向对象程序设计(继承、封装、多态))
java练习题-继承
Java中类的继承
JAVA复习习题(继承)
Java实验五继承与多态
JAVA基础 第4章继承与多态_练习题_200910
JAVA课程设计——员工工资管理(类的继承)
Java实验报告(四)继承和多态
java 中关于 继承 的一个小例子