JAVA第七章总结

继承和多态是面向对象开发中非常重要的一组概念。继承和多态使用得当，整个程序的架构将变得非常有弹性，同时可以减少代码的冗余性。继承机制下，用户可以复用一些定义好的类，减少重复代码的编写。多态机制下，用户可以动态调整对象的调用，降低对象之间的依存关系。为了优化继承与多态，一些类除了可继承父类，还需要使用接口的形式。Java中的类可以同时实现多个接口，接口被用来建立类与类之间关联的标准。正因为具有这些灵活、高效的机制，Java语言才更具有生命力。

7.1 类的继承
继承在面向对象开发思想中是一个非常重要的概念，它使整个程序架构具有一定的弹性。在程将中复用一些已经定义完善的类，不仅可以减少软件开发周期，也可以提高软件的可维护性和可扩展性，本节将详细讲解类的继承。

在Java 语言中，一个类继承另一个类需要使用关键字extends，关键字extends的使用方法如下：class Child extends Parent{}

因为Java只支持单继承，即一个类只能有一个父类，所以类似下面的代码是错误的：

class Child extends Parent1,Parents2{}

子类在继承父类之后，创建子类对象的同时也会调用父类的构造方法。

【例7.1】创建子类对象，观察构造方法执行顺序

父类Parent 和子类Child 都各自有一个无参的构造方法，在main（）方法中创建子类对象时，Java虚拟机会先执行父类的构造方法，然后再执行子类的构造方法。

运行结果：

子类继承父类之后可以调用父类创建好的属性和方法。【例7.2】在电话类基础上衍生的建对的
Telephone 电话类作为父类衍出Mobile手机关，手机类可以直接使用电话类的按键属性和拨打电
 
话行为。 class Telephone{
 
／／电话类
 
String button ="button:0~9";
 
／／成员属性，10个按键
 
void call(){
 
／／拨打电话功能
 
System.out.printin（＂开始拨打电话＂）；
 
子}} class Mobile extends Telephone{
 
／／手机类继承电话类
 
String screen＝＂screen：液晶屏＂；
 
／／成员属性，液晶屏幕
 
} 
 
public class Demo2{ public static void main(Stringl args) {
 
下：
 
Mobile motto=new Mobile(); System.out.println(motto.button);
 
／／子类调用父类属性
 
System.out.println(motto.screen);
 
／／子类调用父类没有的属性
 
motto.call();
 
／／子类调用父类方法 }} 

 

 

子类Mobile 类仅创建了一个显示屏属性，剩余的其他属性和方法都是从父类Telephone 类中继

承的。 Java虽然不允许同时继承两个父类，但不代表没有多继承的关系，可以通过类似“祖父＞父＞儿子＞

孙子”的方式实现多代继承。

例如，绝大多数动物有眼睛、鼻子和嘴，犬类继承动物类，所以犬类也有眼睛、鼻子和嘴，哈士

get

奇是犬类的一个品种，犬类有的特性哈士奇类都有。但哈士奇的眼睛、鼻子和嘴并不是从犬类继承的，

而是从动物类继承的。用Java代码编写则如下：

这三个类的继承关系就是Husky类继承Dog类继承Animal类，虽然Husky类没有直接继承Animal类，但是Husky类可以调用Animal类提供的可被继承的成员变量和方法。

7.2Object类
在开始学习使用class关键字定义类时，就应用到了继承原理，因为在Java中所有的类都直接或间接继承了java.lang.Object类。Object类是比较特殊的类，它是所有类的父类，是Java类层中的最高层类。用户创建一个类时，除非已经指定要从其他类继承，否则它就是从java.lang.Object类继承而来的。Java中的每个类都源于java.lang.Object类，如String类、Integer类等都是继承于Object类。除此之外，自定义的类也都继承于Object类。由于所有类都是 Object 类的子类，所以在定义类时可省略 extends等价于 Object在Object 类中，主要包括 clone（）、finalize（）、equals（）、toString（）等方法，其中常用的两个方法为equals（）和 toString（）方法。由于所有的类都是 Object 类的子类，所以任何类都可以重写Object类中的方法。

