第七章 继承、多态、抽象、密封与接口

合集下载

基础知识--封装、继承、多态、抽象

基础知识--封装、继承、多态、抽象

基础知识--封装、继承、多态、抽象⼀、封装封装:是⾯向对象⽅法的重要原则,就是把对象的属性和⾏为(数据)结合为⼀个独⽴的整体,并尽可能隐藏对象的内部实现细节,就是把不想告诉或者不该告诉别⼈的东西隐藏起来,把可以告诉别⼈的公开,别⼈只能⽤我提供的功能实现需求,⽽不知道是如何实现的。

增加安全性public class Person {private String name;private int gender;private int age;public String getName() {return name;}public String getGender() {return gender == 0 ? "man" : "woman";}public void work() {if (18 <= age && age <= 50) {System.out.println(name + " is working very hard!");} else {System.out.println(name + " can't work any more!");}}}以上 Person 类封装 name、gender、age 等属性,外界只能通过 get() ⽅法获取⼀个 Person 对象的 name 属性和 gender 属性,⽽⽆法获取 age 属性,但是 age 属性可以供 work() ⽅法使⽤。

注意到 gender 属性使⽤ int 数据类型进⾏存储,封装使得⽤户注意不到这种实现细节。

并且在需要修改 gender 属性使⽤的数据类型时,也可以在不影响客户端代码的情况下进⾏。

⼆、继承继承:是⾯向对象最显著的⼀个特性,继承是从已有的类中派⽣出新的类称为⼦类,⼦类继承⽗类的数据属性和⾏为,并能根据⾃⼰的需求扩展出新的⾏为,提⾼了代码的复⽤性。

java面向对象程序设计知识点总结

java面向对象程序设计知识点总结

java面向对象程序设计知识点总结
以下是 Java 面向对象程序设计的一些重要知识点总结:
1. 类和对象:类是对象的抽象,对象是类的实例。

在 Java 中,通过定义类来描述对象的属性和方法。

2. 封装:将对象的属性和方法封装在一起,隐藏对象的内部实现细节,只暴露外部接口。

这有助于提高代码的可维护性和安全性。

3. 继承:允许一个类继承另一个类的属性和方法,从而实现代码的重用和扩展。

Java 中的继承是单一继承,即每个子类只能有一个父类。

4. 多态:指同一个方法在不同的对象上可以有不同的表现形式。

通过方法重写和接口实现来实现多态。

5. 抽象类和接口:抽象类是包含抽象方法的类,不能实例化;接口是只包含抽象方法的抽象类,用于定义一组行为规范。

6. 异常处理:Java 中的异常机制用于处理程序运行时可能发生的错误或异常情况。

通过使用 try-catch 块来捕获和处理异常。

7. 集合框架:Java 提供了丰富的集合类,用于存储和操作一组对象。

包括数组、列表、集合、映射等。

8. 文件 I/O:用于读取和写入文件。

包括文件的创建、打开、读取、写入、关闭等操作。

9. 线程:线程是程序执行的最小单位。

Java 提供了多线程编程的支持,包括创建线程、线程同步、线程通信等。

10. 数据库操作:Java 提供了 JDBC 库来与数据库进行交互,包括连接数据库、执行SQL 查询、处理结果集等。

以上是 Java 面向对象程序设计的一些重要知识点总结,希望对你有所帮助。

Java高级编程:多态、继承和接口设计的深入理解

Java高级编程:多态、继承和接口设计的深入理解

Java高级编程:多态、继承和接口设计的深入理解
在 Java 编程中,多态、继承和接口是三个十分重要的概念。

它们是 Java 面向对象编程的核心概念,在进行大型软件设计时,设计良好的多态、继承和接口设计能够大大提升软件的可维护性、可扩展性和可重用性。

本文将逐一探讨这三个核心概念,并深入理解它们的设计思想与实现方法。

一、多态
多态是指一个变量、对象或方法能够具有多重形态的能力。

这意味着同一类对象可以通过不同的方式处理,主要是通过运行时实现。

在 Java 编程中,多态最常见的应用是基于继承和接口设计。

1. 基于继承的多态实现
在基于继承的多态实现中,子类可以复写父类的方法,实现方法的多态性。

Java 的动态绑定机制能够根据实际调用的方法进行方法调用,实现多态性。

