封装和隐藏

为什么需要封装？封装的作用和含义？

  • 我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内部的结构吗？有必要碰电动机吗？
  • 我要开车，…
  • 我们程序设计追求“高内聚，低耦合”。
  • 高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
  • 低耦合 ：仅对外暴露少量的方法用于使用。
  • 隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提 高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

信息的封装和隐藏

Java中通过将数据声明为私有的(private)，再提供公共的（public） 方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：

  • 隐藏一个类中不需要对外提供的实现细节；
  • 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑， 限制对属性的不合理操作；
  • 便于修改，增强代码的可维护性；
  1. class Animal {
  2. private int legs;// 将属性legs定义为private，只能被Animal类内部访问
  3. public void setLegs(int i) { // 在这里定义方法 eat() 和 move()
  4. if (i != 0 && i != 2 && i != 4) {
  5. System.out.println("Wrong number of legs!");
  6. return; }
  7. legs = i; }
  8. public int getLegs() {
  9. return legs; } }
  10. public class Zoo {
  11. public static void main(String args[]) {
  12. Animal xb = new Animal();
  13. xb.setLegs(4); // xb.setLegs(-1000);
  14. //xb.legs = -1000; // 非法
  15. System.out.println(xb.getLegs());
  16. } }
  1. package com.atguigu.java;
  2. /*
  3.  * 面向对象的特征一：封装
  4.  * 一、问题引入
  5.  * 当我们创建一个类的对象后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。
  6.  * 这里赋值操作要受到属性的数据类型和存储范围的制约，除此之外，没有其他制约条件
  7.  * 但是，实际问题当中，我们往往需要给属性赋值加入额外的限制条件，这个条件不能在属性声明时体现
  8.  * 我们只能通过方法进行限制条件的添加（比如：setLegs），同时避免用户通过"对象.属性"的方式
  9.  * ，对对象的属性进行赋值。则需要讲属性声明为私有的(private)
  10.  * -->此时，针对属性体现封装性
  11.  * 
  12.  * 
  13.  * 二、封装性的体现
  14.  * 我们将类的属性私有化(private)，同时，提供公共(public)的方法来(getXxx)获取
  15.  * 和设置(setXxx)此属性的值
  16.  * 
  17.  * 拓展：封装性体现
  18.  *         1.如上
  19.  *         2.不对外暴露，私有的方法
  20.  *         3.单例模式...
  21.  * 
  22.  * 三、封装性的体现，需要权限修饰符来配合
  23.  * 1.java规定的四种权限(从小到大排列)：private、缺省、protected、public
  24.  * 2.4种权限可以用来修饰类以及类的内部结构：属性、方法、构造器、内部类
  25.  * 3.具体的，4种权限可以用来修饰类以及类的内部结构：属性、方法、构造器、内部类
  26.  *            修饰类的话，只能使用：缺省、public
  27.  *
  28.  * 总结封装性：Java提供4种权限修饰符来修饰类以及类的内部结构、体现类及类的内部结构在被调用时
  29.  *             可见性的大小
  30.  */
  32. public class AnimalTest {
  33.     public static void main(String[] args) {
  34.         Animal a = new Animal();
  35.         a.name = "大黄";
  36. //        a.age = 1;
  37. //        a.legs = 4;//The field Animal.legs is not visible
  39.         a.show();
  41. //        a.legs = -4;
  42.         a.setLegs(6);
  43.         a.setLegs(-6);
  44.         a.show();
  45.     }
  46. }
  48. class Animal{//类
  50.     String name;
  51.     private int age;
  52.     private int legs;//腿的个数
  54.     //对属性设置
  55.     public void setLegs(int l){
  56.         if(l >= 0 && l % 2 == 0){
  57.             legs = l;
  58.         }else{
  59.             legs = 0;
  60.         //抛出异常，暂时没讲
  61.         }
  62.     }
  64.     //对属性设置
  65.     public int getLegs(){
  66.         return legs;
  67.     }
  70.     public void eat(){
  71.         System.out.println("动物进实");
  72.     }
  74.     public void show(){
  75.         System.out.println("name = " + name + ",age = " + age +",legs = " + legs);
  76.     }
  78.     //提供关于属性age的get和set方法
  79.     public int getaAge(){
  80.         return age;
  81.     }
  83.     public void setAge(int a){
  84.         age = a;
  85.     }
  87. }