注意
Object 类中的getClass0、notifyO、notifyAll0)、waitO等方法不能被重写，因为这些方法被定义为 final 类型。
下面详细讲述Object类中的几个重要方法。
1. getClass()方法
getClass()方法是Object类定义的方法，它会返回对象执行时的 Class 实例，然后使用此实例调用 getNameO方法可以取得类的名称。语法如下:
getClass()getname();
可以将getClass()方法与toString0方法联合使用。
2. toString()方法
toString()方法的功能是将一个对象返回为字符串形式，它会返回一个 String实例。在实际的应用中通常重写toString0)方法，为对象提供一个特定的输出模式。当这个类转换为字符串或与字符串连接时，将自动调用重写的toString()方法。

【例7.3】让学生自我介绍
创建Student类，重写toString0方法，使该类的对象可以自定义输出自己的姓名和年龄 

运行结果如下:
我叫张三，今年16岁。我叫李四，今年19岁。

3.equals()方法
在Java，种比较对象的方式，分别为“-”运算符与equalsO方法。两者的区别在二“”比较的是两个对象引用内存地址是否相等，而equalsO方法比较的是两个对象的实际内容。
下面的实例。
【例7.4】根据身份证号判断是否为同一人(实例位置:资源包\TM\sI\7\4)
为People类建身份号和个属性，重写equals方法，仅以身份证号作为区分条件。创个People对象，用equalsO方法和“--”运算符来判断是否存在多个对象代表同一个人。

运行结果如下:
tom与汤姆是否为同一人? equals()方法的结果:
true==运算符的结果:false
tom与张三是否为同一人?false
tom 与 java.lang.Object@48cf768c是否为同一人?false

