新普京娱乐场多态动手动脑。多态动手动脑,多态动脑。

同、怎样判断目标是否可转移?可以以instanceof运算符判断一个对象是否足以转换为指定的色,参看实例:
TestInstanceof.java

多态动手动脑,多态动脑

平、怎样判断目标是否可换?可以运用instanceof运算符判断一个靶是否足以转移为指定的品类,参看实例:
TestInstanceof.java

 

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

 

新普京娱乐场 1

仲、下列语句哪一个拿引起编译错误?为什么?哪一个见面唤起运行时错?为什么?

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 static void main(String args[])
    {
        Mammal m;
        Dog d=new Dog();
        Cat c=new Cat();
        m=d;
        //d=m;
        d=(Dog)m;
        //d=c;
        //c=(Cat)m;

    }
}

 

d=m;

d=c;

c=(Cat)m;

即时三句话出摩擦。

老三、请看之下“变态”的近乎(参看示例ParentChildTest.java),运行以下测试代码,并回答问题:1.程序运行结果是呀?2.公哪分解会收获这样的出口?3.电脑是免见面拧的,之所以取得这样的运作结果为是发案由之,那么从这些运行结果受到,你能总结出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);
    }
}

 

1、结果:

新普京娱乐场 2

2、Java语法特性:

    (1)当子类与父类拥有一致的计,并且给一个父类变量引用一个子类对象时,到底调用哪个方法,由对象好的“真实”类型所决定,这便是说:对象是子类型的,它就是调用子类型的主意,是父类型的,它便调用父类型的法门。

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

    (2)如果子类与父类有雷同之字段,则子类中的字段会代替或隐藏父类的字段,子类方法中做客的是子类中之字段(而休是父类中之字段)。如果子类方法确实想访问父类中叫藏的同名字段,可以为此super关键字来访问它。如果子类被视作父类使用,则经过子类访问的字段是父类的!

季、请用javap查看编译器为TestPolymorphism.java生成的配节码指令,然后经互联网搜寻资料,尝试从底层开始掌握Java编译器是怎么也多态代码生成字节码指令,在程序运行过程被,多态特性又是何等贯彻之。

 

class Parent1        
{
    public int value=100;    
    public void Introduce()
    {
            System.out.println("I'm father");
        }
}
class Son extends Parent1
{
    public int value=101;
         public void Introduce()
    {
            System.out.println("I'm son");    
}
}
class Daughter extends Parent1
{
    public int value=102;
    public void Introduce()
    {
            System.out.println("I'm daughter");    
}
}
public class TestPolymorphism
{
    public static void main(String args[])
    {
        Parent1 p=new Parent1();
        p.Introduce();//子类的方法
        System.out.println(p.value);//父类的变量对象
        p=new Son();
        p.Introduce();
        System.out.println(p.value);
        p=new Daughter();
        p.Introduce();
        System.out.println(p.value);
    }
}

结果:

新普京娱乐场 3

五、在实例中清楚多态的含义和用

新普京娱乐场 4

1、三栽动物对应三单近乎,每个接近定义一个eat()方法,表示吃饲养员给其的食物,再规划一个Feeder类代表饲养员,其name字段保存饲养员名字,三独道分别表示喂养三种不同的动物,其参数分别引用三种植动物对象。

 

package Zoo1;
public class Zoo 
{
    public static void main(String args[])
    {
        Feeder f = new Feeder("小李");
        // 饲养员小李喂养一只狮子
        f.feedLion(new Lion());
        // 饲养员小李喂养十只猴子
        for (int i = 0; i < 10; i++)
         {
            f.feedMonkey(new Monkey());
        }        
        // 饲养员小李喂养5只鸽子
        for (int i = 0; i < 5; i++)
         {
            f.feedPigeon(new Pigeon());
        }    
    }
}
class Feeder 
{
    public String name;
    public Feeder(String name)
    {
        this.name = name;
    }    
    public void feedLion(Lion l)
    {
        l.eat();
    }    
    public void feedPigeon(Pigeon p)
    {
        p.eat();
    }    
    public void feedMonkey(Monkey m)
    {
        m.eat();
    }
}
class Lion
{
    public void eat() 
    {
        System.out.println("我不吃肉谁敢吃肉!");
    }
}
class Monkey 
{
    public void eat() 
    {
        System.out.println("我什么都吃,尤其喜欢香蕉。");
    }
}
class Pigeon 
{
    public void eat() 
    {
        System.out.println("我要减肥,所以每天只吃一点大米。");
    }
}

 

