java的继承与组合的区别

合集下载

java中implement和extends的作用和区别详细解释

java中implement和extends的作用和区别详细解释

java中implement和extends的作⽤和区别详细解释copy from :https:///youyou_go/article/details/83539537⼀、extends是继承类,implements是实现接⼝。

类只能继承⼀个,接⼝可以实现多个。

extends继承⽗类的时候可以重写⽗类的⽅法,也可以调⽤⽗类的⾮私有⽅法;implements实现接⼝,必须实现接⼝的所有⽅法。

⼆、extends后⾯跟的是类,表⽰继承关系;如public class Dog extends Animalimplements后⾯跟的是接⼝,表⽰实现接⼝(可以是多个);如public class Dog implements Runner三、继承这个可以理解为继承⽗类的⽅法,⽗类中的⽅法可以在⼦类中⽤到;实现接⼝就是在接⼝中定义了⽅法,这个⽅法要你⾃⼰去实现,接⼝可以看作⼀个标准,⽐如定义了⼀个动物的接⼝,它⾥⾯有吃(eat())这个⽅法,你就可以实现这个⽅法implements,这个⽅法是⾃⼰写,可以是吃苹果,吃梨⼦,⾹蕉,或者其他的。

IMPLEMENTS就是具体实现这个接⼝。

四:implements 也是实现⽗类和⼦类之间继承关系的关键字,如类 A 继承类 B 写成 class A implements B{}.五:extends,可以实现⽗类,也可以调⽤⽗类初始化 this.parent()。

⽽且会覆盖⽗类定义的变量或者函数。

这样的好处是:架构师定义好接⼝,让⼯程师实现就可以了。

整个项⽬开发效率和开发成本⼤⼤降低。

implements,实现⽗类,⼦类不可以覆盖⽗类的⽅法或者变量。

即使⼦类定义与⽗类相同的变量或者函数,也会被⽗类取代掉。

总结: 这两种实现的具体使⽤,是要看项⽬的实际情况,需要实现,不可以修改,⽤implements,只定义接⼝需要具体实现;可以被修改扩展性好,⽤extends。

————————————————版权声明:本⽂为CSDN博主「Jack++」的原创⽂章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原⽂出处链接及本声明。

简述类间的组合和聚合关系的区别与联系

简述类间的组合和聚合关系的区别与联系

简述类间的组合和聚合关系的区别与联系类间的组合和聚合关系是面向对象编程中常用的两种关系。

它们的区别和联系如下:
1. 区别:
组合关系是指两个类之间存在相互依赖的关系,其中一个类依赖于另一个类的属性或方法。

组合关系中的两个类是相互独立的,它们不能独立存在。

而聚合关系则是指两个类之间存在相互包含的关系,其中一个类包含另一个类的属性或对象,它们彼此之间是相互依赖的关系。

聚合关系中的两个类是相互依赖的,它们不能独立存在。

2. 联系:
组合和聚合关系之间存在一定的联系,组合可以看作是一种更紧密的聚合关系。

在组合关系中,两个类之间的依赖关系更加紧密,它们彼此之间相互依赖,互相提供支持。

而聚合关系则更加松散,两个类之间的依赖关系相对较弱,它们只是相互包含,并不提供支持。

3. 应用场景:
组合关系通常用于实现组件之间的交互和依赖关系,例如,在图形用户界面中,按钮可以作为一个组件与其他组件进行组合,以实现特定的功能。

而聚合关系则通常用于实现组件之间的相互依赖关系,例如,在文件系统中,文件夹可以包含文件,文件也可以包含文件夹,它们彼此之间相互依赖,以实现文件系统的正常运转。

4. 关系类型:
在面向对象编程中,通常有三种关系类型,分别是组合关系、聚合关系和关
联关系。

组合关系和聚合关系都是关系类型中比较典型的例子,它们区别在于它们之间的依赖关系更加紧密或松散。

而关联关系则是指两个类之间存在一对一的关系,例如,在人际关系中,一个人可以有一个父亲或一个母亲,但他们之间并不相互依赖,而是一种相互独立的关系。

【面向对象设计的3个基本特征】

【面向对象设计的3个基本特征】