从这个结果可以看出，“tom”和“汤姆”虽然名字不同，但是两者的身份证号相同，所以equals0方法判断出了这两个对象实际上是同一个，而“=-”运算符无法做出有效判断。如果两个对象的身份证号不同，或者两个对象类型都不同，equals(）方法就会认为两者不是同一个人。

7.3对象类型的转换
对象类型的转换在Java编程中经常遇到，主要包括向上转型与向下转型，接下来讲解对象类型的转换。

7.3.1向上转型
向上转型可以被理解为将子类类型转换为父类类型的对象，即把子类类型的对象直接赋值给父类类型的对象，进而实现按照父类描述子类的效果。

在上述代码中，“people tom = new people();"运用了向上转型的语法，那么该如何理解这行代码的含义呢？理解方式如图 

图为向上转型结合实例的说明

综上所述，因为人类(People)是教师类(Teacher)的父类，所以通过向上转型，能够把教师类
(Teacher)类型的对象(newTeacherO;)直接赋值给人类(People)类型的变量(tom)。也就是说，
进行向上转型，父类类型的对象可以引用子类类型的对象。而且，向上转型是安全的，因为向上转型是将一个较具体的类的对象转换为一个较抽象的类的对象象。例如，可以说平行四边形是四边形，但不能说四边形是平行四边形。
那么，使用向上转型的过程中，父类的对象是否可以以调用子类独有的属性或者方法呢?下面以父类四边形类的对象调用子类平行四边形类独有的属性为例，阐述这一问题。
例如，四边形类是平行四边形类的父类，用 Quadrang gle表示四边形类、用Parallelogram表示平行四边形类;在Parallelogram类中，定义一个值为4的表示底边长度的变量edges;在 Parallelogram类的主方法中,运用向上转型,把平行四边形类(Parallelogram)类型的对象直接赋值给四边形类(Quadrangle)类型的对象。人为强制四边形类(Quadrangle)类型的对象可以调用变量edges，并将 edges的值修改为6，Eclipse能通过编译么?Eclipse的效果图如图73所示，从图中可以看出，Eclipse 在相关代码处显示波浪线等错误标志，说明代码有误。

图为父类的对象是否可以调用子类独有的属性

综上所述，在运用向上转型的过程中，父类的对象无法调用子类独有的属性或者方法。

7.3.2向下转型
向下转型可以被理解为将父类类型的对象转换为小子类类型的对象。但是，运用向下转型，如果把一个较抽象的类的对象转换为一个较具体的类的对象，这样的转型通常会出现错误。例如，可以说某只鸽子是一只鸟，却不能说某只鸟是一只鸽子。因为鸽子是具体的，鸟是抽象的。一只鸟除了可能是鸽子，还有可能是老鹰、麻雀等。因此，向下转型是不安全的。

本题在运行之前,会报错,因为父类对象不能直接赋值给子类对象。

 如果想要告诉编译器“某只鸟就是一只鸽子”，应该如何修正?答案就是强制类型转换。也就是说，要想实现向下转型，需要借助强制类型转换。语法如下:
子类类型  子类对象  =  (子类类型)父类对象;
因此，要想实现把鸟类对象转换为鸽子类对象(相当于告诉编译器“某只鸟就是一只鸽子”)，需要将图7.4中第8行代码修改为:

Pigeon pigeon=(Pigeon)bird;    //通过强制类型转换，告诉编译器“某只鸟就是一只鸽子” 
   
注意
(1)两个没有继承关系的对象不可以进行向上转型或者向下转型。
(2)父类对象可以强制转换为子类对象，但有一个前提:这个父类对象要先引用这个子类对象。
如果把上述实例中的代码:

Bird bird=new Pigeon();    //某只鸽子是一只鸟    
Pigeon pigeon=(Pigeon) bird;    //通过强制类型转换，告诉编译器“某只鸟就是一只鸽子”    
修改为如下代码：

Bird bird= new Bird();    //某只鸽子是一只鸟    
Pigeon pigeon=(Pigeon)bird;    //通过强制类型转换，告诉编译器“某只鸟就是一只鸽子”
7.4 使用instanceof关键字判断对象类型
当在程序中执行向下转型操作时,如果父类对象不是子类对象的实例，发ClassCatException异常，所以在执行向下转型之前需要养成一个良好的习惯，就是判断父类对象是否为子类对象的这个判断通常使用instancof关字成。使用instanceof关键字判是否一个类实现了某个口(行)，也可以用来判断一个实例对象是否属于一个类。
instanceof的语法格式如下:

myobject instanceof ExampleClass

使用instanceof关键字的表达式返回值为布尔值。如果返回值为true，说明myobject对象为 ExampleClass的实例对象;如果返回值为false，说明myobject对象不是ExampleClass的实例对象。
误区警示
instanceof是Java语言的关键字，Java 语言中的关键字都为小写。

在运行这道题前，会报错，因为四边形类与圆形类没有继承关系，所以不能用关键词，正确结果如下

1. false

2. ture

7.5    方法的重载    
在第6章中我们曾学习过构造方法，知道构造方法的名称由类名决定，所以构造方法只有一个名称。如果希望以不同的方式来实例化对象，就需要使用多个构造方法来完成。由于这些构造方法都需要根据类名进行命名，为了让方法名相同而形参不同的构造方法同时存在，必须用到方法重载。虽然方法重载起源于构造方法，但它也可以应用到其他方法中。本节将讲述方法的重载。
方法的重载就是在同一个类中允许存在一个以上的同名方法，只要这些方法的参数个数或类型不同即可。为了更好地解释重载，来看下面的实例。

运行结果如下:
调用add(int,int)方法:3
调用add(doubledouble)方法:5.4调用add(int)方法:1
调用add(int,double)方法:5调用add(doubleint)方法:8

在本实例中分别定义了5个方法，在这5个方法中，前两个方法的参数类型不同，并且方法的返回值类型也不同，所以这两个方法构成重载关系;前两个方法与第3个方法相比，第3个方法的参个数少于前两个方法，所以这3个方法也构成了重载关系;最后两个方法相比，发现除了参数的出顺序不同，其他都相同，同样构成了重载关系。

参数个数可以确定两个方法是否具有重载关系时，会想到定义不定长参数方法。不定长方法的语法如下:
返回值 方法名(参数数据类型…参数名称)
如果将上述代码放在例7.8 中，关键代码如例 7.9所示。

调用add(int,int)方法:3
调用add(doubledouble)方法:5.4
调用add(int)方法:1
调用add(intdouble)方法:5
调用add(double,int)方法:8
调用不定长参数方法:45
调用不定长参数方法:1

在上述实例中，在参数列表中使用“…”形式定义不定长参数，其实这个不定长参数a就是一数组，编译器会将“int…a”这种形式看作是“int]a”，所以在add方法体做累加操作时使用到了循环语句，在循环中是根据数组a的长度作为循环条件的，最后将累加结果返回。

7.6final关键字
final被翻译为最后的，最终的，final是Java关键字，凡是被final关键字修饰过的内容都是不可改变的。