2、第一潮程序重构:引入继承,简化Feeder类

 

package Zoo2;
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("我要减肥,所以每天只吃一点大米。");
    }
}

 

3、第二不行程序重构,修改feedAnimals方法,让它们接受一个Animal数组……

 

package Zoo3;
public class Zoo {
    public static void main(String args[]) {
        Feeder f = new Feeder("小李");
        Animal[] ans = new Animal[16];
        //饲养员小李喂养一只狮子
        ans[0] = new Lion();
        //饲养员小李喂养十只猴子
        for (int i = 0; i < 10; i++) {
            ans[1 + i] = new Monkey();
        }
        //饲养员小李喂养5只鸽子
        for (int i = 0; i < 5; i++) {
            ans[11 + i] = new Pigeon();
        }
        f.feedAnimals(ans);
    }
}
class Feeder {
    public String name;
    Feeder(String name) {
        this.name = name;
    }
    public void feedAnimals(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("我要减肥,所以每天只吃一点大米。");
    }
}

 

4、第三涂鸦重构,修改feedAnimals方法,让该接受一个因素数目可变的靶子容器。

 

package Zoo4;
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("我要减肥,所以每天只吃一点大米。");
    }
}

 

5、从者示例中可见到,通过当编程中行使多态,可以使我们的代码有双重胜的适用性。当求变动时,多态特性可帮我们拿需改的地方压缩及最低限度。

多态编程有些许种重要形式:

(1)继承多态:示例程序行使的方

(2)接口多态:使用接口代替抽象基类。

动用多态最酷之利益是:

当你要改程序并扩张系统不时,你要改的地方比较少,对其他一些代码的熏陶比较小!千万不要看不起这半个“较”字!程序层面越来越老,其优势就更加突出。

六、用多态的计模拟ATM操作流程。

 

//王荣荣 2016/11/18
import java.util.Scanner;
class PersonalAccount{
    private String passWord="123456";//密码
    private String number;//银行卡号
    private int money=0;
    public int getMoney(){
        return money;
        }//余额
    public void setPw(String s){
        passWord=s;
        }//设置密码
    public void addMoney(int x){
        money+=x;
        }//加钱
    public void minusMoney(int x){
        money-=x;
        }//减钱
    public boolean whetherPwTrue(String s){//密码是否正确
        if(s.equals(passWord))
            return true;
        else return false;
    }
    }
    abstract class PATM{
    abstract boolean withdraw(int x);//取款
    abstract void save(int x);//存款
    abstract boolean transfer(String s,int x);//转账
    abstract boolean ifPass(String s);//判断输入的密码是否正确
    abstract int getRest();//查询余额
    abstract void setPassword(String s);//设置密码
    }
    class ATM extends PATM{
    private String numbers[]={"123451","123452",
            "123453","123454","123455"};//数据库中已有的账户卡号
    private PersonalAccount account=new PersonalAccount();
    public boolean withdraw(int x) {
        if(x>account.getMoney())
            return false;
        else{
            account.minusMoney(x);
            return true;
        }
    }
    public void save(int x) {
        account.addMoney(x);
    }
    public boolean transfer(String s, int x) {
        //转账
        //先判断转到账户号是否存在
        //再判断余额是否足够
        boolean flag=false;
        for(int i=0;i<numbers.length;i++)
            if(s.equals(numbers[i])) flag=true;
        if(x>account.getMoney()) flag=false;
        if(x<=account.getMoney()&&flag) account.minusMoney(x);;
        return flag;
    }
    public boolean ifPass(String s) {
        return account.whetherPwTrue(s);
    }
    public int getRest() {
        return account.getMoney();
    }
    public void setPassword(String s) {
        account.setPw(s);        
    }
    }
