黑客24小时在线接单网站

Java的聚成和动态绑定

󦘖

添加微信

16743346318

添加微信

什么是继承?


继承也是面向对象的重要特性之一。顾名思义,继承就是指从已有的类中派生出新类的动作。新的类能吸收已有类的数据属性和行为,并能扩展新的能力。视频-域名解析以及绑定域名.


 


而通俗一点的来说,就是指Java中可以通过继承的方式,从现有的类派生出新的类。该现有类被称为超类(父类),而派生出的新类就被称为子类(派生类)。


首先,子类访问继承超类当中的所有非私有的方法和成员变量;其次,还可以在父类原有的成员的基础上添加一些新的方法和域,或者对父类的方法进行覆写(override)。


 


所有通常也这样讲:父类是子类的一般化表现形式;而子类是父类的特有化表现形式。


 


Java中使用关键字“extends”用于声明一个类继承自另一个类。第三讲 eclipse的使用和Java语言基础.


 


继承的体现


首先,假定我们自定义了一个雇员类“Employee”:


[java] view plaincopyprint?

package com.tsr.j2seoverstudy.extends_demo;

 

public class Employee {

 

private String name; // 姓名

private int salary; // 收入

 

public String getName() {

return name;

}

 

public void setName(String name) {

this.name = name;

}

 

public int getSalary() {

return salary;

}

 

public void setSalary(int salary) {

this.salary = salary;

}

 

}

一个部门中,雇员通常分为经理和普通雇员。二者之间大部分的行为相似,但可能在收入上略有不同。第二讲java概述及环境搭建


假设普通雇员的收入来源为工资,而经理的收入结构则是由工资 + 绩效奖金构的。于是这个时候,原有的雇员类就不足以描述经理了。


于是,使用继承从原有的雇员类中派生出一个新的经理类“Manager”:


[java] view plaincopyprint?

package com.tsr.j2seoverstudy.extends_demo;

 

public class Manager extends Employee {

// 子类新的特有实例域:绩效奖金

private int bonus;

 

public int getBonus() {

return bonus;

}

 

public void setBonus(int bonus) {

this.bonus = bonus;

}

 

}

 


继承的特性


1、子类会继承超类当中的方法以和实例域


 


[java] view plaincopyprint?

package com.tsr.j2seoverstudy.extends_demo;

 

public class JavaExtendsDemo {

public static void main(String[] args) {

Manager m = new Manager();

m.setName("张经理");

System.out.println(m.getName());

m.setBonus(20000);

System.out.println(m.getBonus());

}

}

在这里可以看到的是,我们在派生类“Manager”当中并没有定义成员变量“name”,也没有定义其相关的set/get方法。


但是我们仍然可以通过“Manager”类对这些成员进行访问,正是因为继承的机制带来的。


“Manager”继承自“Employee”类,所以“Emoloyee”类当中的所有非私有化的成员都被隐式的继承到了子类“Manager”当中。


 


2、方法覆写(override)


前面我们已经说过了,经理的收入结构为:工资 + 奖金。所以“Employee”类当中获取雇员收入的方法“getSalary”就不适用于描述经理的收入了。


对于“Manager”类中,“getSalary”方法返回的值应当是:salary + bonus。这时候就涉及到继承中一个重要的知识点:方法覆写(override)


覆写是指:除方法体以外,方法的所有声明都当与父类中相同,而方法的访问修饰符只能比父类更加宽松。


 


一定要牢记覆写的规则,才不会再使用时出错。下面通过一道网上看见的华为的面试题,来更形象的理解一下覆写的概念:


[java] view plaincopyprint?

package com.tsr.j2seoverstudy.extends_demo;

 

public class Test {

 

}

 

class A {

protected int method1(int a, int b) {

return 0;

}

}

 

