8. 面向对象 -- 继承_4)编写一个 java 应用程序,在主类的 main 方法中声明用于存放产品数量的int-CSDN博客

本文链接：https://blog.csdn.net/YuAn_ZHUYUAN/article/details/80295295

1:如何制作帮助文档

(1)写一个类

(2)加入文档注释（/** ….*/）

(3)通过javadoc工具生成即可

javadoc -d 目录 -author -version ArrayTool.java

目录：就可以写一个文件夹的路径

2:通过JDK提供的API学习了Math类(掌握)

(1)API(Application Programming Interface)

应用程序编程接口(帮助文档)

(2)如何使用呢?

1:打开帮助文档

2:点击显示，找到索引，看到输入框

3:知道你要找谁?以Scanner举例

4:在输入框里面输入Scanner，然后回车

5:看包 java.lang包下的类不需要导入，其他的全部需要导入。

6:再简单的看看类的解释和说明，别忘了看看该类的版本

7:看类的结构

成员变量字段摘要

构造方法构造方法摘要

成员方法方法摘要

8:学习构造方法

A:有构造方法就创建对象

B:没有构造方法成员可能都是静态的

9:看成员方法

A:左边

是否静态：如果静态，可以通过类名调用

返回值类型：人家返回什么，你就用什么接收。

B:右边

看方法名：方法名称不要写错

参数列表：人家要什么，你就给什么；人家要几个，你就给几个

(3)Math类

A: 包含用于执行基本数学运算的方法

B:没有构造方法，因为它的成员都是静态的

C:产生随机数

public static doublerandom():返回带正号的 double 值，该值大于等于 0.0 且小于1.0。

D:如何产生一个1-100之间的随机数

int number =(int)(Math.random()*100)+1;

E:猜数字小游戏案例

class GuessNumber {  
    publicstatic void main(String[] args) {  
           //程序产生一个随机数。(被猜的)  
           intnumber = (int)(Math.random()*100)+1;  
           //System.out.println(number);  
           //给出多次猜的机会，猜中就结束。  
           while(true){  
                  //键盘录入数据。(你猜的)  
                  Scannersc = new Scanner(System.in);  
                  System.out.println("请输入你要猜的数据(1-100):");  
                  intguessNumber = sc.nextInt();  
                  //把你猜的和被猜的进行比较  
                  if(guessNumber> number) {  
                         System.out.println("你猜的数据"+guessNumber+"大了");  
                  }elseif(guessNumber < number) {  
                         System.out.println("你猜的数据"+guessNumber+"小了");  
                  }else{  
                         System.out.println("恭喜你，猜中了");  
                         break;  
                  }  
           }  
    }  
}

3:代码块(掌握)

(1) 在Java中，使用{}括起来的代码。

(2)分类：

A:局部代码块

用于限定变量的生命周期，及早释放，提高内存利用率。

B:构造代码块

在类中的成员位置,用{}括起来的代码，每个构造方法执行前，首先执行构造代码块。

C:静态代码块

在类中的成员位置,用{}括起来的代码,只不过它用static修饰了。

对类的数据进行初始化，仅仅只执行一次。

(3)静态代码块,构造代码块,构造方法的顺序问题?（面试题）

静态代码块 >构造代码块 >构造方法

静态代码块：只执行一次

构造代码块：每次调用构造方法都执行

(4)写程序的执行结果案例

我爱李凡

我是main方法

Student静态代码块

Student构造代码块

Student构造方法

Student构造代码块

Student构造方法

[java] view plain copy


 
class Student {  
       static{  
              System.out.println("Student静态代码块");  
       }  
       {  
              System.out.println("Student 构造代码块");  
       }  
       publicStudent() {  
              System.out.println("Student构造方法");  
       }  
}  
class StudentDemo {  
       static{  
              System.out.println("我爱李凡");  
       }  
       publicstatic void main(String[] args) {  
              System.out.println("我是main方法");  
              Students1 = new Student();  
              Students2 = new Student();  
       }  
}

4:继承(掌握)

(1)把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，这多个类就具备了这些内容。这个关系叫继承。

(2)Java中如何表示继承呢?格式是什么呢?

A:用关键字extends表示

