认识Java应用程序并使用（9）

学习目标：

认识第一个Java程序

---

学习内容：

1、 继承与重写
2、重载方法及其与重写方法的区别
2、父类与子类
3、 super的用法

---

学习步骤：

类的继承式面向对象程序设计的一个重要的特点，通过继承可以实现代码重用。被继承的类称为超类（superclass），由继承得到的类称为子类或派生类。

1、继承与重写

继承的概念

自然界中存在一一种称为”继承”的现象， 例如，猎犬和家犬都是大类动物，它们都有大类动物的所有特征，它们都会犬吠(方法)都有腿(属性)等。因此，可以说猎犬和家犬从大类动物那里继承了所有这些特征(属性)和行为(方法)。此时，如果把大类动物称为父类，那么猎犬和家犬都是犬类动物的子类。

从稍广阔的视角来看，狮子、老虎和印度豹都具有-些共同的特征和行为,这是因为它们都继承了相同的猫科动物类。所以，此时的猫科动物类是父类，而狮子、老虎和印度豹是子类。

从更广阔的视角来看，狮子、大象和人类具有一些共同的特征和行为，这是因为我们都继承了哺乳动物类的特征和行为。所以，此时哺乳动物类是父类，而狮子、大象和人类都是子类。

继承涉及将父类的特征和行为传给子类，所以子类的特征和行为与其父类非常相似。在OOP术语中，如果有两个类，它们或多或少地具有一组相同的属性和方法，我们可以创建一一个具有两个类共同属性的父类，再编写两个子类继承父类的全部或部分属性，而不是创建两个单独的类。这样可以确保相同部分的属性和方法代码只编写了一一次，而不是两次，减少了编码量，并提高了代码的可重用性。

有多种表示父类和子类的术语，如父类( parent class) 和子类(child class)、超类和子类、基类和派生类等。有一点需要注意，即派生类是基类的特化类，因此，常常说基类是一般化，而派生类是特殊化。

继承的作用

通过继承可以快速创建新的类，实现代码的重用，提高程序的可维护性，节省大量创建新类的时间，提高开发效率和开发质量。

继承的优点：

继承过来的字段和方法，可以像任何其他字段和方法一样被直接使用；
在子类中可以声明一个与父类中同名的新字段或静态方法，从而“隐藏”父类中的字段和方法；
可以在子类总声明一个在父类中没有的新字段和方法；
可以在子类中编写一个父类当中具有相同名的新实例方法，这称为“方法重载”或“方法覆盖”；
可以在子类中编写一个调用父类构造方法的子类构造方法，既可以隐式地实现，也可以通过使用关键字super来实现。

重写

如果在子类中定义的一个方法，其名称、返回值类型和参数列表正好与父类中的某个方法的名称、返回值的类型和参数列表相匹配，那么可以说，子类的方法重写了父类的方法。

在类体系结构中,当子类中的方法与其父类中的方法具有相同的方法名时，则认为子类中的方法重写了父类中的方法。从子类中调用重写方法时，将总是调用出现在子类中的方法,而父类中的方法被隐藏。

2、重载方法及其与重写方法的区别

在Java中,重写方法是指子类中重新定义了与其父类中有着相同的名称返回值类型和参数列表的方法体，而在同一个类中也可以存在同名但参数列表不同的方法。

重载方法

在Java中，可以在一个类中用相同的名称定义两个或多个方法,但参数项不同。当两个方法名称相同而参数项不同时，就认为此方法被重载，而此过程称为“方法重载”。调用重载方法时,Java使用的参数的类型和数量决定了实际调用重载方法的版本。重载方法可以有不同的返回值类型，但返回值类型本身不足以区分方法的两个版本。因此，重载方法的参数类型和数量必须不同。

调用重载方法时,Java将尝试调用一个参 数类型和数量与此方法的参数类型和数量相匹配的方法，如果不完全匹配,Java的自动类型转换功能将解决此问题.并调用正确的重载方法。

重载与重写的区别

方法的重写和重载是Java多态性的不同表现。重写是父类与子类之间多态性的一种表现,重载是一个类中多态性的一 种表现。 如果在子类中定义的某个方法与其父类中的方法有着相同的名称和参数,就说该方法被重写。子类的对象使用这个方法时,将调用子类中的定义,对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定 义了多个同名的方法，它们或有不同的参数个数,或有不同的参数类型,这称为方法的重载。重载的方法是可以改变返回值的类型的。

重写又称覆盖，从字面意思就可知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。我们在继承中经常会在子类中覆盖父类中的方法.在覆盖时要注意以下几点。

