类的继承性练习

合集下载

类的继承练习

类的继承练习

4.1 继承练习1-继承:1)定义一个父类person,该类包含2个属性(name,age),2个方法吃饭、睡觉;2)设计两个子类Student和Teacher2)让学生类继承Person类,老师类也继承Person。

4)编写测试类Test1,测试Student类和Teacher是否继承了Person类的成员。

定义父类Person,实现继承关系,代码如下:class Person {String name;int age;void eat() {System.out.println("吃饭 ");}void sleep() {System.out.println("睡觉");}}class Student extends Person {int sid; // 学号}class Teacher extends Person {int tid; // 工号void teach() {System.out.println("老师教课");}}2、定义测试类Test1,代码如下:public class Test1{public static void main(String[] args) {Student s = new Student();s.eat();s.sleep();System.out.println("----");Teacher t = new Teacher();t.eat();t.sleep();t.teach();}}运行结果如图4-1所示。

图4-1运行结果总结:1、在Java中,多个类可以继承一个父类,但是一个类不能直接继承多个类,一个类只能有一个直接父类。

2、父类是由子类不断抽取而来的,不断地抽取就形成了体系结构,这个结构称为继承体系结构。

3、子类在继承父类的时候,会自动拥有父类所有的成员。

4、继承的好处是划分了类的层次性,实现了代码重用、扩展了程序功能。

类的继承练习

类的继承练习
车型:小车
车轮:4个
重量:2000公斤
载人:5人
车型:卡车
车轮:10个
重量:8000公斤
载人:3人
效率:0.977012
--------------------------------------------------------
4 设计一个圆类circle和一个桌子类table,另设计一个圆桌类roundtable,他是从前两个类派生的,需要输出一个圆桌的高度、面积和颜色等数据。
};
void main()
{
roundtable rt(0.8,1.2,"黑色");
cout << "圆桌属性数据:" << endl;
cout << "高度:" <<rt.getheight() << "米" << endl;
cout << "面积:" <<rt.getarea() << "平方米" << endl;
}
~subs(){cout<<"destructing sub class"<<endl;}
};
void main()
{
subs s(1,2,3);
}
解:
本题说明 派生类中含有对象成员情况下构造函数和析构函数的调用顺序。这里base为基类,subs为派生类,subs类的构造函数中含有对象成员。
}
void car::show()

JAVA复习习题(继承)

JAVA复习习题(继承)

JAVA复习习题(继承)类的继承习题一、选择题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 AC) class A implements B D) class B extends A4. 下列选项中,用于定义接口的关键字是( A)。

A)interface B) implements C) abstract D) class5. 下列选项中,用于实现接口的关键字是( B)。

A)interface B) implements C) abstract D) class6. Java语言的类间的继承的关键字是( B )。

A) implements B) extends C) class D) public7. 以下关于Java语言继承的说法错误的是( A )。

A)Java中的类可以有多个直接父类B)抽象类可以有子类C)Java中的接口支持多继承D)最终类不可以作为其它类的父类8. 现有两个类M、N,以下描述中表示N继承自M的是(D)。

A) class M extends N B) class N implements MC) class M implements N D) class N extends M9. 现有类A和接口B,以下描述中表示类A实现接口B的语句是(A)。

A) class Aimplements B B) class B implements AC) class Aextends B D) class B extends A10. 下列选项中,定义抽象类的关键字是( C)。

类的继承与派生综合题

类的继承与派生综合题

1. 类的继承与派生综合题1题目描述定义Staff(员工)类,由Staff分别派生出Saleman(销售员)类和Manager(经理)类,再由Saleman(销售员)类和Manager(经理)类采用多重继承方式派生出新类SaleManager(销售经理)类。

要求:a.在Staff类中包含的数据成员有编号(num)、姓名(name)、出勤率(rateOfAttend)、基本工资(basicSal)和奖金(prize)。

在Saleman类中还包含数据成员:销售员提成比例(deductRate)和个人销售额(personAmount),在Manager类中还包含数据成员:经理提成比例(totalDeductRate)和总销售额(totalAmount)。

在SaleManager类中不包含其他数据成员。

