Java课堂练习——多态

一.ATM机

import java.util.Scanner;

abstract class drawmoney{

public abstract double getMoney(double a,double n);

}

class drawmoney100 extends drawmoney{

public double getMoney(double a,double n){

if(a<100){

System.out.println("余额不足,请选择其他业务");

return a;

}

else {

System.out.println("已吐出100元");

return a-=100;

}

}

}

class drawmoney500 extends drawmoney{

public double getMoney(double a,double n){

if(a<500){

System.out.println("余额不足,请选择其他业务");

return a;

}

else {

System.out.println("已吐出500元");

return a-=500;

}

}

}

class drawmoney1000 extends drawmoney{

public double getMoney(double a,double n){

if(a<1000){

System.out.println("余额不足,请选择其他业务");

return a;

}

else {

System.out.println("已吐出1000元");

return a-=1000;

}

}

}

class drawmoney1500 extends drawmoney{

public double getMoney(double a,double n){

if(a<1500){

System.out.println("余额不足,请选择其他业务");

return a;

}

else {

System.out.println("已吐出1000元");

return a-=1000;

}

}

}

class drawmoney2000 extends drawmoney{

public double getMoney(double a,double n){

if(a<2000){

System.out.println("余额不足,请选择其他业务");

return a;

}

else {

System.out.println("已吐2000元");

return a-=2000;

}

}

}

class drawmoney5000 extends drawmoney{

public double getMoney(double a,double n){

if(a<5000){

System.out.println("余额不足,请选择其他业务");

return a;

}

else {

System.out.println("已吐出5000元");

return a-=5000;

}

}

}

class drawmoneyn extends drawmoney{

public double getMoney(double a,double n){

if(a<n){

System.out.println("余额不足,请选择其他业务");

return a;

}

else {

System.out.println("已吐出"+n+"元");

return a-=n;

}

}

}

class Account{

String account;

String usename;

int password;

String date;

double balance;

int Operation;

public Account(){

account="accout1805231593";

usename="宋家林";

password=521114;

date="1997.8.11";

balance=230.15;

Operation=0;

}

public Account(String a,String b,int c,String d,double e,int f){

account=a;

usename=b;

password=c;

date=d;

balance=e;

Operation=f;

}

}

public class ATM {

public Account h=new Account();

}

public boolean shurumina(int a){

if(a==h.password) {

System.out.println("密码正确");

}

else{

System.out.println("密码错误,请重新输入");

return false;

}

public void jiemian(boolean a){

Scanner cin=new Scanner(System.in);

while(a){

System.out.println("1.存款");

System.out.println("2.取款");

System.out.println("3.转账汇款");

System.out.println("4.修改密码");

System.out.println("5.查询余额");

System.out.println("6.退卡");

int b=cin.nextInt();

switch (b){

case 1:deposit(b);break;

case 2:withdrawals(b);break;

case 3:transfer(b);break;

case 4:Passwordservice(b);break;

case 5:System.out.println(h.balance);break;

case 6:a=false;break;

}

}

}

public int withdrawals(int a){

Scanner cin=new Scanner(System.in);

System.out.println("1.100元");

System.out.println("2.500元");

System.out.println("3.1000元");

System.out.println("4.1500元");

System.out.println("5.2000元");

System.out.println("6.5000元");

System.out.println("7.其他金额");

System.out.println("8.返回");

int b=cin.nextInt();

double c=0;

drawmoney m=null;

switch (b){

case 1:m= new drawmoney100();m.getMoney(h.balance, b);break;

case 2:m= new drawmoney500();m.getMoney(h.balance, b);break;

case 3:m= new drawmoney1000();m.getMoney(h.balance, b);break;

case 4:m= new drawmoney1500();m.getMoney(h.balance, b);break;

case 5:m= new drawmoney2000();m.getMoney(h.balance, b);break;

case 6:m= new drawmoney5000();m.getMoney(h.balance, b);break;

case 7:{

System.out.println("输入金额");

c=cin.nextDouble();

m= new drawmoneyn();

m.getMoney(h.balance, c);break;

}

case 8: return a;}

return a;

}

public int deposit(int a){

System.out.println("放入人民币");

System.out.println("输入金额");

Scanner cin=new Scanner(System.in);

int b=cin.nextInt();

h.balance+=b;

System.out.println("已成功");

jiemian(true);

return a;

}

public int transfer(int a){

System.out.println("请输入银行账号");

Scanner cin=new Scanner(System.in);

String b=cin.next();

System.out.println("输入转账的金额");

int c=cin.nextInt();

h.balance-=c;

System.out.println("已成功");

jiemian(true);

return 0;

}

public int Passwordservice(int a){

System.out.println("请输入新密码");

Scanner cin=new Scanner(System.in);

int b=cin.nextInt();

h.password-=b;

System.out.println("已成功");

return 0;

}

public static void main(String[] args) {

// TODO Auto-generated method stub

ATM mm=new ATM();

String out=new String();

out+="请插入银行卡";

System.out.println(out);

System.out.println("已成功");

out+="请输入密码";

System.out.println(out);

Scanner cin=new Scanner(System.in);

int a=cin.nextInt();

while (!mm.shurumina(a)){

a=cin.nextInt();

}

mm.jiemian(true);

}

}

