Java第七章总结

7.1类的继承

继承在面向对象开发思想中是一个非常重要概念，它使整个程序构架具有一定的弹性。

在Java语言每个类只能继承一个父类。一个类继承另一个需要使用关键字extends,关键字extends的使用方法如下：

class Child extends Parent{}

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

class Child extends Parent1,Parent2{} 

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

子类——父类——祖父类
继承：extends
父类：和平常类写法一样public class 父类类名{}子类：public class子类类名 extends 父类类名{}
子类继承父类后，调用后同时会进行子类和父类打印

例题7.1创建类对象

代码如下：

 运行结果如下:

子类继承父类之后可以调用父类创建好的属性和方法

例题7.1文字描述：创建父类和子类，调用构造方法

例题7.2

在电话基础上衍生出手机类

例题7.2文字描述

public class Telephone {   //电话类    
  String button=\"button:0~9\";  //成员属性
   void call() {   //拨打电话功能          System.out.println(\"开始拨打电话\");//输出        }}public class Telephonechild extends Telephone{    //手机继承电话类
 String screen=\"screen：液晶屏\"; //成员属性液晶屏幕 }public class Demo2 {
  public static void main(String[] args) {        // TODO Auto-generated method stub     Telephonechild motto=new Telephonechild();    System.out.println(motto.button);  //子类调用父类属性
  System.out.println(motto.screen);  //子类调用父类没有的属性
      motto.call();//子类调用父类的方法 }}\n\n在所有类的构造方法第一行都有隐藏super ：在执行构造方法之前调用其父类的构造方法

7.3子类Moblic 类仅创建了一个显示屏属性，剩余的其他属性和方法

继承和多态是面向对象中非常重要的一组概念。

所有类的构造第一行都有一个隐藏的”super()；"

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

重写

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

方法的重载

方法名相同 参数不同

代码如下：

运行结果：

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

void add (int a, int b) {

}

void add (int b, int a) {

}

extends 继承

父类 写法与普通写法相同

public class 父类类目（）{

}

子类

public class 子类类名 extends

                                                                  

 Object类

Object类是比较特殊的类，它是所有类的父类，是Java类层中的最高层类。

用户创建一个类是

equals（）方法

有两种比较对象方式，分别为”==“运算符与equals()方法。

代码如下：

 运行结果如下：

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

 对象类型的转换
 Dog a=new Animal ();
向上转型将子类对象赋值给父类引用
自动类型转换Animal a=new  Dog ();子类重写父类的方法强制性转换
注意：两个没有继承关系的对象不可以进行向上转型或者向下转型
父类对象可以强制转换为子类对象，但有一个前提：这个父类对象要先引用这个子类的对象

使用instanceof关键字判断对象类型
语法格式为：myobject instanceof ExampleClass
myobject：某类的对象引用ExampleClass：

某个类误区警示：
imstanceof是java语言的关键字，java语言中的关键字都为小字
对象名  instanceof  类名
判断该对象是否属于这

向上转型:子类对象赋值给转父类的引用

Animal a = new Dog();

自动类型转换

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

例题7.5，tom是谁?

使用向上转型模拟场景：

 

 在上述代码中，“People tom =new Teacher();”运用向上转型的语法，因为人类(People)是教师（Teachar)父类，所以通过向上转型，能够把教师类（Teachar)类型的对象(new Teachar();)直接赋值给人类(People)类型的变量(tom)。也就是说，进行向上转型，父类类型的对象可以引用子类类型的对象。例如可以说平行四边形是四边形，但不能说四边形是平行四边形。

使用向上转型的过程中，父类的对象是否可以调用子类独特有的属性或者方法，例如四边形类是平行四边形的父类，用Ouadrangle表示四边形类，定义一个值为4的表示底边长度的变量

向下转型：父类对象 赋值给转子类引用

Dog a = (Dog) new Animal();

强制类型转换

向下转型可以被理解为将父类的对象转换为子类类型的对象 。但是，运用向下转型，如果把一个较抽象的类的对象转换为一个较具体的对象，这样的转型通常会出现错误，例如，可以说某只鸟和鸽子。

例题7.6谁是鸽子？

class Bird{}

class Pigeon extends Bird{}

public static void main (String[]args){

Bird bird = new Pigeon();                //某只鸽子是一只鸟

Pigeon pigeon - bird;                       //某只鸟是一只鸽子

}

        }

 本例在运行之前，会报错误