【⾯向对象设计的3个基本特征】JAVA中⾯向对象的三⼤特征:⾯向对象具有继承性(Inheritance)⾯向对象具有多态性(Polymorphism)⾯向对象具有封装性(Encapsulation)⼀、继承多个类具有共同的属性(成员变量)与⾏为(成员⽅法)的时候,将这些共同的部分抽取出来定义到⼀个公共的类中,其他及各类可以与这个公共的类形成继承关系,从⽽在多个类中不需要重复定义公共部分!这个公共的类就是⽗类,也称为超类或者基类,其他的类就是⼦类。

⼦类可以直接访问⽗类的⾮私有化成员变量,访问⽗类的私有化成员变量可以使⽤super.get()⽅法。

1、 Java继承的特点:A、Java只存在单个继承不存在多个继承,即:⼀个类只能有⼀个⽗类B、Java可以多层继承,多重继承2、Java继承的优点A、继承是基于存在多个重复代码的时候提出的,那么继承能很好的提⾼复⽤率!B、使类与类之间存在继承关系,是实现多态操作的前提!C、继承关键字:extends3、Java继承的缺点继承使得多个类之间具有了⼦⽗类关系,当⼀个类存在多个⼦类的时候,如果⽗类发⽣变化,那么这些⼦类会跟着⼀同变化,造成类与类之间的“强耦合”关系!4、Java继承注意点A、不要仅仅为了获取某个类的某个功能⽽去继承这个类B、类与类之间要存在所属关系,不能够随意继承例:⼈与狗都具有吃饭的动作,狗为了实现吃饭的动作,⽽继承⼈,这是不合适的!所谓的所属关系是is--a的关系,也就是说AAA is BB 的....学⽣是⼈的某⼀个群体,可以同时具有吃饭的动作5、何时使⽤继承A、具有公共的属性与⾏为操作的时候,提⾼复⽤性B、具有is--a的所属关系的类与类之间6、类的主要组成部分的⼦⽗类继承关系中的特点!A、成员变量a、继承关系中同名的⼦类成员变量、局部变量、⽗类的成员变量这三者之间使⽤顺序:在具有相同变量名的这种情况下,不使⽤this、super等关键字进⾏调⽤时,即成员变量前什么都不写,调⽤顺序按照由局部变量位置---当前类成员变量位置---⽗类成员变量位置依次进⾏查找变量,什么位置先有值,就会使⽤这个值!调⽤⽅式:this,superB、成员⽅法a、继承中的成员⽅法使⽤顺序:当⼦类具有与⽗类同名成员⽅法时,进⾏调⽤过程中不使⽤this、super等关键字,即成员⽅法前什么都不写,⽅法的有效顺序:当前类的成员⽅法---⽗类的成员⽅法⼦类中有⽅法实现,则按照⼦类的实现进⾏,若在⼦类中使⽤super调⽤了⽗类的⽅法,那么⽗类⽅法也要执⾏!但是默认成员⽅法内是没有super调⽤的!!!b、重写概念:⼦类中出现与⽗类⼀模⼀样的⽅法时,会出现⼦类⽅法将⽗类⽅法覆盖的情况,这种情况成为重写或者复写c、重写注意事项- ⽗类中的私有⽅法不可以被重写,覆盖!- ⼦类重写⽗类⽅法后,继续使⽤⽗类的⽅法时候,可以使⽤super调⽤- 重写时,⼦类的⽅法的访问权限要⼤于或者等于⽗类成员⽅法的访问权限- 静态⽅法只能被静态⽅法覆盖- ⼦类对于⽗类的功能有增强需求的时候,可以重写⽗类的⽅法以增强其功能!d、重写与重载的区别重写:⼦⽗类之间,⽅法完全相同(返回值、⽅法名、参数列表),但是⼦⽗类之间的⽅法体必须不同,否则没有意义!重载:同⼀个类中,⽅法名相同,参数列表不同,与返回值⽆关!(参数列表:包括两项:参数个数,对应参数的数据类型)重载何时使⽤:当⼀个类中需要完成某个相同功能,但是⽅法的参数不同需要分别进⾏操作时!C、构造⽅法a、⼦类中所有的构造⽅法默认都访问⽗类中⽆参构造b、每个构造⽅法的第⼀⾏是super();super(参数列表);如果把这两⾏代码放在⾮第⼀⾏位置会报错c、根据构造⽅法的特性,在⼿动给出任意⼀个构造⽅法的时候,之前默认的⽆参构造会被覆盖,此时具有继承关系的时候,⼦类之前默认存在的每个构造都调⽤⽆参构造super()失效,此时必须在每个构造⽅中⼿动给出super(参数列表)的⽅式直接或间接调⽤之前⼿动在⽗类中给出的构造!d、构造⽅法执⾏了⼀定会创建相应对象吗?不⼀定,当具有继承关系的类时,⼦类创建对象的时候会调⽤⽗类的构造⽅法,⽤来初始化⽗类的成员变量,这个时候⽗类的构造执⾏了,但是内存中并没有⽗类的对象!e、构造⽅法是否可以被重写或者继承?不可以,因为构造⽅法名需要与类名相同,假如出现继承或者重写关系,就会有⼦类中有⼀个与⽗类的类名相同的构造⽅法,但是⼜由于构造⽅法需要与类名相同,此时⼦类类名需要与构造相同,这个时候就会出现⽗类与⼦类的类名相同,⽗类类名==构造⽅法名==⼦类类名,不能存在同名的类!⼆、多态java程序中定义的引⽤变量所指向的具体类型和通过该引⽤类型发出的⽅法在调⽤时不确定,该引⽤变量发出的⽅法到底调⽤哪个类的实现的⽅法,必须在程序运⾏期间才能决定,这就是多态。

