《Core Java》读书笔记——第5章

最新推荐文章于 2024-09-21 10:38:43 发布

威尔金斯bhf

最新推荐文章于 2024-09-21 10:38:43 发布

阅读量252

点赞数

分类专栏： java 文章标签： java 读书笔记

本文链接：https://blog.csdn.net/u012148952/article/details/72837617

版权

java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

继承

5.1 类、超类和子类

本章代码
“is-a”关系是继承的一个明显特征，例如经理和雇员之间的关系，每一个经理都是一个雇员。

    class Manager extends Employee
    {
        添加方法和域
    }

子类的方法不能直接访问超类的私有域。在子类中可以增加域，增加方法或者覆盖超类中的方法，然而绝对不能删除继承的任何域和方法。在Java中使用关键字super调用超类的方法。

由于子类的构造器不能访问超类的私有域，所以必须利用超类的构造器对这部分私有域进行初始化，可以通过super实现对超类构造器的调用。使用super调用构造器的语句必须是子类构造器的第一条语句

如果子类构造器没有显式地调用超类的构造器，则将自动调用超类默认构造器。如果超类不含不带参数的默认构造器，而子类构造器中又没有显式调用其他超类的构造器，则编译器会报错。

超类的对象变量既可以引用超类对象，又可以引用子类对象。这种特性涉及到多态和动态绑定的概念，后面会详细讨论。

5.1.1 继承层次

继承并不仅限于一个层次。有一个公共超类派生出来的所有类的集合被称为继承层次。但是Java并不支持多继承。

5.1.2 多态

“is-a” 规则的另一个表述法是置换法则。它表明程序中出现超类对象的任何地方都可以用子类对象置换

    Employee e;
    e = new Employee(...); // Employee object expected
    e = new Manager(...); // OK, Manager can be used as well

但是超类对象变量引用子类对象之后，只能访问超类的方法，不能访问子类特有的方法和实例域。

    Manager boss = new Manager(...);
    Employee[] staff = new Employee[3];
    staff[0] = boss;  // staff[0] 和 boss引用同一个对象
    boss.setBonus(5000); // OK
    staff[0].setBonus(5000); // Error

但是不能让子类的对象变量引用超类对象。

    Manager m = staff[1]; //error

5.1.3 动态绑定

对象方法的执行过程

编译器查看对象的声明类型和方法名，获取所有可能被调用的候选方法（包括父类的）。
接下来，编译器将查看调用方法时提供的参数类型。这个过程被称为重载解析。
如果是private方法、static方法、final方法，编译器将可以准确地知道应该调用哪个方法，这种调用方式称为静态绑定。
动态绑定指的是，虚拟机一定调用与x所引用对象的实际类型最合适的那个类的方法。

    public class ManagerTest {
    public static void main(String[] args)
    {

        Manager boss = new Manager("Carl Craker", 80000, 2007, 12, 15);
        boss.setBonus(5000);

        Employee[] staff = new Employee[3];

        staff[0] = boss;
        staff[1] = new Employee("Harry Hacker",50000,2008,10,1);
        staff[2] = new Employee("Tommy Tester",40000,2009,11,22);

        for(Employee e : staff)
            System.out.println("name="+e.getName() + " ,salary=" + e.getSalary());
    }
}

上面的代码中，Manager类是Employee类的子类，并且Manager中覆盖了超类的getSalar()_方法。具体代码可参见文章开头的链接。
虚拟机预先为每个类创建了一个方法表，其中累出了所有方法的签名和实际调用的方法。对于Employee类

Employee:
getName() -> Employee.getName()
getSalary() -> Employee.getSalary()
getHireDay() -> Employee.getHireDay()
raiseSalary(double) -> Employee.raiseSalary(double)

Manager:
getName() -> Employee.getName()
getSalary() -> Manager.getSalary()
getHireDay() -> Employee.getHireDay()
raiseSalary(double) -> Employee.raiseSalary(double)
setBonus(double) -> Manager.setBonus(double)

在运行时，调用e.getSalary()的解析过程为：
首先，提取e的实际类型的方法表。
然后，虚拟机搜索定义getSalary签名的类。
最后，虚拟机调用方法。

