详解Java面向对象编程之多态

详解Java面向对象编程之多态

目录java面向对象编程之多态一.对于多态的理解：二.多态的实现方法总结

Java面向对象编程之多态

一.对于多态的理解：

通俗点理解，多态其实就是一词多义，就是一种方法的多种状态，即不同的类对象，调用同一个方法名，有不同的实现效果，如下面这段代码块：

public class Test {

public static void main(String[] args) {

Dog dog = new Dog("豆豆");

Cat cat = new Cat("花花");

dog.eat();

cat.eat();

}

}

对象dog和cat看似都调用了eat方法，都没有传参，按理说输出的结果应该一样，但其实不是这样的，让我们来看一下输出的结果：

这就是多态的一种表现，所属不同类的不同对象调用同一个方法名，却有着不同的实现效果。

二.多态的实现方法

Java中通过 方法重写（也叫方法覆写）、方法重载和接口实现多态（主要依赖于继承机制+方法覆写）

1.方法重载

方法重载十分好理解，就是子类和父类的方法名相同，但是参数个数或类型不一样，返回值不作要求，这里不再赘述

2.方法重写

对于方法重写，通常结合向上转型和向下转型两种形式进行应用，其中向上转型更为常见，向下转型相对使用较少

（1）向上转型：就是子类向父类转，向上转型最大的好处就是可以实现参数统一化，向上转型可以表现在三个地方：

其一：产生对象时：

注意：用这种形式创建的实例化对象dog1,其能调用的方法范围由父类Animal决定，即只能调用Animal类中的方法，而不能调用子类独有的方法，只有当子类有对父类的方法重写时，才调用子类重写后的方法！！！

其二：方法参数的传递：

其三：方法返回值的传递

向上转型的最大好处就是——参数统一化，父类引用可以接收子类所有对象

看下面这个例子：

完整代码为：

public class Animal {

public String name;

public Animal(String a){

name = a;

}

public void eat(){

System.out.println("食物");

}

public static void fun(Animal animal){

animal.eat();

}

}

public class Dog extends Animal{

public Dog(String name){

super(name);

}

public void eat(){

System.out.println("骨头");

}

}

public class Cat extends Animal{

public Cat(String name){

super(name);

}

public void eat(){

System.out.println("鱼");

}

}

public class Test {

public static void main(String[] args) {

Dog dog = new Dog("豆豆");

Cat cat = new Cat("花花");

dog.fun(dog);

cat.fun(cat);

}

}

结果为：

拆开来分析：

fun方法的参数为Animal类的实例化对象

Animal的子类对象，可以直接传入

也就是说，对于Animal类的所有子类实例化对象，均可以直接向fun方法传参，避免了重复性的写诸如 public static void fun(Dod d){}, public static void fun(Cat a){}等方法

（2）向下转型：向上转型是子类向父类转，向下转型则是将转为的父类还原为子类，这里用 还原 这个词是因为能向下转型的前提是：先发生向上转型且我们需要使用子类独有的方法时，才使用向下转型，也很好理解，父类不一定是子类，只有由子类转成的才可以向下转型还原，向下转型的形式如下：

Animal animal = new Dog("豆豆http://");

Dog dog = (Dog)animal;

基本类似与强制类型转换

注意：向下转型是有风险的，可能无法强制转换成功，这里可以引用instanceof类，用if语句判断，避免报错

if(dog instanceof Dog){

}

（3）方法重写的几点注意要求：

只能覆写成员方法，不能重写static静态方法，但是方法重载是可以重载static方法的子类进行方法重写，子类方法的权限修饰符>=父类方法的权限修饰符，同时，子类并不能覆写父类的private方法，对于父类的包访问权限修饰方法，在不同包下的子类也不能覆写用final修饰的方法也不能覆写哦（JDK中的String类就是一个final类）返回值必须相同，或是向上转型的，即覆写的方法的返回值可以是父类方法返回类型的子类注意方法覆写与方法重载的区别，方法覆写：子类与父类的方法名一样，参数、返回值类型均一样，如果只返回值类型不一样编译会报错可使用@override 检验方法覆写是否一样

（4）最后是一道例题，容易掉坑：

public class A {

public A(){

this.func();

}

public void func(){

System.out.println("A");

}

}

class B extends A{

private int num;

public B(int num){

this.num = num;

}

public void func(){

System.out.println("B的num==" + num);

}

public static void main(String[] args) {

B b = new B(100);

b.func();

}

}

分析运行后会输出什么呢?

仔细想想，小心掉坑，答案在文章末尾给出

3.抽象类

对于方法的覆写，一般的继承关系下，子类是可以选择覆写也可以选择不覆写的，但在一些场景下，我们想对子类作出强制性覆写要求，这就引出了抽象类的概念

（1）抽象类用abstract修饰，抽象类是普通类的超集，它只是在普通类的基础上多了抽象方法，抽象方法是没有方法体的，形式如下：

（2）抽象类必须有子类继承