B:格式： class子类名 extends父类名 {}

(3)继承的好处：

A:提高了代码的复用性

B:提高了代码的维护性

C:让类与类产生了一个关系，是多态的前提

(4)继承的弊端：

A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。

开发的原则：低耦合，高内聚。

耦合：类与类的关系

内聚：自己完成某件事情的能力

B:打破了封装性

(5)Java中继承的特点

A:Java中类只支持单继承

B:Java中可以多层(重)继承(继承体系)

(6)继承的注意事项：

A:子类只能继承父类所有非私有的成员(成员方法和成员变量)

B:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。

C:不要为了部分功能而去继承

(7)什么时候使用继承呢?

A:继承体现的是：is a的关系。

B:采用假设法

如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。

(8)Java继承中的成员关系

A:继承中成员变量

a:子类的成员变量名称和父类中的成员变量名称不一样，这个太简单

b:子类的成员变量名称和父类中的成员变量名称一样，这个怎么访问呢?

子类的方法访问变量的查找顺序：

在子类方法的局部范围找，有就使用。

在子类的成员范围找，有就使用。

在父类的成员范围找，有就使用。

找不到，就报错。

B:继承中构造方法

a:子类中所有的构造方法默认都会访问父类中空参数的构造方法

为什么呢?

因为子类会继承父类中的数据，可能还会使用父类的数据。

所以，子类初始化之前，一定要先完成父类数据的初始化。

注意：子类每一个构造方法的第一条语句默认都是：super();

b:如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢?

报错。

如何解决呢?

1:在父类中加一个无参构造方法

2:通过使用super关键字去显示的调用父类的带参构造方法

3:子类通过this去调用本类的其他构造方法

子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化。

注意事项：

this(...)或者super(...)必须出现在第一条语句上。

如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一条语句上。

class Student {  
       static{  
              System.out.println("Student静态代码块");  
       }  
       {  
              System.out.println("Student 构造代码块");  
       }  
       publicStudent() {  
              System.out.println("Student构造方法");  
       }  
}  
class StudentDemo {  
       static{  
              System.out.println("我爱李凡，我很伤心");  
       }  
       publicstatic void main(String[] args) {  
              System.out.println("我是main方法");  
              Students1 = new Student();  
              Students2 = new Student();  
       }  
}

C:继承中成员方法

a:子类的成员方法和父类中的成员方法名称不一样，这个太简单

b:子类的成员方法和父类中的成员方法名称一样，这个怎么访问呢?

通过子类对象访问一个方法的查找顺序：

a:先找子类中，看有没有这个方法，有就使用

b:再看父类中，有没有这个方法，有就使用

c:如果没有就报错。

5:方法重载(掌握)

方法重写：子类中出现了和父类中方法声明一模一样的方法。

方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值无关。

子类对象调用方法的时候：先找子类本身，再找父类。

方法重写的应用：

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。

这样，即沿袭了父类的功能，又定义了子类特有的内容。

class Phone {  
       publicvoid call(String name) {  
              System.out.println("给"+name+"打电话");  
       }  
}  
class NewPhone extends Phone {  
       publicvoid call(String name) {  
              //System.out.println("给"+name+"打电话");  
              super.call(name);  
              System.out.println("问她今天开不开心");  
       }  
}  
class ExtendsDemo9 {  
       publicstatic void main(String[] args) {  
              NewPhonenp = new NewPhone();  
              np.call("李凡");  
       }  
}

方法重写的注意事项

A:父类中私有方法不能被重写

因为父类私有方法子类根本就无法继承

B:子类重写父类方法时，访问权限不能更低

最好就一致

C:父类静态方法，子类也必须通过静态方法进行重写

其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中讲解

子类重写父类方法的时候，最好声明一模一样。

(9)两个面试题：

A:Override和Overload的区别?Overload是否可以改变返回值类型?

方法重写：

在子类中，出现和父类中一模一样的方法声明的现象。

方法重载：

同一个类中，出现的方法名相同，参数列表不同的现象。

方法重载能改变返回值类型，因为它和返回值类型无关。

Override：方法重写

Overload：方法重载

B:this和super的区别和各自的作用?

this:代表当前类的对象引用

