Java之方法重写、方法重载、多态

Java之方法重写、方法重载、多态
博客分类: java语言
Java重写重载多态
一、方法重写(Override)

子类可以重写父类的方法。
方法的返回值类型、参数类型、参数个数都不能改变,只能重写方法体。

方法的重写规则

  • 参数列表必须完全与被重写方法的相同;
  • 返回类型必须完全与被重写方法的返回类型相同;
  • 访问权限不能比父类中被重写的方法的访问权限更低。
    例如:如果父类的一个方法被声明为public,那么在子类中重写该方法就不能声明为protected。
    解释:用于多态(父类引用子类对象)。
  • 声明为final的方法不能被重写。
  • 构造方法不能被重写。
  • 如果不能继承一个方法,则不能重写这个方法。
    如:父类中 private 的方法不能被子类重写。
  • 声明为static的方法不能被重写,但是能够被再次声明。
  • 子类中重写的方法不能抛出比父类更广泛的异常。
    解释:用于多态(父类引用子类对象)。

二、方法重载(Overload)

重载(overloading) 是在一个类里面,方法名字相同,而参数不同。
返回类型可以相同也可以不同。

方法的重载规则
-被重载的方法必须改变参数列表;

-被重载的方法可以改变返回类型;
-被重载的方法可以改变访问修饰符;
-被重载的方法可以声明新的或更广的检查异常;

三、多态(Polymorphism)

Polymorphism : the condition of occurring in several different forms.

  • 父类可以引用不同的子类,这就是多态。
  • 实现多态有三个必要条件:继承、重写、向上转型。
  • 在Java中有两种形式可以实现多态:继承和接口。

注意:

1、父类的引用可以调用父类中定义的属性和方法(可能被子类重写),
但不能引用子类自己定义的属性和方法。

2、子类的引用指向子类对象时,可以调用父类的方法。

例子:

Java代码 收藏代码
public class A {
public String show(D obj) {
return ("A and D");
}

public String show(A obj) {
    return ("A and A");
}   

}

public class B extends A{
public String show(B obj){
return ("B and B");
}

public String show(A obj){
    return ("B and A");
}   

}

public class C extends B{

}

public class D extends B{

}

public class Test {
public static void main(String[] args) {
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();

    System.out.println("1--" + a1.show(b));
    System.out.println("2--" + a1.show(c));
    System.out.println("3--" + a1.show(d));
    System.out.println("4--" + a2.show(b));
    System.out.println("5--" + a2.show(c));
    System.out.println("6--" + a2.show(d));
    System.out.println("7--" + b.show(b));
    System.out.println("8--" + b.show(c));
    System.out.println("9--" + b.show(d));
}  

}

/*

1--A and A
2--A and A
3--A and D
4--B and A
5--B and A
6--A and D
7--B and B
8--B and B
9--A and D

*/

引用:
http://www.cnblogs.com/chenssy/p/3372798.html
http://www.runoob.com/java/java-override-overload.html

原文地址:https://blog.51cto.com/6612493/2457173

时间: 2024-10-11 21:09:58

Java之方法重写、方法重载、多态的相关文章

类的继承,抽象类,接口,方法重写和重载

类的继承 C#与java:1.C#中继承用“:”,Java中继承用extends2.重写父类的方法,C#中需要关键字override,Java中不需要3.C#中调用父类的成员用base,Java中使用super4.子类的构造方法中如果没有显示的调用父类的构造方法,   编译器会自动在第一行代码添加super() 抽象类: 1.含有抽象方法的类必须是抽象类,抽象类中不一定有抽象方法2.抽象类的子类如果是抽象类,可以不需要重写父类的抽象方法3.抽象类不能被实例化,构造方法和静态方法不能是抽象的 接口

继承、多态及方法重写、重载

