第七章总结

类的继承
继承在面向对象开发思想中是一个非常重要的概念，它使整个程序架构具有一定的弹性。在程序中复用一些已经定义完善的类，不仅可以减少软件开发周期，也可以提高软件的可维护性和可扩展性。

在Java语言中，一个类继承另一个类需要使用关键字extends，关键字extends的使用方法如下：

class Child extends Parent{ }

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

class Child estends Parent1,parents2{ }

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

例7.1 创建子类对象，观察构造方法执行顺序

class Parent {
    public Parent(){
        System.out.println("调用父类构造方法");
    }
}
class Child extends Parent{
    public Child() {
        System.out.println("调用子类构造方法");
    }
}
public class Demo {
    public static void main(String[]args) {
        new Child();
    }
}

运行结果如下：

 

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

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

class Telephone{                                //电话类
    String button = "button:0~9";                //成员属性，10个按键
    void call() {                                //拨打电话的功能
        System.out.println("开始拨打电话");
    }
}
class Mobile extends Telephone{                    //手机类继承电话类
    String screen = "screen:液晶屏";                //成员属性，液晶屏幕
}
public class Demo2 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Mobile motto = new Mobile();
        System.out.println(motto.button);        //子类调用父类属性
        System.out.println(motto.screen);        //子类调用父类没有的属性
        motto.call();
    }                                            //子类调用父类方法
 
}

运行结果如下：

 

 子类Mobile类仅创建了一个显示屏属性，剩余的其他属性和方法都是从父类Telephone类中继承的。

Java虽然不允许同时继承两个父类，但不代表没有多的继承关系，可以通过类似“祖父>父>儿子>孙子”的方式实现多代继承。

7.2 Object类
Object类是比较特殊的类，它是所有类的父类，是Java类层中最高层类。用户创建一个类时，除非已经指定要从其他类继承，否则它就是从Java.lang.Object类继承而来的。Java中的每个类都源于Java.lang.Object类，如String类、Integer类等都是继承Object类。除此之外，自定义的类也都继承于Object类。

在Object类中，主要包括clone（）、finalize（）、equals（）、toString（）等方法，由于所有的类都是Object类的子类，所以任何类都可以重写Object类中的方法。

注意：Object类中的getClass()、notify()、notifyAll()、wait()等方法不能被重写，因为这些方法被定义为final类型。

a.getClass()方法
getClass()方法是Object类定义的方法，它会返回对象执行时的Class实例，然后使用此实例调用getName()方法可以取得类的名称。语法如下：

getClass().getname();

可以将getClass()方法与toString()方法联合使用。

b. toString（）方法
toString（）方法的功能是将一个对象返回为字符串形式，它会返回一个String实例。在实际的应用中通常重写toString（）方法，为对象提供一个特定的输出模式。当这个类转换为字符串或与字符串连接时，将自动调用重写的toString（）方法。

例7.3 让学生自我介绍

public class Student {
    String name;
    int age;
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;  
    }
    public String toString() {
        return"我叫"+name+",今年"+age+"岁。";
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Student s1 = new Student("张三",16);
        System.out.println(s1);
        Student s2 = new Student("李四",19);
        System.out.println(s2);
    }
 
}

运行结果如下：

 

c.equals()方法

在Java语言中，有两种比较对象的方式，分别为“==”运算符与equals()方法。两者的区别在于：“==”比较的两个对象引用内地地址是否相等，而equals()方法比较的是两个对象的实际内容。

例7.4 根据身份证号判断是否为同一人

public class People {
    int id;                                    //身份证号
    String name;                            //名字
    
    public People(int id,String name) {
        this.id=id;
        this.name=name;
    }
    
    public boolean equals(Object obj) {      //重写Object类的equals()方法
        if(this==obj)                      //如果参数与本类是同一个对象
            return true;
        if(obj==null)                        //如果参数是null
            return false;
        if(getClass()!=obj.getClass())        //如果参数与本类类型不同
            return false;
        People other = (People)obj;        //将参数强转成本类对象
        if(id!=other.id)                    //如果两者的身份证号不相等
            return false;
        return true;
    }
    public String toString() {        //重写Object类的toString（）方法
        return name;                    //只输出名字
    }
    
