java之多态精选

前言:

梯子的梯阶从来不是用来搁脚的,它只是让人们的脚放上一段时间,以便让别一只脚能够再往上登~

学习是需要长期坚持的,一步一个脚印地走向未来,未来的你一定会感谢今天学习的你。兄弟们学起来~

java之多态精选

一.介绍  

    所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量倒底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类,这样,不用修改源程序代码,就可以让引用变量绑定到各种不同的类实现上,从而导致该引用调用的具体方法随之改变,即不修改程序代码就可以改变程序运行时所绑定的具体代码,让程序可以选择多个运行状态,这就是多态性。

      比如你是一个酒神,对酒情有独钟。某日回家发现桌上有几个杯子里面都装了白酒,从外面看我们是不可能知道这是些什么酒,只有喝了之后才能够猜出来是何种酒。你一喝,这是剑南春、再喝这是五粮液、再喝这是金谷酒….在这里    我们可以描述成如下:

    酒 a = 剑南春

    酒 b = 五粮液

    酒 c = 金谷酒

      这里所表现的的就是多态。剑南春、五粮液、金谷酒都是酒的子类,我们只是通过酒这一个父类就能够引用不同的子类,这就是多态——我们只有在运行的时候才会知道引用变量所指向的具体实例对象。

二.知识点介绍

    1、向上转型

    2、多态的优点

    3、多态的实现

三.知识点详解

1、向上转型

    在上面的喝酒例子中,酒(Wine)是父类,剑南春(JNC)、五粮液(WLY)、金谷酒(JGJ)是子类。我们定义如下代码:

JNC a = new JNC();

    对于这个代码我们非常容易理解无非就是实例化了一个剑南春的对象嘛!但是这样呢?

Wine a = new JNC();

    在这里我们这样理解,这里定义了一个Wine 类型的a,它指向JNC对象实例。由于JNC是继承与Wine,所以JNC可以自动向上转型为Wine,所以a是可以指向JNC实例对象的。这样做存在一个非常大的好处,在继承中我们知道子类是父类的扩展,它可以提供比父类更加强大的功能,如果我们定义了一个指向子类的父类引用类型,那么它除了能够引用父类的共性外,还可以使用子类强大的功能。

    但是向上转型存在一些缺憾,那就是它必定会导致一些方法和属性的丢失,而导致我们不能够获取它们。所以父类类型的引用可以调用父类中定义的所有属性和方法,对于只存在与子类中的方法和属性它就望尘莫及了。

代码示例:

package com.Test;

//酒类
class Wine {
public void fun1(){
System.out.println("Wine 的Fun.....");
fun2();
}
public void fun2(){
System.out.println("Wine 的Fun2...");
}
}
class JNC extends Wine{
/**
@desc 子类重载父类方法
父类中不存在该方法,向上转型后,父类是不能引用该方法的
@param a
@return void
*/
public void fun1(String a){
System.out.println("JNC 的 Fun1...");
fun2();
}
/**
子类重写父类方法
指向子类的父类引用调用fun2时,必定是调用该方法
*/
public void fun2(){
System.out.println("JNC 的Fun2...");
}
}
class Test {
private final static String name = "磊哥的java历险记-@51博客";
public static void main(String[] args) {
Wine a = new JNC();
a.fun1();
System.out.println("============="+name+"=============");

}
}

java之多态精选

java之多态精选

2、多态的优点:

1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性

3、多态的实现

      Java实现多态有三个必要条件:继承、重写、向上转型。

    (1)继承:在多态中必须存在有继承关系的子类和父类。

    (2)重写:子类对父类中某些方法进行重新定义,在调用这些方法时就会调用子类的方法。

    (3)向上转型:在多态中需要将子类的引用赋给父类对象,只有这样该引用才能够具备技能调用父类的方法和子类的方法,父类引用指向子类对象:Parent p = new Child();

java之多态精选

    只有满足了上述三个条件,我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象,从而达到执行不同的行为。

    对于Java而言,它多态的实现机制遵循一个原则:当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。 