零碎点

零碎点

抽象类:规定一个或多个抽象方法的类别本身必须定义为abstract,抽象类只是用来派生子类,而不能用它来创建对象。

final类:又称“最终类”,它只能用来创建对象,而不能被继承,与抽象类刚好相反,而且抽象类与最终类不能同时修饰同一个类。

包:Java中的包是相关类和接口的集合,创建包须使用关键字package。

多态类:在java中,对象变量是多态的。

而java中不支持多重继承。

接口:Java中的接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)。

Java中的每一个类都是从Object类扩展而来的。

object类中的equal和toString方法。

equal用于测试一个对象是否同另一个对象相等。

toString返回一个代表该对象的字符串,每一个类都会从Object类继承该方法,有些类重写了该方法,以便返回当前状态的正确表示。

(toString 方法是一个很重要的方法)通用编程:任何类类型的所有值都可以同object类型的变量来代替。

封装:就是把数据和行为结合起在一个包中,并对对象使用者隐藏数据的实现过程,一个对象中的数据叫他的实例字段(instance field)。

重载:当多个方法具有相同的名字而含有不同的参数时,便发生重载。

编译器必须挑选出调用哪个方法进行编译。

重写:也可称为方法的“覆盖。

”在Java中,子类可继承父类中的方法,而不需要重新编写相同的方法。

但有时子类并不想原封不动地继承父类的方法,而是想作一定的修改,这就需要采用方法的重写。

值得注意的是,子类在重新定义父类已有的方法时,应保持与父类完全相同的方法头声明。

数组列表:ArrayList动态数组列表,是一个类库,定义在java.util包中,可自动调节数组的大小。

class类object类中的getclass方法返回class类型的一个实例,程序启动时包含在main方法的类会被加载,虚拟机要加载他需要的所有类,每一个加载的类都要加载它需要的类。

java中extends与implements的区别

java中extends与implements的区别

JAVA中extends 与implements有啥区别?1. 在类的声明中,通过关键字extends来创建一个类的子类。

一个类通过关键字implements 声明自己使用一个或者多个接口。

