制作信用卡类：
        类的属性：账户金额
        类的方法：充值，取款，查看余额，查看是否透支
   
        在main 函数中实现使用信用卡类完成如下功能
        实例化两张信用卡对象 card1,card2;  
        为card1 充值 1000 元，card2 充值 500 元；
        从card2 取款 600 元
        向card1 充值500 元
        分别输出 card1和card2 的余额，以及是否透支

liuch111 发表于 2015-8-27 10:32
2楼好厉害 2分钟解决问题

表示两分钟还没看完问题

这个题目就不严谨。
不过能写是真的。
在正式项目中不能这样写。考虑的还需要很多

1. 
   
2. /*
   
3. *
   
4. 制作信用卡类：
   
5.         类的属性：账户金额
   
6.         类的方法：充值，取款，查看余额，查看是否透支
   
7.    
   
8.         在main 函数中实现使用信用卡类完成如下功能
   
9.         实例化两张信用卡对象 card1,card2;  
   
10.         为card1 充值 1000 元，card2 充值 500 元；
    
11.         从card2 取款 600 元
    
12.         向card1 充值500 元
    
13.         分别输出 card1和card2 的余额，以及是否透支
    
14. */
    
15. 
    
16. class CreditCard
    
17. {
    
18.         private float yuE=0;
    
19.         //充值方法
    
20.         public boolean  chongZhi(float jinE)
    
21.         {
    
22.                 yuE+=jinE;
    
23.                 return true;
    
24.         }
    
25.         //取款方法
    
26.         public boolean quKuan(float jinE)
    
27.         {
    
28.                 yuE-=jinE;
    
29.                 return true;
    
30.         }
    
31.         //查余额方法
    
32.         public float chaYuE()
    
33.         {
    
34.                 return yuE;
    
35.         }
    
36.         //查看是否透支方法
    
37.         public boolean chaTouZhi()
    
38.         {
    
39.                 return yuE<0;
    
40.         }
    
41.        
    
42.        
    
43. }
    
44. public class BankDemo {
    
45. 
    
46.         public static void main(String[] args) {
    
47.                 CreditCard card1 = new CreditCard();
    
48.                 CreditCard card2 = new CreditCard();
    
49.                 System.out.println("card1充值1000元："+card1.chongZhi(1000));
    
50.                 System.out.println("card2充值500元："+card2.chongZhi(500));
    
51.                 System.out.println("card2取款600："+card2.quKuan(600));
    
52.                 System.out.println("card1充值500："+card1.chongZhi(500));
    
53.                 System.out.println("card1余额："+card1.chaYuE());
    
54.                 System.out.println("card1是否透支："+card1.chaTouZhi());
    
55.                 System.out.println("card2余额："+card2.chaYuE());
    
56.                 System.out.println("card2是否透支："+card2.chaTouZhi());
    
57.                
    
58.                
    
59.         }
    

复制代码

这个不涉及多线程吧。每个人有自己的卡。不存在操作同一账号的情况。没必要的，就是一个简单地面向对象。我根据实际情况设计了下，可以参考下。

1. 
   
2.         public class Card {
   
3.         private int MAXLIMIT=0;
   
4.         private String name="";//为账户加个名字
   
5.         private int money = 0;//账户余额
   
6.     //构造函数初始账户最高信用额度
   
7.         public Card(String name,int num)
   
8.         {
   
9.                 MAXLIMIT=num;
   
10.                 this.money=MAXLIMIT;
    
11.                 this.name=name;
    
12.                 System.out.println(name+"账户额度：￥"+money+"元" );
    
13.         }
    
14.         //还款
    
15.         public void addMoney(int num) {
    
16.                 money+=num;
    
17.                 System.out.println(name+"账户还款：￥"+num+"元  当前额度：￥"+money+"元");
    
18.         }
    
19.         //获取账户当前额度
    
20.         public int getMoney()
    
21.         {
    
22.                 return money;
    
23.         }
    
24.         //透支
    
25.         public int isOver (int money)
    
26.         {
    
27.                 return money-1000;
    
28.         }
    
29.         //消费函数
    
30.         public void getoutMoney(int num)
    
31.         {
    
32.                 money-=num;
    
33.                 System.out.println(name+"消费：￥"+num+"元  当前额度：￥"+ getMoney()+"元");
    
34.         }
    
35.         //获取账户信息
    
36.         public void cardInfo()
    
37.         {
    
38.                 //账户的额度大于等于初始额度,没有透支，反之透支。。
    
39.                 System.out.println(name+"的账户当前额度：￥"+ getMoney()+"元\t"+(isOver(getMoney())>0?"没有透支":"透支了￥"+isOver(getMoney())+"元"));
    
40.         }
    
41.         public static void main(String[] args)
    
42.         {
    
43.                 Card c1=new Card("小明",1000);
    
44.                 Card c2=new Card("花花",1000);
    
45.                 c1.getoutMoney(1500);
    
46.                 c2.getoutMoney(2500);
    
47.                 c1.addMoney(1000);
    
48.                 c2.addMoney(1500);
    
49.                 c1.cardInfo();
    
50.                 c2.cardInfo();
    
51.         }
    
52. }

复制代码

2楼好厉害 2分钟解决问题

这应该是使用多线程解决问题的一个案例吧

public class creditCard {
        //余额属性
        private int restMoney;

        public int getRestMoney() {
                return restMoney;
        }

        public void setRestMoney(int restMoney) {
                this.restMoney = restMoney;
        }
      
        //充值
        public int topUp(int Money){
                this.restMoney += Money;
                return restMoney;
        }
      
        //取款
        public int withdrawals(int Money){
                this.restMoney = restMoney - Money;
                return restMoney;
        }
      
        //查看余额
        public int viewMoney(){
                return this.restMoney;
        }
      
        //判断是否透支
        public boolean ifOverdraft(){
                if(this.restMoney < 0){
                        return true;
                }else{
                        return false;
                }
        }
      
        public static void main(String[] args){
                creditCard card1 = new creditCard();
                card1.setRestMoney(0);
                creditCard card2 = new creditCard();
                card2.setRestMoney(0);
                card1.topUp(1000);
                card2.topUp(500);
                card2.withdrawals(600);
                card1.topUp(500);
                System.out.println("card1的余额："+card1.getRestMoney());
                System.out.println("card2的余额："+card2.getRestMoney());
                if(!card1.ifOverdraft()){
                        System.out.println("card1未透支");
                }else{
                        System.out.println("card1已透支");
                }
                if(!card2.ifOverdraft()){
                        System.out.println("card2未透支");
                }else{
                        System.out.println("card2已透支");
                }
        };

};