b.各类人员的实发工资公式如下:员工实发工资=基本工资+奖金*出勤率销售员实发工资=基本工资+奖金*出勤率+个人销售额*销售员提成比例经理实发工资=基本工资+奖金*出勤率+总销售额*经理提成比例销售经理实发工资=基本工资+奖金*出勤率+个人销售额*销售员提成比例+总销售额*经理提成比例c.每个类都有构造函数、输出基本信息函数(Output)和输出实发工资函数(OutputWage)。

主函数如下:int main(){Salemanobjsale(101101, "LD", 0.88f, 1200, 800, 0.05f, 10000);Manager objmana(101102, "NXG", 0.90f, 2500, 1000, 0.10f, 20000);SaleManagerobjsalemana(101103, "HDY", 0.99f, 3500, 2000, 0.20f, 100000, 0.20f,150000);objsale.Output();cout<< "销售员的实发工资:" << " ";cout<<objsale.OutputWage(0.88f, 1200, 800, 0.05f, 10000) <<endl;cout<<endl;objmana.Output();cout<< "经理的实发工资:" << " ";cout<<objmana.OutputWage(0.90f, 2500, 1000, 0.10f, 20000) <<endl;cout<<endl;objsalemana.Output();cout<< "销售经理的实发工资:" << " ";cout<<objsalemana.OutputWage(0.99f, 3500, 2000, 0.20f, 10000, 0.20f, 150000) <<endl;cout<<endl;return 0;}输入描述略输出描述略样例输入略样例输出员工的基本信息:编号姓名出勤率基本工资奖金101101 LD 0.88 1200 800提成比例:0个人销售额:10000销售员的实发工资: 2403员工的基本信息:编号姓名出勤率基本工资奖金101102 NXG 0.9 2500 1000提成比例:0.1总销售额:20000经理的实发工资: 5399员工的基本信息:编号姓名出勤率基本工资奖金101103 HDY 0.99 3500 2000提成比例:0个人销售额:100000提成比例:0.2总销售额:150000销售经理的实发工资: 374802. 类的继承与派生综合题2题目描述创建一个银行账户的继承层次,表示银行的所有客户账户。

继承练习题

继承练习题

继承练习题一、选择题1. 关于Java中的继承说法正确的是:A. 子类可以继承父类的私有成员B. 子类可以继承父类的protected成员C. 子类可以继承父类的静态成员D. 子类不能继承父类的构造方法2. 在Java中,下列哪个关键字用于声明继承?A. extendsB. implementsC. interfaceD. class3. 如果一个类声明为final,那么它:A. 可以被继承B. 不能被继承C. 可以被实例化D. 不能被实例化4. 关于Java中的方法重写,下列说法正确的是:A. 重写的方法必须具有相同的返回类型B. 重写的方法可以有不同的访问权限C. 重写的方法可以抛出新的异常D. 重写的方法必须抛出与父类方法相同的异常5. 在Java中,下列哪个操作是不合法的?A. 子类覆盖父类的静态方法B. 子类覆盖父类的非静态方法C. 子类覆盖父类的私有方法D. 子类覆盖父类的protected方法二、填空题6. 在Java中,如果一个类没有明确指定继承哪个类,那么它默认继承______类。

7. 在Java中,使用______关键字可以实现对父类方法的重写。

8. 如果子类要调用父类的构造方法,可以使用______关键字。

9. 在Java中,子类可以______父类的成员变量和方法。

10. 在Java中,如果子类和父类都有相同的成员变量,那么在子类中访问这个变量时,默认访问的是______。

三、判断题11. 在Java中,一个类只能继承一个类,但可以实现多个接口。

()12. 子类可以继承父类的私有成员变量,但不能继承私有方法。

()13. 在Java中,子类必须显式调用父类的构造方法。

()14. 如果父类的构造方法有参数,那么子类的构造方法也必须有相同参数的构造方法。

()15. 在Java中,子类可以覆盖父类的静态方法。

()四、编程题16. 定义一个父类`Animal`,包含一个方法`makeSound()`。

java继承练习题

java继承练习题

java继承练习题Java继承练习题Java是一种面向对象的编程语言,其核心思想是将现实世界中的事物抽象为对象,并通过类的定义和实例化来描述和操作这些对象。

在Java中,继承是一种重要的机制,它允许一个类继承另一个类的属性和方法,从而实现代码的复用和扩展性。

在本文中,我们将通过一些练习题来巩固对Java继承的理解和应用。

练习题一:动物类和子类我们先定义一个动物类Animal,它具有属性name和age,并且有一个方法say()用于输出动物的叫声。