对四种权限修饰的测试

  1. package com.atguigu.java;
  3. public class Order {
  4.     //类内部
  5.     private int orderPrivate;
  6.     //同一个包
  7.     int orderDefaule;
  8.     //同一个工程
  9.     public int orderPublic;
  11.     private void mathodprivate(){
  12.         orderPrivate = 1;
  13.         orderDefaule = 2;
  14.         orderPublic = 3;
  15.     }
  17.     void methodDefault(){
  18.         orderPrivate = 1;
  19.         orderDefaule = 2;
  20.         orderPublic = 3;
  21.     }
  23.     public void methodPublic(){
  24.         orderPrivate = 1;
  25.         orderDefaule = 2;
  26.         orderPublic = 3;
  27.     }
  29. }
  1. package com.atguigu.java;
  3. public class OrderTest {
  4.     public static void main(String[] args) {
  5.         Order order = new Order();
  7.         order.orderDefaule = 1;
  8.         order.orderPublic = 2;
  9.         //出了Order类之后，私有的结构就不可以调用
  10. //        order.orderPrivate = 3;//The field Order.orderPrivate is not visible
  12.         order.methodDefault();
  13.         order.methodPublic();
  14. //        order.mathodprivate();//The method mathodprivate() from the type Order is not visible
  15.     }
  16. }
  1. package com.atguigu.java1;
  3. import com.atguigu.java.Order;
  5. public class OrderTest {
  6.     public static void main(String[] args) {
  7.         Order order = new Order();
  9.         order.orderPublic = 2;
  10.         // 出了Order类所属的包以后，私有结构、缺省声明的结构就不可以调用了
  11. //        order.orderDefaule = 1;
  12.         //出了Order类之后，私有的结构就不可以调用
  13. //        order.orderPrivate = 3;//The field Order.orderPrivate is not visible
  15.         order.methodPublic();
  16.         // 出了Order类所属的包以后，私有结构、缺省声明的结构就不可以调用了
  17. //        order.methodDefault();
  18. //        order.mathodprivate();//The method mathodprivate() from the type Order is not visible
  19.     }
  20. }

练习

  1. package com.atguigu.exer;
  2. /*
  3.  * 1.创建程序,在其中定义两个类：Person和PersonTest类。定义如下：
  4.  * 用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。 在 PersonTest 类 中实例化 Person 类的对象 b ， 调 用 setAge() 和
  5.  * getAge()方法，体会Java的封装性。
  6.  * 
  7.  */
  8. public class Person {
  10.     private int age;
  12.     public void setAge(int a){
  13.         if(a < 0 || a > 130){
  14.             System.out.println("传入的数据非法");
  15.             return ;
  16.         }
  17.         age =  a;
  18.     }
  20.     public int getAge(){
  21.         return age;
  22.     }
  24. }
  1. package com.atguigu.exer;
  3. public class PersonTest {
  4.     public static void main(String[] args) {
  5.         Person p1 = new Person();
  7. //        p1.age = 1;//编译不通过
  9.         p1.setAge(12);
  10.     }
  11. }