super:代表父类存储空间的标识。(可以理解为父类的引用，可以操作父类的成员)

怎么用呢?

A:调用成员变量

this.成员变量调用本类的成员变量

super.成员变量调用父类的成员变量

B:调用构造方法

this(...) 调用本类的构造方法

super(...) 调用父类的构造方法

C:调用成员方法

this.成员方法调用本类的成员方法

super.成员方法调用父类的成员方法

(10)数据初始化的面试题

一个类的初始化过程?子父类的构造执行过程?分层初始化?

一个类的初始化过程

成员变量的初始化

默认初始化

显示初始化

构造方法初始化

子父类的初始化(分层初始化)

子类构造方法执行前默认先执行父类的无参构造方法(先进行父类初始化，然后进行子类初始化)。

(11)案例：

A: 猫狗案例的分析和实现

/* 
    猫狗案例讲解 
     
    先找到具体的事物，然后发现具体的事物有共性，才提取出一个父类。 
     
    猫： 
        成员变量：姓名，年龄，颜色 
        构造方法：无参，带参 
        成员方法： 
            getXxx()/setXxx() 
            eat() 
            palyGame() 
    狗： 
        成员变量：姓名，年龄，颜色 
        构造方法：无参，带参 
        成员方法： 
            getXxx()/setXxx() 
            eat() 
            lookDoor() 
             
    共性： 
        成员变量：姓名，年龄，颜色 
        构造方法：无参，带参 
        成员方法： 
            getXxx()/setXxx() 
            eat() 
             
    把共性定义到一个类中，这个类的名字叫：动物。 
    动物类： 
        成员变量：姓名，年龄，颜色 
        构造方法：无参，带参 
        成员方法： 
            getXxx()/setXxx() 
            eat() 
             
        猫：   
            构造方法：无参，带参 
            成员方法：palyGame() 
        狗： 
            构造方法：无参，带参 
            成员方法：lookDoor() 
*/  
//定义动物类  
class Animal {  
    //姓名  
    private String name;  
    //年龄  
    private int age;  
    //颜色  
    private String color;  
      
    public Animal() {}  
      
    public Animal(String name,int age,String color) {  
        this.name = name;  
        this.age = age;  
        this.color = color;  
    }  
      
    public String getName() {  
        return name;  
    }  
      
    public void setName(String name) {  
        this.name = name;  
    }  
      
    public int getAge() {  
        return age;  
    }  
      
    public void setAge(int age) {  
        this.age = age;  
    }  
      
    public String getColor() {  
        return color;  
    }  
      
    public void setColor(String color) {  
        this.color = color;  
    }  
      
    public void eat() {  
        System.out.println("不要睡了,该吃饭了");  
    }  
}  
  
//定义猫类  
class Cat extends Animal {  
    public Cat() {}  
      
    public Cat(String name,int age,String color) {  
        super(name,age,color);  
    }  
      
    public void playGame() {  
        System.out.println("猫玩英雄联盟");  
    }  
}  
  
//定义狗类  
class Dog extends Animal {  
    public Dog() {}  
      
    public Dog(String name,int age,String color) {  
        super(name,age,color);  
    }  
      
    public void lookDoor() {  
        System.out.println("狗看家");  
    }  
}  
  
//测试类  
class ExtendsTest5 {  
    public static void main(String[] args) {  
        //测试猫  
        //方式1  
        Cat c1 = new Cat();  
        c1.setName("Tom");  
        c1.setAge(3);  
        c1.setColor("白色");  
        System.out.println("猫的名字是："+c1.getName()+";年龄是："+c1.getAge()+";颜色是："+c1.getColor());  
        c1.eat();  
        c1.playGame();  
        System.out.println("---------------");  
          
        //方式2  
        Cat c2 = new Cat("杰瑞",5,"土豪金");  
        System.out.println("猫的名字是："+c2.getName()+";年龄是："+c2.getAge()+";颜色是："+c2.getColor());  
        c2.eat();  
        c2.playGame();  
          
        //略：测试狗  
    }  
}

class Product{  
    private int id;  
    private String name;  
    private float price;  
      
