java编程操作心血2

     银行，账户两个类对象的关系。has-a关系

 银行：package pc1;

 

public class Bank {

String bankName;//银行名

double deposit_rate;//存款率

double borrow_rate;//取款率

double transfer_fee;//转账率

public String getBankName() {

return bankName;

}

public void setBankName(String bankName) {

this.bankName = bankName;

}

public double getDeposit_rate() {

return deposit_rate;

}

public void setDeposit_rate(double deposit_rate) {

this.deposit_rate = deposit_rate;

}

public double getBorrow_rate() {

return borrow_rate;

}

public void setBorrow_rate(double borrow_rate) {

this.borrow_rate = borrow_rate;

}

public double getTransfer_fee() {

return transfer_fee;

}

public void setTransfer_fee(double transfer_fee) {

this.transfer_fee = transfer_fee;

}

public Bank(String bankName, double deposit_rate, double borrow_rate,double transfer_fee) 

{

super();

this.bankName = bankName;

this.deposit_rate = deposit_rate;

this.borrow_rate = borrow_rate;

this.transfer_fee = transfer_fee;

}

 

}

账户：package pc1;

 

import java.util.Date;

 

public class Account {

private String user_id;//用户号

private String user_Name;//用户名

private Date account_date;//申请日期

private Bank   bank;//银行（这个账户是属于哪个银行的），

private double account_money;//金额

public Account(String user_id, String user_Name, Bank bank,//构造函数

double account_money) {

super();

this.user_id = user_id;

this.user_Name = user_Name;

this.bank = bank;

this.account_money = account_money;

this.account_date=new Date();

}

 

public void deposit(double account_money){//存钱和银行无关

if(account_money>0){

this.account_money=this.account_money+account_money;

}else

{

System.out.println("存款金额不能小0!");

}

 

}

 

public void withdraw(double money){//取钱和银行没有关系

if(account_money>0){

this.account_money=this.account_money-money;

}else

{

System.out.println("取款金额不能小0!");

}

}

 

public void transfer(double money, Account account){//转账要考虑率

if(money>0){

this.account_money=this.account_money-money-this.bank.getTransfer_fee()*(money/100);

account.deposit(money);

}else{

System.out.println("转账金额不能小0!");

}

}

 

public void settle(){

this.account_money=this.account_money+this.account_money*this.bank.getDeposit_rate()*2;

}

 

public void displayMoney(){

System.out.println(user_Name+"的余额是: "+this.account_money);

}

 

public void displayAccountMessage(){

System.out.println("账户名        账号                  开户日期                    结算日期                     账户余额     ");

System.out.print(this.user_Name);

System.out.print("   "+this.user_id);

System.out.println("   "+this.account_date);

System.out.println("   "+new Date());

System.out.println("   "+this.account_money);

 

}

}

//has-a关系的实际使用

test

package pc1;

 

public class Test {

 

public static void main(String[] args) {

// TODO Auto-generated method stub

Bank bank1=new Bank("CBC", 0.035, 0.0581, 3);

Bank bank2=new Bank("BC", 0.025, 0.0585, 1);

Account ac1=new Account("10001", "甲",bank1 ,200000.0);

Account ac2=new Account("20001", "乙",bank2 ,300000.0);

ac1.displayAccountMessage();

ac2.displayAccountMessage();

ac2.transfer(100000.0, ac1);

ac1.settle();

ac2.settle();

ac1.displayAccountMessage();

ac2.displayAccountMessage();

}

 

}

输出：甲   10001   Mon Jan 05 23:27:19 CST 2015

   Mon Jan 05 23:27:19 CST 2015

   200000.0

账户名        账号                  开户日期                    结算日期                     账户余额     

乙   20001   Mon Jan 05 23:27:19 CST 2015

   Mon Jan 05 23:27:19 CST 2015

   300000.0

账户名        账号                  开户日期                    结算日期                     账户余额     

甲   10001   Mon Jan 05 23:27:19 CST 2015

   Mon Jan 05 23:27:19 CST 2015

   321000.0

账户名        账号                  开户日期                    结算日期                     账户余额     

乙   20001   Mon Jan 05 23:27:19 CST 2015

   Mon Jan 05 23:27:19 CST 2015

   208950.0

 

DEMO2

多态fuxi

