java-08多态与异常处理

1.运行以下代码:

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);
    }
}

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

第一个是父类自身的对象,同时调用了父类自己的方法。第二个是子类自身的对象调用了子类自己的方法。

第三个父类变量引用子类对象调用子类的方法。第四个引用了子类的对象,调用了子类的方法。

第五个通过类型转换改变了子类的变量,用了子类的方法。

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

2.

import java.util.Scanner;

class Account{
    String account;
    String name;
    String date;
    int key;
    double money;

    public Account(String a,String b,String c,int d,double e)
    {
        account=a;
        name=b;
        date=c;
        key=d;
        money=e;
    }

}

public class Option {
    public static void main(String[] args) {
        Account aa=new Account("622888040311","zxw","2016.11.15",123456,1000);
        int a,b;
        System.out.println("请选择语言:1.中文 2.英文");
        Scanner in =new Scanner(System.in);
        a=in.nextInt();
        System.out.println("请输入密码:");
        Scanner in1 =new Scanner(System.in);
        b=in1.nextInt();
        if(b==aa.key){
            while(true){

            int choose;
            System.out.println("请选择操作:1.存款 2.取款 3.转账汇款 4.修改密码 5.查询余额");
            Scanner in2 =new Scanner(System.in);
            choose=in2.nextInt();
            if(choose==1){
                System.out.println("请输入存款金额:");
                Scanner in3 =new Scanner(System.in);
                double cun=in3.nextInt();
                aa.money=aa.money+cun;
                continue;
            }
            else if(choose==2){
                System.out.println("请输入取款金额:");
                Scanner in4=new Scanner(System.in);
                double qu=in4.nextDouble();
                if(aa.money<qu){
                    System.out.println("卡内余额不足");
                }
                aa.money=aa.money-qu;
                continue;
            }
            else if(choose==3){
                System.out.println("请输入要转账的卡号:");
                Scanner in6=new Scanner(System.in);
                String hang=in6.nextLine();
                if(hang.equals(aa.account)){
                    System.out.println("请输入转账金额:");
                    Scanner in5=new Scanner(System.in);
                    double zhuan=in5.nextDouble();
                    aa.money=aa.money-zhuan;
                }
            }
            else if(choose==4){
                System.out.println("请输入原密码:");
                Scanner in7=new Scanner(System.in);
                int mi=in7.nextInt();
                if(mi==aa.key){
                    System.out.println("请输入新密码:");
                    Scanner in8=new Scanner(System.in);
                    int mi2=in8.nextInt();
                    aa.key=mi2;
                }
            }
            else if(choose==5){
                System.out.println("现在的余额为:"+aa.money);
            }

            }
        }
        else
            System.out.println("密码错误,该卡已被锁定,无法操作");

    }

}
时间: 2024-10-17 18:04:55

java-08多态与异常处理的相关文章

08 多态与异常处理

课后作业一:接口多态:使用接口代替抽象基类一.源代码package zoo4; import java.util.Vector; public class Zoo2 { public static void main(String args[]) { Feeder f = new Feeder("小李"); Vector<Animal> ans = new Vector<Animal>();//可随时向其中加入或移除对象 //饲养员小李喂养一只狮子 ans.ad

Java语言中的----多态和异常处理

day13 Java语言中的----多态和异常处理 一.概述: 学习Java语言就要理解Java中的面向对象的四大特征:分别是封装.抽象.继承.多态.前面三个我们已经学完了,下面我们来学一下多态.什么是多态?不明思议就是具有两种形态性,一个方法可以定义两种形态,这就是方法的多态性.同时我们还会学习到什么是方法重载.和方法签名. 异常处理就是在编译的时候需要我们手动的去处理一下编译都不能够通过的程序.使用try {} catch{}结构就可以处理异常. 二.多态: 1.所有类的基类是object,

多态与异常处理

多态与异常处理 动手动脑1 运行结果截图 动手动脑2 运行结果截图 动手动脑3 Finally语句一定会执行,运行截图如下

复习java基础第二天(异常处理)

一.常见的异常类型: public class TestException { public static void main(String[] args) { int i = 10; //数学异常: java.lang.ArithmeticException int j = i / 0; System.out.println(j); int [] scores = new int[]{1, 2, 4, 5}; //数组下标越界异常: java.lang.ArrayIndexOutOfBound

Java 编程中关于异常处理的 10 个最佳实践

异常处理是书写 强健 Java应用的一个重要部分.它是关乎每个应用的一个非功能性需求,是为了优雅的处理任何错误状况,比如资源不可访问,非法输入,空输入等等.Java提供了几个异常处理特性,以try,catch和finally 关键字的形式内建于语言自身之中.Java编程语言也允许你创建新的异常,并通过使用  throw 和 throws关键字抛出它们.事实上,异常处理不仅仅是知道语法.书写一个强健的代码更多的是一门艺术而不仅仅是一门科学,这里我们将讨论一些关于异常处理的Java最佳实践.这些 J

java不求有功,但求无过—异常处理

在程序开发中,错误往往有两种.一种是编译时出现的错误,该种错误比较容易发现.另一种是运行时出现的错误,该种错误是开发人员比较头疼的.异常就是一个运行时的错误,例如,除数为0 ,数组越界等. 异常处理,就是我们定义一个代码段(可能出错的代码段)来捕获和处理异常. 这样当异常情况发生时,一个代表该异常的对象会被创建,并在产生异常的方法中被引发.该方法可以选择自己处理异常,也可以抛出该异常,但无论是哪种,最终异常都会被处理. 例如以下的代码: import java.io.*; public clas

Java中多态的一些简单理解

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

JAVA之IO技术异常处理机制

package ioTest.io1; import java.io.FileWriter; /* * IO异常的处理: * 读或写实际上都是调用系统的资源区做操作.只要和系统资源相关的都有可能出现异常. */ import java.io.IOException; public class FileWriterDemo1 { public static void main(String[] args) { FileWriter fWriter=null;//在外层创建对象的引用,在try代码块

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

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

JAVA泛型多态

先度娘一下多态的概念: 多态==晚绑定. 不要把函数重载理解为多态. 因为多态是一种运行期的行为,不是编译期的行为. 多态:父类型的引用可以指向子类型的对象. 比如 Parent p = new Child(); 当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误: 如果有,再去调用子类的该同名方法. (来源:http://www.cnblogs.com/mengdd/archive/2012/12/25/2832288.html) 那如果要在Java中泛型做多态如何使用