如果想要告诉编译器“某只鸟就是一只鸽子”，语法如下：

子类类型 子类类型=(子类类型）=父类对象； 

想要实现把鸟类对象转换为鸽子类对象修改代码为：

Pigeon pigeon=(Pigeon)bird;            //通过强制类型转换，告诉编译器“某只鸟就是一只鸽子” 

不定义长参数

代码如下：

 运行结果如下：

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

大写转小写  定义一个值为66的整数，编写两个名字的print()方法，一个方法用于

 final关键字

final被译为“最后的”“最终的”，final是Java语言中的一个关键字，凡是被fianl关键字修饰过的内容都是不可改变的。

7.6.1final变量

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

final double PI =3.14;

当在程序中使用PI这个常量时，它的值就是3.14.如果在程序中再次对定义为final的常量赋值，编译器将不会接受。

final关键字定义的变量必须在声明时对其进行赋值操作。final除了可以修饰基本数据类型的常量，还可以修饰对象引用。由于数组也可以被看作一个对象来引用，所以final可以修饰数组。一旦一个对象引用被修饰为final后，它就只能恒定指向一个对象，无法将其改变以指向另一个对象。一个即是static又是一个final的字段只占据一段不能改变的存储空间。

下面实例例题7.10 代码如下：

本实例在运行之前，Eclipse就会报出错误，常量PI不允许被修改。

7.6.2final方法

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

例如下面的语句：

private final void test()

例题7.11代码使用final关键字为电视上儿童锁

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

final 修饰变量——不能被改变（常量）

final修饰方法——不能被重写

final修饰类——不能被继承

instanceof

对象名  instanceof  类名

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

7.6.3final类

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

final 类名{}

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

例如，已知JDK中的Java.lang包下的Math数学类和String字符串类都是由final关键字修饰的类，这两个类就无法做任何类的父类，如果这两个类出现在extends右侧就会发生编译错误，如图7.9所示

7.4使用instanceof关键字判断对象类型

当在程序中执行向下转型操作时，如果父类对象不是子类对象的实例，就会发生ClassCastException异常，所以在执行向下转型之前需要养成一个良好的习惯，就是判断父类对象是否子类对象的实例。这个判断通常使用instanceof关键字来完成。可以使用insetance关键字判断是否一个类实现某个接口，实例对象是否属于一个类。

insetanceof的语法格式如下：

myobject instanceof ExampleClass

使用instanceof 关键字的表达式返回值为布尔值。如果返回值为ture,说明myobject对象为ExampleClass的实例对象；如果返回值为false,说明myobject对象不是ExampleClass的实例对象。

误区警示：instanceof是Java语言的关键字，Java语言中的关键字都为小写。 

7.7 多态

利用多态可以使用程序具有良好的扩展性，并可以对所有类对象进行通用的处理。

通过子类对象可以作为父类的对象实例使用，这种将子类对象视为父类对象的做法称为：“向上转型”。

假如现在要编写一个绘制图形的方法draw(),如果传入正方形对象就绘制正方形，如果传入圆形对象就绘制圆形，这种场景可以使用重裁来实现，定义如下：

public void draw(Square s){      //绘制正方形的方法

}

public void raw(Circular c){      //绘制圆形的方法

}

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

例题【7.12】万能的绘制方法

创建Shape图形类，作为Square 正方形类和Circular圆形的父类。代码如下：

运行结果如下： 

 运行结果如下：

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

7.8 抽象类与接口

7.8.1抽象类

在解决实际问题时，一般将父类定义为抽象类，需要使用这个父类进行继承与多态处理。

回想多态与继承原理，继承树中越是上方的类越抽象，如鸽子类继承鸟类，鸟类继承动物类等。在多态机制中，并不需要将父类初始化为对象，我们需要的只是子类对象，所以Java语言中设置抽象类不可以实例化为对象。

使用abstart关键字定义的类称为抽象类，而使用这个关键字定义的方法称为抽象方法。抽象方法没有方法体，这个方法本身没有任何意义，除非它被重写，而继承这个抽象方法的抽象类必须被继承。实际上抽象类除了被继承没有任何意义。定义抽象类的语法如下：

public abstarct class Parent{
abstarct void testAbstarct();                //定义抽象方法

}

反过来，如果声明一个抽象方法，就必须将继承载这个抽象方法的类定义为抽象类，不能在非抽象类中获取抽象方法。换句话说就是只要类中有一个抽象方法，此类就被标记为抽象类。

抽象类被继承后需要实现其中所有的抽象方法，也就是保证以相同的方法名称，参数列表和返回值类型创建出非抽象方法，继承抽象类的所有子类修改为抽象类，将draw()方法设置为抽象方法，然后每个子类都重写这个方法来处理。但又这会出现太多的成余的代码，同时这样的父类局限性很大，也许某个不需要draw()方法放置在另一个类中，让那些需要draw()方法的类继承该类，不需要draw()方法的类继承图形类，又产生新的问题：所有的子类都需要继承图形类，因为这些类都是从图形中导出，同时某些类还需要draw()方法，而Java中规定类不能同时继承多个父类 

public abstract void methodName();

抽象类 有抽象方法的类一定是抽象类 

修饰符  abstract class 类名{
}

7.8.2接口
接口是抽象类的延申，可以将它看作是纯碎的抽象类，接口中的所有方法都没有方法体。

将draw()方法封装到一个接口中，使需要draw()方法的类实现这个接口，同时也继承图形类，这就是接口存在的必要性。描述了各个子类继承图形类后使用接口的关系。

接口使用interface关键字进行定义，其语法如下：

public interface Paintable {
void draw();                                //定义接口方法可省略public abstract 关键字

}

 >public:接口可以像类一样被权限修饰符修饰，但public关键字仅权限于接口用于接口在与其同名的文件被定义。

一个类继承一个父类的同时再实现一个接口，可以写成如下形式：

public class Parallelogram extends Quadrangle implements Paintable 

.....

}