二.

1.左边的程序运行结果是什么?

2. 计算机是不会出错的,之所以得到这样的运行结果也是有原因的,那么从这些运行结果中,你能总结出Java的哪些语法特性?

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

这个特性实际上就是面向对象“多态”特性的具体表现。

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

如果子类被当作父类使用,则通过子类访问的字段是父类的!

牢记:在实际开发中,要避免在子类中定义与父类同名 的字段。不要自找麻烦!——但考试除外,考试 中出这种题还是可以的。

三.

可以使用instanceof运算符判断一个对象是否可以转换为指定的类型:

Object obj="Hello";if(obj instanceof String)

System.out.println("obj对象可以被转换为字符串");

程序代码:public class TestInstanceof {

public static void main(String[] args)

{

//声明hello时使用Object类,则hello的编译类型是Object,Object是所有类的父类

//但hello变量的实际类型是String

Object hello = "Hello";

//String是Object类的子类,所以返回true。

System.out.println("字符串是否是Object类的实例:" + (hello instanceof Object));

//返回true。

System.out.println("字符串是否是String类的实例:" + (hello instanceof String));

//返回false。

System.out.println("字符串是否是Math类的实例:" + (hello instanceof Math));

//String实现了Comparable接口,所以返回true。

System.out.println("字符串是否是Comparable接口的实例:" + (hello instanceof Comparable));

String a = "Hello";

//String类既不是Math类,也不是Math类的父类,所以下面代码编译无法通过

//System.out.println("字符串是否是Math类的实例:" + (a instanceof Math));

}

}

四.为什么要用多态?它有什么好处?
使用多态最大的好处是:当你要修改程序并扩充系统时,你需要修改的地方较少,对其它部分代码的影响较小!千万不要小看这两个“较”字!程序规模越大,其优势就越突出。

时间: 2024-12-29 11:32:34

Java课堂练习——多态的相关文章

java 小结2 多态问题。

面向对象这个东西,其实我们一直是不是都没有感觉到自己在用,以后我一定要用用.以前学c#时候认真的看过一次,最近一直研究java.随便再看看. 多态问题: 在java中多态分为(1)编译时多态和(2)运行时多态 (1)编译时多态比较容易理解:其实就是通过方法重载,就是方法的重载,同一个函数名但是可以参数不一样.这就是重载(so easy) (2)运行时多态:这个是通过方法覆盖实现的,就是子类在继承父类的时候,通过对某个方法的重写,覆盖父类方法. 简单的说:比如我们有个父类A,子类B通过Extend

java继承和多态