    public static void main(String[]args) {
        People p1 = new People(220,"tom");
        People p2 = new People(220,"汤姆");
        People p3 = new People(330,"张三");
        Object o = new Object();
        
        System.out.println(p1+"与"+p2+"是否为同一个人？");
        System.out.println("equals()方法的结果："+p1.equals(p2));
        System.out.println("==运算符的结果："+(p1==p2));
        
        System.out.println();
        System.out.print(p1+"与"+p3+"是否为同一人?");
        System.out.println(p1.equals(p3));
        System.out.print(p1+"与"+o+"是否为同一人？");
        System.out.println(p1.equals(o));
    }
}

运行结果如下：

 

7.3 对象类型的转换

7.3.1 向上转型

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

例7.5 tom是谁？

class People{}
class Teacher extends People{}
public class Demo3 {
    public static void main(String[] args) {
        People tom = new Teacher();
    }
}

在上述代码中，“ People tom = new Teacher();”运用了向上转型的语法。在运用向上转型的过程中，父类的对象无法调用子类独有的属性或者方法。

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

class Bird{}
class Pigeon extends Bird{}
public class Demo4 {
    public static void main(String[]args) {
    Bird bird = new Pigeon();  //某只鸽子是一只鸟
    Pigeon pigeon = bird;      //某只鸟是一只鸽子
    }
}

运行结果如下：

发现报错是因为父类对象不能直接赋值给予类对象。如何修正呢？答案就是强制类型转换。语法如下：

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

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

myobject instanceof ExampleClass

myobject：某类的对象引用

ExampleClass：某个类

例7.7 分析几何图形之间的继承关系

class Quadrangle{}
class Square extends Quadrangle{}
class Circular{}
public class Demo5 {
    public static void main(String args[]) {
        Quadrangle q = new Quadrangle();  //四边形对象
        Square s = new Square();        //正方形对象
        System.out.println(q instanceof Square);//判断四边形是否为正方形的子类
        System.out.println(s instanceof Quadrangle);//判断正方形是否为四边形的子类
        System.out.println(q instanceof Circular);//判断正方形是否为圆形的子类
    }
}

 

运行结果如下：

 发现报错是因为四边形类与圆形类没有继承关系，因此两者不能使用instanceof关键字进行比较，否则会发生不兼容的错误。

7.5 方法的重载
方法的重载就是在同一个类中允许存在一个以上的同名方法，只要这些方法的参数个数或类型不同即可。

例7.8编写不同形式的加法运算方法

public class OverLoadTest {
    public static int add(int a, int b) {        //定义一个方法
        return a + b;
    }
    public static double add(double a,double b) {    //与第一个方法名称相同、参数类型不同
        return a + b;
    }
    public static int add(int a) {                //与第一个方法参数个数不同
        return a;
    }
    public static int add(int a,double b) {        //先int参数，后double参数
        return a;                                //输出int参数值
    }
    public static int add(double a,int b) {        //先double参数，后int参数
        return b;                                //输出int参数值
    }
    public static void main(String args[]) {
        System.out.println("调用add（int，int）方法："+add(1,2));
        System.out.println("调用add（double,double）方法："+add(2.1,3.3));
        System.out.println("调用add（int）方法："+add(1));
        System.out.println("调用add（int，double）方法："+add(5,8.0));
        System.out.println("调用add（double，int）方法："+add(5.0,8));
    }
}

运行结果如下：

 

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

final double PI = 3.14;

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

private final void test（）{
               …省略一些程序代码

}

例7.11 使用final关键字为电视机上儿童锁

public class Dad {
	public final void turnOnTheTV{
		System.out.println("爸爸打开了电视");
	}
}
class Baby extends Dad{
	public final void turnOnTheTV{
		System.out.println("宝宝也要打开电视");
	}
}

运行结果如下：

报错，因为打开电视这个方法是由final修饰的，子类无法重写。

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

final 类名{}

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