1.多态: 多态指的是同一个方法的调用,由于对象不同可能会有不同的行为.现实生活中,同一个方法,具体实现完全不同. 多态的要点: (1)多态是方法的多态,不是属性的多态(多态与属性无关): (2)多态的存在要有3个必要条件:继承.方法重写.父类引用指向子类对象: (3)父类引用指向子类对象后,用该父类引用调用子类重写的方法,此时多态就出现了. /** * - - - (1)多态是方法的多态,不死属性的多态(多态与属性无关): * - - - (2)多态的存在要有3个必要条件:继承.方法重写.父类

什么是多态、方法重写与重载

什么是多态 多态的概念呢比较简单,就是同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果. 如果按照这个概念来定义的话,那么多态应该是一种运行期的状态. 为了实现运行期的多态,或者说是动态绑定,需要满足三个条件. 即有类继承或者接口实现.子类要重写父类的方法.父类的引用指向子类的对象. public class Parent{ public void call(){ sout("im Parent"); } } public class Son extends Parent

Objective-c 类的继承 方法重写 方法重载

一.类的继承 Objective-c中类的继承与C++类似,不同的是Objective-c不支持多重继承,一个类只能有一个父类,单继承使Objective-c的继承关系很简单,易于管理程序. Objective-c中所有类的父类是NSObject. Objective-c中类的继承例子: [cpp] view plaincopy @interface Person: NSObject { NSString* name; int age; } - (NSString*) name; - (int)

方法重写3之多态

Main.m #import <Foundation/Foundation.h> #import "ColorPrinte.h" #import "Blackprinter.h" #import "ThreeDPrinter.h" #import "Printer.h" #import "Person.h" int main(int argc, const char * argv[]) { /*

访问修饰符private/protected/默认(friendly)protected 方法重写,重载

访问修饰符 本类 同包 子类 其他 private True   False False    False 默认(friendly) True   True False  False protected True True  True  False public True  True  True  True 重载:方法名相同,参数列表(参数数据类型.个数等)不同 重写:有继承才有重写,子类重写方法,方法名.返回值.参数列表相同,访问修饰符不能呢比父类更严格 package com.jredu.c

Java 继承与重写、重载

1.类的继承 1)继承 父类:所有子类所共有的属性和行为 子类:子类所特有的属性和行为 通过extends关键字来实现类的继承 子类(Sub class)可以继承父类(Super class)的成员变量及成员方法,同时也可以定义自己的成员变量和成员方法 Java语言不支持多重继承,一个类只能继承一个父类(单一继承),但一个父类可以有多个子类 继承具有传递性,子类的子类可以继承父类的父类的成员变量及成员方法 2)继承中构造方法(super关键字) Java规定:构造子类之前必须先构造父类 子类的构

面向对象概念中方法重写与重载的区别?

重载:重载一定是在同一个类当中,有一组方法名字相同,功能是类似的,但参数不同. 重写:在父子类当中,子类拥有与父类同名.同参.同返回类型的方法,可以改变父类的行为.父类加关键字virtual虚方法(为了在子类当中去重写父类的方法),子类中要加关键字override,体现了面向对象中的多态性(都不叫就不是方法的重写,而是方法的覆盖).

java中的重写和重载

重写 在java中有很多的继承,继承下来的有变量.方法.在有一些子类要实现的方法中,方法名.传的参数.返回值跟父类中的方法一样,但具体实现又跟父类的不一样,这时候我们就需要重写父类的方法,就比如我们有一个类叫做Animals,Animals类中有一个叫做Call,然后我们继承Animals又生成了Cat类和Dog类,Cat和Dog也分别有自己特别的叫声,程序如下: 1 class Animals { 2 public void call() { 3 System.out.println("啊啊啊

Java方法重写与方法重载

继承和多态都是面向对象程序设计的特点.使用继承可以在一个父类的基础上再创建一个子类,这个子类不但拥有父类已有的属性和方法,还可以创建属于自己的属性和方法.由于子类和父类之间的关系,从而引出了方法重写和方法重载的问题.方法重写及方法重载在继承和多态性方面的应用中会存在很多问题,这些概念很容易混淆,掌握重写和重载的区别对学会使用多态的方式编写程序.提高程序的可维护性奠定了基础.一.方法重写(0veriding)如何定义重写:在Java程序中,类的继承关系可以产生一个子类,子类继承父类,它具备了父类所