【Java程序设计】类的重用

类的重用

一、类的继承

• 充分重用已有的设计和实现，在已有类的基础上设计新的类
• 继承已有类的全部属性和行为，在此基础上改造、扩展

(1)类继承的定义

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

• 根据已有类来定义新类，新类拥有已有类的所有功能
• Java只支持类的单继承，每个子类只能有一个直接超类
• 超类是所有子类的公共属性及方法的集合，子类则是超类的特殊化
• 继承机制可以提高程序的抽象程度，提高代码的可重用性

(2)超类和子类

1.子类拥有父类非 private 的属性、方法。

2.子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

3.子类可以用自己的方式实现父类的方法。

子类对象与超类对象存在“是一个…”(或“是一种…”)的关系

超类(superclass)

• 也称基类(base class)
• 是被直接或间接继承的类

子类 (subclass)

• 也称派生类(derived-class)
• 继承其他类而得到的类
• 继承所有祖先的状态和行为
• 派生类可以增加变量和方法
• 派生类也可以覆盖(override)继承的方法

(3)继承的语法

[ClassModifier] class ClassName extends SuperClassName
{ 
	//类体
}

(4)继承类型

Java 不支持多继承，但支持多重继承:

(5)隐藏和覆盖

1.属性的隐藏

子类中声明了与超类中相同的成员变量名

• 从超类继承的变量将被隐藏
• 子类拥有了两个相同名字的变量，一个继承自超类，另一个由自己声明
• 当子类执行继承自超类的操作时，处理的是继承自超类的变量，而当子类执行它自己声明的方法时，所操作的就是它自己声明的变量
• 本类中声明的方法使用“super.属性”访问从超类继承的属性

2.方法的覆盖

方法覆盖定义：

• 如果子类不需使用从超类继承来的方法的功能，则可以声明自己的同名方法，称为方法覆盖
• 覆盖方法的返回类型，方法名称，参数的个数及类型必须和被覆盖的方法一样
• 只需在方法名前面使用不同的类名或不同类的对象名即可区分覆盖方法和被覆盖方法
• 覆盖方法的访问权限可以比被覆盖的宽松，但是不能更为严格

方法覆盖的应用场合：

• 子类中实现与超类相同的功能，但采用不同的算法或公式 ；
• 在名字相同的方法中，要做比超类更多的事情 ；
• 在子类中需要取消从超类继承的方法。

方法覆盖的注意事项：

• 必须覆盖的方法：派生类必须覆盖基类中的抽象的方法，否则派生类自身也成为抽象类.

• 不能覆盖的方法
  ▫ 基类中声明为final的终结方法
  ▫ 基类中声明为static 的静态方法

• 调用被覆盖的方法

  super.overriddenMethodName();
  

(6)子类的构造方法

• 子类不能从超类继承构造方法
• 最好在子类的构造方法中使用super关键字显式调用超类的某个构造方法，调用语句必须出现在子类构造方法的第一行。
• 如子类构造方法体中没有显式调用超类构造方法，则系统在执行子类的构造方法时会自动调用超类的默认构造方法（即无参的构造方法）

二、Object类

• 所有Java类的直接或间接超类。
• 如果一个类没有继承任何超类，那么就隐含直接继承了Object类

(1)Java Object 类

Java Object 类是所有类的父类，也就是说 Java 的所有类都继承了 Object，子类可以使用 Object 的所有方法

Object 类位于 java.lang 包中，编译时会自动导入，我们创建一个类时，如果没有明确继承一个父类，那么它就会自动继承 Object，成为 Object 的子类。

Object 类可以显示继承，也可以隐式继承：

• 显示继承:

  public class Runoob extends Object{
  
  }
  

• 隐式继承:

  public class Runoob {
  
  }
  

(2)Object类的主要方法

clone()

protected Object clone()

Object clone() 方法用于创建并返回一个对象的拷贝。
clone 方法是浅拷贝，对象内属性引用的对象只会拷贝引用地址，而不会将引用的对象重新分配内存。

equals()

boolean equals(Object obj)

equals() 方法比较两个对象，是判断两个对象引用指向的是同一个对象，即比较 2 个对象的内存地址是否相等

如果子类重写了 equals() 方法，就需要重写 hashCode() 方法。

finalize()

protected void finalize()

Object finalize() 方法用于实例被垃圾回收器回收的时触发的操作。

