学Java必备的知识--类的重用

朱雀 2020-05-12 14:42 994阅读 0赞

# 类继承的概念和语法

## 类继承的概念

- 根据已有类来定义新类,新类拥有已有类的所有功能。
- Java只支持类的单继承,每个子类只能有一一个直接超类（父类）。
- 超类是所有子类的公共属性及方法的集合，子类则是超类的特殊化。
- 继承机制可以提高程序的抽象程度，提高代码的可重用性。
- 超类和子类
  子类对象与超类对象存在“是一个…”或“是一种…”的关系。
- 子类对象
  - - 从外部来看,它应该包括
      - 与超类相同的接口
      - 可以具有更多的方法和数据成员
    - 其内包含着超类的所有变量和方法
  - 继承的语法

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

- 类继承举例
  设有三个类: Person（人）, Employee（员工）,Manager（管理人员）。很明显：Person是范围最广的一个，Employee次之，Manager的范围最小，其类层次如图:

![](/images/1589294535233.png)

有如下代码：
`Preson.java`

```java
public class Person {
    public String name;
    public String getName() {
    return name;
    }
}
```

``Employee.java``

```java
public class Employee extends Person {
    public int employeeNumber;
    public int getEmployeeNumber() {
        return employeeNumber;
    }
}
```

``Manager.java ``

```java
public class Manager extends Employee {
    public String responsibilities;
    public String getResponsibilities() {
        return responsibilities;
    }
}
```

可以看出Employee（员工）是一种特殊的Person（人），所以Employee继承于Person类。而Manager（管理人员）是一种特殊的Employee（员工），所以Manager继承于Employee类。
下面为测试类：

```java
public class Test {
    public static void main(String args[]){
        Employee li = new Employee();
        li.name = "Li Ming";
        li.employeeNumber = 123456;
        System.out.println(li.getName());
        System.out.println(li.getEmployeeNumber());
        Manager he = new Manager();
        he.name = "He Xia";
        he.employeeNumber = 543469;
        he.responsibilities = "Internet project" ;
        System.out.println(he.getName());
        System.out.println(he.getEmployeeNumber());
        System.out.println(he.getResponsibilities());
    } 
}

```

类中定义了一个`Employee`类`li`,输出`li`的名字和编号
一个`Manager`类`he`,输出`he`的名字，编号和职责。

运行结果：
![](/images/1589294505360.png)

## 属性的隐藏

有以下代码：

```java
class Parent {
	Number aNumber;
}
```

```java
class Child extends Parent
	Float aNumber;
}
```

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

- 从超类继承的变量将被隐藏
- 子类拥有了两个相同名字的变量，一个继承自超类,另-一个由自己声明
- 当子类执行继承自超类的操作时,处理的是继承自超类的变量，而当子类执行它自己声明的方法时，所操作的就是它自己声明的变量

**那么如果子类想要访问被隐藏的属性该怎么办？**

- 访问被隐藏的超类属性调用从超类继承的方法,则操作的是从超类继承的属性
- 本类中声明的方法使用"super.属性”访问从超类继承的属性

假设有两个类A1和B1

```java
class A1{ 
   int x= 2;
   public void setx(int i){ 
       x=i;
   }
   void printa(){
       System.out.println(x);
   }
}

class B1 extends A1 { 
   int x=100;
   void printb(){ 
       super.x = super.x +10 ;
       System.out.println("super.x=" +
       super.x+" x=" + x); 
   }
}
```

之后运行测试代码：

```java
public class Test {
    public static void main(String args[]){
        A1 a1=new A1();
        a1.setx(4);
        a1.printa();
        
        B1 b1 = new B1();
        b1.printb();
        b1.printa();
         
        b1.setx(6); // 将继承x值设置为6
        b1.printb(); 
        b1.printa();
         
        a1.printa();
    } 
}
```

运行结果：
![](/images/1589294467559.png)

## 方法覆盖

- 如果子类不需使用从超类继承来的方法的功能,则可以声明自己的同名方法,称为方法覆盖
- 覆盖方法的返回类型,方法名称,参数的个数及类型必须和被覆盖的方法一模一样
- 只需在方法名前面使用不同的类名或不同类的对象名即可区分覆盖方
  法和被覆盖方法
- 覆盖方法的访问权限可以比被覆盖的宽松，但是不能更为严格
- 方法覆盖的应用场合
  - 子类中实现与超类相同的功能,但采用不同的算法或公式;
  - 在名字相同的方法中,要做比超类更多的事情;
  - 在子类中需要取消从超类继承的方法。
- 方法覆盖的注意事项：
  - 必须覆盖的方法
    - 派生类必须覆盖基类中的抽象的方法,否则派生类自身也成为抽象类.
  - 不能覆盖的方法
    - 基类中声明为final的终结方法基类中声明为static的静态方法
  - 调用被覆盖的方法
    - super.overriddenMethodName();

# Object类

- 所有类的直接或间接超类,处在类层次最高点;
- 包含了所有Java类的公共属性。

## Object类的主要方法

- public final Class getClass(）
  获取当前对象所属的类信息,返回Class对象。
- public String toStringO
  返回表示当前对象本身有关信息的字符串对象。
- public boolean equals(Object obj)
  比较两个对象引用是否指向同一对象，是则返回true ,否则返回false。
- protected Object clone()
  复制当前对象，并返回这个副本。
- public int hashCode(）
  返回该对象的哈希代码值。
- protected void finalize() throws Throwable
  在对象被回收时执行，通常完成的资源释放工作。

# 终结类与终结方法

- 用final修饰的类和方法;
- 终结类不能被继承;
- 终结方法不能被子类覆盖。

# 抽象类

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

```java
abstract class Number {
}
```

如果写`new Number()`将会编译错误。

## 抽象方法

- 声明的语法形式为:

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

- 仅有方法原型,而没有方法体;
- 抽象方法的具体实现由子类在它们各自的类声明中完成;
- 只有抽象类可以包含抽象方法。

## 抽象方法的优点

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

# 类的组合

- 组合的语法
  - 将已存在类的对象放到新类中即可
  - 例如，可以说"厨房( kitchen)里有一个炉子( cooker )和一一个冰箱( refrigerator )”。所以,可简单的把对象myCooker和myRefrigerator放在类Kitchen中:

```java
class Cooker{  类的语句}
class Refrigerator{  类的语句}
class Kitchen{
	Cooker myCooker;
	Refrigerator myRefrigerator;
}
```

例：组合举例——线段类

- 一条线段包含两个端点

```java
public class Point //点类
{
	private int x, y; //coordinate
	public Point(int x, int y){ this.x = x; this.y = y;}
	public int GetX() { return x; }
	public int GetY( { return y; }
}
```

```java
class Line //线段类
{
	private Point p1,p2; // 两端点
	Line(Point a, Point b) {
		p1 = new Point(a.GetX(),a.GetY());
		p2 = new Point(b.GetX(),b.GetY());
	}
	public double Length() {
		return Math.sqrt(Math.pow(p2.GetX(-p1.GetX0,2)
		+ Math.pow(p2.GetY0)-p1.GetY0.2));
	}
}
```

一个线段类包含两个端点，也就是组合了两个点类。