java方法直接调用原理推测 有错误还望指正 当直接调用某对象的某方法时  会更具该对象获取到类信息对象   在从类信息对象中找到该方法 没找到 获取父类信息对象继续查找 找到了执行  jdk距离实现是通过反射还是其它? 如果按以上原理    以下情况解释不通 创建一子类对象  赋值给一父类指针变量  通过父类指针变量掉run方法   run方法在父类或子类中为私有  这种情况调用的是父类的run方法 并非子类的run方法 反射jar包 package extend; import org.ju

Java继承,多态,组合应用

继承:  面向对象的三大特征之一:    是类和类之间的一种拓展关系,是一种从一般到特殊的关系;    格式: sub   extends Super,  我们把sub称为子类或者拓展类, 把super称为父类或者基类(超类)   泛化: 把子类中的共性抽取到父类的过程; 特化: 子类在父类的基础之上,拓展自己特有的状态和特征;    Object: 是所有类的直接父类后间接父类;      class  Student{} 等价于  class  Student extends Object{

Java基础十一--多态

Java基础十一--多态 一.多态定义 简单说:就是一个对象对应着不同类型. 多态在代码中的体现: 父类或者接口的引用指向其子类的对象. 1 /* 2 3 对象的多态性. 4 5 class 动物 6 {} 7 8 class 猫 extends 动物 9 {} 10 11 class 狗 extends 动物 12 {} 13 14 15 16 猫 x = new 猫(); 17 18 动物 x = new 猫();//一个对象,两种形态. 19 20 21 22 猫这类事物即具备者猫的形态,

Java类的多态机制

Java中将一个方法调用同一个方法主体关联起来被称作绑定.绑定分为前期绑定和后期绑定.前期绑定是在编译器决定的,而后期绑定是在程序运行时决定的.Java中除了static方法和final方法(private方法也是final方法,只不过是隐式的为final)之外,其他所有的方法都是后期绑定.Java类的多态指的是当将子类向上转型为父类型并调用父类型中相应的方法时,多态机制会根据动态绑定自动判断出调用相应的子类的方法.也就是说多态机制的存在的基础是子类实现了对父类中相应方法的函数覆盖.比如有一个S

java中实现多态的机制是什么?

多态性是面向对象程序设计代码重用的一个重要机制,我们曾不只一次的提到Java多态性.在Java运行时多态性:继承和接口的实现一文中,我们曾详细介绍了Java实现运行时多态性的动态方法调度:今天我们再次深入Java核心,一起学习Java中多态性的实现. “polymorphism(多态)”一词来自希腊语,意为“多种形式”.多数Java程序员把多态看作对象的一种能力,使其能调用正确的方法版本.尽管如此,这种面向实现的观点导致了多态的神奇功能,胜于仅仅把多态看成纯粹的概念. Java中的多态总是子类型

Java 继承和多态

                                                    Java  继承和多态 Java 继承 继承的概念 继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类. 继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为. 生活中的继承: 兔子和羊属于食草动物类,狮子和豹属于食肉动物类. 食草动物和食肉动物又是属于动物类. 所以继承需要符合的关系是:is-a,父

java中对象多态时成员变量,普通成员函数及静态成员函数的调用情况

/* 样例1: class Parent{ int num = 3; } class Child extends Parent{ int num = 4; } */ /* 样例2: class Parent{ } class Child extends Parent{ int num = 4; } */ /* 样例3: class Parent{ void show(){ System.out.println("Parent Show!"); } } class Child exten

Java封装继承多态

Java中的类可以分为三种: 类:使用class定义且不含有抽象方法的类. 抽象类:使用abstract class定义的类,它可以含有,也可以不含有抽象方法. 接口:使用interface定义的类. 类可以继承(extends)类,可以继承(extends)抽象类,可以继承(implements)接口. 抽象类可以继承(extends)类,可以继承(extends)抽象类,可以继承(implements)接口. 接口只能继承(extends)接口. 1.封装 类使得数据和对数据的操作集成在一起