类的成员之三：构造器(或构造方法)

  1. package com.atguigu.java1;
  2. /*
  3.  * 类的结构之三：构造器(或构造方法)的使用
  4.  * construct
  5.  * 
  6.  * 一、构造器的作用
  7.  * 1.创建对象
  8.  * 2.初始化对象的信息
  9.  * 
  10.  * 二、说明
  11.  * 1.如果没有显示的定义类的构造器的话，系统默认提供一个空参的构造器
  12.  * 2.定义构造器的格式：权限修饰符 类名(形参列表){}
  13.  * 3.一个类中定义多个构造器，彼此构成重载
  14.  * 4.一旦显示定义类的构造器之后,系统不在提供默认的空参构造器
  15.  * 5.一个类中，至少有一个构造器
  16.  */
  17. public class PersonTest {
  18.     public static void main(String[] args) {
  19.         //创建类的对象：new + 构造器
  20.         Person p = new Person();//类型 变量名 = new 构造器器
  22.         p.eat();
  24.         Person p1 = new Person("Tom");
  26.         System.out.println(p1.name);
  27.     }
  29. }
  31. class Person{
  32.     //属性
  33.     String name;
  34.     int age;
  36.     //构造器
  37.     public Person(){
  38.         System.out.println("Person()....");
  39.     }
  41.     public Person(String n){
  42.         name = n;
  43.     }
  45.     //方法
  46.     public void eat(){
  47.         System.out.println("吃饭");
  48.     }
  49. }

练习

练习1和练习2

  1. package com.atguigu.exer;
  2. /*
  3.  * 1.创建程序,在其中定义两个类：Person和PersonTest类。定义如下：
  4.  * 用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。 在 PersonTest 类 中实例化 Person 类的对象 b ， 调 用 setAge() 和
  5.  * getAge()方法，体会Java的封装性。
  6.  * 
  7.  * 2.练习
  8.  * 1. 在前面定义的Person类中添加构造器，利用构造器设置所有人的age属性初始值都为18。
  9.  * 2. 修改上题中类和构造器，增加name属性,使得每次创建Person对象的同时初始化对象的age属性值和name属性值。
  10.  *  
  11.  */
  12. public class Person {
  14.     private int age;
  15.     private String name;
  17.     public Person(){
  18.         age = 18;
  19.     } 
  21.     public Person(String n,int a){
  22.         name = n;
  23.         age = a;
  24.     }
  26.     public void setAge(int a){
  27.         if(a < 0 || a > 130){
  28.             System.out.println("传入的数据非法");
  29.             return ;
  30.         }
  31.         age =  a;
  32.     }
  34.     public int getAge(){
  35.         return age;
  36.     }
  38.     public void setName(String n){
  39.         name = n;
  40.     }
  42.     public String getName(){
  43.         return name;
  44.     }
  45. }
  1. package com.atguigu.exer;
  3. public class PersonTest {
  4.     public static void main(String[] args) {
  5.         Person p1 = new Person();
  7. //        p1.age = 1;//编译不通过
  9.         //p1.setAge(12);
  11.         System.out.println("年林" + p1.getAge());
  13.         Person p2 = new Person("Jerrmy", 21);
  14.         System.out.println("name = " + p2.getAge() + ",age = " + p2.getName());
  15.     }
  16. }

练习3

  1. package com.atguigu.exer1;
  2. /*
  3.  * 3.编写两个类，TriAngle和TriAngleTest，其中TriAngle类中声明私有的底
  4.  * 边长base和高height，同时声明公共方法访问私有变量。此外，提供类必要的构造器。
  5.  * 另一个类中使用这些公共方法，计算三角形的面积。
  6.  */
  8. //任何情况都可用
  9. public class TriAngle {
  11.     private double base;//底边长
  12.     private double height;//高
  14.     public TriAngle(){
  16.     }
  18.     public TriAngle(double b,double h){
  19.         base = b;
  20.         height = h;
  21.     }
  23.     public void setBase(double b){
  24.         base = b;
  25.     }
  27.     public double getBase(){
  28.         return base;
  29.     }
  31.     public void setHeight(double h){
  32.         height = h;
  33.     }
  35.     public double getHeight(){
  36.         return height;
  37.     }
  38. }
  1. package com.atguigu.exer1;
  3. public class TriAngleTest {
  4.     public static void main(String[] args) {
  5.         TriAngle t1 = new TriAngle();
  6.         t1.setBase(2.0);
  7.         t1.setBase(2.4);
  8. //        t1.base = 2.5;//The field TriAngle.base is not visible
  9. //        t1.height = 4.3;//The field TriAngle.height is not visible 
  10.         System.out.println("base" + t1.getBase() + ",height" + t1.getHeight());
  12.         TriAngle t2 = new TriAngle(5.1,5.6);
  13.         System.out.println("base" + t1.getBase() + ",height" + t1.getHeight());
  14.     }
  15. }

