类的继承性练习
类的继承练习
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复习习题(继承)类的继承习题一、选择题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继承的理解和应用。
练习题一:动物类和子类我们先定义一个动物类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_程龙
类的继承习题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中,类(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。
java练习题-继承
一.extends和super的使用和方法的重写1.定义一个人的类(属性有名字,年龄。
写一个能输出各个属性值的方法showlnfo()),定义一个学生类(属性有性别),学生继承人类要求:(1)父类的属性赋值用构造方法来实现(分别用有参数构造方法和无参数构造方法实现)(2)子类的属性也用构造方法来赋值。
(3)在子类中重写父类的showInfo()方法(4)声明学生类的对象,调用学生的显示信息的方法。
2定义Animal父类,含有属性name,sex,age,方法sleep,run,编写一个子类Person,继承Animal类,然后调用父类的属性和方法- *■ ♦1、试编写三个具有继承关系的类,人、8、€(8继承人,C继承B)。
要求A中包含方法a1()、a2(),B类中的方法b1()访问了 a1()和 a2(),C 类中的方法 c1()访问了@1()、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;//类别boolean dressAllowance; 〃是否提供服装津贴,有一个构造方法负责构造所有属性,还有一个自定义方法isDressAll()这个方法负责通过判断dressAllowance的值输出,是否提供服装津贴。
自考Java语言程序设计(一)第五章以后课后习题及答案
m_dRealPart = d;
}
void setImaginaryPart(double d)
{
m_dImaginPart = d;
}
//复数运算方法
ComplexNumber complexAdd(ComplexNumber c)
{
return new ComplexNumber(
this.m_dRealPart + c.getRealPart(),
{
suhData=new Data;
}
intgetData()
{
return subData;
}
}
3.“子类的域和方法的数目一定大于等于父类的域和方法的数目”,这种说法是否正确?为什么?
4.在Java程序中,通过类的定义只能实现单重继承()
5.下列哪些说法是正确的?
A、Java语言只允许单一继承
B、Java语言只允许实现一个接口
·m_dlmaginPart虚部,代表复数的虚数部分。
(2)复数类ComplexNumber的方法
·ComplexNumber()构造方法,将实部、虚部都置为0。
·ComplexNumber(doubler,doublei)构造方法,创建复数对象的同时完成复数的实部、虚部的初始化;r为实部的初值,i为虚部的初值。
A.两个或两个以上的方法取相同的方法名,但形参的个数或类型不同考试大论坛
B.两个以上的方法取相同的名字和具有相同的参数个数,但形参的类型可以不同
C.两个以上的方法名字不同,但形参的个数或类型相同
D.两个以上的方法取相同的方法名,并且方法的返回类型相同
3.什么是方法的覆盖?方法的覆盖与域的隐藏有何不同?与方法的重载有何不同?
java 继承练习题
java 继承练习题Java 继承练习题Java 是一种面向对象的编程语言,继承是其核心概念之一。
通过继承,我们可以创建新的类,并从现有的类中继承属性和方法。
继承不仅提高了代码的可重用性,还使得代码更加易于维护和扩展。
在本文中,我们将通过一些练习题来巩固和加深对 Java 继承的理解。
1. 创建一个 Animal 类,具有属性 name 和 age,以及方法 eat() 和 sleep()。
然后创建一个 Dog 类,继承自 Animal 类,并添加一个方法 bark()。
最后创建一个 Cat 类,也继承自 Animal 类,并添加一个方法 meow()。
在主函数中创建一个 Dog 对象和一个 Cat 对象,并调用它们的方法。
2. 创建一个 Shape 类,具有属性 color 和 filled,以及方法 getArea() 和getPerimeter()。
然后创建一个 Circle 类,继承自 Shape 类,并添加一个属性radius,以及重写的方法 getArea() 和 getPerimeter()。
最后创建一个 Rectangle 类,也继承自 Shape 类,并添加属性 width 和 height,以及重写的方法getArea() 和 getPerimeter()。
在主函数中创建一个 Circle 对象和一个 Rectangle 对象,并调用它们的方法。
3. 创建一个 Person 类,具有属性 name 和 age,以及方法 eat() 和 sleep()。
然后创建一个 Student 类,继承自 Person 类,并添加属性 grade,以及重写的方法 eat() 和 sleep()。
最后创建一个 Teacher 类,也继承自 Person 类,并添加属性 subject,以及重写的方法 eat() 和 sleep()。
在主函数中创建一个 Student 对象和一个 Teacher 对象,并调用它们的方法。
java练习册--类的继承
——JAVA篇JAVA语言中的类的继承一、练习目标:二、练习时间与作业要求:分钟。
翻译练习写在JAVA笔记本上,书面作业写在JAVA 家庭作业本上。
后面的书面作业不包括在这个时间范围内。
三、翻译练习:Understanding InheritanceA subclass inherits variables and methods from its superclass and all of its ancestors. The subclass can use these members as is, or it can hide the member variables or override the methods.What Members Does a Subclass Inherit?Rule: A subclass inherits all of the members in its superclass that are accessible to that subclass unless the subclass explicitly hides a member variable or overrides a method. Note that constructors are not members and are not inherited by subclasses.The following list itemizes the members that are inherited by a subclass: •Subclasses inherit those superclass members declared as public or protected.•Subclasses inherit those superclass members declared with no access specifier as long as the subclass is in the same package as the superclass.•Subclasses don't inherit a superclass's member if the subclass declaresa member with the same name. In the case of member variables, the membervariable in the subclass hides the one in the superclass. In the case of methods, the method in the subclass overrides the one in thesuperclass.Creating a subclass can be as simple as including the extends clause in your class declaration. However, you usually have to make other provisions in your code when subclassing a class, such as overriding methods or providing implementations for abstract methods.Hiding Member VariablesAs mentioned in the previous section, member variables defined in the subclass hide member variables that have the same name in the superclass.While this feature of the Java language is powerful and convenient, it can bea fruitful source of errors. When naming your member variables, be careful tohide only those member variables that you actually wish to hide.One interesting feature of Java member variables is that a class can accessa hidden member variable through its superclass. Consider the followingsuperclass and subclass pair:class Super {Number aNumber;}class Subbie extends Super {Float aNumber;}The aNumber variable in Subbie hides aNumber in Super. But you can access Super's aNumber from Subbie withsuper.aNumbersuper is a Java language keyword that allows a method to refer to hidden四、上机练习:1)在静态方法中分别访问该类的静态与非静态属性2)在静态方法中分别访问该类的静态与非静态方法3)在非静态方法中分别访问该类的静态属性与方法4)在测试类的main方法直接去引用该类的属性与方法,看能使用哪些属性与方法?5)实例化一个该类,看还能不能通过该类的对象对访问它的静态方法6)实例化两个该类的对象,通过一个对象将类的静态属性改变,看一个另一个对象的该属性有没有改变。
java练习册(013)--类的继承(2)
练习册——JAVA篇类的多态和继承(2)分钟。
翻译练习写在JAVA笔记本上,书面作业写在JAVA 家庭作业本上。
Order of constructor callsA constructor for the base class is always called during the construction process for a derived class, chaining up the inheritance hierarchy so that a constructor for every base class is called. This makes sense because the constructor has a special job: to see that the object is built properly. A derived class has access to its own members only, and not to those of the base class (whose members are typically private). Only the base-class constructor has the proper knowledge and access to initialize its own elements. Therefore, it’s essential that all constructors get called, otherwise the entire object wouldn’t be constructed. That’s why the compiler enforces a constructor call for every portion of a derived class. It will silently call the default constructor if you don’t explicitly call a base-class constructor in the derived-class constructor body. If there is no default constructor, the compiler will complain. (In the case where a class has no constructors, the compiler will automatically synthesize a default constructor.)The order of the constructor calls is important. When you inherit, you know all about the base class and can access any public and protected members of the base class. This means that you must be able to assume that all the members of the base class are valid when you’re in the derived class. In a normal method, construction has already taken place, so all the members of all parts of the object have been built. Inside the constructor, however, you must be able to assume that all members that you use have been built. The only way to guaranteethis is for the base-class constructor to be called first. Then when you’re in the derived-class constructor, all the members you can access in the base class have been initialized. Knowing that all members are valid inside the constructor is also the reason that, whenever possible, you should initialize all member objects (that is, objects placed in the class using composition) at their point of definition in the class (e.g., b, c, and l in the preceding example). If you follow this practice, you will help ensure that all base class members and member objects of the current object have been initialized.2、编写一个车类,列出其中的属性和方法;(属性包含:颜色,型号,速度;方法包括:启动,运行,停止)。
自学考试Java语言程序的设计(一)第五章以后课后习题与答案
自考Java语言程序设计(一)第五课后习题及答案自考Java语言程序设计(一)第五章类的继承课后习题五、类的继承l.什么是继承?什么是父类?什么是子类?继承的特性可给面向对象编程带来什么好处?什么是单重继承?什么是多重继承?2.观察下面的程序片断,指出其中的父类和子类,以及父类和子类的各个域和方法。
class SuperClass{int data;voidsetData(intnewData){data=newData~}intgetData(){return data~}}class SubClass extends SuperClass{int suhData;void setSubData(intnewData){suhData=new Data;}intgetData(){return subData;}}3.“子类的域和方法的数目一定大于等于父类的域和方法的数目”,这种说法是否正确?为什么?4. 在Java程序中,通过类的定义只能实现单重继承()5.下列哪些说法是正确的?A、 Java 语言只允许单一继承B、 Java 语言只允许实现一个接口C、 Java 语言不允许同时继承一个类并实现一个接口D、 Java 语言的单一继承使得代码更加可靠6.Java中所有类都是类________的子类。
7. 请写出下面程序的运行结果。
public class Test extends TT{public void main(String args[]){Test t = new Test("Tom");}public Test(String s){super(s);System.out.println("How do you do?");}public Test(){this("I am Tom");}} .Eclass TT{public TT(){System.out.println("What a pleasure!");}public TT(String s){this();System.out.println("I am "+s);}}结果:________8.父类的成员在子类中的访问权限由决定。
第6章继承性习题参考答案
第6章继承性习题参考答案第6章继承性习题参考答案6.1 什么是继承性?请举例说明。
继承性有哪些好处?【解答】继承性:在现有类的基础上创建类,保持已有类的特性而构造新类的过程。
例如,在学生类Student的基础上创建大学生类:UStudent。
继承性有下列主要好处:面向对象的程序设计中通过继承实现重用reuse——便于重用,扩充。
可以在原有的基础上扩充,不修改原有代码。
即使原来的代码完全不符合当前的要求,也不必修改原有的代码。
可以只增加新的代码来实现新的功能。
6.4 在多继承中,容易出现什么问题?答:在多继承中,容易出现二义性问题,即在子类中可能出现祖先类的两份拷贝。
C++语言中引入虚基类解决了这个问题。
6.6 什么是赋值兼容规则?请举例说明。
【解答】赋值兼容规则时指在公有派生条件下,任何可以使用基类对象的地方都可以用其派生类的对象替代。
1)可以用派生类的对象给基类对象赋值。
比如:class A {…};clas s B : public A {void fun( ) {…}};A a;B b;A a=b; //将对象b 中所含类A 成员的值赋给对象a复制的结果是将派生类对象中所含基类成员的值赋给基类对象中相同的成员。
2)可以用派生类的对象初始化基类对象的引用。
比如:class A {…}class B : public A {void fun( ) {…}};A a;B b;A &a=b; //用派生类对象初始化基类对象的引用3)可以用派生类的对象的地址给基类对象的指针赋值。
比如:class A {…};class B : public A {void fun( ) {…}};A a;B b;A *pa =&b //用派生类对象的地址初始化基类对象的指针赋值兼容规则的注意事项:1) 不能将一个派生类对象的指针指向其基类对象。
2) 通过指向基类对象的指针可以指向它的公有派生的对象,但不能指向私有派生的对象。
Python3类的继承小练习
Python3类的继承⼩练习1、打印并解释结果class Parent(object):x = 1class Child1(Parent):passclass Child2(Parent):passprint(Parent.x, Child1.x, Child2.x)Child1.x = 2print(Parent.x, Child1.x, Child2.x)Parent.x = 3print(Parent.x, Child1.x, Child2.x)1 1 11 2 13 2 3第⼀⾏: ⼦类会继承⽗类的属性第⼆⾏: Child1.x = 2给Child1类添加了派⽣属性, 属性的搜索顺序是先⼦类后⽗类第三⾏: Parent.x = 3修改了⽗类的属性, Child2继承了Parent的x属性, Child1优先使⽤⾃⾝的x属性2、打印并解释结果(多重继承的执⾏顺序)class A(object):def __init__(self):print('A')super(A, self).__init__()class B(object):def __init__(self):print('B')super(B, self).__init__()class C(A):def __init__(self):print('C')super(C, self).__init__()class D(A):def __init__(self):print('D')super(D, self).__init__()class E(B, C):def __init__(self):print('E')super(E, self).__init__()class F(C, B, D):def __init__(self):print('F')super(F, self).__init__()class G(D, B):def __init__(self):print('G')super(G, self).__init__()if __name__ == '__main__':g = G()f = F()GDABFCBDA1. 调⽤类会⾃动触发__init__函数2. 新式类的多重继承按从左到右, ⼴度优先的顺序搜索3、什么是新式类,什么是经典类,⼆者有什么区别?什么是深度优先,什么是⼴度优先?1. 新式类: 所有继承object的类及其⼦类都是新式类2. 经典类: Python2没有继承object的类及其⼦类都是经典类3. 深度优先: 当类经典类时, 多重继承时, 会按深度优先的⽅式查找4. ⼴度优先: 当类是新式类时, 多重继承时, 会按⼴度优先的⽅式查找4、⽤⾯向对象的形式编写⼀个⽼师类, ⽼师有特征:编号、姓名、性别、年龄、等级、⼯资,⽼师类中有功能。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 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所示。