接下来,我们定义两个子类Dog和Cat,它们分别继承自Animal类,并且分别重写父类的say()方法。

其中,Dog类的say()方法输出"汪汪汪",Cat类的say()方法输出"喵喵喵"。

```javaclass Animal {protected String name;protected int age;public Animal(String name, int age) { = name;this.age = age;}public void say() {System.out.println("动物发出叫声");}}class Dog extends Animal {public Dog(String name, int age) {super(name, age);}@Overridepublic void say() {System.out.println("汪汪汪");}}class Cat extends Animal {public Cat(String name, int age) {super(name, age);}@Overridepublic void say() {System.out.println("喵喵喵");}}public class AnimalTest {public static void main(String[] args) {Animal animal = new Animal("动物", 5);animal.say();Dog dog = new Dog("小狗", 2);dog.say();Cat cat = new Cat("小猫", 1);cat.say();}}```练习题二:形状类和子类接下来,我们定义一个形状类Shape,它具有一个抽象方法area()用于计算形状的面积。

程龙-类的继承习题_1505120607_程龙

程龙-类的继承习题_1505120607_程龙

类的继承习题1.定义一个父类People,下面关于子类Student对父类People继承语法正确的是()A.class People extends Student{...}B.class Student extends People(){...}C.class Student extend People(){...}D.class Student extends People{...}2.如果子类和父类在同一个包中,下面哪一个父类的成员变量不能被子类继承()A.public int money;B.private int money;C.private void setWeight(){...}D.protected double height;3.在父类A中定义一个方法”protected int f(int a,int b){return a+b;}”则在子类B中对此方法重写正确的是()A.protected int f(double a,double b){return a-b;}B.protected double f(double a,double b){return a+b;}C.protected int f(int a,int b){return a*b;}D.int f(int a,int b){return a*b;}4.子类可以隐藏继承的成员变量,则下列说法正确的是()A.子类对象可以调用从父类继承的方法操作隐藏的成员变量B.子类对象不可以调用从父类继承的方法操作隐藏的成员变量C.父类对象可以调用从子类继承的方法操作隐藏的成员变量D.父类对象可以调用从父类继承的方法操作隐藏的成员变量5.子类可以隐藏父类的成员变量和方法,但是通过使用super关键字可以访问父类隐藏的数据成员,则下列访问直接父类隐藏的数据成员语法正确的是()A.super.(数据成员)B.super.数据成员C.super.数据成员()D.super(数据成员)6.final关键字可以修饰类,成员变量和方法中的局部变量,下列关于final关键字说法正确的是()A.final类能被继承,可以有子类B.final类不能被继承,可以有子类C.final类不能被继承,不能有子类D.final类能被继承,不可以有子类7.假设A类时B类的父类,则下列不是上转型对象的是()A.A a;a=new B();B.A a;B b=new B();a=b;C.A c;c=new B();D.A a=new A();8.abstract关键字修饰的类是抽象类,abstract关键字修饰的方法是抽象方法,则下列关于abstract 关键字说法正确的是()A.abstract方法允许声明,允许实现B.abstract方法允许声明,不允许实现C.可以使用final修饰abstract方法D.abstract类不可以有方法9.分析下列程序,哪几句在编译时出错,为什么?classA {finaldoublePI;publicdoublegetArea(finaldouble r){r = 10.0;return PI*r*r;}publicfinalvoidspeak(){System.out.println("Hello");}}classBextendsA{publicvoidspeak(){System.out.println("你好");}}10.约瑟夫环问题:设编号为1,2,3,……,n的n(n>0)个人按顺时针方向围坐一圈,m为任意一个正整数。

python 类的继承与组合 例题

python 类的继承与组合 例题

主题:Python类的继承与组合---随着人工智能、大数据和云计算等领域的快速发展,Python作为一种灵活、简洁、强大的编程语言,受到了越来越多的关注和应用。

在Python中,类(class)是一种重要的编程元素,而类的继承与组合则是面向对象编程的重要概念。

本篇文章将探讨Python类的继承与组合,并通过实际例题进行详细解析。

一、类的继承在面向对象编程中,继承是一种重要的概念。

通过继承,一个类可以直接使用另一个类的属性和方法,而不需要重新编写相同的代码。

在Python中,类的继承使用关键字“class”。