属性赋值的先后顺序

  1. package com.atguigu.java1;
  2. /*
  3.  * 总结：属性赋值的先后顺序
  4.  * 
  5.  * 1.默认初始化值
  6.  * 2.显示初始化
  7.  * 3.构造器中初始化
  8.  * 
  9.  * 4.通过“对象.方法” 或“对象.属性”的方式，赋值
  10.  * 
  11.  * 以上操作的先后顺序：1--> 2 --> 3 --> 4
  12.  */
  13. public class UserTest {
  14.     public static void main(String[] args) {
  15.         User u = new User();
  17.         System.out.println(u.age);
  19.         User u1 = new User(2);//构造器中赋值
  21.         u1.setAge(3);//对象.方法
  23.         System.out.println(u1.age);
  24.     }
  25. }
  27. class User{
  28.     String name;//默认初始化
  29.     int age = 1;//显示初始化
  31.     public User(){
  33.     }
  35.     public User(int a){
  36.         age = a;
  37.     }
  39.     public void setAge(int a){
  40.         age = a;
  41.     }
  42. }

JavaBean

  • JavaBean是一种Java语言写成的可重用组件。

  • 所谓javaBean，是指符合如下标准的Java类：

    • 类是公共的
    • 有一个无参的公共的构造器
    • 有属性，且有对应的get、set方法
  • 用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以 用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP 页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用
    户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。
  1. package com.atguigu.java1;
  2. /*
  3.  * 1.JavaBean是一种Java语言写成的可重用组件。 
  4.  * 2.所谓javaBean，是指符合如下标准的Java类： 
  5.  *     - 类是公共的 
  6.  *     - 有一个无参的公共的构造器 
  7.  *     - 有属性，且有对应的get、set方法
  8.  * 3.用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以 用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP 页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用 
  9.  *户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。 
  10.  */
  11. public class Customer {
  13.     private int id;
  14.     private String name;
  15.     //构造器的权限默认和类的权限相同
  16.     public Customer(){
  18.     }
  20.     public int getId(){
  21.         return id;
  22.     }
  24.     public void setId(int id){
  25.         this.id = id;
  26.     }
  28.     public String getName(){
  29.         return name;
  30.     }
  32.     public void setName(String name){
  33.         this.name = name;
  34.     }
  35. }

