java中多态的使用

一.动手动脑

public class ParentChildTest {
    public static void main(String[] args) {
        Parent parent=new Parent();
        parent.printValue();
        Child child=new Child();
        child.printValue();

        parent=child;
        parent.printValue();

        parent.myValue++;
        parent.printValue();

        ((Child)parent).myValue++;
        parent.printValue();

    }
}

class Parent{
    public int myValue=100;
    public void printValue() {
        System.out.println("Parent.printValue(),myValue="+myValue);
    }
}
class Child extends Parent{
    public int myValue=200;
    public void printValue() {
        System.out.println("Child.printValue(),myValue="+myValue);
    }
}

截图结果

结论:

当子类与父类拥有一样的方法,并且让一个父类变量引用一个子类对象时,到底调用哪个方法,由对象自己的“真实”类型所决定。

这就是说:对象是子类型的,它就调用子类型的方法,是父类型的,它就调用父类型的方法。

如果子类与父类有相同的字段,则子类中的字段会代替或隐藏父类的字段,子类方法中访问的是子类中的字段(而不是父类中的字段)。如果子类方法确实想访问父类中被隐藏的同名字段,可以用super关键字来访问它。
如果子类被当作父类使用,则通过子类访问的字段是父类的!

二:动手动脑

动物园

public class Zoo
{

	public static void main(String args[])
	{

        	Feeder f = new Feeder("小李");

        	//饲养员小李喂养一只狮子

        	f.feedAnimal(new Lion());
        	//饲养员小李喂养十只猴子

        	for (int i = 0; i < 10; i++)
		{

	            f.feedAnimal(new Monkey());

        }

        	//饲养员小李喂养5只鸽子

        	for (int i = 0; i < 5; i++)
		{

	            f.feedAnimal(new Pigeon());

        	}

    }

}

class Feeder
{

    public String name;

    Feeder(String name)
    {

        this.name = name;

    }

    public void feedAnimal(Animal an)
   {

        an.eat();

    }

}

abstract class Animal
{

    public abstract void eat();

}

class Lion extends Animal
{

    public void eat()
   {

        System.out.println("我不吃肉谁敢吃肉!");

    }

}

class Monkey extends Animal
{

    public void eat()
    {

        System.out.println("我什么都吃,尤其喜欢香蕉。");

    }

}

class Pigeon extends Animal
{

    public void eat()
    {

        System.out.println("我要减肥,所以每天只吃一点大米。");

    }

}

  

ATM机的实现:

import java.util.Scanner;

public class ATM {
	private  static String name;
	private  static String Data;
	private  static String mima;
	  static double money;
	  static ATM code=new ATM("岳志浩","11.13","123456",1000);
	static Scanner str=new Scanner(System.in);

