方法重载与抽象类3-13

简介: 方法重载与抽象类3-13

方法重载与抽象类

方法重载

在一个类中,我们可以定义多个方法。如果有一系列方法,它们的功能都是类似的,只有参数有所不同,那么,可以把这一组方法名做成同名方法。例如,在Hello类中,定义多个hello()方法:

class Hello {
    public void hello() {
        System.out.println("Hello, world!");
    }
    public void hello(String name) {
        System.out.println("Hello, " + name + "!");
    }
    public void hello(String name, int age) {
        if (age < 18) {
            System.out.println("Hi, " + name + "!");
        } else {
            System.out.println("Hello, " + name + "!");
        }
    }
}


这种方法名相同,但各自的参数不同,称为方法重载(Overload)。

注意:方法重载的返回值类型通常都是相同的。

方法重载的目的是,功能类似的方法使用同一名字,更容易记住,因此,调用起来更简单。

举个例子,String类提供了多个重载方法indexOf(),可以查找子串:

int indexOf(int ch):根据字符的Unicode码查找;

int indexOf(String str):根据字符串查找;

int indexOf(int ch, int fromIndex):根据字符查找,但指定起始位置;

int indexOf(String str, int fromIndex)根据字符串查找,但指定起始位置。

试一试:

// String.indexOf()
1.
 Run
练习
public class Main {
    public static void main(String[] args) {
        Person ming = new Person();
        Person hong = new Person();
        ming.setName("Xiao Ming");
        // TODO: 给Person增加重载方法setName(String, String):
        hong.setName("Xiao", "Hong");
        System.out.println(ming.getName());
        System.out.println(hong.getName());
    }
}

# 抽象类

由于多态的存在,每个子类都可以覆写父类的方法,例如:

class Person {
    public void run() { … }
}
class Student extends Person {
    @Override
    public void run() { … }
}
class Teacher extends Person {
    @Override
    public void run() { … }
}


从Person类派生的Student和Teacher都可以覆写run()方法。

如果父类Person的run()方法没有实际意义,能否去掉方法的执行语句?

class Person {
    public void run(); // Compile Error!
}

答案是不行,会导致编译错误,因为定义方法的时候,必须实现方法的语句。

能不能去掉父类的run()方法?

答案还是不行,因为去掉父类的run()方法,就失去了多态的特性。例如,runTwice()就无法编译:

public void runTwice(Person p) {
    p.run(); // Person没有run()方法,会导致编译错误
    p.run();
}

如果父类的方法本身不需要实现任何功能,仅仅是为了定义方法签名,目的是让子类去覆写它,那么,可以把父类的方法声明为抽象方法:

class Person {
    public abstract void run();
}

把一个方法声明为abstract,表示它是一个抽象方法,本身没有实现任何方法语句。因为这个抽象方法本身是无法执行的,所以,Person类也无法被实例化。编译器会告诉我们,无法编译Person类,因为它包含抽象方法。

必须把Person类本身也声明为abstract,才能正确编译它:

abstract class Person {
    public abstract void run();
}

抽象类

如果一个class定义了方法,但没有具体执行代码,这个方法就是抽象方法,抽象方法用abstract修饰。

因为无法执行抽象方法,因此这个类也必须申明为抽象类(abstract class)。

使用abstract修饰的类就是抽象类。我们无法实例化一个抽象类:

Person p = new Person(); // 编译错误


无法实例化的抽象类有什么用?

因为抽象类本身被设计成只能用于被继承,因此,抽象类可以强迫子类实现其定义的抽象方法,否则编译会报错。因此,抽象方法实际上相当于定义了“规范”。

例如,Person类定义了抽象方法run(),那么,在实现子类Student的时候,就必须覆写run()方法:

// abstract class


Run

面向抽象编程

当我们定义了抽象类Person,以及具体的Student、Teacher子类的时候,我们可以通过抽象类Person类型去引用具体的子类的实例:

Person s = new Student();
Person t = new Teacher();


这种引用抽象类的好处在于,我们对其进行方法调用,并不关心Person类型变量的具体子类型:

// 不关心Person变量的具体子类型:
s.run();
t.run();

同样的代码,如果引用的是一个新的子类,我们仍然不关心具体类型:

// 同样不关心新的子类是如何实现run()方法的:
Person e = new Employee();
e.run();


这种尽量引用高层类型,避免引用实际子类型的方式,称之为面向抽象编程。

面向抽象编程的本质就是:

上层代码只定义规范(例如:abstract class Person);

不需要子类就可以实现业务逻辑(正常编译);

具体的业务逻辑由不同的子类实现,调用者并不关心。


相关文章
|
6月前
|
C++
C++一分钟之-虚函数与抽象类
【6月更文挑战第21天】在C++中,虚函数与抽象类是多态的基础,增进类间耦合与灵活性。虚函数实现动态绑定,抽象类定义不可实例化的接口。关键点包括:记得使用`virtual`,避免滥用虚函数,确保派生类实现纯虚函数。抽象类不能直接实例化,派生类必须实现所有纯虚函数。通过实例代码学习和实践,能更好地掌握这些概念以优化代码设计。
56 2
|
C++
52 C++ - 纯虚函数和多继承
52 C++ - 纯虚函数和多继承
29 0
|
2月前
|
Java
方法重载和方法重写有什么区别?
本文解释了Java中方法重载(Method Overloading)和方法重写(Method Overriding)的区别,包括它们的定义位置、参数要求、返回值要求、业务功能以及绑定方式的不同,并提供了示例代码。
54 2
方法重载和方法重写有什么区别?
|
5月前
|
Java 编译器
Java面向对象(三)详解: 封装 | 继承 | 方法重写 | 抽象类
Java面向对象(三)详解: 封装 | 继承 | 方法重写 | 抽象类
|
7月前
|
C++
C++面向对象编程中的 纯虚函数 与 抽象类
C++面向对象编程中的 纯虚函数 与 抽象类
|
C#
C#方法重写
C#方法重写
70 0
|
7月前
|
C++
56纯虚函数与抽象类
56纯虚函数与抽象类
26 0
纯虚函数和抽象类
纯虚函数和抽象类
58 0
|
编译器
【多态-动态绑定-向上转型-抽象类】
【多态-动态绑定-向上转型-抽象类】
51 0
C++的纯虚函数和抽象类
在C++中,可以将虚函数声明为纯虚函数,语法格式为: virtual 返回值类型 函数名 (函数参数) = 0; 纯虚函数没有函数体,只有函数声明,在虚函数声明的结尾加上=0,表明此函数为纯虚函数。 最后的=0并不表示函数返回值为0,它只起形式上的作用,告诉编译系统“这是纯虚函数”。 包含纯虚函数的类称为抽象类(Abstract Class)。之所以说它抽象,是因为它无法实例化,也就是无法创建对象。原因很明显,纯虚函数没有函数体,不是完整的函数,无法调用,也无法为其分配内存空间。抽象类通常是作为基类,让派生类去实现纯虚函数。派生类必须实现纯虚函数才能被实例化。纯虚函数使用举例:

热门文章

最新文章