public class Atm1 {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        ATM atm=new ATM();
        int choose=0,num=0;
        String pw="";
        next:while(true){
            System.out.println("是否进入账户(0否1是):");
            int kk=in.nextInt();
            if(kk==0) break;
            else if(kk!=1){
                System.out.println("输入错误!");
                continue;
            }
            System.out.println("输入账户密码:");
            pw=in.next();
            if(atm.ifPass(pw)){
                while(true){
                    showFace();
                    choose=in.nextInt();
                    switch(choose){
                    case 1:
                        System.out.println("输入存款金额:");
                        num=in.nextInt();
                        atm.save(num);
                        System.out.println("存款成功!");
                        System.out.println("当前余额:"+atm.getRest()+"元");
                        break;
                    case 2:
                        System.out.println("请选择:");
                        int a[]={100,500,1000,1500,2000,5000};
                        for(int i=0;i<a.length;i++)
                            System.out.println((i+1)+"."+a[i]+"元");
                        System.out.println("7.其他");
                        int ch=in.nextInt();
                        if(ch>=1&&ch<=6){
                            if(atm.withdraw(a[ch-1]))
                                System.out.println("取款成功!");
                            else
                                System.out.println("余额不足!");
                        }
                        else if(ch==7){
                            System.out.println("请输入取款金额:");
                            num=in.nextInt();
                            if(atm.withdraw(num))
                                System.out.println("取款成功!");
                            else 
                                System.out.println("余额不足!");
                        }
                        else 
                            System.out.println("输入有误!");
                        System.out.println("当前余额:"+atm.getRest()+"元");
                        break;
                    case 3:
                        System.out.println("账户号:");
                        String s=in.next();
                        System.out.println("转账金额:");
                        int i=in.nextInt();
                        if(atm.transfer(s, i))
                            System.out.println("转账成功!");
                        else
                            System.out.println("转账失败!");
                        System.out.println("当前余额:"+atm.getRest()+"元");
                        break;
                    case 4:
                        System.out.println("输入六位数密码:");
                        String p=in.next();
                        atm.setPassword(p);
                        break;
                    case 5:
                        System.out.println("当前余额:"+atm.getRest()+"元");
                        break;
                    default:
                        continue next;
                    }
                }
            }
            else
                System.out.println("密码错误!");
        }
    }
  //显示菜单方法
    public static void showFace(){
        System.out.println("1.存款");
        System.out.println("2.取款");
        System.out.println("3.转账汇款");
        System.out.println("4.修改密码");
        System.out.println("5.查询余额");
        System.out.println("6.退卡");
        System.out.println("请选择:");
    }
    }

 

结果:

新普京娱乐场 5

新普京娱乐场 6

新普京娱乐场 7

 

 

 

 

 

 

 

 

http://www.bkjia.com/Javabc/1173620.htmlwww.bkjia.comtruehttp://www.bkjia.com/Javabc/1173620.htmlTechArticle多态动手动脑,多态动脑
一、怎样判断目标是不是可转移?可以采取 instanceof
运算符判断一个对象是否足以转换为指定的种类,参看实例…

 

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

 

新普京娱乐场 8

其次、下列语句哪一个用唤起编译错误?为什么?哪一个会晤挑起运行时错?为什么?

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 static void main(String args[])
    {
        Mammal m;
        Dog d=new Dog();
        Cat c=new Cat();
        m=d;
        //d=m;
        d=(Dog)m;
        //d=c;
        //c=(Cat)m;

    }
}

 

d=m;

d=c;

c=(Cat)m;

立马三词话出错。

老三、请圈之下“变态”的接近(参看示例ParentChildTest.java),运行以下测试代码,并回复问题:1.程序运行结果是呀?2.公如何解释会取得这么的出口?3.电脑是未见面拧的,之所以取得这样的运转结果吗是有案由之,那么从这些运行结果丁,你可知总结出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);
    }
}

 

1、结果:

新普京娱乐场 9

2、Java语法特性:

    (1)当子类及父类拥有一致的道,并且吃一个父类变量引用一个子类对象时,到底调用哪个方法,由对象好之“真实”类型所控制,这即是说:对象是子类型的,它就调用子类型的办法,是父类型的,它就是调用父类型的主意。

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

    (2)如果子类与父类有一致之字段,则子类中的字段会代替或藏父类的字段,子类方法吃访问的是子类中之字段(而无是父类中之字段)。如果子类方法确实想拜会父类中于藏的同名字段,可以为此super关键字来访问它。如果子类被作父类使用,则透过子类访问的字段是父类的!

季、请用javap查看编译器为TestPolymorphism.java生成的字节码指令,然后经互联网搜寻资料,尝试从脚开始理解Java编译器是何许也多态代码生成字节码指令,在程序运行过程中,多态特性又是哪实现之。

 