	public ATM(String name1,String Data1,String mima1,double money1)
	{
		name=name1;
		Data=Data1;
		mima=mima1;
		money=money1;
	}
	/*public static  void qu()
	{
		System.out.println("选择存取金额"+"\n"+"1、100元"+"\n"+"2、500"+"\n"+"3、1000"+"\n"+"4、1500"+"\n"+"5、2000"+"\n"+"6、5000"+"\n"+"7、其他金额");
		int caozuo=str.nextInt();

		if(caozuo==1)
		{
		    if(money<100)
		    {
		    	System.out.println("余额不足");
		    	qu();
		    }
			money=money-100;
			System.out.println("余额"+money);
		}
		if(caozuo==2)
		{

			    if(money<500)
			    {
			    	System.out.println("余额不足");
			    	qu();
			    }
			money=money-500;
			System.out.println("余额"+money);
		}
		if(caozuo==3)
		{

			    if(money<1000)
			    {
			    	System.out.println("余额不足");
			    	qu();
			    }
			money=money-1000;
			System.out.println("余额"+money);
		}
		if(caozuo==4)
		{

			    if(money<1500)
			    {
			    	System.out.println("余额不足");
			    	qu();
			    }
			money=money-1500;
			System.out.println("余额"+money);
		}
		if(caozuo==5)
		{

		    if(money<2000)
		    {
		    	System.out.println("余额不足");
		    	qu();
		    }
			money=money-2000;
			System.out.println("余额"+money);
		}
		if(caozuo==6)
		{
			   if(money<5000)
			    {
			    	System.out.println("余额不足");
			    	qu();
			    }
			money=money-5000;
			System.out.println("余额"+money);
		}
		if(caozuo==7)
		{
			double money1=str.nextDouble();
			    money=money-money1;
			System.out.println("余额"+money);
		}

	}
	*/
	public static  void qu()
	{
		System.out.println("选择存取金额"+"\n"+"1、100元"+"\n"+"2、500"+"\n"+"3、1000"+"\n"+"4、1500"+"\n"+"5、2000"+"\n"+"6、5000"+"\n"+"7、其他金额");
		int caozuo=str.nextInt();
		Qu a=new Qu();
		if(caozuo==1)
		{
			Qu100 b=new Qu100();
			a=b;
			b.qu(code);
			System.out.println("余额"+money);
		}
		if(caozuo==2)
		{
			Qu500 b=new Qu500();
			a=b;
			b.qu(code);
			System.out.println("余额"+money);
		}
		if(caozuo==3)
		{
			Qu1000 b=new Qu1000();
			a=b;
			a.qu(code);
			System.out.println("余额"+money);
		}
		if(caozuo==4)
		{
			Qu1500 b=new Qu1500();
			a=b;
			a.qu(code);
			System.out.println("余额"+money);
		}
		if(caozuo==5)
		{
			Qu2000 b=new Qu2000();
			a=b;
			a.qu(code);
			System.out.println("余额"+money);
		}
		if(caozuo==6)
		{
			Qu5000 b=new Qu5000();
			a=b;
			a.qu(code);
			System.out.println("余额"+money);
		}

	}
	public static void zhuan()
	{
		System.out.println("输入要转入的卡号");
		String ka=str.next();
		System.out.println("输入要转入金额");
		double money1=str.nextDouble();
		money=money-money1;
		System.out.println("转账成功");

	}
	public static void cun()
	{

		System.out.println("输入存取金额");
			double money1=str.nextDouble();
			money=money+money1;
			System.out.println("余额"+money);
	}
	public static void xugai()
	{
		System.out.println("输入要修改的密码");
		String mima1=str.next();
		mima=mima1;

	}
	public static void main(String args[])
	{

		System.out.println("输入密码");
		String mima1=str.next();
		if(mima1.equals(ATM.mima))
		{
			int x=0;
		while (x!=5)
		{

			if(x==1)
			{
				qu();

			}
			if(x==2)
			{
				cun();
			}
			if(x==3)
			{
				zhuan();
			}
			if(x==4)
			{
				xugai();
			}
			if(x==5)
			{
				System.out.println("用户名:"+name+"日期:"+Data+"余额:"+money);
				break;
			}
			System.out.println("选择操作");
			System.out.print("1.取款"+"\n"+"2.存款"+"\n"+"3.转账"+"\n"+"4.修改密码"+"\n"+"5.退卡");
			int w=str.nextInt();
			x=w;

		}
		}
		else
		{
			System.out.println("密码错误");
		}

	}

}
class Qu
{

	public void qu(ATM a)
	{
	}
}
class Qu100 extends Qu
{

	public void qu(ATM a)
	{
		a.money=a.money-100;
	}
}
class Qu500 extends Qu
{

	public  void qu(ATM a)
	{
		a.money=a.money-500;
	}
}
class Qu1000 extends Qu
{

	public void qu(ATM a)
	{
		a.money=a.money-1000;
	}
}
class Qu1500 extends Qu
{

	public void qu(ATM a)
	{
		a.money=a.money-1500;
	}
}
class Qu2000 extends Qu
{

	public void qu(ATM a)
	{
		a.money=a.money-2000;
	}
}
class Qu5000 extends Qu
{

	public void qu(ATM a)
	{
		a.money=a.money-5000;
	}
}

  结果截图

时间: 2024-10-10 09:01:36

java中多态的使用的相关文章

Java中多态的一些简单理解

什么是多态 1.面向对象的三大特性:封装.继承.多态.从一定角度来看,封装和继承几乎都是为多态而准备的.这是我们最后一个概念,也是最重要的知识点. 2.多态的定义:指允许不同类的对象对同一消息做出响应.即同一消息可以根据发送对象的不同而采用多种不同的行为方式.(发送消息就是函数调用) 3.实现多态的技术称为:动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法. 4.多态的作用:消除类型之间的耦合关系. 5.现实中,关于多态的例子不

个人对Java中多态的一些简单理解

