银行，账户两个类对象的关系。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!
鸭子会飞
第二种叫声
鸭子不会飞
第三种叫声