class Parent1        
{
    public int value=100;    
    public void Introduce()
    {
            System.out.println("I'm father");
        }
}
class Son extends Parent1
{
    public int value=101;
         public void Introduce()
    {
            System.out.println("I'm son");    
}
}
class Daughter extends Parent1
{
    public int value=102;
    public void Introduce()
    {
            System.out.println("I'm daughter");    
}
}
public class TestPolymorphism
{
    public static void main(String args[])
    {
        Parent1 p=new Parent1();
        p.Introduce();//子类的方法
        System.out.println(p.value);//父类的变量对象
        p=new Son();
        p.Introduce();
        System.out.println(p.value);
        p=new Daughter();
        p.Introduce();
        System.out.println(p.value);
    }
}

结果:

新普京娱乐场 10

五、在实例中掌握多态的含义和用

新普京娱乐场 11

1、三种植动物对应三单近乎,每个接近定义一个eat()方法,表示吃饲养员给它们的食品,再规划一个Feeder类代表饲养员,其name字段保存饲养员名字,三独主意分别代表喂养三种植不同的动物,其参数分别引用三栽动物对象。

 

package Zoo1;
public class Zoo 
{
    public static void main(String args[])
    {
        Feeder f = new Feeder("小李");
        // 饲养员小李喂养一只狮子
        f.feedLion(new Lion());
        // 饲养员小李喂养十只猴子
        for (int i = 0; i < 10; i++)
         {
            f.feedMonkey(new Monkey());
        }        
        // 饲养员小李喂养5只鸽子
        for (int i = 0; i < 5; i++)
         {
            f.feedPigeon(new Pigeon());
        }    
    }
}
class Feeder 
{
    public String name;
    public Feeder(String name)
    {
        this.name = name;
    }    
    public void feedLion(Lion l)
    {
        l.eat();
    }    
    public void feedPigeon(Pigeon p)
    {
        p.eat();
    }    
    public void feedMonkey(Monkey m)
    {
        m.eat();
    }
}
class Lion
{
    public void eat() 
    {
        System.out.println("我不吃肉谁敢吃肉!");
    }
}
class Monkey 
{
    public void eat() 
    {
        System.out.println("我什么都吃,尤其喜欢香蕉。");
    }
}
class Pigeon 
{
    public void eat() 
    {
        System.out.println("我要减肥,所以每天只吃一点大米。");
    }
}

 

2、第一浅程序重构:引入继承,简化Feeder类

 

package Zoo2;
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("我要减肥,所以每天只吃一点大米。");
    }
}

 

3、第二赖程序重构,修改feedAnimals方法,让它接受一个Animal数组……

 

package Zoo3;
public class Zoo {
    public static void main(String args[]) {
        Feeder f = new Feeder("小李");
        Animal[] ans = new Animal[16];
        //饲养员小李喂养一只狮子
        ans[0] = new Lion();
        //饲养员小李喂养十只猴子
        for (int i = 0; i < 10; i++) {
            ans[1 + i] = new Monkey();
        }
        //饲养员小李喂养5只鸽子
        for (int i = 0; i < 5; i++) {
            ans[11 + i] = new Pigeon();
        }
        f.feedAnimals(ans);
    }
}
class Feeder {
    public String name;
    Feeder(String name) {
        this.name = name;
    }
    public void feedAnimals(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("我要减肥,所以每天只吃一点大米。");
    }
}

 

4、第三不行重构,修改feedAnimals方法,让该接到一个因素数目可变的目标容器。

 

package Zoo4;
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("我要减肥,所以每天只吃一点大米。");
    }
}

 

5、从之示例中得观看,通过以编程中运用多态,可以假设我们的代码有双重强的适用性。当需要变化时,多态特性可辅助我们将急需改的地方压缩到低限度。

多态编程有少栽主要形式:

(1)继承多态:示例程序用的法门

(2)接口多态:使用接口代替抽象基类。

使用多态最特别之补是:

当你如果改程序并扩张系统时,你待改的地方比较少,对另一些代码的震慑比较小!千万不要轻视这简单个“较”字!程序层面越来越怪,其优势就进一步突出。

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

 

