java基础-继承

最新推荐文章于 2024-10-03 19:13:18 发布

朱佳丽1840

最新推荐文章于 2024-10-03 19:13:18 发布

阅读量148

点赞数

分类专栏： java核心技术卷一读后感

本文链接：https://blog.youkuaiyun.com/qq_23962427/article/details/84825025

版权

java核心技术卷一读后感专栏收录该内容

7 篇文章

订阅专栏

1、类、超类和子类

a、回忆一下super和this关键字的使用：

b、多态

c、警告：在 Java 中，子类数组的引用可以转换成超类数组的引用，而不需要采用强制类型转换。

1、类、超类和子类

继承是一个"is-a"关系是继承的一个明显特征。每一个经理是一个雇员 Manager extends Employee。Manager 称为superclass，base class or parent class；Employee named by subclass，derived class or child class。 However，superclass and subclass is an usual saying。

a、回忆一下super和this关键字的使用：

this：一是引用隐式参数，二是调用该类其他的构造器。同样，super 关键字也有两个用途：一是调用超类的方法，二是调用超类的构造器。在调用构造器的时候，这两个关键字的使用方式很相似。调用构造器的语句只能作为另一个构造器的第一条语句出现。

b、多态

e 引用 Employee 对象时， e.getSalary( ) 调用的是 Employee 类中的 getSalary 方法；当
e 引用 Manager 对象时，e.getSalary( ) 调用的是 Manager 类中的 getSalary 方法。虚拟机知道
e 实际引用的对象类型，因此能够正确地调用相应的方法。
一个对象变量（例如，变量 e ) 可以指示多种实际类型的现象被称为多态（ polymorphism)。

Employee[] staff = new Employee[3];
Manager boss = new Manager();
staff[0] = boss;

注意：不能将一个超类的引用赋给子类变量。例如，下面的赋值是非法的

c、警告：在 Java 中，子类数组的引用可以转换成超类数组的引用，而不需要采用强制类型转换。

Manager[] managers = new Manager[10];
将它转换成 Employee[] 数组完全是合法的：
EmployeeQ staff = managers; // OK

staff[0] = new Employee("Harry Hacker", . . .);//ok
//编译器竟然接纳了这个赋值操作。但在这里， stafflO] 与 manager[0] 引用的是同一个
对象， 似乎我们把一个普通雇员擅自归入经理行列中了。 这是一种很忌伟发生的情形，
当调用 managers[0].setBonus(500) 的时候， 将会导致调用一个不存在的实例域， 进而搅
乱相邻存储空间的内容。为了确保不发生这类错误,例如， 使用 new managers[10] 创建的数组是一个经理
数组。如果试图存储一个 Employee 类型的引用就会引发 ArrayStoreException 异常。

d、编译器调用方法的顺序

step1：编译器查看对象的声明类型和方法名。比如调用manager.getBouns()，编译器会获取到manager类的以及超类的所有的getBouns（）所有可能被调用的候选方法（根据方法名匹配）。

step2：接下来，编译器将查看调用方法时提供的参数类型，匹配一个方法，this progress is overloading resolution。注意：如果发现超过2个以上的方法与之匹配，就会报告一个错误。

step3：如果是private方法、static方法、final方法或者构造器，那么编译器将可以准确知道调用那个方法。这种调用方式为static binding。在我们列举的示例中，编译器采用动态绑定的方式生成一条调用f(String)的指令。

step4：当程序运行，并且采用动态绑定调用方法时，虚拟机一定调用这个方法所引用对象的实际类型最合适的类（这个类以及超类中）进行调用。

每次调用方法都要进行搜索，时间开销相当大。因此，虚拟机预先为每个类创建了一个方法表（method table), 其中列出了所有方法的签名和实际调用的方法。这样一来，在真正调用方法的时候，虚拟机仅查找这个表就行了。

