java 作业08 多态与异常处理

一、用多态实现模拟Atm的过程

源代码：

import java.util.Scanner;
interface fangfa{

public void show();
public void qukuan();
public void cunkuan();
public void zhuanzhang();
public void setAcount(String string, String string2, String string3, String string4, double i);
public String getMima();
}
class atm implements fangfa{
String kahao; //私有变量
String name;
String riqi;
double yue;
String mima;

public atm(){ //无参构造函数

}
public atm(String kahao,String name,String riqi,String mima,double yue){ //有参构造函数

this.kahao=kahao;
this.name=name;
this.riqi=riqi;
this.mima=mima;
this.yue=yue;
}

public void setAcount(String kahao,String name,String riqi,String mima,double yue){ //赋值

this.kahao=kahao;
this.name=name;
this.riqi=riqi;
this.mima=mima;
this.yue=yue;
}
public String getkahao(){ return kahao;}//获得值

public String getName(){return name;}
public String getRiqi(){return riqi;}
public String getMima(){return mima;}
public double getYue(){return yue;}

public void show()
{
System.out.println("余额为："+yue);
}
public void cunkuan(){
System.out.println("请输入存款金额:");
Scanner s=new Scanner(System.in);
yue+=s.nextDouble();
show();
}

public void zhuanzhang()
{
atm q=new atm();
Scanner s=new Scanner(System.in);
System.out.println("请输入对方卡号:");
q.kahao=s.nextLine();
System.out.println("请输入转账金额:");
double zhuan=s.nextDouble();
yue=yue-zhuan;
q.yue=q.yue+zhuan;
show();
}
public void qukuan(){
boolean f=true;
while(f){
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、退卡");
System.out.println("9、返回");
System.out.println("请选择");
Scanner s=new Scanner(System.in);
int ch=s.nextInt();
switch(ch){
case 1:
yue=yue-100;
show();
break;
case 2:
yue=yue-500;
show();
break;
case 3:
yue=yue-1000;
show();
break;
case 4:
yue=yue-1500;
show();
break;
case 5:
yue=yue-2000;
show();
break;
case 6:
yue=yue-5000;
show();
break;
case 7:
System.out.println("请输入取款金额：");
double qu=s.nextDouble();
yue=yue-qu;
show();
break;
case 8:
f=false;
break;
case 9:
f=false;
break;

}
}
}

}
public class Atmduotai {

public static void main(String[] args) {
// TODO Auto-generated method stub

fangfa a=new atm();
a.setAcount("111111111111", "nasdf", "199508030048", "123456", 20000);
System.out.println("请输入密码：");
Scanner aa=new Scanner(System.in);
String ba=aa.nextLine();
if(ba.equals(a.getMima()))

while(true){

System.out.println("1、取款");
System.out.println("2、存款");
System.out.println("3、转账");
System.out.println("4、查询");
System.out.println("请选择：");
Scanner s=new Scanner(System.in);
int b=s.nextInt();
switch(b){
case 1:
a.qukuan();
break;
case 2:
a.cunkuan();
break;
case 3:
a.zhuanzhang();
break;
case 4:
a.show();
}
}
}
}

 实验结果截屏：

 

 

 

 

 

二、验证类

1、请看以下变态的类

    

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

运行上述代码，回答下列问题：

1）上述代码的运行结果是什么？

2）为什么会出现这样的结果？
3）计算机是不会出错的，之所以会出现这样的结果也是有原因的，从这些结果中请总结java的语法特征。

1）

2）父类的变量引用父类的对象，调用父类的方法，父类的方法里调用父类的变量输出父类的myvalue，第一个结果100；

第二个结果同理；

子类对象可以直接赋值给父类变量，父类变量引用子类对象调用子类的方法，在子类的方法中，子类用自己的变量，所以

第三个结果是200；

parent.myValue++parent本身是父类的对象，所以是父类的myValue++，而parent引用子类的对象，调用的是子类的

方法，子类的方法用子类的myValie所以第四个结果是200；

parent通过类型转换赋值给子类，所以子类的myValue++，通过父类变量引用子类对象调用子类方法，子类方法用子类的变量，输出201

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

对象是子类型的，它就调用子类型的方法，是父类型的，它就调用父类型的方法。如果子类与父类有相同的的字段，则子类中的字段会代替或

隐藏父类的字段，子类方法中访问的是子类中的字段，而不是父类中的字段。如果子类方法确实想访问父类中被隐藏的同名字段，可以用super

关键字来访问它。如果子类被当作父类使用，则通过子类访问的字段是父类的。

 

2、多态有两种形式，一个是继承多态，一个是接口多态。

1）继承多态

import java.util.Vector;

public class Zoo {

public static void main(String args[]) {
Feeder f = new Feeder("小李");
Vector<Animal> ans = new Vector<Animal>();

//饲养员小李喂养一只狮子
ans.add(new Lion());
//饲养员小李喂养十只猴子
for (int i = 0; i < 10; i++) {
ans.add(new Monkey());
}
//饲养员小李喂养5只鸽子
for (int i = 0; i < 5; i++) {
ans.add(new Pigeon());
}
f.feedAnimals(ans);
}
}

class Feeder {

public String name;

Feeder(String name) {
this.name = name;
}

public void feedAnimals(Vector<Animal> ans) {
for (Animal an : ans) {
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("我要减肥，所以每天只吃一点大米。");
}
}

 

 

2）接口多态

 

import java.util.Vector;



public class Zoo 
{

    public static void main(String args[]) 
{
        Feeder f = new Feeder("小李");
        
Vector<Animal> ans = new Vector<Animal>();

        //饲养员小李喂养一只狮子
       
 ans.add(new Lion());
        //饲养员小李喂养十只猴子
       
 for (int i = 0; i < 10; i++)
 {
            ans.add(new Monkey());
        }
        
//饲养员小李喂养5只鸽子
     
   for (int i = 0; i < 5; i++) 
{
            ans.add(new Pigeon());
        }
    
    f.feedAnimals(ans);
    }

}


class Feeder
 {

    public String name;

    Feeder(String name) 
{
        this.name = name;
    }

  
  public void feedAnimals(Vector<Animal> ans) 
{
        for (Animal an : ans) 
{
            an.eat();
        }
    
}

}


interface Animal 
{

    public abstract void eat();
}


class Lion implements Animal 
{

    public void eat() {
        System.out.println("我不吃肉谁敢吃肉！");
    }
}


class Monkey implements Animal 
{

    public void eat() {
        System.out.println("我什么都吃，尤其喜欢香蕉。");
    }
}


class Pigeon implements Animal {

    public void eat() {
        System.out.println("我要减肥，所以每天只吃一点大米。");
    }
}