7.6.1final变量
final关键字可用于变量明，一旦该变量被设定，就不可以再改变该变量的值。通常，由finalg义的变量为常量。例如，在类中定义PI值，可以使用如下语句:

final double P/=3.14;
当在程序中使用到PI这个常量时，它的值就是3.14。如果在程中再次对定义为final的常量赋值编译器将不会接受。
final关键字定义的变量必须在声明时对其进行赋值操作。final除了可以修饰基本数据类型的常量还可以修饰对象引用。由于数组也可以被看作一个对象来引用，所以final可以修饰数组。一旦一个对象引用被修饰为final后,它就只能恒定指向一个对象,无法将其改变以指向另一个对象。一个既是stat又是final的字段只占据一段不能改变的存储空间。为了深入了解 final 关键字，来看下面的实例。

7.6.2 final 方法
将方法定义为 final类型，可以防止子类修改父类的定义与实现方式，同时定义为final的方法的执行效率要高于非final方法。在修饰权限中曾经提到过private修饰符，如果一个父类的某个方法被设置为private，子类将无法访问该方法，自然无法覆盖该方法。也就是说，一个定义为private的方法隐式被指定为final类型，因此无须将一个定义为private的方法再定义为final类型。例如下面的语句:

1. private final void test(){

2. …//省略一些程序代码}

   本实例在运行之前，Eclipse 就会报出如图 7.8所示的编译错误。因为打开电视这个方法是由final修饰 的，子类无法重写。所以 Baby 想要打开电视，就只能找爸爸来打开了。

   7.6.3final类
   定义为final的类不能被继承。如果希望一个类不被任何类继承，并且不允许其他人对这个类进行任何改动，可以将这个类设置为final类。final 类的语法如下:
   final 类名{}

   如果将某个类设置为final类，则该类中的所有方法都被隐式设置为final方法，但是final类中的成员变量可以被定义为final或非final形式。

   7.7多态
   利用多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理。在7.3节中已经习过子类对象可以作为父类的对象实例使用，这种将子类对象视为父类对象的做法称为“向上转假如现在要编写一个绘制图形的方法draw，如果传入正方形对象就绘制正方形，如果传入圆对象就绘制圆形，这种场景可以使用重载来实现，定义如下:

   public void draw(Square s){    //绘制正方形的方法    
   public void draw(Circular c){    //绘制圆形的方法    
   但是这种写法有个问题:正方形和圆形都是图形，这场景细分的重载方式不仅增加了代码量，还降低了“易用度”。如果定义一个图形类，让它处理所有继承该类的对象，根据“向上转型”原则可以使每个继承图形类的对象作为draw方法的参数，然后在draw方法中做一些限定就可以根据不同图形类对象绘制相应的图形。这样处理能够很好地解决代码冗余问题，同时程序也易于维护。

   

   运行结果如下:绘制父类图形
   绘制正方形
   绘制圆形

3. 从本实例的运行结果中可以看出，以不同类对象为参数调用draw0方法，可以处理不同的图形绘制问题。使用多态节省了开发和维护时间，因为程序员无须在所有的子类中定义执行相同功能的方法，避免了大量重复代码的编写。同时，只要实例化一个继承父类的子类对象，即可调用相应的方法，如果需求发生了变更，只需要维护一个draw()方法即可。

   Java语言每一个类只能继承一个父类

   子类  父类  祖父类

   继承 extends

   父类 和普通类写法相同

   public class 父类类名{
   }

   子类 需要继承父类

   public class 子类类名 extends 父类类名{
   }

   所有类的构造方法第一行都有一个隐藏的“super（）；”

   作用是在执行该构造方法之前调用其父类构造方法

   object类

   方法的重写

   返回参数相同 方法名相同  传入参数相同  方法体不同

   向上转型：将子类对象赋值给父类引用（需要进行自动类型转换）

   animal a=new  dog

   向下转型：将父类对象赋值给子类引用（需要进行强制类型转换）

   dog a=(dog) new animal

   方法的重载

   方法名相同  参数不同 

   final

   final修饰变量----常量

   final修饰方法----不可以被重写

   final修饰类-------不可以被继承 

   instanceof

   对象名 instanceof 类名   

   判断该对象是否属于该类或其子类
   欸嘿！