在运行时，调用 e.getSalary()的解析过程为：
1 ) 首先，虚拟机提取 e 的实际类型的方法表。既可能是 Employee、 Manager 的方法表，也可能是 Employee 类的其他子类的方法表。
2 ) 接下来，虚拟机搜索定义 getSalary 签名的类。此时，虚拟机已经知道应该调用哪个方法。
3 ) 最后，虚拟机调用方法。
动态绑定有一个非常重要的特性：无需对现存的代码进行修改，就可以对程序进行扩展。假设增加一个新类 Executive, 并且变量 e 有可能引用这个类的对象，我们不需要对包含调用e.getSalary() 的代码进行重新编译。如果 e 恰好引用一个 Executive 类的对象，就会自动地调用 Executive.getSalary(）方法。

警告：在覆盖一个方法的时候，子类方法不能低于超类方法的可见性。

e、阻止继承的final类和方法

将方法或类声明为 final 主要目的是：确保它们不会在子类中改变语义。例如， Calendar类中的 getTime 和 setTime 方法都声明为 final。String 类也是 final 类，这意味着不允许任何人定义 String 的子类。换言之，如果有一个 String 的引用，它引用的一定是一个 String 对象，而不可能是其他类的对象。

假设有希望阻止人们定义Executive类的子类时候:

public final class Excutive extends manager{

}

类中的特定的方法也可以被声明为final。如果这样做，子类就不能override这个方法。

public class Employee{
    private String name;
    public final String getName(){
        return name;
    }
}

f、强制类型转换

这个包括了数据类型的转换以及对象之间的转换。

Manager boss = （Manager）staff[1];//error
/*运行这个程序时，java运行时系统会产生一个ClassCastException异常。可以用下面的代码进行判断是否可以进行类型的转换。*/
if(staff[1] instance of Manager){
    boss = (Manager) staff[1];
    ...
}

综上所述：

只能在继承层次内进行类型转换
在将超类转换成子类之前，应该使用instance of 进行检查。

g、受保护访问

Java 用于控制可见性的 4 个访问修饰符：
1 ) 仅对本类可见 private。
2 ) 对所有类可见 public：
3 ) 对本包和所有子类可见 protected。
4 ) 对本包可见—默认（很遗憾，) 不需要修饰符。

注意：要谨慎使用 protected 属性。假设需要将设计的类提供给其他程序员使用，而在这个类中设置了一些受保护域，由于其他程序员可以由这个类再派生出新类，并访问其中的受保护域。在这种情况下，如果需要对这个类的实现进行修改，就必须通知所有使用这个类的程序员。这违背了 OOP 提倡的数据封装原则。

h、泛型数组列表：

ArrayList 是一个采用类型参数（ type parameter ) 的泛型类（generic class )。

ArrayList<Employee>  employeeList = new ArrayList<>();
for(){
    employeeList.add(new Employee实例);
}

使用 add 方法可以将元素添加到数组列表中。数组列表管理着对象引用的一个内部数组。最终， 数组的全部空间有可能被用尽。这就显现出数组列表的操作魅力： 如果调用 add 且内部数组已经满了，数组列表就将自动地创建
一个更大的数组，并将所有的对象从较小的数组中拷贝到较大的数组中。
如果已经清楚或能够估计出数组可能存储的元素数量， 就可以在填充数组之前调用ensureCapacity方法：
staff.ensureCapacity(lOO);
这个方法调用将分配一个包含 100 个对象的内部数组。然后调用 100 次 add, 而不用重新分配空间。

employeeList.add(new Employee) 如何操作原理:

当通过add方式插入的快要

所有类的超类-Object

equals方法：比较对象的引用

1、

public class Employee
public boolean equals(Object othe「Object)
{
    // a quick test to see if the objects are identical
if (this == otherObject) return true;
    // must return false if the explicit parameter is null
if (otherObject == null) return false;
    // if the classes don't match, they can't be equal
if (getClassO != otherObject.getClass())
    return false;
// now we know otherObject is a non-null Employee
    Employee other = (Employee) otherObject;
// test whether the fields have identical values
    return Objects.equals(name, other.name) && salary = other, salary && hireDay.equals(other, hireDay);

注意：
Objects.equals(name, other.name) ：name.equals(other.name)会出现name为null的情况，
现：如果俩个都是null，返回true，其中一个为null，返回false，俩个都不为null，进行 name.equals（other.name）比较。

}
}

2、

在子类中定义 equals 方法时首先调用超类的 equals。 如果检测失败， 对象就不可能相
等。 如果超类中的域都相等， 就需要比较子类中的实例域。
public class Manager extends Employee
public boolean equals(Object otherObject)
{
if (!s叩er equals(otherObject)) return false;
// super.equals checked that this and otherObject belong to the same class
Manager other = (Manager) otherObject;
return bonus == other.bonus;
}
}

相等测试和与继承

在判断俩个类是否相等的时候，很多同行喜欢用

 if ( KotherObject instanceof Employee)) return false;

然而这种方式并不推荐。这样做不仅无法判断KotherObject是子类的情况，也会导致一些麻烦。

Java 语言规范要求 equals 方法具有下面的特性：
1 ) 自反性：对于任何非空引用 x, x.equals(x) 应该返回 true
2 ) 对称性: 对于任何引用 x 和 y, 当且仅当 y.equals(x) 返回 true, x.equals(y) 也应该返回 true。
3 ) 传递性：对于任何引用 x、 y 和 z, 如果 x.equals(y) 返回true， y.equals(z) 返回 true,
x.equals(z) 也应该返回 true。
4 ) 一致性：如果 x 和 y 引用的对象没有发生变化，反复调用 x.equals(y) 应该返回同样的结果。
5 ) 对于任意非空引用 x, x.equals(null) 应该返回 false.