Java实例教程（4）信用卡应用程序-CSDN博客

类是一个抽象，因此可以有自己的属性，该属性通常用某一个变量来进行描述。类的属性是所有对象所共有的，是抽象的，而对象的属性微观的、具体的。例如上述的动物中，如果把腿（脚）的个数作为属性，那么每种动物都有这个属性，但是并不能具体描述动物的腿（脚）的个数，而每个对象（鸡、猫、狗、牛）对应这个属性都有具体的值。

当需要引用该属性时，通过通过下述方式：

对象名 . 属性名

下面定义一个信用卡的类，类中定义了 float 型变量 money ，用它来表示当前账户的余额。

1 public class CreditCard1 {

2 float money;

3 public static void main(String args[])

4 {

5 CreditCard1 john=new CreditCard1();

6 john.money=1000;

7 System.out.println("john 的账户上有 "+john.money+" 元 ");

8 john.money=john.money-800; //john 买了一块手表，消费了 800 元。

9 System.out.println("john 购买手表花了 800 元 ");

10 System.out.println(" 此时， john 的账户上有 "+john.money+" 元 ");

11 }

12 }

在程序中首先定义了一个类“ CreditCard1 ”，类中有一个变量 money 用来存取当前的账户余额。在程序的第 5 行定义了当前类的一个对象 john ，表示开了一张具体的信用卡 john 。在第 6 行，对信用卡进行了充值，充值后账面的余额为 1000 元。在第 7 行对当前的账户余额进行了显示。在第 8 行将对象 john 的 money 属性进行算数运算，即从其账面上减去 800 元，此操作用来模拟该信用卡的购买手表消费。第 9 、 10 行对账户信息进行显示，显示购买手表后账户余额情况。

运行程序，程序的运行结果如图 4.1 所示。

图 4.1 程序运行结果

4.2 包

Java 语言中每个类都包含在一个包中，包是唯一命名的类的集合。简单理解，包就是管理若干源文件的一个文件夹，因此有效使用包，能够提高程序的可读性和开发效率。包语句的格式如下：

Package packageName;

包名的第一个字母通常小写。

下面将新建的文件建在包 lesson4 中，具体代码如下：

1 package lesson4;

3 public class CreditCard2 {

4 float money;

5 public static void main(String args[])

6 {

7 CreditCard2 john=new CreditCard2();

8 john.money=1000;

9 System.out.println("john 的账户上有 "+john.money+" 元 ");

10 john.money=john.money-800;

11 System.out.println("john 购买手表花了 800 元 ");

12 System.out.println(" 此时， john 的账户上有 "+john.money+" 元 ");

13 }

14 }

首先对程序进行编译，在当前目录“ e:\book\demo\lesson4 ”下执行“ javac CreditCard2.java ”后按回车键，如图 4.2 所示。

图 4.2 编译源程序

在当前目录下执行“ cd.. ”回到上一级目录，然后执行“ java lesson4.CreditCard2 ”，得到运行结果如图 4.3 所示。执行语句“ java lesson4.CreditCard2 ”的含义为执行当前目录下“ lesson4 ”包中的类文件“ CreditCard2 ”。

图 4.3 程序运行结果

4.3 方法

在现实世界中，每个实体通常除了具有自身的属性外，大多还具有动态行为特征。例如动物不仅仅有体重、腿（脚）个数等静态属性，还具有跑、跳、吃等动态行为特征。在面向对象程序设计中，类由变量和方法来描述，变量对应的是静态属性，方法对应的是动态属性。因此，通常应用方法来完成一个特定的操作。

方法的定义格式为：

返回值数据类型方法名 ( )

{

语句块

}

返回值类型值方法操作完成后所返回数据的数据类型，如果当前没有任何的返回值，则定义为“ void ”表示无返回值。语句块即为方法的具体实现。

定义了方法后，就可以对其进行引用，引用（调用）方法的方式为：

对象名 . 方法名 ()

下面在信用卡的应用程序中定义两个方法，其中一个是购买手表（ buyWatch ）的方法，该方法首先实现将账户余额减去 800 元，然后显示“购买手表花了 800 元”；另外一个是显示（ show ）的方法，该方法能够显示当前信用卡上的余额信息。

修改后的程序为：

1 package lesson4;

3 public class CreditCard3 {

4 float money;

5 void buyWatch()

6 {

7 money=money-800;

8 System.out.println(" 购买手表花了 800 元 ");

9 }

10 void show()

11 {

12 System.out.println(" 当前账上余额为 "+money+" 元 ");

13 }

14 public static void main(String args[])

15 {

16 CreditCard3 john=new CreditCard3();

17 john.money=1000;

18 john.show();

19 john.buyWatch();

20 john.show();

21 }

22 }

程序第 5 ～ 9 行定义了一个 buyWatch 方法，表示购买一块 800 元的手表。方法体内首先将账面余额减去 800 元，然后打印了提示信息。第 10 ～ 13 行定义了方法 show ，用来显示当前账上余额。在 main 函数中， 18 行、 20 行对函数 show 进行了调用以显示账上余额；第 19 行对 buyWatch 进行了调用，首先处理了账面余额然后打印了账面余额信息。

对该程序进行编译，运行，结果如图 4.4 所示。

图 4.4 程序运行结果

4.4 方法的参数

上述的方式实现了购买手表和打印输出。在实际使用过程中信用卡可能需要购买不同价格的物品。为了实现更多功能，需要使用带有参数的方法。带有参数的方法，能够通过更灵活的方式来实现对当前对象的操作。