动态绑定的好处是，无需对现存的代码进行修改，就可以对程序进行扩展。超类的对象变量引用子类的对象，子类只需重新覆盖超类的方法，就可以实现子类独有的功能，其他部分无需任何改动。

5.1.4 阻止继承：final类和方法

不允许扩展的类被称为final类，在定义类的时候使用final修饰符即可。

    final class Executive extends Manager
    {
        ...
    }

一个类被声明为final时，其中的方法自动地成为final，不包括域。final方法不能被子类覆盖。

5.1.5 强制类型转换

关于对象引用的类型转换

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

将一个超类引用赋值给子类变量，一定要进行类型转换。

5.1.6 抽象类

abstract关键字，包含抽象方法的类本身必须被声明为抽象类。但是抽象类也可以包含具体的数据和方法。抽象方法充当占位的角色，它们的具体实现在子类中。抽象类不能被实例化。可以定义一个抽象类的对象变量，但是只能引用非抽象子类对象。

5.1.7 受保护访问

修饰词	本类	同一个包中的类	继承类	其他类
private	√	×	×	×
无（默认）	√	√	×	×
protected	√	√	√	×
public	√	√	√	√

5.2 Object：所有类的超类

Ojbect类是Java中所有类的始祖，在Java中每个类都是由它扩展而来的。可以用Obeject类型的变量引用任何类型的对象。之后可以进行类型转换，访问类中的具体内容。

5.2.1 equals方法

Object类中的equals方法用于检测一个对象是否等于另外一个对象。在Object类中，这个方法将判断两个对象是否具有相同的引用。利用下面这个示例演示equals方法的实现机制。

    class Employee
    {
        public boolean equals(Object otherObject)
        {
            //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(getClass() != otherObject.getClass()) 
                return false;

            //now we know otherObject is a non-null Employee
            Employee other = (Employee) otherOjbect;            

            //test whether the fields have identical values
            return name.equals(other.name) && salary == other.salary && hireDay.equals(other.hireDay);
        }
    }

如果子类中定义equals方法时，首先调用超类的equals。

    class Manager extends Employee
    {
        public boolean equals(Object otherObject)
        {
            if(!super.equals(otherObject)) return false;
            Manager other = (Manager)otherObject;
            return bonus ==other.bonus;
        }
    }

5.2.2 相等测试与继承

Java语言规范要求equals方法具有下面的特性：

自反性：对于任何非空引用x，x.equals(x)应该返回true。
对称性：对于任何引用x和y，如果x.equals(y) 返回true，y.equals(x)也应该返回true。
传递性：对于任何引用x、y和z，如果x.equals(y)为true，y.equals(z)为true，那么x.equals(z)应该为true。
一致性，如果x和y的引用对象没有发生变化，反复调用x.equals(y)应该返回同样的结果
对于任何非空引用x，x.equals(null)应该返回false

equals方法中的类的检测到底用instanceof还是用getClass()来检测（这决定这子类是否需要重写equals方法）

如果子类能够拥有自己的相等的概念，则对称性需求将强制采用getClass进行检测。子类就需要重写equals方法
如果由超类决定相等的概念，那么就可以使用instanceof进行检测，这样可以在不同的子类对象之间进行相等比较。子类就无需重写equals方法。

在雇员和经理的例子中，经理有新增的域bonus，也就是说Manager类有自己相等的概念，所以要使用getClas检测。
但是，如果假设Employee用ID来作为相等测试的标准，那么这个相等概念可以适用于所有子类，就可以使用instanceof进行检测，并应该将Employee.equals方法声明为final。

写出完美equals方法的建议：

显式参数命名为otheObject，稍后需要将它转换成另一个叫做other的变量。
检测this与otherObject是否引用同一个对象：
if(this == otherObject) return true;
检测oterhObject是否为null，如果是，则返回false。
if(otherObject == null) return false;
比较this与otherObject 是否属于同一个类。如果equals的语义在每个子类中有所改变，就使用getClass进行检测：
if(getClass() != otherObject.getClass()) return false;
如果所有的子类都有统一的语义，就用instanceof进行检测：
if(!otherObject instanceof ClassName) return false;
将otherObject转换为相应类的类型变量。
ClassName other = (ClassName)otherObject;
现在开始对所有需要比较的域进行比较了。使用==比较基本类型域，使用equals比较对象域。
如果在子类中重新定义equals，就要在其中包含调用super.equals(other)。