什么是多态 面向对象的三大特性:封装.继承.多态.从一定角度来看,封装和继承几乎都是为多态而准备的.这是我们最后一个概念,也是最重要的知识点. 多态的定义:指允许不同类的对象对同一消息做出响应.即同一消息可以根据发送对象的不同而采用多种不同的行为方式.(发送消息就是函数调用) 实现多态的技术称为:动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法. 多态的作用:消除类型之间的耦合关系. 现实中,关于多态的例子不胜枚举. 下面是多态

从虚拟机指令执行的角度分析JAVA中多态的实现原理

从虚拟机指令执行的角度分析JAVA中多态的实现原理 前几天突然被一个"家伙"问了几个问题,其中一个是:JAVA中的多态的实现原理是什么? 我一想,这肯定不是从语法的角度来阐释多态吧,隐隐约约地记得是与Class文件格式中的方法表有关,但是不知道虚拟机在执行的时候,是如何选择正确的方法来执行的了.so,趁着周末,把压箱底的<深入理解Java虚拟机>拿出来,重新看了下第6.7.8章中的内容,梳理一下:从我们用开发工具(Intellij 或者Eclipse)写的 .java 源程

深入Java核心 Java中多态的实现机制(1)

多态性是Java面向对象的一个重要机制,本文将向您详细介绍Java语言中多态性的实现原理和方法,通过多态一点带出更多Java面向对象有趣而实用的知识. 多态性是面向对象程序设计代码重用的一个重要机制,我们曾不只一次的提到Java多态性.在Java运行时多态性:继承和接口的实现一文中,我们曾详细介绍了Java实现运行时多态性的动态方法调度:今天我们再次深入Java核心,一起学习Java中多态性的实现. “polymorphism(多态)”一词来自希腊语,意为“多种形式”.多数Java程序员把多态看

Java 中多态的实现(上)

Java 中语法上实现多态的方式分为两种:1. 重载.2. 重写,重载又称之为编译时的多态,重写则是运行时的多态. 那么底层究竟时如何实现多态的呢,通过阅读『深入理解 Java 虚拟机』这本书(后文所指的书,如无特殊说明,指的都是这本书),对多态的实现过程有了一定的认识.以下内容是对学习内容的记录,以备今后回顾. 写着写着突然发现内容有点多,分为上和下,上主要记录重载的知识点,下则是重写的相关知识点. 重载 重载就是根据方法的参数类型.参数个数.参数顺序的不同,来实现同名方法的不同调用,重载是通

Java中多态、抽象类和接口

1:final关键字(掌握) (1)是最终的意思,可以修饰类,方法,变量. (2)特点: A:它修饰的类,不能被继承. B:它修饰的方法,不能被重写. C:它修饰的变量,是一个常量. (3)面试相关: A:局部变量 a:基本类型 值不能发生改变 b:引用类型 地址值不能发生改变,但是对象的内容是可以改变的 B:初始化时机 a:只能初始化一次. b:常见的给值 定义的时候.(推荐) 构造方法中. 2:多态(掌握) (1)同一个对象在不同时刻体现出来的不同状态. (2)多态的前提: A:有继承或者实

java中多态的详解

定义:指允许不同类的对象对同一消息做出响应.即同一消息可以根据发送对象的不同而采用多种不同的行为方式.(发送消息就是函数调用) 多态的前提: A:有继承或者实现关系. B:有方法重写. C:有父类或者父接口引用指向子类对象. 多态的分类: a:具体类多态 class Fu {} class Zi extends Fu {} Fu f = new Zi(); b:抽象类多态 abstract class Fu {} class Zi extends Fu {} Fu f = new Zi(); c

Java中多态的理解

---------------------------------- 最近在学习Java,接触了 多态的概念,用了好久才 搞懂,来给大家分享一下 博主的想法: ---------------------------------- 多态,就是指一个对象在 不同时候体现出来的不同 状态: ---------------------------------- 多态的实现要有3个前提: 1.要有继承关系: 2.要有方法重写: 3父类引用指向子类对象: 即 父 f = new 子(): ---------

JAVA中多态与C++多态的区别

原文出自:http://blog.csdn.net/hihui/article/details/8604779 #include <stdio.h> class Base { public: int i; Base() { i = 99; amethod(); } virtual void amethod() { printf("Base.amethod()\n"); } }; class Derived : public Base { public: int i; Der