当 GC (垃圾回收器) 确定不存在对该对象的有更多引用时，对象的垃圾回收器就会调用这个方法。

hashCode()

int hashCode()

Object hashCode() 方法用于获取对象的 hash 值。
hashCode是一个返回对象散列码的方法，该方法实现的一般规定是：

• 在一个Java程序的一次执行过程中，如果对象“相等比较”所使用的信息没有被修改的话，同一对象执行hashCode方法每次都应返回同一个整数。在不同的执行中，对象的hashCode方法返回值不必一致。
• 如果依照equals方法两个对象是相等的，则在这两个对象上调用hashCode方法应该返回同
  样的整数结果。
• 如果依据equals方法两个对象不相等，并不要求在这两个对象上调用hashCode方法返回值
  不同。

toString()

String toString()

Object toString() 方法用于返回对象的字符串表示形式。

getClass()

object.getClass()

• final 方法，返回一个Class对象，用来代表对象所属的类。
• 通过Class 对象，可以查询类的各种信息：比如名字、超类、实现接口的名字等。

三、终结类与终结方法

• 有些类，或类的方法从安全的角度或者算法的角度不希望被修改，就可以设为终结类、终结方法
• 终结类不可以被继承（扩展）
• 终结方法不可以被覆盖

用final修饰的类和方法；

• 终结类不能被继承

  public final class Test {
     // 类体
  }
  

• 终结方法不能被子类覆盖

  public class Test{
      public final void changeName(){
         // 方法体
      }
  }
  

四、抽象类与抽象方法

• 代表一个抽象概念的类；
• 规定整个类家族都必须具备的属性和行为。

(1)抽象类

abstract class ClassName {
. . .
}

• 类名前加修饰符abstract；
• 可包含常规类能包含的任何成员，包括非抽象方法；
• 也可包含抽象方法：用abstract修饰，只有方法原型，没有方法的实现；
• 没有具体实例对象的类，不能使用new方法进行实例化，只能用作超类；
• 只有当子类实现了抽象超类中的所有抽象方法，子类才不是抽象类，才能产生实例；
• 如果子类中仍有抽象方法未实现，则子类也只能是抽象类。

(2)抽象方法

规定子类应该具有的行为，但在抽象超类中尚不能实现的方法，可以声明为抽象方法。

• 声明的语法形式为：

  public abstract <returnType> <methodName>(...);
  

• 仅有方法原型，而没有方法体；

• 抽象方法的具体实现由子类在它们各自的类声明中完成；

• 只有抽象类可以包含抽象方法。

抽象方法的优点

• 隐藏具体的细节信息，所有的子类使用的都是相同的方法原型，其中包含了调用该方法时需要了解的全部信息；
• 强迫子类完成指定的行为，规定所有子类的“标准”行为。

五、泛型

• 不仅数据可以作为参数，类型也可以作为参数。
• 使用类型参数，可以使程序更为通用，适用于处理不同类型的数据

• 泛型的本质是参数化类型，即所操作的数据类型被指定为一个参数；
• 可以声明泛型类、泛型方法和泛型接口。

(1)泛型类、泛型方法定义

• 泛型类

  class GeneralType <Type...> {
  	Type object;
  	public GeneralType(Type object) {
  		this.object = object;
  	}
  	public Type getObj() {
  		return object;
  	} 
  }
  

• 泛型方法

  <Type...> void funname(Type object) {
  	...
  } 
  

(2)有限制的泛型

• 虽然可以使用泛型使程序能够处理多种不同类型对象，并不是所有对象都能进行某些操作；
• 有时候需要将泛型中参数代表的类型做限制，此时就可以使用有限制的泛型。

在参数“Type”后面使用“extends”关键字并加上类名或接口名，表明参数所代表的类型必须是该类的子类或者实现了该接口。
注意，对于实现了某接口的有限制泛型，也是使用extends关键字，而不是implements关键字

六、类的组合

• 组合是另一种类重用机制——部件组装的思想
• 在声明一个新的类时，用已有类的对象作为成员

• 面向对象的程序用软件对象来模仿现实世界的对象：

• 现实世界中，大多数对象由更小的对象组成；
• 与现实世界的对象一样，软件中的对象也常常是由更小的对象组成。

• Java的类中可以有其他类的对象作为成员，这便是类的组合。

• 组合也是一种重用机制，可以使用“有一个” 来描述这种关系。

组合与继承的比较：

• “包含”关系用组合来表达

• “属于”关系用继承来表达