equals的参数类型一定是Object

5.2.3 hashCode方法

散列码是由对象导出的一个整型值，没有规律。hashCode方法定义在Object类中，因此每个对象都有一个默认的三列码，其值为对象的存储地址。
如果重新定义equals方法，就必须重新定义hashCode方法。hashCode方法返回一个整型数值。

    class Employee
    {
        public int hashCode(0
        {
            return 7*name.hashCode()
                    +11*new Double(salary).hashCode
                    +13 * hireDay.hashCode();
        }
    }

Java 7 中还可以做两个改进

    public int hashCode()
    {
        return 7 * Objects.hashCode(name)
            +  11 * new Double(salary).hashCode()
            +  13 * Objects.hashCode(hireDay);
    }

注意，是Objects 而不是 Object。还有更好的做法，当组合多个散列值时，可以调用Objects.hash

    public int hashCode()
    {
        return Objects.hash(name,salary,hireDay);
    }

5.2.4 toString 方法

toString方法用于返回表示对象值的字符串。数组可以用Arrays.toString 和 Arrays.deepToString方法。

5.3 泛型数组列表

    ArrayList<Employee> staff = new ArrayList<Employee>();

这样可以解决运行时动态更改数组的问题。

5.3.1 访问数组列表元素

ArrayList使用get和set方法实现访问或改变数组元素的操作。下面这个技巧可以一举两得，既可以灵活地扩展数组，又可以方便地访问数组元素。

    ArrayList<X> list = nwe ArrayList<>();
    while(...)
    {
        x = ...;
        list.add(x);
    }
    X[] a = new X[list.size()];
    list.toArray(a);

使用泛型数组列表后

.不必指出数组大小
.使用add将任意多的元素添加到数组中
.使用size()替代length计算元素中的数目。
使用a.get(i)替代a[i]访问元素。

5.3.2 类型化与原始数组列表的兼容性

    public class EmployeeDB 
    {
        pubilc void update(ArrayList list){...}
        public ArrayList find(String query){...}
    }

5.4 对象包装器与自动装箱

所有的基本类型都有一个与之对应的类。通常，这些类称为包装器（wrapper）。对象包装器类是不可变的，一旦构造了包装器，就不允许更改其中的值。对象包装器类还是final，因此不能定义它们的子类。Java SE 5.0 的另一个改进之处是更加便于添加或获得数组元素。
list.add(3) 将自动得变换成list.add(Integer.valueOf(3));这叫做自动装箱。相反，将一个Integer对象赋给一个int值时，将会自动拆箱。
int n = list.get(i)
=>int n = list.get(i).intValue();

== 也可应用于对象包装器对象，只不过是检测的是对象是否指向同一个存储区域。

5.5 参数数量可变的方法

    public class PrintStream
    {
        public PrintStream printf(String fmt, Object... args) {return format(fmt,args);}
    }

上面的方法接受两个参数，一个是格式字符串，另一个是Object[]数组。再看另外一个例子。

    public static double max(double... values)
    {
        double largest = Double.MIN_VALUE;
        for(double v : values) if(v > largest) largest = v;
        return largest;
    }

编译器将new double[] {…}传递给max方法。

5.6 枚举类

    public enum Size{SMALL,MEDIUM,LARGE,EXTRA_LARGE};

在比较两个枚举类型的值时，直接使用==即可。上面的枚举类有4个实例。

直接看一个简单的代码实例

    public class EnumTest
    {
        public static void main(String[] args)
        {
            Scanner in = new Scanner(System.in);
            System.out.print("Enter a size: (SMALL,MEDIUM,LARGE,EXTRA_LARGE) ");
            String input = in.next().toUpperCase();
            Size size = Enum.valueOf(size.class,input);
            System.out.println("size=" + size);
            System.out.println("abbreviation=" + size.getAbbreviation());
            if(size == Size.EXTRA_LARGE)
                System.out.println("Good job--you paid attention to the _.");
        }
    }
enum Size
{
    SMALL("S"),MEDIUM("M"),LARGE("L"),EXTRA_LARGE("XL");
    private Size(String abbreviation) {this.abbreviation = abbreviation;}
    public String getAbbreviation(){return abbreviation;}
    private String abbreviation;
}