在接口中，方法必须被定义为public或abstart形式，其他修饰权限不被Java编译器认可，或者说，即使不该将方法声明为public形式，它也是public形式。

 在接口中定义的任何字段都自动是static 和final的。

例题【7.13】将绘制方法设为接口方法。

 运行结果如下：

  从这个结果可以看出，“绘制”这个行为可不是四边形独有的，圆形也能绘制，所以draw()方法被独立封装在可绘制接口中。正方形类与平行四边形分别继承了四边形类并实现了可绘制接口，所以正方形与平行四边形类既可以调用绘制方法，又可以调用四边形提供的doAnything()方法。但是，圆形不属于四边形，且可以会绘制，所以最后圆形对象只调用了draw()方法。

Java中不允许出现多重继承，但使用接口就可以实现多重继承。一个类可以同时实现多个接口，因此可以将所有需要继承的接口放置在implements关键字后并使用逗号隔开。实现多个接口的语法如下：

class 类名 implements 接口1，接口2，...,接口n

但这可能会在一个类中产生庞大的代码量，因为继承一个接口时需要有一个抽象的生产方法。一个接口可以继承另一个接口，语法如下：

interface intf1 {}

interface intf {}                //接口继承接口
 

本实例中，正方形类与平行四边形类分别实现了drawTest接口，所以需要覆盖接口中的方法。在调用draw()方法时，首先将平行四边形类对象与正方形类对象向上转型为drawTest接口形式。这里也许很多读者会有疑问，接口是否可以向上转型?其实在Java 中无论是将一个类向上转型为父类对象，还是向上转型为抽象父类对象，或者向上转型为该类实现接口，都是没有问题的。然后使用d[i]数组中的每一个对象调用draw()， 由于向上转型，所以d[i]数组中的每一个对象分别代表正方形类对象与平行四边形类对象，最后结果分别调用正方形类与平行四边形类中覆盖的draw()方法。