    public Product(){  
          
    }  
    public Product(int id,String name,float price){  
        this.id = id;  
        this.name = name;  
        this.price = price;  
    }  
      
    public void setId(int id){  
        this.id = id;  
    }  
    public int getId(){  
        return id;  
    }  
    public void setName(String name){  
        this.name = name;  
    }  
    public String getName(){  
        return name;  
    }  
    public void setPrice(float price){  
        this.price = price;  
    }  
    public float getPrice(){  
        return price;  
    }  
      
    public void show(){  
        System.out.println("    商品ID："+id+",商品名称："+name+",商品价格："+price);  
    }  
}

2.复杂类定义题  
写一个订单类，用来描述用户生成的订单Order，订单包含以下属性：  
   订单id  
   订单所属的用户名username  
   商品数组products（数组中存放的是多个商品对象）  
   订单总金额amount（不能让调用者直接赋值，应该在内部自动计算!!! 订单总金额=商品数组中各商品价格的总和）  
   订单实际应支付额payment  
     （不能让调用者直接赋值，应该在内部自动计算!!!）  
      实际应支付额的计算逻辑：  
       如果 订单总金额 在[0-99] 之间，则应支付额=总金额  
       如果 订单总金额 在[100-199] 之间，则应支付额=总金额*0.9  
       如果 订单总金额  >=200，则应支付额=总金额*0.8）

class Order{  
    private int id;  
    private Customer customer;  
    private Product[] products;  
    private float amount;  
    private float payment;  
      
    public Order(){  
          
    }  
    public Order(int id,Customer customer,Product[] products){  
        this.id = id;  
        this.customer = customer;  
        this.products = products;  
    }  
      
    public void setId(int id){  
        this.id = id;  
    }  
    public int getId(){  
        return id;  
    }  
    public void setCustomer(Customer customer){  
        this.customer = customer;  
    }  
    public Customer getCustomer(){  
        return customer;  
    }  
    public void setProducts(Product[] products){  
        this.products = products;  
    }  
    public Product[] getProducts(){  
        return products;  
    }  
    //订单总金额  
    public float getAmount(){  
        //订单总金额=商品数组中各商品价格的总和  
        float sum = 0;  
        //遍历商品数组，取出每一个商品的价格累加  
        if(null!=products){  
            for(int i=0; i<products.length; i++){  
                Product p = products[i];  
                sum += p.getPrice();  
            }  
        }  
        amount = sum;  
        return amount;  
    }  
      
    //订单实际支付金额  
    public float getPayment(){  
        //拿到总金额  
        float money = getAmount();  
          
        if(money>=100 && money<200){//如果 订单总金额 在[100-199] 之间，则应支付额=总金额*0.9  
            money *= 0.9f;  
        }else if(money>=200){//如果 订单总金额  >=200，则应支付额=总金额*0.8）  
            money *= 0.8f;  
        }  
         
        payment = money;  
          
        //根据用户等级打折  
        //取出用户的等级  
        int level = customer.getLevel();  
        switch(level){  
            case 1:  
                payment *= 0.8f;  
                break;  
            case 2:  
                payment *= 0.9f;  
                break;  
        }  
          
        return payment;  
    }  
      
    //可以通过调用订单对象上的一个自定义方法直接获取该订单中最贵的商品  
    public Product getMaxProduct(){  
        //求数组中的最大值  
        Product max = products[0];  
        for(int i=1; i<products.length; i++){  
            if(products[i].getPrice()>max.getPrice()){  
                max = products[i];  
            }  
        }  
        return max;  
    }  
      
    public void show(){  
        customer.show();  
        System.out.println("订单ID："+id+",订单总金额："+getAmount()+",订单实际应支付额："+getPayment());  
        if(null != products){  
            //遍历商品数组对象  
            for(int i=0; i<products.length; i++){  
                //取出商品对象，调用show方法  
                products[i].show();  
            }  
        }  
    }  
}

3.类和对象使用题  
写一个程序，模拟生成5个商品对象，比如：  
 商品对象1：  
    id=“pdt_001”  
    name = “小米5sPlus”  
    price = 1999.00  
  