3.1实现形式:

    基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写,多个子类对同一方法的重写可以表现出不同的行为。

代码示例:

package com.Test;

class Wine {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Wine(){
}
public String drink(){
return "喝的是 " +
getName();
}
/**
重写toString()
*/
public String toString(){
return null;
}
}
class JNC extends Wine{
public JNC(){
setName("剑南春");
}
/**
重写父类方法,实现多态
*/
public String drink(){
return "喝的是 " +
getName();
}

/**
重写toString()
*/
public String toString(){
return "Wine : " +
getName();
}
}
class JGJ extends Wine{

public JGJ(){
setName("金谷酒");
}
/**
重写父类方法,实现多态
*/
public String drink(){
return "喝的是 " +
getName();
}
/**
重写toString()
*/
public String toString(){
return "Wine : " +
getName();
}
}


class Test {
private final static String name = "磊哥的java历险记-@51博客";
public static void main(String[] args) {
//定义父类数组
Wine[] wines = new Wine[2];
//定义两个子类
JNC jnc = new JNC();
JGJ jgj = new JGJ();

//父类引用子类对象
wines[0] = jnc;
wines[1] = jgj;

for(int i = 0 ; i < 2 ; i++){
System.out.println(wines[i].toString()
+ "--" + wines[i].drink());
}
System.out.println("============="+name+"=============");

}
}

java之多态精选

java之多态精选

java之多态精选

java之多态精选

3.2多态混合输出:

代码示例:

//父类A
class A {
public String show(D obj) {
return ("A and D");
}

public String show(A obj) {
return ("A and A");
}
}
//子类B继承A类
class B extends A{
public String show(B obj){
return ("B and B");
}

public String show(A obj){
return ("B and A");
}
}
//子类C继承B类
class C extends B{

}
//子类D继承B类
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));
}
}

java之多态精选

java之多态精选

java之多态精选

3.3多态代码练习:   

当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法。

       多态的好处:可以使程序有良好的扩展,并可以对所有类的对象进行通用处理。

代码展示:

package com.Test;

public class Wine {
private final static String name = "磊哥的java历险记-@51博客";
public static void main(String[] args) {
// 以 Cat 对象调用 show 方法
show(new Cat());
// 以 Dog 对象调用 show 方法
show(new Dog());
// 向上转型
Animal a = new Cat();
// 调用的是 Cat 的 eat
a.eat();
// 向下转型
Cat c = (Cat)a;
// 调用的是 Cat 的 work
c.work();
System.out.println("============="+name+"=============");
}

//对象判断是cat还是dog
public static void show(Animal a) {
a.eat();
String aName = a.getName();
// 判断对象是猫还是狗
if (aName.equals( "cat")) {
// 猫做的事情
Cat c = (Cat)a;
c.work();
} else if (aName.equals( "dog")) {
// 狗做的事情
Dog c = (Dog)a;
c.work();
}
}
}
//动物类
abstract class Animal {
String name;
public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}
abstract void eat();
}
//猫继承动物类
class Cat extends Animal {
public String getName() {
return "cat";
}
public void eat() {
System.out.println("猫喜欢吃鱼");
}
public void work() {
System.out.println("猫的职责是抓老鼠");
}
}
//狗继承动物
class Dog extends Animal {
public String getName() {
return "dog";
}
public void eat() {
System.out.println("狗喜欢吃骨头");
}
public void work() {
System.out.println("狗的职责是看家");
}
}

java之多态精选

java之多态精选

java之多态精选

结语:

任何的收获不是巧合,而是每天的努力与坚持得来的!人生因有梦想而充满动力,不怕你每天迈一小步,只怕你停滞不前;不怕你每天做一点事,只怕你无所事事。坚持,是生命的一种毅力;执行,是努力的一种坚持!

在这钢筋混凝土的森林里,数不尽的豺狼虎豹,能做的就是努力往上爬,一路的打怪升级,为的只是让太阳有空隙落在头上~

发表评论

相关文章