extends 是继承某个类, 继承之后可以使用父类的方法, 也可以重写父类的方法; implements 是实现多个接口, 接口的方法一般为空的, 必须重写才能使用2.extends是继承父类,只要那个类不是声明为final或者那个类定义为abstract的就能继承,JAVA中不支持多重继承,但是可以用接口来实现,这样就要用到implements,继承只能继承一个类,但implements可以实现多个接口,用逗号分开就行了比如class A extends B implements C,D,E===========================================================implements学了好久,今天终于明白了implements,其实很简单,看下面几个例子就ok啦~~接口的一些概念public inerface Runner{int ID = 1;void run ();}interface Animal extends Runner{void breathe ();}class Fish implements Animal{public void run (){System.out.println("fish is swimming");}public void breather(){System.out.println("fish is bubbing");}}abstract LandAnimal implements Animal{public void breather ()System.out.println("LandAnimal is breathing");}}class Student extends Person implements Runner{......public void run (){System.out.println("the student is running"); }......}interface Flyer{void fly ();}class Bird implements Runner , Flyer{public void run (){System.out.println("the bird is running");}public void fly (){System.out.println("the bird is flying");}}class TestFish{public static void main (String args[]){Fish f = new Fish();int j = 0;j = Runner.ID;j = f.ID;}接口实现的注意点:a.实现一个接口就是要实现该接口的所有的方法(抽象类除外)。

day01课堂笔记

day01课堂笔记

今日内容介绍◆基础知识回顾◆继承今日学习目标◆能够解释类名作为参数和返回值类型◆能够理解匿名对象◆能够写出类的继承格式◆能够说出继承的特点◆能够说出子类调用父类的成员特点第1章基础知识回顾1.1类类:现实生活中一类事物的抽象描述;类的组成:构造方法、属性(成员变量)、成员方法;Public class 类名{构造方法、属性(成员变量)、成员方法;}对象:现实生活中的具体某个事物的体现;(个体)类与对象的关系:一个类可以创建多个对象,每一个对象必须有所属的类型;对象与对象的关系:每一个对象都是独立的个体;(对象中的成员变量互不影响);1.2构造方法构造方法的格式:Public 类名(参数列表){写代码;(通常是给成员变量赋值)}执行特点:在创建对象的过程中,由java虚拟机自动匹配对应的构造方法,并调用一次;构造方法的作用:1、创建对象;2、给成员变量赋值;构造方法与set方法的区别:1、构造方法是在对象创建的过程中对成员变量赋值;2、Set方法是对象创建成功后,修改对象中成员变量的值;1.3This关键字This是当前对象的引用;(哪个对象调用方法,那么它就是当前对象)每个对象中成员变量的值,互不影响;成员变量是随着对象的创建而产生,随着对象的死亡而死亡;1.4方法的参数与返回值的问题关于基本数据类型参数传递的规则:在一个方法内部,对基本数据类型(包含String)的变量的值,进行修改,不会对原方法的变量的值影响;关于引用数据类型参数传递的规则:在一个方法内部,对引用数据类型(不包含String)的变量的值,进行修改,会对原方法的变量的值影响;1.5匿名对象没有起名字的对象,就是匿名对象;Person p = new Person();new Person();匿名对象的特点:1、只能使用一次;2、必须在创建完之后立刻使用;匿名对象只是一个代码简写的形式第2章继承2.1组合的概念将两个独立的事物,硬组成在一起;在java中的代码体现:在一个类(A)中有另一个类(B),此时A类和B类就是组合关系;数据类型变量名;2.2继承描述类与类之间的一种关系;2.3继承的格式:使用关键字extendsPublic class 子类类名extends 父类类名{子类的成员;}2.4继承的思想子类可以直接使用父类非私有的属性和方法;父类是通过不同的子类不断的向上抽取而来;2.5练习子类直接使用父类成员在子类的方法内部可以直接调用父类的非私有的方法或属性;每个子类都可以拥有父类完整的一份,所有子类互不干涉;2.6继承的特点:1、java中类与类之间的继承只能是单继承;2、继承具有传递性;(孙子可以使用爷爷的成员)3、子父类是相对概念,只有Object是绝对父类;(任何一个类都直接或间接的继承了Object)。

java 枚举类继承

java 枚举类继承

java 枚举类继承java枚举类继承是指一种使用Java编程语言定义的枚举类可以继承另一个枚举类,从而在枚举类中添加其它枚举常量值。

使用枚举类继承可以实现多维度枚举类型,比如从一个基础枚举类型上衍生出新的枚举类型,以及定义新的枚举值。

在Java语言中,枚举类继承是基于类的继承机制实现,因此,一个枚举类型可以被另一个枚举类型所继承,并且继承枚举类可以重新定义其它枚举常量值。

首先,通过定义子类,可以在枚举类中声明其它枚举常量:public enum ParentEnum {VALUE1, VALUE2;}public enum ChildEnum extends ParentEnum {VALUE3;}这里,定义了一个ParentEnum枚举类,其中定义了VALUE1和VALUE2两个枚举常量;而ChildEnum枚举类继承了ParentEnum,并且定义了一个新的枚举常量VALUE3。

其次,可以使用类型安全的枚举类型,从而实现同一个枚举类中存在多种类型枚举常量:public enum ParentEnum {VALUE1(1), VALUE2(2);private int value;public int getValue(){return value;}ParentEnum(int value){this.value=value;}}public enum ChildEnum extends ParentEnum {VALUE3(3);ChildEnum(int value){super(value);}}借助上述代码实现的枚举类继承,可以在同一个枚举中,定义不同类型的枚举常量:VALUE1、VALUE2和VALUE3。

此外,java枚举类继承还可以实现重载构造函数,以及定义实例方法,方法可以根据枚举常量值进行条件判断:public enum ParentEnum {VALUE1(1), VALUE2(2);private int value;public int getValue(){return value;}ParentEnum(int value){this.value=value;}public boolean isVALUE1(){return VALUE1.equals(this);}public boolean isVALUE2(){return VALUE2.equals(this);}}public enum ChildEnum extends ParentEnum {VALUE3(3);ChildEnum(int value){super(value);}public boolean isVALUE3(){return VALUE3.equals(this);}}定义重载构造函数和实例方法,可以使得枚举类型更加灵活,并能够实现更复杂的业务逻辑。

java练习题-继承

java练习题-继承

一.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-publicB) public-default-protected-privateC) private-protected-default-publicD) public-protected-default-private10.以下(D)不是Object类的方法A) clone()B) finalize()C) toString()D) hasNext()11.多态的表现形式有(A)A) 重写B) 抽象C) 继承D) 封装12.以下对重载描述错误的是(B)A) 方法重载只能发生在一个类的内部B) 构造方法不能重载C) 重载要求方法名相同,参数列表不同D) 方法的返回值类型不是区分方法重载的条件13.以下(D)添加到ComputerBook中不会出错class Book{protected int getPrice(){return 30;}}public class ComputerBook extends Book{}A) protected float getPrice(){}B) protected int getPrice(int page){}C) int getPrice(){}D) public int getPrice(){return 10;}14.以下对抽象类的描述正确的是(C)A) 抽象类没有构造方法B) 抽象类必须提供抽象方法C) 有抽象方法的类一定是抽象类D) 抽象类可以通过new关键字直接实例化15.以下对接口描述错误的有(D)A) 接口没有提供构造方法B) 接口中的方法默认使用public、abstract修饰C) 接口中的属性默认使用public、static、final修饰D) 接口不允许多继承16.以下代码,描述正确的有(A)interface IDemo{public static final String name;1void print();2public void getInfo();3}abstract class Person implements IDemo{4public void print(){}}A) 第1行错误,没有给变量赋值B) 第2行错误,方法没有修饰符C) 第4行错误,没有实现接口的全部方法D) 第3行错误,没有方法的实现17.接口和抽象类描述正确的有(B,C)(两项)A) 抽象类没有构造函数B) 接口没有构造函数C) 抽象类不允许多继承D) 接口中的方法可以有方法体18.以下描述错误的有(C)A) abstract 可以修饰类、接口、方法B) abstract修饰的类主要用于被继承C) abstract 可以修饰变量D) abstract修饰的类,其子类也可以是abstract修饰的19.以下描述正确的有(B)A) 方法的重写应用在一个类的内部B) 方法的重载与返回值类型无关C) 构造方法不能重载D) 构造方法可以重写20.以下程序运行结果是(A)public class Test extends Father{private String name=”test”;public static void main(String[] args){Test test = new Test();}}class Father{private String name=”father”;public String getName() {return name;}}A) fatherB) testC) 编译出错D) 运行出错,无输出21.以下对异常的描述不正确的有(C)A) 异常分为Error和ExceptionB) Throwable是所有异常类的父类C) Exception是所有异常类父类D) Exception包括RuntimeException和RuntimeException之外的异常22.在try-catch-finally语句块中,以下可以单独与finally一起使用的是(B)A) catchB) tryC) throwsD) throw23.下面代码运行结果是(B)public class Demo{public int add(int a,int b){try{return a+b;}catch(Exception e){语句块”);}finally{语句块”);}return 0;}public static void main(String[] args){Demo demo = new Demo();和是:”+(9,34));}}A) 编译异常B) finally语句块和是:43C) 和是:43 finally语句块D) catch语句块和是:4324.以下描述不正确的有(D)A) try块不可以省略B) 可以使用多重catch块C) finally块可以省略D) catch块和finally块可以同时省略25.以下对自定义异常描述正确的是(C)A) 自定义异常必须继承ExceptionB) 自定义异常可以继承自ErrorC) 自定义异常可以更加明确定位异常出错的位置和给出详细出错信息D) 程序中已经提供了丰富的异常类,使用自定义异常没有意义26.以下程序运行结果是(D)public class Test {public int div(int a, int b) {try {return a / b;}catch(Exception e){}catch(NullPointerException e){}catch (ArithmeticException e) {} finally {}return 0;}public static void main(String[] args) {Test demo = new Test();商是:” + (9, 0));}}A) Exception finally 商是:0B) ArithmeticException finally 商是:0C) finally商是:0D) 编译报错27. 以下对TCP和UDP描述正确的是(D)A) TCP不能提供数据的可靠性B) UDP能够保证数据库的可靠性C) TCP数据传输效率高于UDPD) UDP数据传输效率高于TCP28. 在Java中,下面对于构造函数的描述正确的是(D)。

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