然后模拟生成一个订单对象，比如  
   订单1：  
      id="order_001"  
      username = "远哥"  
      items = [商品对象1，商品对象2，商品对象3，商品对象4]  
      amount = <各商品价格累加>  
      payment = <按照题4中描述的规则计算>  
  
然后，在程序中打印该订单的所有信息；  
*/

class Test{  
    public static void main(String[] args){  
        //创建5个商品  
        Product p = new Product(1001,"小米5",1000);  
        Product p2 = new Product(1002,"小米mix2s",3299);  
        Product p3 = new Product(1003,"iPhoneX",8500);  
        Product p4 = new Product(1004,"华为Mate10",3899);  
        Product p5 = new Product(1005,"vivoX21",3500);  
          
        //创建一个用户对象  
        Customer c = new Customer("张三",3);  
          
        Order order = new Order(10001,c,new Product[]{p,p2,p3,p4,p5});  
        order.show();  
    }  
}

/* 
4.扩展提升题（对以上订单模型进行增强） 
再写一个类描述客户Customer，客户包含以下属性： 
   客户名称username 
   客户等级level（等级的值可以是“至尊钻石VIP”“尊享白金VIP”“普通客户”） 
 
然后将题2中的订单类的username属性改成用客户对象来表示,其他属性与题2一致，即： 
   订单id 
   订单所属用户，如 Customer c; 
   商品数组items（数组中存放的是多个商品对象） 
   订单总金额amount（订单总金额=商品数组中各商品价格的总和） 
   订单实际应支付额payment（改变之前逻辑：在之前的总金额打折基础上，根据客户的等级再打折，比如：至尊钻石VIP叠加一个8折，尊享白金vip叠加一个9折，普通客户不叠加折扣） 
 
 
然后写程序模拟创建几个商品，一个订单，然后打印订单信息 
（扩展需求：可以通过调用订单对象上的一个自定义方法直接获取该订单中最贵的商品） 
*/  
class Customer{  
    private String username;  
    private int level;  
      
    public Customer(){  
          
    }  
    public Customer(String username,int level){  
        this.username = username;  
        this.level = level;  
    }  
      
    public void setUsername(String username){  
        this.username = username;  
    }  
    public String getUsername(){  
        return username;  
    }  
    public void setLevel(int level){  
        this.level = level;  
    }  
    public int getLevel(){  
        return level;  
    }  
      
    public void show(){  
        String s = null;  
        switch(level){  
            case 1:  
                s = "至尊钻石VIP";  
                break;  
            case 2:  
                s = "尊享白金VIP";  
                break;  
            default:  
                s = "普通用户";  
                break;  
        }  
        System.out.println("用户名："+username+",用户等级："+s);  
    }  
}

/* 
5.数组存放自定义对象 
定义一个Student类，有如下属性：学号<String>，姓名<String>，年龄<int>，总分<int>以及吃饭，打游戏，学习等行为，并创建Student类的对象，设置属性值;定义一个Student类的数组，放入5个Student对象，然后找出其中年龄最大的Student对象，并将其信息打印到控制台 
*/  
class Test2{  
    public static void main(String[] args){  
        Student s = new Student("x10001","张三",20,80);  
        Student s2 = new Student("x10002","李四",22,60);  
        Student s3 = new Student("x10003","王五",18,70);  
        Student s4 = new Student("x10004","赵六",21,88);  
        Student s5 = new Student("x10005","周七",24,89);  
          
        Student[] arr = {s,s2,s3,s4,s5};  
          
        //假设第一个学生年龄是最大的  
        Student max = arr[0];  
        for(int i=1; i<arr.length; i++){  
            //先把i对应的学生对象取出来  
            Student v = arr[i];  
            if(v.getAge()>max.getAge()){  
                max = v;  
            }  
        }  
          
        max.show();  
    }  
}  
class Student{  
    private String number;  
    private String name;  
    private int age;  
    private int score;  
      
    public Student(){  
          
    }  
    public Student(String number,String name,int age,int score){  
        this.number = number;  
        this.name = name;  
        this.age = age;  
        this.score =score;  
    }  
      
