Java(多态)动手动脑

1>

请看以下“变态”的类(参看示例ParentChildTest.java)

上述代码的特点是: 子类和父类定义了一模一样的字段和方法

运行以下测试代码

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

2. 你如何解释会得到这样的输出?

第一个100:是parent调用PrintValue方法输出parent类中myValue值为100;

第二个200:是child调用PrintValue方法输出child类中myValue值为200;

第三个200:是parent = child,将子类对象的赋值给父类,但此时parent只能调用子类的方法,调用子类PrintValue时,输出的当然是子类的myValue值200。

第四个200:虽然parent = child,但parent不能调用子类的变量,所以parent.myValue++;只是将父类对象中的变量myValue值+1但不能改变子类的myValue值,但调用的是子类PrintValue方法时,输出的是子类的myValue值200。

第五个201:(Child)parent,强制转化parent为child对象,此时parent完全成为child对象,所以输出值为201。

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

(1):当子类和父类拥有同名方法时,并且让一个父类变量引用一个子类对象时,调用哪个方法由自己的真实类型来决定。

(2):如果子类与父类有相同的字段,则子类中的字段会代替或隐藏父类的字段,子类方法中访问的是子类中的字段(而不是父类中的字段)。

2>

用多态的方法模拟ATM操作流程。

import java.util.Scanner;
abstract class atma{
    public abstract void QuKuan();
    public abstract void CunKuan();
    public abstract void ZhuanZhang();
    public abstract void updataMima(String str);
    public abstract void showMoney();
}
public class ATM {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Account A = new Account();
        A.display();
    }

}
class Account extends atma
{
    String account;
    String name;
    String data;
    int leixing;
    String mima;
    double money;
    Account(){}
    Account(String account,String name,String data,String mima,double money)
    {
        this.account = account;
        this.name = name;
        this.data = data;
        this.mima = mima;
        this.money = money;
    }
    public String getMima()
    {
        return mima;
    }

    public void Mune()
    {
        System.out.println("1.取款");
        System.out.println("2.存款");
        System.out.println("3.转账汇款");
        System.out.println("4.修改密码");
        System.out.println("5.查询余额");
        System.out.println("6.退卡");
    }
    public void QuKuan()
    {
        System.out.println("100元");
        System.out.println("500元");
        System.out.println("1000元");
        System.out.println("1500元");
        System.out.println("2000元");
        System.out.println("5000元");
        System.out.println("其他金额");
        System.out.println("返回");
        Scanner in = new Scanner(System.in);
        System.out.println("请输入取款金额:");
        int M = in.nextInt();
        if(M <= money)
        {
            System.out.println("正在取款请稍后。。。");
            money = money - M;
            System.out.println("取款成功!");
        }
        else
        {
            System.out.println("余额不足,取款失败!");
        }
    }
    public void CunKuan()
    {
        Scanner in = new Scanner(System.in);
        System.out.println("请输入存款金额:");
        int M = in.nextInt();
        money = money + M;
        System.out.println("存款成功!");
    }
    public void ZhuanZhang()
    {
        Scanner in = new Scanner(System.in);
        System.out.println("请输入转账行号:");
        String H = in.next();
        System.out.println("你要转账的人的姓名是否为xxx?0:是,1:否");
        int X=in.nextInt();
        if(X==0)
        {
            System.out.println("请输入转账金额:");
            int M = in.nextInt();
            if(money >= M)
            {
                System.out.println("转账成功!");
                money = money - M;
            }
            else
            {
                System.out.println("余额不足,转账失败!");
            }
        }
        if(X==1)
        {
            System.out.println("卡号错误!");
        }
    }
    public void updataMima(String str)
    {
        if(str.equals(mima))
        {
            System.out.println("新密码不得与旧密码重复!");
        }
        else
        {
            mima = str;
            System.out.println("修改成功!");
        }
    }
    public void showMoney()
    {
        System.out.println("您的账户余额为:"+money);
    }
    public void display()
    {
        Scanner in = new Scanner(System.in);
        Account[] a = new Account[100];
        a[0] = new Account("123456789101","ctt","2016/11/15","123456",1000);
        System.out.println( "请输入密码:" );
        String input = in.next();
        boolean flag = false;
        for(int i  = 0;i<50;i++)
        {
            if(a[i].getMima().equals(input)&& a[i]!=null)
                flag = true;
            break;
        }
        int s1;
        if(flag)
        {
            boolean p = true;
            while(p)
            {
            Mune();
            System.out.println( "请输入要执行的操作:" );
            s1 = in.nextInt();
            if(s1 == 1)
            {
                QuKuan();
                continue;
            }
            if(s1 == 2)
            {
                CunKuan();
                continue;
            }
            if(s1 == 3)
            {
                ZhuanZhang();
                continue;
            }
            if(s1 == 4)
            {
                System.out.println("请输入新密码:");
                String str = in.next();
                updataMima(str);
                continue;
            }
            if(s1 == 5)
            {
                showMoney();
                continue;
            }
            else
            {
                p = false;
                System.out.println("已退出!");
            }
        }
        }

        else
        {
            System.out.println("输入错误!");
        }
    }
}