在方法定义过程中使用的参数称为形式参数，在程序运行过程中，方法调用时所使用的参数称为实际参数。参数在传递过程中应该保证实参和形参在个数、类型上的一致性。

修改上述程序如下：

1 package lesson4;

3 public class CreditCard4 {

4 float money;

5 void shopping(float goodsMoney)

6 {

7 money=money-goodsMoney;

8 System.out.println(" 购物刷卡，花掉 "+goodsMoney+" 元 ");

9 }

10 void show()

11 {

12 System.out.println(" 当前账上余额为 "+money+" 元 ");

13 }

14 public static void main(String args[])

15 {

16 CreditCard4 john=new CreditCard4();

17 john.money=1000;

18 john.show();

19 john.shopping((float)200);

20 john.show();

21 }

22 }

程序中第 5 行定义了一个 shopping 方法，该方法有一个参数 goodsMoney ，用来表示每次刷卡消费的金额。方法中首先，通过算数运算减去刷卡金额，然后通过输出语句对当前的消费情况进行打印输出。

程序第 19 行“（ float ） 200 ”表示强制类型转换。因为当前的实参类型为 int ，而形参为 float ，它们的类型不一致，为了保证类型的一致需要进行强制类型转换。强制类型转换的形式为在需要转换的变量前加上由括号组成的要转化成的数据类型。

编译并运行该程序，如图 4.5 所示。

图 4.5 编译运行过程

4.5 字符串

Java 语言中，字符串是作为对象而存在的，每个字符串都是 String 类的对象。定义字符串的方法为：

String 字符串名 = 字符串常量值

定义时，可以根据需要选择是否对字符串进行赋初值。例如，定义一个名字为 goodsName 的字符串变量，可以采用如下方式：

String goodsName ；

或者

String goodsName ="TV";

在实际操作中，通常需要用用户名等信息来对不同的信用卡进行识别、管理等操作。为了便于管理，在信用卡类中定义持卡人姓名（ name ）这个属性。

修改后的程序如下：

1 package lesson4;

3 public class CreditCard5 {

4 double money;

5 String name;

6 void shopping(String goodsName,double goodsMoney)

7 {

8 money=money-goodsMoney;

9 System.out.println(name+" 购买 "+goodsName+", 刷卡花掉 "+goodsMoney+" 元 ");

10 }

11 void show()

12 {

13 System.out.println(name+" 当前账上余额为 "+money+" 元 ");

14 }

15 public static void main(String args[])

16 {

17 CreditCard5 john=new CreditCard5();

18 john.name="Ross John";

19 john.money=1000;

20 CreditCard5 MW=new CreditCard5();

21 MW.name="Mke walt";

22 MW.money=2000;

23 john.show();

24 john.shopping("MP3",200.50);

25 john.show();

26 MW.show();

27 MW.shopping("TV", 500);

28 MW.show();

29 }

30 }

编译运行该程序，如图 4.6 所示。

图 4.6 编译运行示意图

4.6 构造函数

在定义一个对象后，可以通过给对象赋值的方式来完成对象的初始化工作。但是，这样操作起来比较麻烦，而且不直观。因此， Java 在类里提供了一个特殊的成员函数，叫做构造函数（ Constructor ）。一个构造函数是对象被创建时初始对象的成员函数。它具有和它所在的类完全一样的名字。一旦定义好一个构造函数，创建对象时就会自动调用它。构造函数没有返回类型，即使是 void 类型也没有。这是因为一个类的构造函数的返回值的类型就是这个类本身。构造函数的任务是初始化一个对象的内部状态，所以用 new 操作符创建一个实例后，立刻就会得到一个清楚、可用、具体的对象。

需要注意的是， Java 语言中在定义类的过程中会自动定义没有参数的构造函数。在编写程序的过程中，如果创建了自己的构造函数，那么原先的没有参数的构造函数便不再存在。以后在定义对象过程中，必须按照自定义构造函数的格式来定义新的对象。

修改上述程序代码，在类中添加构造函数，实现如下：

1 package lesson4;

3 public class CreditCard6{

4 double money;

5 String name;

6 CreditCard6(String sName,double sMoney)

7 {

8 name=sName;

9 money=sMoney;

10 }

11 void shopping(String goodsName,double goodsMoney)

12 {

13 money=money-goodsMoney;

14 System.out.println(name+" 购买 "+goodsName+", 刷卡花掉 "+goodsMoney+" 元 ");

15 }

16 void show()

17 {

18 System.out.println(name+" 当前账上余额为 "+money+" 元 ");

19 }

20 public static void main(String args[])

21 {

22 CreditCard6 mike=

23 new CreditCard6("ROBER MIKE",2356);

24 CreditCard6 ross=

25 new CreditCard6("RIGHT ROSS",8957);

26 mike.show();

27 mike.shopping("MP3",200.50);

28 mike.show();

29 ross.show();

30 ross.shopping("TV", 500);

31 ross.show();

32 }

33 }

程序中，第 6 ～ 10 行定义了一个构造函数。该函数内有 3 参数，分别用来实现对 ID ， nmae ， money 的初始化工作。在第 22 ～ 25 行定义了两个对象 mike 、 ross 。在定义对象的过程中均使用了在第 6 ～ 10 行定义的构造函数。

编译、运行该程序，如图 4.7 所示。

图 4.7 编译、运行显示