//王荣荣 2016/11/18
import java.util.Scanner;
class PersonalAccount{
    private String passWord="123456";//密码
    private String number;//银行卡号
    private int money=0;
    public int getMoney(){
        return money;
        }//余额
    public void setPw(String s){
        passWord=s;
        }//设置密码
    public void addMoney(int x){
        money+=x;
        }//加钱
    public void minusMoney(int x){
        money-=x;
        }//减钱
    public boolean whetherPwTrue(String s){//密码是否正确
        if(s.equals(passWord))
            return true;
        else return false;
    }
    }
    abstract class PATM{
    abstract boolean withdraw(int x);//取款
    abstract void save(int x);//存款
    abstract boolean transfer(String s,int x);//转账
    abstract boolean ifPass(String s);//判断输入的密码是否正确
    abstract int getRest();//查询余额
    abstract void setPassword(String s);//设置密码
    }
    class ATM extends PATM{
    private String numbers[]={"123451","123452",
            "123453","123454","123455"};//数据库中已有的账户卡号
    private PersonalAccount account=new PersonalAccount();
    public boolean withdraw(int x) {
        if(x>account.getMoney())
            return false;
        else{
            account.minusMoney(x);
            return true;
        }
    }
    public void save(int x) {
        account.addMoney(x);
    }
    public boolean transfer(String s, int x) {
        //转账
        //先判断转到账户号是否存在
        //再判断余额是否足够
        boolean flag=false;
        for(int i=0;i<numbers.length;i++)
            if(s.equals(numbers[i])) flag=true;
        if(x>account.getMoney()) flag=false;
        if(x<=account.getMoney()&&flag) account.minusMoney(x);;
        return flag;
    }
    public boolean ifPass(String s) {
        return account.whetherPwTrue(s);
    }
    public int getRest() {
        return account.getMoney();
    }
    public void setPassword(String s) {
        account.setPw(s);        
    }
    }
public class Atm1 {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        ATM atm=new ATM();
        int choose=0,num=0;
        String pw="";
        next:while(true){
            System.out.println("是否进入账户(0否1是):");
            int kk=in.nextInt();
            if(kk==0) break;
            else if(kk!=1){
                System.out.println("输入错误!");
                continue;
            }
            System.out.println("输入账户密码:");
            pw=in.next();
            if(atm.ifPass(pw)){
                while(true){
                    showFace();
                    choose=in.nextInt();
                    switch(choose){
                    case 1:
                        System.out.println("输入存款金额:");
                        num=in.nextInt();
                        atm.save(num);
                        System.out.println("存款成功!");
                        System.out.println("当前余额:"+atm.getRest()+"元");
                        break;
                    case 2:
                        System.out.println("请选择:");
                        int a[]={100,500,1000,1500,2000,5000};
                        for(int i=0;i<a.length;i++)
                            System.out.println((i+1)+"."+a[i]+"元");
                        System.out.println("7.其他");
                        int ch=in.nextInt();
                        if(ch>=1&&ch<=6){
                            if(atm.withdraw(a[ch-1]))
                                System.out.println("取款成功!");
                            else
                                System.out.println("余额不足!");
                        }
                        else if(ch==7){
                            System.out.println("请输入取款金额:");
                            num=in.nextInt();
                            if(atm.withdraw(num))
                                System.out.println("取款成功!");
                            else 
                                System.out.println("余额不足!");
                        }
                        else 
                            System.out.println("输入有误!");
                        System.out.println("当前余额:"+atm.getRest()+"元");
                        break;
                    case 3:
                        System.out.println("账户号:");
                        String s=in.next();
                        System.out.println("转账金额:");
                        int i=in.nextInt();
                        if(atm.transfer(s, i))
                            System.out.println("转账成功!");
                        else
                            System.out.println("转账失败!");
                        System.out.println("当前余额:"+atm.getRest()+"元");
                        break;
                    case 4:
                        System.out.println("输入六位数密码:");
                        String p=in.next();
                        atm.setPassword(p);
                        break;
                    case 5:
                        System.out.println("当前余额:"+atm.getRest()+"元");
                        break;
                    default:
                        continue next;
                    }
                }
            }
            else
                System.out.println("密码错误!");
        }
    }
  //显示菜单方法
    public static void showFace(){
        System.out.println("1.存款");
        System.out.println("2.取款");
        System.out.println("3.转账汇款");
        System.out.println("4.修改密码");
        System.out.println("5.查询余额");
        System.out.println("6.退卡");
        System.out.println("请选择:");
    }
    }

 

结果:

新普京娱乐场 12

新普京娱乐场 13

新普京娱乐场 14

 

 

 

 

 

 

 

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注