（3）抽象类无法实例化对象，仅能用子类new相应的对象

（4）普通子类继承抽象类，必须覆写所有的抽象方法，当子类仍为抽象类时，可以选择不覆写，依旧保留抽象方法

（5）abstract修饰符不能和final同时使用，也不能和private同时使用

4.接口

上面讲的抽象类虽然能实现方法的覆写，但还是有缺陷的，比如抽象类还是遵循单继承原则，一个类也只能继承一个抽象类，同时，在语义上，只要继承，就是A is B 的意思，有时候并不符合逻辑，故而又引出了接口这个概念

（1）接口的定义与使用

我们用关键字interface来定义接口，子类用关键字 implements来实现接口，同时，通常，在命名接口时，我们会用大写的字母“I”开头命名以示区别，如下面一段代码的接口名为 IMessage ，而对于实现接口的子类命名我们通常用Impl作后缀

（2）接口的特点：

接口中只有全局常量和抽象方法（JDK8之前，JDK8又扩展了default方法，了解即可），如:

public interface IMessage {

public static final int a = 10;

public abstract void print();

}

接口中只有public权限,且全部为全局常量和抽象方法，故而，在接口内，public、static、final、abstract可以省略不写，默认即为这些关键字，故上一段代码可以直接写成下面这段：

public interface IMessage {

int a = 10;

void print();

}

接口是没有单继承限制的，子类可以implements多个父接口，父接口之间用逗号隔开，如：

public class CImpl implements IB,IMessage{ public void print(){ } public void printf(){ }}

同时，接口之间也可以多继承，一个接口可以extends多个父接口接口同抽象类一样，是不能直接实例化对象的，必须通过实现它的子类进行实例化如果一个子类既有继承的父类，也有实现的接口，则先继承父类再实现父接口

（3）常用的JDK内置的两大接口

a：Comparable接口

当使用Arrays.sort()方法排序时，当排序对象为自定义的类时，sort方法不知道应该按照对象的什么属性进行排序，故而待排序的自定义类需实现该接口，并将抽象方法compareTo覆写，形式如下：

import java.util.Arrays;

public class Person implements Comparable {

// 两个属性，name和age

private String name;

private int age;

// 有参构造

public Person(String name,int age){

this.name = name;

this.age = age;

}

// 定义输出

public String toString(){

return name + "的年龄是" + age;

}

// 覆写compareTo方法

public int compareTo(Person o){

return (this.age - o.age);

}

public static void main(String[] args) {

Person p1 = new Person("言希",18);

Person p2 = new Person("温衡",16);

Person p3 = new Person("思莞",17);

Person []p = new Person[]{p1,p2,p3};

// 用sort方法排序

Arrays.sort(p);

System.out.println(Arrays.toString(p));

}

}

输出结果（按年龄升序）：

b: Cloneable接口

Cloneable接口位于java.lang包中，顾名思义，就是用于克隆，在代码中也就是复制新的对象，新对象的属性方法都是从原对象中拷贝过来的，在实现该接口时，只需要覆写Object类提供的clone方法，如下面示例：

//实现Cloneable接口

public class Animall implements Cloneable{

private String name;

// clone方法

protected Animall clone() throws CloneNotSupportedException {

return (Animall)super.clone();

}

public static void main(String[] args) throws CloneNotSupportedException{

Animall a1 = new Animall();

a1.name = "豆豆";

// a2由a1克隆而来

Animall a2 = a1.clone();

// 输出a2，和a1一致

System.out.println(a2.name);

// 但是a1并不是a2

System.out.println(a1 == a2);

}

}

结果如下：

补充：

Cloneable接口是标记接口，即它本身并没有任何抽象方法，当一个类实现了该接口，就表示该类具备了克隆能力clone方法的源代码为protected native object clone() throws CloneNotSupportedException；,其中native也是一个关键字，表明是本地方法，即调用了C++的同名方法故而，我们还可以发现，native修饰的方法也是没有方法体的没有方法体的一定是抽象方法 ⅹ错误，因为native方法也是没有方法体的

好了，多态的内容基本就是这么多了，java中的多态主要依赖于继承和方法覆写，而对于那些需要强制性覆写的方法，我们又引出了抽象类，再鉴于抽象类有局限，我们又学习了接口，整体上内容就是这么多了，注意的细节比较多，多敲代码理解理解更棒。

最后，将文中那道例题答案奉上：

答案解析来啦

从main方法开始，执行的第一句为 B b = new B(100)；，因为B继承自A，故而执行B 的构造方法要先去执行A的构造方法，public A(){ this.func(); }，这里注意，虽然是A的构造，但对象是B的，故这里的this,func()实际是B.func()，public void func(){System.out.println(“B的num==” + num);}

因为这里其实还没给num赋值成功，所以num现在还是默认值0，所以输出了答案的第一句 B的num == 0，然后接着执行B的构造方法，将100赋值给了num,最后执行b.func,也就输出了答案的第二句 B的num ==100

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注我们的更多内容!

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。