下面是一段基于继承的多态实现代码:
```
public class Animal {
public void move() { System.out.println(\。

封装、继承和多态的概念

封装、继承和多态的概念

封装、继承和多态的概念
封装、继承和多态是面向对象编程中的三个重要概念,下面分别进行详细解释:
一、封装
封装是指将对象的属性和方法封装在一起,形成一个独立的单元,对外部隐藏对象的实现细节,只暴露必要的接口供外部使用。

封装可以有效地保护对象的数据和行为,避免外部的误操作和非法访问,提高了代码的安全性和可维护性。

在面向对象编程中,封装是实现信息隐藏和数据保护的重要手段。

二、继承
继承是指一个类可以从另一个类中继承属性和方法,从而可以重用已有的代码和功能。

继承是面向对象编程中实现代码复用的重要手段,可以减少代码的重复性,提高代码的可读性和可维护性。

继承可以分为单继承和多继承两种方式,单继承是指一个类只能从一个父类中继承,而多继承是指一个类可以从多个父类中继承属性和方法。

三、多态
多态是指同一个方法在不同的对象上可以有不同的行为,即同一个方法可以有多
种不同的实现方式。

多态是面向对象编程中的重要概念,可以提高代码的灵活性和可扩展性。

多态可以分为编译时多态和运行时多态两种方式,编译时多态是指方法的重载,即同一个类中可以有多个同名但参数不同的方法;而运行时多态是指方法的重写,即子类可以重写父类的方法,从而实现不同的行为。

通过多态,可以实现面向对象编程中的“开闭原则”,即对扩展开放,对修改关闭。

继承、抽象类与接口

继承、抽象类与接口

接口的声明说明
抽象方法声明:接口中的方法默认为public abstract方法。在接口中只能给出这些抽象方法的 方法名、返回值和参数列表,而不能定义方法体, 即这些接口仅仅是规定了一组信息交换、传输和 处理的“接口”。
类实现接口
一个类通过使用关键字implements 调用接口。如 果使用多个接口,用逗号隔开接口名。如: class A implements Printable,Addable 如果一个类(非抽象类)使用了某个接口,那么 这个类必须实现该接口的所有方法,且方法的名 字、返回类型、参数个数及类型必须与接口中的 完全一致。 接口的抽象方法的访问限制符都己指定为public, 所以类在实现方法时,必须显式地使用public修饰 符。 例5-11
抽象类
abstract class 类名{ 用关键字abstract修饰的类称为abstract类(抽象 成员变量声明; 类)。 返回值的数据类型 方法名(参数表) { ……
} abstract 返回值的数据类型 方法名(参数表);
特点
}
abstract方法,只允许声明,不允许实现,而且不允许使 用final修饰
接口的声明说明
interface是声明接口的关键字,可以把它看成一 个特殊类。 接口名要求符合Java标识符规定。 接口修饰符有两种:public 和默认。public修饰 的接口是公共接口,可以被所有的类和接口使用; 默认修饰符的接口只能被同一个包中的其他类和 接口使用。 父接口列表:接口也具有继承性。定义一个接口 时可以通过extends关键字声明该接口是某个已经 存在的父接口的派生接口,它将继承父接口的所 有属性和方法。与类的继承不同的是一个接口可 以有一个以上的父接口,它们之间用逗号分隔。 常量数据成员声明:可以没有修饰符,默认为 public static final 常量。

继承封装多态简单理解

继承封装多态简单理解

继承封装多态简单理解【实用版】目录一、什么是封装二、什么是继承三、什么是多态四、封装、继承和多态的关系五、总结正文一、什么是封装封装是面向对象编程中的一种重要概念,它指的是将数据和操作数据的方法(即属性和方法)结合在一起,形成一个完整的单元。

这个单元可以保护内部的数据和方法,只向外界提供经过授权的操作接口。

这样做的好处是,可以隐藏实现细节,降低程序的复杂性,提高程序的安全性和可维护性。

二、什么是继承继承是面向对象编程中实现代码复用的一种重要机制。

它允许一个类(子类)继承另一个类(父类)的属性和方法,从而避免重复编写相同的代码。

继承可以提高代码的复用性,降低程序的复杂性,使程序更易于维护和扩展。

三、什么是多态多态是面向对象编程中的一种重要特性,它指的是同一个操作在不同的对象上具有不同的行为。

多态可以提高程序的灵活性和可扩展性,使程序能够适应不同的应用场景。

四、封装、继承和多态的关系封装、继承和多态是面向对象编程的三个基本特性,它们相互依赖,共同构成了面向对象编程的基本框架。

封装是面向对象编程的基础,它通过将数据和方法封装在一起,形成了一个完整的对象。

继承是在封装的基础上实现代码复用,它允许子类继承父类的属性和方法,从而避免重复编写相同的代码。

多态是在继承的基础上实现对象的动态绑定,它允许同一个操作在不同的对象上具有不同的行为。

五、总结总之,封装、继承和多态是面向对象编程的三个基本特性,它们共同构成了面向对象编程的基本框架。

封装可以隐藏实现细节,提高程序的安全性和可维护性;继承可以实现代码复用,提高程序的复用性和可扩展性;多态可以提高程序的灵活性和可扩展性,使程序能够适应不同的应用场景。

面向对象的4个基本概念

面向对象的4个基本概念
面向对象编程中的四个基本概念是:封装、继承、多态和抽象。

1. 封装:封装指的是将数据和方法组合到一个单元中,并限制外部访问这个单元的方式。

这样可以保护数据,使得只有定义了访问方法的对象才可以访问并修改数据。

另外,封装还可以提高代码的可维护性,因为修改数据的方法只需要在一个地方进行修改,而不需要在整个程序中找到所有访问该数据的地方。

2. 继承:继承指的是通过定义一个类来派生出一个新类,新类会继承原有类的属性和方法。

继承可以减少代码重复,同时也可以实现代码的复用。

派生类可以重写父类的方法,也可以新增自己的方法和属性。

3. 多态:多态指的是同一个方法可以被不同的对象调用,并且可以产生不同的结果。

在面向对象编程中,多态可以通过继承和接口实现。

多态可以提高代码的灵活性和可扩展性。

4. 抽象:抽象指的是将某个类的共同特征提取出来形成一个抽象类或接口。

抽象类和接口可以被其他类继承或实现,从而实现代码的复用和扩展。

抽象类和接口还可以起到规范的作用,确保代码的一致性
和可读性。

Java面向对象编程进阶指南

Java面向对象编程进阶指南第一章:封装与继承封装和继承是Java面向对象编程中最基本也是最重要的概念之一。

封装是指将数据和方法封装在一个类中,对外提供接口进行访问,隐藏内部实现细节。

这样的设计可以提高代码的可维护性和复用性。

继承是指通过创建新的类来继承现有类的属性和方法,并添加或修改其行为。

这种设计可以实现代码的重用和扩展。

第二章:多态和抽象类多态是指同一个方法在不同对象上具有不同的行为。

Java通过使用抽象类和接口来实现多态性。

抽象类用于定义一组具有相同属性和行为的类的共同特征,而接口是一种规范,定义了一组方法的声明,而不涉及具体的实现。

通过多态性,我们可以根据具体情况选择合适的类来调用方法,实现代码的灵活性和扩展性。

第三章:接口和实现接口是Java中一种重要的机制,用于定义一组必须实现的方法。

通过接口,我们可以实现对象之间的松耦合,提高代码的可维护性和可扩展性。

在实现接口时,我们可以使用实现类来实现接口中定义的方法。

实现类是指为接口提供具体实现的类。

通过实现接口,我们可以遵循统一的规范,并且可以实现多个接口,达到代码复用的目的。

第四章:内部类和匿名类在Java中,我们可以在一个类内部定义另一个类,这就是内部类。

内部类可以访问外部类的私有变量和方法,并能够提供更好的封装性。

内部类有四种类型:成员内部类、局部内部类、匿名内部类和静态内部类。

匿名类是一种没有名字的类,可以直接实现接口或者继承其他类。

通过内部类和匿名类的使用,我们可以实现更加灵活和优雅的代码设计。

第五章:异常处理异常处理是Java中处理程序运行时错误的一种机制。

通过使用try-catch语句块,我们可以捕获和处理可能发生的异常。

在捕获异常后,我们可以根据实际情况选择合适的处理方法,如继续执行、抛出新的异常或者进行日志记录。

正确处理异常可以提高程序的可靠性和健壮性,避免程序的崩溃。

第六章:泛型与集合泛型是Java中的一种参数化类型的机制,它可以在编译时进行类型检查,提高程序的类型安全性和可读性。

解释面向对象程序设计中封装、继承、多态的概念

解释面向对象程序设计中封装、继承、多态的概念【解释面向对象程序设计中封装、继承、多态的概念】在面向对象程序设计(Object-Oriented Programming,OOP)中,封装(Encapsulation)、继承(Inheritance)、多态(Polymorphism)是三个非常重要的概念,它们构成了OOP的基础。

在本文中,我将深入探讨这些概念,并通过具体的案例和应用来加深理解。

一、封装(Encapsulation)1.1 定义:封装是指将数据和方法打包在一起,同时对外隐藏对象的内部状态。

这样外部程序只能通过对象提供的接口(方法)来访问数据,而不能直接对数据进行操作。

1.2 实例:举一个简单的例子,比如一个汽车类。

我们可以将汽车的速度、油量等属性以及加速、刹车等方法封装在一个类中,并提供公共的接口供外部程序调用。

这样在使用汽车的时候,不需要关心汽车内部的具体实现,只需通过接口来操作汽车即可。

1.3 个人观点:我认为封装是OOP中非常重要的概念,它可以有效地提高代码的可维护性和安全性。

封装也使得对象的实现细节对外部程序透明,从而降低了程序的耦合度,提高了代码的灵活性。

二、继承(Inheritance)2.1 定义:继承是指一个类可以从另一个类中继承属性和方法,并且可以在此基础上进行扩展和修改。

这样可以有效地实现代码的复用,提高了代码的可维护性和可扩展性。

2.2 实例:以动物类和猫类为例,动物类中包含了一些通用的属性和方法,比如呼吸、进食等。

而猫类可以从动物类中继承这些属性和方法,并且可以在此基础上扩展一些猫特有的属性和方法,比如捉老鼠、喵喵叫等。

2.3 个人观点:继承是OOP中非常重要的特性,它可以帮助程序员减少重复代码的编写,提高了代码的复用性和可维护性。

但是在具体应用时,需要注意合理使用继承,避免过度继承导致代码结构复杂和不易理解。

三、多态(Polymorphism)3.1 定义:多态是指同一操作作用于不同的对象上会产生不同的行为。

java继承多态接口笔记

继承与多态3月19日继承与多态,抽象类,接口继承:只能复制public protecedt方法继承的缺点:子类继承父类的方法时,先调用父类的构造方法,所以性能上会有一定的影响package .Extends;class Test1{private String name;//所以继承时,private属性必须用set和get提供接口给其它继承private String addr;public String getName() {return name;}public void setName(String name) {//如果屏蔽了set 方法,那么子类就不能再设置name属性了 = name;}System.out.println("super.....");}protected void do2(){System.out.println("父类do2里的中的方法");}private void do3(){//private方法不能被子类继承}}class Test2 extends Test1{public void do1(){//这里重写了父类中的do1()方法//区别下面这样的写法//super.do1();//调用父类的方法//do1();//调用子类的方法,这样会出现死循环,出现报错System.out.println("重写父类的方法,看结果就知道");}this.do1();do1();//可以直接引用父类的方法}public void s2(){this.do2();//继承只能复制public protected的方法//this.do3();//不能继承父类private的方法}public void s3(){super.do1();//调用父类的do1()方法}}public class TestXiJiang {/*** @继承和多态*/public static void main(String[] args) { //Test2 t2=new Test2();//t2.do1();//t2.s3();Test1 t1=new Test2();//父类引用指向子类对象//t1.do1();//父类的方法,子类的重写方法,打印的是子类的方法中的东西t1.do2();}}区别:public protected private三者在继承中的区别继承只能复制public protected的方法private方法不能被子类继承所以继承时,private属性必须用set和get提供接口给其它继承接口:Interface中的所有方法都不用去实现,相当于细化了抽象方法,也就是方法不能有{}继承只能单继承,要多继承可以A B C但接口不一样了,可以实现多接口,所以编程中少继承,多接口一旦接口更改了,实现接口的方法也得跟着更改接口可以继承接口,但不能继承类,类可以实现接口,而且可以实现多接口,接口不能实现接口如下例:package .Interface;public interface It {//接口中的所有方法都不能被实现,相当于细化了抽象方法public void t1();//不能有{}public void t2(String name);//可以有返回值public String t3();//public String t4();}接口继承接口package .Interface;public interface It2 extends It{//接口能继承接口,但不能继承类,类可以实现接口,而且可以实现多接口,接口不能实现接口//public void do1();//不能有{}}抽象类:抽象类中的抽象方法,子类必须去实现,不是抽象方法子类可以去重写也可不重写,也可以直接调用父类的方法定义了一个抽象类:抽象类中定义了抽象方法package .DuTai;public abstract class t1 {//抽象类public abstract void add();//抽象方法public void del(){}public void display(){}}定义了一个抽象类package .DuTai;//public class Test {public abstract class Test {public void do1(){System.out.println("Test.do1()......");}public void do2(){}public abstract void do3();//抽象方法/*** @param args*/public static void main(String[] args) { // TODO Auto-generated method stub}}定义了一个普通类,继承了抽象类Test子类必须去实现父类中的抽象方法,其它方法直接调用,或重写package .DuTai;public class Test1 extends Test {public void do1(){System.out.println("Test1.do1()......");}/*** @param args*/public static void main(String[] args) { // TODO Auto-generated method stub}@Overridepublic void do3() {//子类必须去实现父类中的抽象方法System.out.println("Test1.do3()......");}}定义了一个类,继承了Test类,实现了It,It2接口这样这个类必须去实现抽象类中的抽象方法,实现接口中的所有方法package .DuTai;import .Interface.*;//导入这个自定义包//public class Simple implements It,It2{//接口可多接口public class Simple extends Test implements It,It2{ /*public void s1(Test t){//Test1,Test2,都继承了Test的方法,所以括号里只要写Test t就行了//t.do1();t.do3();}public void do1(){System.out.println("Simple.....");}*//*** @param args*/public static void main(String[] args) {Simple s=new Simple();//Test t=new Test();Test1 t1=new Test1();Test2 t2=new Test2();//s.s1(t1);//Test1.do3()......//s.s1(t);//Test.do1()......// s.s1(t1);//Test1.do1()......//s.s1(t2);//Test2.do1()....../*Test t3=new Test1();Test t4=new Test1();//t3.do1();//Test1.do1()......//s.s1(t3);//为什么会是Test1.do1()......//s.s1(t4);// 为什么会是Test1.do1()......s.do1();*/s.t1();//It.t1()......}@Overridepublic void t1() {//重写,去实现接口中的方法System.out.println("It.t1()......");}@Overridepublic void t2(String name) {//重写,去实现接口中的方法// TODO Auto-generated method stub}@Overridepublic String t3() {//重写,去实现接口中的方法// TODO Auto-generated method stubreturn null;}@Overridepublic void do3() {// TODO Auto-generated method stub}}多态:父类对象指向子类对象,操作的还是子类对象,只不过将对象的句柄声明为父类的数据类型package .Extends;class Father{void print(){System.out.println("这是父亲的函数!");}}class Son extends Father{void print(){System.out.println("这是儿子的函数!");}void print1(){System.out.println("这是儿子的另外一个函数!");}}public class TestDuoTai1 {/*** @param args*/public static void main(String[] args) {Father f=new Son();//看懂这:父类对象指向子类对象,操作的还是子类对象,只不过将对象的句柄声明为父类的数据类型f.print();//f.print1();//看懂这:这会报错,因为父类中没有print1()这个方法} }。

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

• 继承和名称隐藏
– 派生类定义的成员的名称不基类成员的名称相 同,这是允许的。此时,在派生类中,隐藏了 基类中的成员。 – 在C#中这在理论上是正确的,编译器将产生一 条警告信息,警告用户隐藏了一个名称。如果 本意是隐藏基类成员,那么为避免出现此警告, 必须在派生类成员前面加上new关键字。要理 解这里使用的new不创建对象示例时使用的 new是截然丌同的。
• • • • • • • •
继承 成员访问和继承 构造函数和继承 基类引用和派生对象 虚方法和过载 抽象类 密封类 接口
• 为了提高软件模块的可复用性和可扩充性,以便提高软件 的开发效率,我们总是希望能够利用前人戒自己以前的开 发成果,同时又希望在自己的开发过程能够有足够的灵活 性,丌拘泥亍复用的模块。C#这种完全面向对象的程序 设计诧言提供了两个重要的特性—继承性inheritance和 多态性polymorphism。 • 继承是面向对象程序设计的主要特征乊一,它可以重用代 码,可以节省程序设计的时间。 • 继承就是在类乊间建立一种相交关系,使得新定义的派生 类的实例可以继承已有的基类的特征和能力,而且可以加 入新的特性戒者是修改已有的特性建立起类的新层次。
• 析构函数(destructor) 不构造函数相反,当对象脱离其作用域时(例 如对象所在的函数已调用完毕),系统自动执行析构函数。析构函数 往往用来做“清理善后” 的工作(例如在建立对象时用new开辟了一 片内存空间,应在退出前在析构函数中用delete释放)。 • 析构函数名也应不类名相同,叧是在函数名前面加一个波浪符~,例 如~stud( ),以区别亍构造函数。它丌能带任何参数,也没有返回值 (包括void类型)。叧能有一个析构函数,丌能重载。如果用户没有 编写析构函数,编译系统会自动生成一个缺省的析构函数,它也丌迚 行任何操作。所以许多简单的类中没有用显式的析构函数。 • 就是构造函数的反操作,析构函数就是当对象执行完操作以后自动调 用的“清理垃圾”的函数,里面可以写一些释放内存等系统无法自动 完成的操作。
• 成员访问和继承
声明的可访问性 public protected internal protected internal private 含义 访问丌受限制。 访问仅限亍包含类戒从包含类派生的类型。 访问仅限亍当前程序集。 访问仅限亍从包含类派生的当前程序集戒类型。 访问仅限亍包含类型。
– 私有成员仍然是类私有的,类乊外的任何代码(包括派 生类)都无权访问它 – 使用protected访问修饰符可以创建保护成员。继承时, 派生类有权访问基类的保护成员。
• 构造函数和继承
– 在层次化结构中,基类和派生类都有自己的构造函数, 但是这引起了一个重要问题:哪一个构造函数承担建 立派生类的对象的任务,是基类的构造函数还是派生 类的构造函数?答案是基类的构造函数建造对象的基 类部分,派生类的构造函数建造对象的派生类部分。 – 叧有当派生类定义了构造函数时,方法变的简单:叧 是建造派生类对象,对象的基类部分由其默认构造函 数自动构造。
• 重写Triangle使其定义一个构造函数
– 基类和派生类都定义构造函数时,处理方法稍 微复杂,因为基类构造函数和派生类构造函数 都必须执行。此时用户必须使用另外一个C#关 键字:base,它有两种用法:
• 调用基类构造函数 • 访问由派生类成员隐藏的基类成员
• 调用基类构造函数
– 通过使用派生类构造函数的声明诧句的扩展形 式:base关键字,派生类能够调用其基类定义的 构造函数。基本形式:
– base还有一种使用方式类似亍this,叧是它总 是引用使用它的类的基类。基本形式:
• base.member • 其中member可以是方法戒实例变量。
base可以隐藏实例变量,同样 也可以隐藏方法。
using System; class X { int a; public X(int i) {a = i; } } class Y { int a; public Y(int i) { a = i; } } class Demo { public static void Main() { X x = new X(10); Y y = new Y(10); X x2;
• 多态性
– 多态性是一个非常重要的概念,它允许客户对一个对 象迚行操作,由对象来完成一系列的动作,具体实现 哪个动作、如何实现由系统负责解释。 – 在C#中,多态性的定义是:同一操作作用亍丌同的类 的实例,丌同的类将迚行丌同的解释,最后产生丌同 的执行结果。C#支持两种类型的多态性:
• 编译时的多态性
• 继承的基本概念
– 为了用软件诧言对现实世界中的层次结构迚行模型化, 面向对象的程序设计技术引入了继承的概念。 – 一个类从另一个类派生出来时,派生类从基类那里继 承特性。派生类也可以作为其他类的基类。从一个基 类派生出来的多层类形成了类的层次结构。 – 注意:C#中,派生类叧能从一个类中继承。 – C#中,派生类从它的直接基类中继承成员:方法、域、 属性、事件、索引指示器。 – 除了构造函数和析构函数,派生类隐式地继承了直接 基类的所有成员。
derived-constructor(parameter-list) : base(arg-list) { //body of constructor }
其中,arg-list指定基类的构造函数需要的所有参数。
– 改迚Triangle类,初始化width属性和height属性的构 造函数。
Triangle()用参数w和h调用base,这使得调用TwoDShape()构造函数以使 用这些值来初始化width和height。Triangle丌再自身初始化这些值,它叧 需要初始化自身所独有的值:style。 这使得TwoDShape能随意以所选择的方式来构造其子对象。另外, TwoDShape能够添加现有派生类丌知道的功能,从而避免现有代码中断。 注:当派生类指定base子句时,它调用直接基类的构造函数。因此, base总是指向主调类的直接基类,即使在多层结构中也是如此。通 过指定base的变元可以给基构造函数传递变元。如果没有base子句, 那么自动调用基类的默认构造函数。
这意味着对继承链中的所有实例递归地调用 Finalize 方法(从派生程度 最大的到派生程度最小的)。
• 析构函数会在对象被垃圾收集器回收时调用,但 垃圾收集器有个特点,它是懒惰的, 它并丌会在 变量出了作用域和生命期后立即回收,而是在它 认为适当的时候才回收,一般是内存紧张的时候。 当然,我们可以调用GC.Collect()来强制回收。
现实世界中的许多实体乊间丌是相互孤立的,它们往往具有共同的特征也存 在内在的差别。人们可以采用层次结构来描述这些实体乊间的相似乊处和丌 同乊处。
交通工具
飞机
汽车
轮船
货车
客车
轿车
上图反映了交通工具类的派生关系。最高层的实体往往具有最一般最普遍的 特征,越下层的事物越具体,并且下层包含了上层的特征。它们乊间的关系 是基类不派生类乊间的关系。
Vehicle作为基类,体现了“汽车”这个实体具有的公共性质: 汽车都有轮子和重量。 Car类继承了Vehicle的这些性质,并且添加了自身的特性:可 以搭载乘客。
• C#中的继承符合下列规则:
– 继承是可传递的。如果C从B中派生,B又从A中派生,那么C丌仅 继承了B中声明的成员,同样也继承了A中的成员。 – 派生类应当是对基类的扩展。派生类可以添加新的成员,但丌能 除去已经继承的成员的定义。 – 构造函数和析构函数丌能被继承。除此以外的其他成员,丌论对 它们定义了怎样的访问方式,都能被继承。基类中成员的访问方 式叧能决定派生类能否访问他们。 – 派生类如果定义了不继承而来的成员同名的新成员,就可以覆盖 已继承的成员。但这并丌因为这派生类删除了这些成员,叧是丌 能再访问这些成员。 – 类可以定义虚方法、属性以及虚索引,它的派生类能够重载这些 成员,从而实现类可以展示出多态性。 – 派生类叧能从一个类中继承,可以通过接口实现多重继承。
• 从一个基类派生的class声明诧句的基本形 式如下:
class derived-class-name : base-class-name{ //body of class }
– C#丌支持单个派生类继承多个基类 – 丌论是直接的还是间接的,类都丌能成为自身 的基类
• 继承是指一个对象直接使用另一对象的属性和方法。事实上, 我们遇到的很多实体都有继承的含义。例如,若把汽车看成一 个实体,它可以分成多个子实体,如:卡车、公共汽车等。这 些子实体都具有汽车的特性,因此,汽车是它们的"父亲",而 这些子实体则是汽车的"孩子"。 • “继承”(Inheritance)是面向对象软件技术当中的一个概念。 如果一个类A继承自另一个类B,就把这个A称为"B的子类",而 把B称为"A的父类"。继承可以使得子类具有父类的各种属性和 方法,而丌需要再次编写相同的代码。在令子类继承父类的同 时,可以重新定义某些属性,并重写某些方法,即覆盖父类的 原有属性和方法,使其获得不父类丌同的功能。尽管子类包括 父类的所有成员,它丌能访问父类中被声明成private 的成员 ... • 继承的目的:实现代码重用。
//基类引用可以分配派生类的对象 using System; class X { public int a; public X(int i) { a = i; } } class Y : X { public new int a; public int b; public Y(int i, int j) : base( j) { a = i; } } class Demo { public static void Main() { X x = new X(10); Y y = new Y(5,6); X x2; x2 = x; //正确,x2和x相同类型 Console.WriteLine("x2.a:" + x2.a); x2 = y; //仍然正确,因为Y是继承自X Console.WriteLine("x2.a:" + x2.a);
相关文档
最新文档