我们以一个简单的例子来说明类的继承:```class Animal:def __init__(self, name): = namedef speak(self):passclass Dog(Animal):def speak(self):return "Woof!"class Cat(Animal):def speak(self):return "Meow!"```在上面的例子中,我们定义了一个Animal类,它有一个初始化方法__init__和一个speak方法。

我们定义了两个子类Dog和Cat,它们分别继承了Animal类并重写了speak方法。

这样,在创建Dog和Cat对象时,它们就可以直接使用Animal类中定义的方法。

二、类的组合除了继承外,类的组合是另一种重要的面向对象编程方式。

通过组合,一个类可以使用另一个类的实例作为自己的属性,从而达到代码复用和灵活性的目的。

下面我们来看一个使用类组合的例子:```class Engine:def start(self):return "Engine started."class Car:def __init__(self, engine):self.engine = enginedef start(self):return self.engine.start()my_engine = Engine()my_car = Car(my_engine)print(my_car.start())```在上面的例子中,我们定义了一个引擎类Engine和一个汽车类Car。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验七类的继承性练习新类可从现有的类中产生,并保留现有类的成员变量和方法并可根据需要对它们加以修改。

新类还可添加新的变量和方法。

这种现象就称为类的继承。

当建立一个新类时,不必写出全部成员变量和成员方法。

只要简单地声明这个类是从一个已定义的类继承下来的,就可以引用被继承类的全部成员。

被继承的类称为父类或超类(superclass),这个新类称为子类。

Java 提供了一个庞大的类库让开发人员继承和使用。

设计这些类是出于公用的目的,因此,很少有某个类恰恰满足你的需要。

你必须设计自己的能处理实际问题的类,如果你设计的这个类仅仅实现了继承,则和父类毫无两样。

所以,通常要对子类进行扩展,即添加新的属性和方法。

这使得子类要比父类大,但更具特殊性,代表着一组更具体的对象。

继承的意义就在于此。

6.1、创建将被继承的类(1) 程序源代码如下。