class B extends A {

// 合法,通过提高访问权限(protected → public)的方式覆写父类方法。

public int method1(int a, int b) {

return 0;

}

 

// 不合法,注意覆写的规则:方法的访问修饰符只能比父类更加宽松。

private int method1(int a, int b) {

return 0;

}

 

// 合法,但并不是方法覆写。而仅仅是在类B中,针对继承的方法method1进行了重载;

private int method1(int a, long b) {

return 0;

}

 

// 不合法,首先方法返回类型不能作为方法重载的标示。那么就只能是覆写的情况,但覆写要求:除方法体外,方法所有声明都与父类中相同。

public short method1(int a, int b) {

return 0;

}

 

// 不合法,同样还是因为方法声明与父类不同。

static protected int method1(int a, int b) {

return 0;

}

}

 


3、引用父类关键字“super”


我们在第2点特性中说到,对于“Manager”类中,“getSalary”方法返回的值应当是:salary + bonus。也就是说“Manager”类中,“getSalary”的实现应当为:


[java] view plaincopyprint?

public int getSalary(){

return bonus + salary;

}

但实际上,这样做肯定是行不通的,因为salary在父类中被声明为私有的。所以在子类中是无法直接进行访问的。


所以,我们只能通过父类中,针对于该成员变量提供的访问方法“getSalary”获取它的值。所以可能正确的实现应该是:


[java] view plaincopyprint?

@Override

public int getSalary() {

return getSalary() + bonus;

}

但因为我们本身已经根据新的需求对该方法进行了覆写,所有这样做也是行不通的。


这是因为通过方法的覆写,“Employee”类当中已经有了自己特有的“getSalary”方法,所以上面的做法实际上是在让“getSalary”不断的调用自身,直到程序崩溃。



 


想要调用到父类当中的成员,就可以使用Java的关键字之一:super。


super是Java提供的一个用于只是编译器调用超类成员的特殊关键字。所以修改后的“getSalary”方法应当为:


[java] view plaincopyprint?

@Override

public int getSalary() {

return super.getSalary() + bonus;

}


 


 


4、多态以及动态绑定


多态是指:同一事物根据上下文环境不同使用不同定义的能力。例如我们熟悉的重载、覆写都是多态的一种体现。多态是面向对象的又一重要特性。


而多态在Java里继承中的体现形式,主要分别为:


对象的多态:例如我们定义了一个超类动物类"Animal",其中老虎类"Tiger"和鱼类"Fish"都继承自"Animal"。这就是一种类的对象的多态体现。因为一个动物(Animal)构造出的对象既可以是一头老虎"Tiger",也可以是一条鱼“Fish”。

方法的多态:假设动物类“Animal”提供了一个动物呼吸的方法“Breath”。但因为老虎和鱼的呼吸方式是不同的,老虎用肺呼吸,而鱼通过腮呼吸。所以我们需要分别在对应的子类中覆写“Breath”方法。这也方法的多态的一种体现形式。

 

动态绑定是指:程序在运行期(而不是编译时期)根据对象的具体类型进行绑定,所以又被称为运行时绑定。动态绑定的执行过程大概为:


1、首先,编译器首先查看并获取到对象的声明类型和方法名;


然后在其声明类型对应的相应类及其超类的方法表进行查找;


最终搜索出所有方法声明为“pulbic”的对应方法名的方法,得到所有可能被执行的候选方法。


 


注:方法表也就是指,当一个类第一次运行,被类装载器(classloader)进行装载工作时,其自身及其超类的所有方法信息都会被加载到内存中的方法区内。


 


2、编译器将查看调用方法时传入的参数的类型。


如果在执行第一步工作中所获得的所有候选方法中,存在一个与提供的参数类型完全符合,则会决定绑定调用该方法。


这个过程被称为重载解析。也就可以明白:用重载表现的多态,其动态绑定的解析工作就是这样完成的。


另外,由于Java允许类型转换,所以这一步过程可能会很复杂。


如果没有找到与参数类型匹配的方法,或者经过类型转换过后有多个匹配的方法,则会报告编译错误。


 


注:方法名+参数列表 = 方法签名。所以前面我们谈到的方法的覆写规则也可以理解为:方法签名必须与父类相同,访问修饰符只能更宽松。


但值得注意的是,方法返回类型不是方法签名的一部分。在JDK1.5之前,要求覆写时,返回类型必须相同。


而在这之后的版本中,覆写允许将父类返回类型的子类作为返回类型,这被称为协变返回类型。

 


 