(1)重写方法的参数列表必须与被重写的方法完全相同,否则不是重写,而是重载。

(2)重写方法的访问修饰符一定要 大于被重写方法的访问修饰符，即要保证public>protected> default > private。

(3)重写方法的返回值必须和被重写的方法的返回值一致。

(4)重写的方法抛出的异常必须和被重写的方法所抛出的异常一致，或者是该异常类的子类。

(5)被重写的方法不能为private, 否则在其子类中只是新定义了一个方法，面并没有对其进行重写。

(6)静态方法不能被重写为非静态方法.否则会编译出错。

重载是指可以在类中定义一些名称 相同的方法，通过定义不同的输人参数来区分这些方法,然后在调用时，由JVMJava虚拟机)根据不同的参数样式来选择合适的方法执行。在使用重载时要注意以下几点。

(1)只能通过不同的参数样式来实现。例如，不同的参数类型或不同的参数个数。

(2)不能通过访向权限、返回类型.抛出的异常进行重载。

(3)方法的异常类型和数目不会对重载造成影响。

3、父类与子类

继承的主要优势在于代码的可重用性。一个类一经定义和调试，便可以用来创建新的子类,这样做除了节省大量的时间和精力之外，还无须重新输人相同的代码。另外，父类的数据和方法可用于它的子类，但如果将父类的数据和方法声明为私有使用(关键字为pri-vate)，则子类不能访问它们。

4、super的用法

super的三种用法：
1.在子类的成员方法中，访问父类的成员变量。
2.在子类的成员方法中，访问父类的成员方法。
3.在子类的构造方法中，访问父类的构造方法（包括重载方法）。

例题1：

package com.hg.day09;

public class Employee {
    String name;
    int age;

    public void method(){
        System.out.println("我是父类--雇员的方法");
    }

}

package com.hg.day09;

public class Teacher extends Employee {
    public void methodChildren() {
        System.out.println("我是子类--老师的方法");
        System.out.println("我要讲课");
    }

}

package com.hg.day09;

public class Assistant extends Employee {

    public void methodChildren() {
        System.out.println("我是子类--助教的方法");
        System.out.println("我要改作业");
    }


}

package com.hg.day09;

public class Demo01Extends {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();

        teacher.method();
        teacher.methodChildren();

        Assistant assistant = new Assistant();

        assistant.method();
        assistant.methodChildren();


    }
}

程序运行结果：

例题2：

package com.hg.day0902;

public class Fu {
    int numFu=10;
    int num=100;

    public void methdFu() {

        System.out.println("我是父类方法："+num);
    }
}

package com.hg.day0902;

public class Zi extends Fu{
    int numZi=20;
    //int num=200;

    public void methdFu() {

        System.out.println("我是子类方法："+num);
    }
}

package com.hg.day0902;

public class Demo02Extend {
    public static void main(String[] args) {
        Fu fu=new Fu();
        System.out.println(fu.numFu);

        System.out.println("=============");

        Zi zi=new Zi();

        System.out.println(zi.numFu);
        System.out.println(zi.numZi);

        System.out.println("=============");

        System.out.println(zi.num);

        System.out.println("=============");
        zi.methdFu();
    }
}

程序运行结果：

例题3：

package com.hg.day0904;

public class Phone {
    public void call() {
        System.out.println("打电话");

    }

    public void send() {
        System.out.println("发消息");

    }

    public void show() {
        System.out.println("老手机显示号码");
    }
}

package com.hg.day0904;

public class NewPhone extends Phone{
    public void show() {
        super.show();

        System.out.println("显示头像");
        System.out.println("显示归属地");
    }
}

package com.hg.day0904;

public class Demo04Phone {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.call();
        phone.send();
        System.out.println("===");
        phone.show();

        System.out.println("================");
        NewPhone newphone=new NewPhone();
        newphone.call();
        newphone.send();
        System.out.println("================");
        newphone.show();
    }
}

程序运行结果：

例题4：

package com.hg.day0906;

public class Fu {
    int num =100;

    public void method() {
        System.out.println("父类方法");
    }

}

package com.hg.day0906;

public class Zi extends Fu {
    int num =20;
    public Zi(){
        super();
    }

    public void method() {
        System.out.println("子类方法");
    }
    public void methodZi(){
        System.out.println(num);

        System.out.println(super.num);

        super.method();
    }
}

package com.hg.day0906;

public class Demo06Extends {
    public static void main(String[] args) {
        Zi zi=new Zi();
        zi.methodZi();
    }
}

程序运行结果：