public class EXP3_7{protected String xm; //具有保护修饰符的成员变量protected int xh;void setdata(String m,int h) //设置数据的方法{xm =m;xh = h;}public void print() //输出数据的方法{System.out.println(xm+", "+xh);}}(2) 编译源程序。

6.2、创建将被继承的类(1) 程序功能:通过EXP3_7类产生子类EXP3_8,其不仅具有父类的成员变量xm(姓名)、xh(学号),还定义了新成员变量xy(学院)、xi(系)。

在程序中调用了父类的print 方法,同时可以看出子类也具有该方法。

(2) 程序源代码如下。

class EXP3_8 extends EXP3_7{protected String xy;protected String xi;public static void main(String args[]){EXP3_7 p1 = new EXP3_7();p1.setdata("李四",12321) ;p1.print();EXP3_8 s1 = new EXP3_8() ;s1.setdata("张三",12345); //调用父类的成员方法s1.xy="成都信息工程学院"; //访问本类的成员变量s1.xi="计算机系"; //访问本类的成员变量s1.print();System.out.print(s1.xm+", "+s1.xy+", "+s1.xi);}}(1)编译并运行,结果如图3.7所示。

图 3.76.3、了解成员方法的覆盖方式通过继承子类可以继承父类中所有可以被子类访问的成员方法,但如果子类的方法与父类方法同名,则不能继承,此时称子类的方法覆盖了父类的方法,简称为方法覆盖(override)。

方法覆盖为子类提供了修改父类成员方法的能力。

例如,子类可以修改层层继承下来的Object 根类的toString 方法,让它输出一些更有用的信息。

下面的程序显示了在子类Circle 中添加toString 方法,用来返回圆半径和圆面积信息。

(1)编写覆盖Object 类toString方法的程序文件EXP3_9.java,源代码如下。

class Circle {private int radius;Circle(int r) {setRadius(r);}public void setRadius(int r) {radius=r;}public int getRadius() {return radius;}public double area() {return 3.14159*radius*radius;}public String toString() {return "圆半径:"+getRadius()+" 圆面积:"+area(); }}public class EXP3_9{public static void main(String args[]) {Circle c=new Circle(10);System.out.println("\n"+c.toString());}}(2)编译并运行,结果如图3.8所示。

图 3.86.1、this、super和super()的使用(1)程序功能:程序功能:说明this、super 和super()的用法。

程序首先定义Point(点)类,然后创建点的子类Line(线)。

最后通过LX3_10 类输出线段的长度。

程序中通过super(a,b)调用父类Point 的构造方法为父类的x 和y 赋值。

在子类Line 的setLine方法中,因为参数名和成员变量名相同,为给成员变量赋值,使用this 引用,告诉编译器是为当前类的成员变量赋值。

在length 和toString 方法中使用父类成员变量时,使用super 引用,告诉编译器使用的是父类的成员变量。

(2)程序源代码如下。

class Point {protected int x, y;Point(int a, int b) {setPoint(a, b);}public void setPoint(int a, int b) {x=a;y=b;}}class Line extends Point {protected int x, y;Line(int a, int b) {super(a, b);setLine(a, b);}public void setLine(int x, int y) {this.x=x+x;this.y=y+y;}public double length() {int x1=super.x, y1=super.y, x2=this.x, y2=this.y;return Math.sqrt((x2-x1) * (x2-x1) + (y2-y1) * (y2-y1));}public String toString() {return "直线端点:[" + super.x + "," + super.y + "] [" +x + "," + y + "] 直线长度:" + this.length();}}public class EXP3_10{public static void main(String args[]) {Line line=new Line(50, 50);System.out.println("\n"+line.toString());}}(3)编译并运行,结果如图3.9。

图 3.91、类的多态性练习类的继承发生在多个类之间,而类的多态只发生在同一个类上。

在一个类中,可以定义多个同名的方法,只要确定它们的参数个数和类型不同。

这种现象称为类的多态。

多态使程序简洁,为程序员带来很大便利。

在OOP 中,当程序要实现多个相近的功能时,就给相应的方法起一个共同的名字,用不同的参数代表不同的功能。

这样,在使用方法时不论传递什么参数,只要能被程序识别就可以得到确定的结果。

类的多态性体现在方法的重载(overload)上,包括成员方法和构造方法的重载。

7.1、方法的重载(1) 程序功能:使用同名方法对两个、三个或用数组容纳的一组数进行排序(2) 程序源代码如下。

class IntSort {public String sort(int a, int b) {if (a>b)return a+" "+b;elsereturn b+" "+a;}public String sort(int a, int b, int c) {int swap;if (a<b) {swap=a;a=b;b=swap;}if (a<c) {swap=a;a=c;c=swap;}if (b<c) {swap=b;b=c;c=swap;}return a+" "+b+" "+c;}public String sort(int arr[]) {String s=" ";int swap;for (int i=0; i<arr.length; i++)for (int j=0; j<arr.length-1; j++)if (arr[j]>arr[j+1]) {swap=arr[j];arr[j]=arr[j+1];arr[j+1]=swap;}for (int i=0; i<arr.length; i++)s=s+arr[i]+" ";return s;}}public class EXP3_11 {public static void main(String[] args){IntSort s=new IntSort();int a=30, b=12, c=40;int arr[]={34,8,12,67,44,98,52,23,16,16};System.out.println("两个数的排序结果:"+s.sort(a,b));System.out.println ("三个数的排序结果:"+s.sort(a,b,c));System.out.println ("数组的排序结果:"+s.sort(arr));}}(3) 编译并运行,结果如图3.10所示。

图 3.107.2、构造函数的重载构造方法的名称和类同名,没有返回类型。

尽管构造方法看起来和一般的成员方法没有差别,但它不是方法,也不是类的成员。

因此,构造方法不能直接调用,只能由new 操作符调用。

构造方法对于类是十分重要的,对象的初始化任务要靠构造方法来完成。

重载构造方法的目的是提供多种初始化对象的能力,使程序员可以根据实际需要选用合适的构造方法来初始化对象。

(1)程序源代码如下。

class RunDemo {private String userName, password;RunDemo() {System.out.println("全部为空!");}RunDemo(String name) {userName=name;}RunDemo(String name, String pwd) {this(name);password=pwd;check();}void check() {String s=null;if (userName!=null)s="用户名:"+userName;elses="用户名不能为空!";if (password!="12345678")s=s+" 口令无效!";elses=s+" 口令:********";System.out.println(s);}}public class EXP3_12 {public static void main(String[] args) { new RunDemo();new RunDemo("张三");new RunDemo(null,"李四");new RunDemo("王五","12345678");}}(2)编译并运行,结果如图3.11所示。

相关文档
最新文档