九、关键字：this的使用

  1. package com.atguigu.java2;
  2. /*
  3.  * this关键字的使用
  4.  * 1.this可以用来修饰、调用：属性、方法、构造器
  5.  * 
  6.  * 2.this修饰属性和方法：
  7.  *     this理解为:当前对象 或当前正在创建的对象
  8.  *     
  9.  *     2.1在类的方法当中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象的属性或方法
  10.  *     但是，通常情况下，选择省略"this."。特殊情况下，如果方法的形参和属性同名，我们必须显示使用
  11.  *     "this.变量"的方式,表明此变量是属性，而非形参
  12.  * 
  13.  *     2.2在类的构造器当中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象的属性或方法
  14.  *     但是，通常情况下，选择省略"this."。特殊情况下，如果构造器的形参和属性同名，我们必须显示使用
  15.  *     "this.变量"的方式,表明此变量是属性，而非形参
  16.  * 
  17.  * 3.this调用构造器
  18.  *     3.1我们在类的构造器中，可以显示的使用"this(形参列表)"方式，调用本类中指定的其他构造器
  19.  *     3.2构造器中不能通过"this(形参列表)"方式,调用自己
  20.  *     3.3如果一个类中有n个构造器，则最多有n-1构造器中使用"this(形参列表)"
  21.  *     3.4规定："this(形参列表)"必须在当前构造器首行
  22.  *     3.5构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器
  23.  */
  24. public class PersonTest {
  25.     public static void main(String[] args) {
  26.         Person p1 = new Person();
  28.         p1.setAge(1);
  29.         System.out.println(p1.getAge());
  31.         p1.eat();
  33.         System.out.println();
  35.         Person p2 = new Person("Jerrmy",20);
  36.     }
  37. }
  39. class Person{
  40.     private String name;
  41.     private int age;
  43.     public Person(){
  44.         //this.eat();
  45.         String info = "Person初始化时，需要考虑如下1，2，3，4（共40行代码）";
  46.         System.out.println(info);
  47.     }
  49.     //构造器没有返回值
  50.     public Person(String name){
  51.         this();//调用空参构造器、且必须在当前构造器首行
  52.         this.name = name;
  53.         //Person初始化时，需要考虑如下1，2，3，4（共40行代码）
  54.     }
  56.     public Person(int age){
  57.         this();
  58.         this.age = age;
  59.         //Person初始化时，需要考虑如下1，2，3，4（共40行代码）
  60.     }
  62.     public Person(String name,int age){
  63.         this(age);
  64.         this.name = name;
  65.         //this.age = age;
  66.         //Person初始化时，需要考虑如下1，2，3，4（共40行代码）
  67.     }
  69.     public void setName(String name){
  70.         this.name = name;
  71.     }
  73.     public String getName(){
  74.         return name;
  75.     }
  77.     public void setAge(int age){
  78.         this.age = age;
  79.     }
  81.     public int getAge(){
  82.         return age;
  83.     }
  85.     public void eat(){
  86.         System.out.println("人吃饭");
  87.         this.study();
  88.     }
  90.     public void study(){
  91.         System.out.println("人学习");
  92.     }
  93. }