package pc3;

class Father{   

    //父类有一个打孩子方法   

    public void hitChild(){   

    }   

}   

class Son1 extends Father{   

    //重写父类打孩子方法   

    public void hitChild(){   

      System.out.println("为什么打我？我做错什么了！");   

    }   

}   

class Son2 extends Father{   

    //重写父类打孩子方法   

    public void hitChild(){   

      System.out.println("我知道错了，别打了！");   

    }   

}   

class Son3 extends Father{   

    //重写父类打孩子方法   

    public void hitChild(){   

      System.out.println("我跑，你打不着！");   

    }   

}   

/*

  父亲打孩子，不同的孩子表现出不同的行为

 */

public class FS {

 

public static void main(String[] args) {

// TODO Auto-generated method stub

Father father;   

     father = new Son1();   

     father.hitChild();   

     father = new Son2();   

     father.hitChild();   

     father = new Son3();   

     father.hitChild(); 

}

 

}

 

    //都调用了相同的方法，出现了不同的结果！这就是多态的表现。

 

//上面的示例也就是工厂模式的一个简单体现

 

 

Demo3、鸭子会飞与否，也会叫与否，但是所有的鸭子都会游泳，设计一个鸭子类

package pc3;

abstract class Duck {

protected  FlyBehavior  flyBehavior;     

/*

接口类型的引用，作为成员变量，可以指向不同的实现这个接口的类

*/

protected  QuackBehavior  quackBehavior; 

 

public void setFlyBehavior(FlyBehavior flyBehavior) {

this.flyBehavior = flyBehavior;//设立新的flyBehavior类型的值

}

 

public void setQuackBehavior(QuackBehavior quackBehavior) {

this.quackBehavior = quackBehavior;//设立新的quackBehavior类型的值

}

 

public void performFly(){

flyBehavior.fly();           //调用flyBehavior的fly()方法

}

 

public void performQuack(){

quackBehavior.quack();  //调用quackBehavior的quack ()方法

}

 

public abstract void display();         //定义一个显示鸭子外观的抽象方法

 

public void swim(){                 //定义一个所有鸭子都会游泳的方法

System.out.println("All ducks float, even decoys!");

}

}

 

 

 interface FlyBehavior {   //定义一个模拟鸭子飞的行为接口

   void fly();

}

 interface QuackBehavior { //定义一个模拟鸭子叫的行为接口

 void quack();

 }

 

  class FlyNoWay implements FlyBehavior{  //不会飞的

public void fly()

{

System.out.println("鸭子不会飞");

}

}

   class FlyWithWings implements FlyBehavior {  //会飞的

   public void fly()

   {

   System.out.println("鸭子会飞");

   }

}

   //实现flyBehavior这个接口，要么鸭子会飞，要么不会飞

    class Quack implements QuackBehavior{  //第一种叫声

   public void quack()

   {

System.out.println("第一种叫声");

   }

   }

   class Squeak implements QuackBehavior{//第二种叫声

    public void quack()

       {

    System.out.println("第二种叫声");

       }

   }

    class MuteQuack implements QuackBehavior{ //不会叫

    public void quack()

       {

    System.out.println("第三种叫声");

       }

   }

   

//实现quackBehavior这个接口，类里面要实现接口的每一个方法

 

public class ADuck extends Duck {  //定义一个鸭子类，其中含有main()的测试类

public ADuck() {

flyBehavior = new FlyWithWings();  //生成一个会飞的鸭子对象，接口的引用指向对象

quackBehavior = new Squeak();    //生成一个会叫的鸭子对象。接口的引用指向该对象

}

 

public void display() {

System.out.println("I'm a duck model.");

}

 

public void changeBehavior() {          

setFlyBehavior(new FlyNoWay());  //生成一个不会飞的鸭子对象

setQuackBehavior(new MuteQuack()); ////生成一个不会叫的鸭子对象

}

 

public static void main(String[] args) {

ADuck aDuck = new ADuck();

aDuck.display();

aDuck.swim();

aDuck.performFly();

aDuck.performQuack();

aDuck.changeBehavior();

aDuck.performFly();

aDuck.performQuack();

}

}

 

 

输出：I'm a duck model.

All ducks float, even decoys!

鸭子会飞

第二种叫声

鸭子不会飞

第三种叫声