结果:

分析:利用抽象类实现。

时间: 2024-08-11 01:22:15

Java(多态)动手动脑的相关文章

java多态动手动脑

实验任务一:多态实现ATM工作原理 1)源代码: package demo; import java.util.Scanner; class A{ String name; String date; String mima; int yu; String kahao; public A(String name,String date,String mima,int yu,String kahao) { this.name=name; this.date=date; this.mima=mima;

第八章多态动手动脑

[动手动脑一] "类型转换"知识点考核-2 下列语句哪一个将引起编译错误?为什么?哪一个会引起运行时错误?为什么? m=d; d=m; d=(Dog)m; d=c; c=(Cat)m; 先进行自我判断,得出结论后,运行TestCast.java实例代码,看看你的判断是否正确. class Mammal{} class Dog extends Mammal {} class Cat extends Mammal {} public class TestCast { public stat

继承多态动手动脑

[1] 为什么子类的构造方法在运行之前,必须调用父类的构造方法?能不能反过来?为什么不能反过来? 提示: 构造函数的主要作用是什么? 从这个方面去想! [答] 构造函数(constructor)是一种特殊的方法.主要用来在创建对象时初始化对象,即为对象成员变量赋初始值,总与new运算符一起使用在创建对象的语句中.特别的一个类可以有多个构造函数,可根据其参数个数的不同或参数类型的不同来区分它们即构造函数的重载.构造函数的功能主要用于在类的对象创建时定义初始化的状态. 构造一个对象,先调用其构造方法

继承与多态 动手动脑

[1] 为什么子类的构造方法在运行之前,必须调用父类的构造方法?能不能反过来?为什么不能反过来? 提示: 构造函数的主要作用是什么? 从这个方面去想! [答] 构造函数(constructor)是一种特殊的方法.主要用来在创建对象时初始化对象,即为对象成员变量赋初始值,总与new运算符一起使用在创建对象的语句中.特别的一个类可以有多个构造函数,可根据其参数个数的不同或参数类型的不同来区分它们即构造函数的重载.构造函数的功能主要用于在类的对象创建时定义初始化的状态. 构造一个对象,先调用其构造方法

java的动手动脑10月20日

(1)动手动脑 该函数没有赋初值再就是如果类提供一个自定义的构造方法,将导致系统不在提供默认的构造方法. (2) public class test { /*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubInitializeBlockClass obj=new InitializeBlockClass();System.out.println(obj.field)

Java的动手动脑

动手动脑及课后实 仔细阅读示例: EnumTest.java,运行它,分析运行结果? public class EnumTest { public static void main(String[] args) { Size s=Size.SMALL; Size t=Size.LARGE; //s和t引用同一个对象? System.out.println(s==t);  // //是原始数据类型吗? System.out.println(s.getClass().isPrimitive());

java异常处理动手动脑问题解决和课后总结

动手动脑 一.问题:请阅读并运行AboutException.java示例,然后通过后面的几页PPT了解Java中实现异常处理的基础知识. 1.源代码 import javax.swing.*; class AboutException { public static void main(String[] a) { int i=1, j=0, k; //k=i/j; try { k = i/j; // Causes division-by-zero exception throw new Exc

JAVA中动手动脑

第一个动手动脑: 首先用枚举类型定义两个变量,然后判断两个变量是否引用同一对象,在判断枚举类型是否是原始数据类型,再从字符串中转换,最后列出所有的对象. 很明显,这两个变量都是枚举类型,但是这两个变量引用的对象不一样,同样,枚举类型并不是原始数据类型. 得出的结论就是,同是枚举类型,但是引用的对象可以不同,枚举类型并不是原始数据类型. 我可能还是用不好枚举类型. 第二个动手动脑: 很明显,+a+b,只不过是先显示a再显示b, 而a+b+“  .. ”,就是先把a+b的结果显示出去,然后再加上要显

Java课堂动手动脑-截图集锦

课堂实践性问题 没有数据类型,名称与类名相同,没有返回值 类本身有自定义的构造方法,调用时应有参数,这时系统不再使用默认构造方法 类字段初始化顺序 1.执行类成员定义时指定的默认值或累的初始化块,执行哪一个看哪一个排在前面. 2.执行类的构造函数 动手动脑问题(类之间继承,创建子类对象导致父类初始化块的执行) 静态初始化执行顺序 1.静态初始化块只执行一次 2.创建子类的对象时,父类的初始化块也会执行 静态方法访问实例成员变量如下:

03继承与多态 动手动脑

动手实验:继承条件下的构造方法调用 运行 TestInherits.java 示例,观察输出,注意总结父类与子类之间构造方法的调用关系修改Parent构造方法的代码,显式调用GrandParent的另一个构造函数,注意这句调用代码是否是第一句,影响重大! class Grandparent { public Grandparent() { System.out.println("GrandParent Created."); } public Grandparent(String st