练习11

  1. package com.atguigu.exer2;
  3. public class Boy {
  4.     private String name;
  5.     private int age;
  7.     public Boy() {
  9.     }
  11.     public Boy(String name,int age){
  12.         this.name = name;
  13.         this.age = age;
  14.     }
  16.     public String getName() {
  17.         return name;
  18.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  22.     public int getAge() {
  23.         return age;
  24.     }
  25.     public void setAge(int age) {
  26.         this.age = age;
  27.     }
  29.     public void marry(Girl girl){
  30.         System.out.println("我想娶" + girl.getName());
  31.     }
  33.     public void shout(){
  34.         if(this.age >= 22){
  35.             System.out.println("你可以登记结婚了");
  36.         }else{
  37.             System.out.println("多谈谈恋爱");
  38.         }
  39.     }
  40. }
  1. package com.atguigu.exer2;
  3. public class Girl {
  4.     private String name;
  5.     private int age;
  7.     public Girl(){
  9.     }
  11.     public Girl(String name,int age){
  12.         this.name = name;
  13.         this.age = age;
  14.     }
  15.     public String getName() {
  16.         return name;
  17.     }
  18.     public void setName(String name) {
  19.         this.name = name;
  20.     }
  22.     public void marry(Boy boy){
  23.         System.out.println("我想嫁给" + boy.getName());
  24.         boy.marry(this);//传递的是Girl类型，this表示当前对象
  25.     }
  27.     public int compare(Girl girl){
  28.         /*if(this.age > girl.age){
  29.             return 1;
  30.         }else if(this.age < girl.age){
  31.             return -1;
  32.         }else {
  33.             return 0;
  34.         }*/
  36.         return this.age - girl.age;    
  37.     }
  38. }
  1. package com.atguigu.exer2;
  3. public class BoyGirlTest {
  5.     public static void main(String[] args) {
  7.         Boy boy = new Boy("罗密欧", 21);
  8.         boy.shout();
  10.         Girl girl = new Girl("朱丽叶", 18);
  11.         girl.marry(boy);
  13.         Girl girl1 = new Girl("祝英台", 18);
  14.         int compare = girl.compare(girl1);
  15.         if(compare > 0){
  16.             System.out.println(girl.getName() + "大");
  17.         }else if(compare > 0){
  18.             System.out.println(girl1.getName() + "大");
  19.         }else{
  20.             System.out.println("一样大");
  21.         }
  22.     }
  23. }

实验1

实验2（难、收获大）

1.按照如下的 UML 类图，创建相应的类，提供必要的结构

3.（封装、构造器、this） - 图1

在提款方法 withdraw()中，需要判断用户余额是否能够满足提款数额的要求，如果不能，

应给出提示。deposit()方法表示存款。

2.按照如下的 UML 类图，创建相应的类，提供必要的结构

3.（封装、构造器、this） - 图2

  1. 按照如下的 UML 类图，创建相应的类，提供必要的结构
    3.（封装、构造器、this） - 图3

    • addCustomer 方法必须依照参数（姓，名）构造一个新的 Customer 对象，然后把
      它放到 customer 数组中。还必须把 numberOfCustomer 属性的值加 1。

    • getNumOfCustomers 方法返回 numberofCustomers 属性值。

    • getCustomer 方法返回与给出的 index 参数相关的客户。

  2. 创建 BankTest 类，进行测试。
    Account

  1. package com.atguigu.exer4;
  3. public class Account {
  5.     private double balance;
  7.     public Account(double init_balance){
  8.         this.balance = init_balance;
  9.     }
  11.     public double getBalance(){
  12.         return balance;
  13.     }
  15.     //存钱操作
  16.     public void deposit(double amt){
  17.         if(amt > 0){
  18.             balance += amt;
  19.         }
  20.     }
  22.     //取钱操作
  23.     public void withdraw(double amt){
  24.         if(balance >= amt){
  25.             balance -= amt;
  26.             System.out.println("取钱成功");
  27.         }else{
  28.             System.out.println("余额不足");
  29.         }    
  30.     }
  31. }

Bank

  1. package com.atguigu.exer4;
  3. public class Bank {
  4.     private Customer[] customers;//存放多个数组
  5.     private int numerOfCustomer;//记录客户个数
  7.     public Bank(){
  8.         customers = new Customer[10];
  9.     }
  11.     //添加客户
  12.     public void addCustomer(String f,String l){
  13.         Customer cust = new Customer(f,l);//new一个,创建对象
  14.         //报空指针异常，数组没有初始化
  15.         customers[numerOfCustomer++] = cust;//存放地址
  16.     }
  18.     //获取指定位置上客户
  19.     public Customer getCustomer(int index) {
  20.         if(index >= 0 && index <= numerOfCustomer){
  21.             return customers[index]; 
  22.         }
  24.         return null;
  26.     }
  28.     public int getNumerOfCustomer() {
  29.         return numerOfCustomer;
  30.     }    
  31. }

Customer

  1. package com.atguigu.exer4;
  3. public class Customer {
  4.     private String firstName;
  5.     private String lastName;
  6.     private Account account;
  8.     public Customer(String f, String l){
  9.         this.firstName = f;
  10.         this.lastName = l;
  11.     }
  13.     public Account getAccount() {
  14.         return account;
  15.     }
  17.     public void setAccount(Account account) {
  18.         this.account = account;
  19.     }
  21.     public String getFirstName() {
  22.         return firstName;
  23.     }
  25.     public String getLastName() {
  26.         return lastName;
  27.     }    
  28. }

BankTest

  1. package com.atguigu.exer4;
  3. public class BankTest {
  4.     public static void main(String[] args) {
  5.         Bank bank = new Bank();
  7.         bank.addCustomer("Jane","Smith");
  8.         //匿名对象
  9.         bank.getCustomer(0).setAccount(new Account(2000));
  11.         bank.getCustomer(0).getAccount().withdraw(500);
  13.         double balance = bank.getCustomer(0).getAccount().getBalance();
  14.         System.out.println("客户 ：" + bank.getCustomer(0).getFirstName() + 
  15.                 "账户的余额为：" + balance);
  17.         System.out.println("***************************");
  19.         bank.addCustomer("万里", "鹏程");
  20.         System.out.println("银行客户个数为 " + bank.getNumerOfCustomer());
  21.     }    
  22. }