java的继承与组合的区别
java的继承与组合的区别
继承和组合的概念
在新类里简单地创建原有类的对象。我们把这种方法叫作“组
合”,因为新类由现有类的对象合并而成。我们只是简单地重复利用
代码的功能,而不是采用它的`形式。
第二种方法是创建一个新类,将其作为现有类的一个“类型”。
我们可以原样采取现有类的形式,并在其中加入新代码,同时不会对
现有的类产生影响。这种魔术般的行为叫作“继承”(Inheritance),
涉及的大多数工作都是由编译器完成的。对于面向对象的程序设计,
“继承”是最重要的基础概念之一。对于组合和继承这两种方法,大
多数语法和行为都是类似的(因为它们都要根据现有的类型生成新类型)。
使用场合:
组合:各部件之间没什么关系,只需要组合即可。like组装电脑,
需要new CPU(),new RAM(),new Disk()……
演示代码如下:
public class Computer {
public Computer() {
CPU cpu=new CPU();
RAM ram=new RAM();
Disk disk=new Disk();
}
}
class CPU{ }
class RAM{ }
class Disk{ }
继承:子类需要具有父类的功能,各子类之间有所差异。like
Shape类作为基类,子类有Rectangle,CirCle,Triangle……
演示代码如下:
class Shape {
public void draw() {
System.out.println("draw a shape");
}
public void erase() {
System.out.println("erase");
}
}
class Square extends Shape {
@Override
public void draw() {
System.out.println("draw a Square");
}
public static void main(String[] args) {
Square s = new Square();
s.draw();
s.erase();
}
}
一、相比于组合,继承有以下优点:
1、在继承中,子类自动继承父类的非私有成员(default类型视是
否同包而定),在需要时,可选择直接使用或重写。
2、在继承中,创建子类对象时,无需创建父类对象,因为系统会
自动完成;而在组合中,创建组合类的对象时,通常需要创建其所使用
的所有类的对象。
二、组合的优点:
1、在组合中,组合类与调用类之间低耦合;而在继承中子类与父
类高耦合。
2、可动态组合。
总结:
虽然继承是OOP的一大特性,但很多时候并不推荐使用,因为它
常常容易使结构复杂化,容易出错。因此,除非我们确信使用继承会
使程序效率最高,否则,不考虑使用它。
下载全文

相关文档
最新文档