3、与之对应的:如果是被声明为private、static、final的方法或构造器,编译器将可以直接的准确知道应当调用的方法。这种方式又被称为静态绑定。


 


4、如果采用的是动态绑定的方式。当程序运行时,一定会选择:对象引用所指向的实际对象所属类型中,最合适的方法。


这也是为什么在继承中,子类覆写超类中的方法后。如果使用超类的类型进行声明,而实际引用子类的对象的对象引用调用方法,会准确的调用到子类中覆写后的方法的原因。


[java] view plaincopyprint?

package com.tsr.j2seoverstudy.extends_demo;

 

public class Test {

public static void main(String[] args) {

Animal [] animals = new Animal[3];

animals[0] = new Animal();

animals[1] = new Tiger();

animals[2] = new Fish();

for (Animal animal : animals) {

animal.breath();

}

}

}

class Animal{

void breath(){

System.out.println("动物呼吸");

}

}

class Tiger extends Animal{

@Override

void breath() {

System.<span style="font-size:12px;">out</span>.println("老虎用肺呼吸");

}

}

class Fish extends Animal{

@Override

void breath() {

System.out.println("鱼用腮呼吸");

}

}

 


5、继承结构:单继承和多重继承


Java中不支持多继承。其继承结构分为:单继承和多重继承。


顾名思义,单继承也就是指:一个类只能继承自一个超类。


而多重继承则是指:C类继承自B类,而B类继承自A类这样的继承层次结构。


多重继承的应用是很常见的。还是以动物为例,老虎继承自动物。而老虎可能又分为东北虎之类的很多品种,那么新定义的东北虎类就应该继承老虎类。


这就是多重继承的一种常见体现形式。


 


6、继承体系中子类的构造过程


[java] view plaincopyprint?

package com.tsr.j2seoverstudy.extends_demo;

 

public class JavaExtendsDemo {

public static void main(String[] args) {

Son s = new Son();

}

}

 

class Far{

Far(){

System.out.println("父类构造初始化..");

}

}

 

class Son extends Far{

Son() {

//这里有一个隐式的构造语句:super(),调用父类的构造初始化工作..

System.out.println("子类构造初始化..");

}

}

也就是说,子类的构造过程是依赖于父类的,当开始子类的构造工作之前,会先完成其所属超类的对象构造工作。


这是理所应当的,因为我们已经知道子类的很多属性与方法是依赖于父类的,如果在此之前不先完成父类的构造工作,对于子类的使用就很容易引起错误。

 


 


什么时候使用继承?


要了解什么使用继承,首先我们应当知道使用继承可以带来的好处是什么:


通过继承构成体系,能让程序的条理性更加清晰。

若出现特殊需求,子类可以较方便的改动父类的实现。

最大的好处在于方便实现代码的复用,减少了编码工作。

所以,最长在什么时候使用继承呢?


1、声名远扬的“IS-A”关系


例如上面说到的“经理是一个雇员”,“老虎是一种动物”都是归属于这种关系。


2、想要通过继承实现多态


以一段代码更好理解,假如我们的程序提供了一个接口用于获取动物的奔跑速度:


[java] view plaincopyprint?

int getSpeed(Animal animal){

return animal.getRunSpeed();

}

通过继承,通过这样简单的代码。只要传入的参数对象的类型位于该Animal的继承体系当中,就可以通过动态绑定的机制正确获取到其奔跑速度。


这实际上也是”策略设计模式“的一种体现方式。而如果假设不使用继承的话,就需要提供对应数量的方法来分别获取不同动物的奔跑速度。

 


 


但与此同时,继承也有一定的弊端:


类继承是在编译时刻静态定义的,所以无法在运行时改变继承类的实现。

通过继承的复用方式被称为“白箱复用",因为父类的实现细节对子类可见。

父类通常都至少定义了子类的部分行为,所以父类的改变都有可能影响到子类的使用。


    所以,正如这个世界上任何事物都有两面性一样,对于继承的使用还是应该结合实际情况作出最适合的决定。


󦘖

添加微信

16743346318

添加微信
分享:
扫描分享到社交APP

微信号复制成功

打开微信,点击右上角"+"号,添加朋友,粘贴微信号,搜索即可!