    public void setNumber(String number){  
        this.number = number;  
    }  
    public String getNumber(){  
        return number;  
    }  
    public void setName(String name){  
        this.name = name;  
    }  
    public String getName(){  
        return name;  
    }  
    public void setAge(int age){  
        this.age = age;  
    }  
    public int getAge(){  
        return age;  
    }  
    public void setScore(int score){  
        this.score = score;  
    }  
    public int getScore(){  
        return score;  
    }  
      
    public void show(){  
        System.out.println("学生编号："+number+",姓名："+name+",年龄："+age+",总分："+score);  
    }  
}

/*  
6.在LOL游戏中，游戏中的用户应该用一个类来进行描述，比如，有以下属性信息：  
    用户的游戏账号（比如： "天王盖地虎"）username  
    用户所在的对局ID（比如： "艾欧尼亚-1001"）id  
    用户所使用的英雄角色（比如： 易大师或者阿狸....）hero  
    所装配的装备（装备应该可以是多个，比如"无尽之刃"、"狂徒铠甲"等）equipments  
    用户助攻数 ReboundsRebs  
    用户所杀的人头数 head  
    斩杀小兵数 soldier  
    本局游戏实时得分（游戏得分=助攻数*10+击杀人头数*20+小兵数*2+装备件数*5）score  
    角色的等级   level  
    注：等级规则如下：  
    累计得分---> [0-100]，等级1  
    累计得分---> [101-200]，等级2  
    .... 以此类推，最高等级为18级  
      
    同时，需要具备以下方法：  
        获取各属性值（如获取账号，对局ID，英雄角色名等）  
        设置各属性值（如设置账号，对局ID，英雄角色名等）  
    ①　注：游戏实时得分值不应该直接设置，而是，当助攻数、人头数、斩杀小兵数、装备数发生变化时，对象自动更新游戏得分  
    ②　注：角色等级不应该直接设置，而是，根据当游戏历史总得分发生变化时，对象自动更新游戏等级  
      
    需求：在程序中创建一个游戏用户对象  
    然后修改该用户对象的各个能直接修改的属性值  
    然后查看该用户的当前状态（即对象中的所有当前属性值）  
*/  
class Test3{  
    public static void main(String[] args){  
        String[] equipments = {"急速之靴","无尽之刃","三相之力","火炮"};  
        LOL lol = new LOL("不要杀我好不好","艾欧尼亚-1001","提莫",equipments,20,20,300);  
        lol.show();  
    }  
}  
class LOL{  
    private String username;  
    private String id;  
    private String hero;  
    private String[] equipments;  
    private int ReboundsRebs;  
    private int head;  
    private int soldier;  
    private int score;  
    private int level;  
      
    public LOL(){}  
    public LOL(String username,String id,String hero,String[] equipments,int ReboundsRebs,int head,int soldier){  
        this.username = username;  
        this.id = id;  
        this.hero = hero;  
        this.equipments = equipments;  
        this.ReboundsRebs = ReboundsRebs;  
        this.head = head;  
        this.soldier = soldier;  
    }  
      
    public int getScore(){  
        //本局游戏实时得分（游戏得分=助攻数*10+击杀人头数*20+小兵数*2+装备件数*5）score  
        score = ReboundsRebs*10+head*20+soldier*2+equipments.length*5;  
        return score;  
    }  
    public int getLevel(){  
        /*  
        注：等级规则如下：  
            累计得分---> [0-100]，等级1  
            累计得分---> [101-200]，等级2  
            .... 以此类推，最高等级为18级  
        */  
        int score = getScore();  
          
        if(score%100!=0){  
            level =  score/100;  
            level += 1;  
        }else{  
            level = score/100;  
        }  
          
        //判断level的特殊值  
        if(level==0){  
            level = 1;  
        }else if(level>18){  
            level = 18;  
        }  
        return level;  
    }  
      
    public void show(){  
        System.out.println("用户的游戏账号:"+username+",用户所在的对局ID:"+id+",用户所使用的英雄角色:"+hero+",用户助攻数:"+ReboundsRebs+",用户所杀的人头数:"+head+",斩杀小兵数:"+soldier+",本局游戏实时得分:"+getScore()+",角色的等级:"+getLevel());  
        for(int i=0; i<equipments.length; i++){  
            System.out.print(equipments[i]+" ");  
        }  
        System.out.println();  
    }  
}