李清华201772020113《面向对象程序设计（Java）》第六周学习总结

第一部分 理论知识

1.继承

用已有类来构建新类的一种机制。新类可以继承父类的方法和域，同时可以在新类中添加新的方法和域。

已有类称为：超类、基类或父类。新类称作：子类、派生类或孩子类。

子类的构造器不能直接访问超类的私有域，必须通过调用超类构造器，而且必须是第一条语句。子类不能直接访问超类的私有域，必须和其它方法一样，使用公有接口。

在子类中可以增加域、增加方法或覆盖超类的方法，但绝对不能删除超类的任何域和方法。

super关键字一般有两个用途：一是调用超类的方法（格式：super.方法名（）），二是调用超类的构造器(格式：super())。

若子类构造器没有显式地调用超类的构造器，则将自动地调用超类默认构造器。如果超类只定义了带参数的构造器，若子类构造器没有显式地调用超类的构造器，则Java编译器将报告错误。

Java不支持多继承。

2.多态性

多态性泛指在程序中同一个符号在不同的情况下具有不同解释的现象。

超类中定义的域或方法，被子类继承之后，可以具有不同的数据类型或表现出不同的行为。

这使得同一个域或方法在超类及其各个子类中具有不同的语义。超类中的方法在子类中可方法重写。

Java中，对象变量是多态的。

不能把对超类的对象引用赋给子类对象变量。

继承层次结构中，每个子类对象也可视作是超类对象，因此，可以将子类对象赋给超类变量。

3.抽象类

从某种角度看，祖先类更加通用，人们只将它作为派生其他类的基类，而不作为特定的实例类。

用abstract方法定义抽象类时，abstract方法只能声明，不能实现！

包含一个或多个抽象方法的类本身必须被声明为抽象类。除了抽象方法之外，抽象类还可以包含具体数据和具体方法。

抽象方法充当着占位的角色，它们的具体实现在子类中。扩展抽象类可以有两种选择：一种是在子类中实现部分抽象方法，这样就必须将子类也标记为抽象类；另一种是实现全部抽象方法，这样子类就可以不是抽象类。此外，类即使不含抽象方法，也可以将类声明为抽象类。

抽象类不能被实例化，即不能创建对象，只能产生子类。可以创建抽象类的对象变量，只是这个变量必须指向它的非抽象子类的对象。

4.受保护访问

如果希望超类的某些方法或域允许被子类访问，就需要在超类定义时，将这些方法或域声明为protected。

实际中要谨慎使用protected的属性。假设需要将设计的类提供给其他程序员使用，而在这个类中设置了一些受保护域，由于其他程序员可以由这个类再派生出新类，并访问其中的受保护域。在这种情况下，如果对这个类进行修改，就必须通知所有使用这个类的程序员。这违背了OOP提倡的数据封装原则。

如果定义类时要限制某个方法的使用，就可以将它声明为protected。这表明子类得到信任，可以使用这个方法，而其他类则不行。

Java用于控制可见性的4个访问权限修饰符：private（只有该类可以访问），protected（该类及其子类的成员可以访问，同一个包中的类也可访问），public（该类或非该类均可访问），默认（相同包中的类课以访问）。注：不写访问修饰符时默认为friendly。

使用访问修饰符的原因：实现受限信息隐藏。

信息隐藏目的：
– 对类中任何实现细节的更改不会影响使用该类的代码。
– 防止用户意外删除数据。
– 易于使用类。

5.Objective类

Object类是Java中所有类的祖先——每一个类都由它扩展而来。在不给出超类的情况下，Java会自动把Object作为要定义类的超类。

可以使用类型为Object的变量指向任意类型的对象。但要对它们进行专门的操作都要进行类型转换。

第二部分 实验

1、实验目的与要求

(1) 理解继承的定义；

(2) 掌握子类的定义要求

(3) 掌握多态性的概念及用法；

(4) 掌握抽象类的定义及用途；

(5) 掌握类中4个成员访问权限修饰符的用途；

(6) 掌握抽象类的定义方法及用途；

(7)掌握Object类的用途及常用API；

(8) 掌握ArrayList类的定义方法及用法；

(9) 掌握枚举类定义方法及用途。

2、实验内容和步骤

实验1： 导入第5章示例程序，测试并进行代码注释。

测试程序1：

Ÿ 在elipse IDE中编辑、调试、运行程序5-1 （教材152页-153页） ；

Ÿ 掌握子类的定义及用法；

Ÿ 结合程序运行结果，理解并总结OO风格程序构造特点，理解Employee和Manager类的关系子类的用途，并在代码中添加注释。

实验代码：

 package inheritance;

 /**
  * This program demonstrates inheritance.
  * @version 1.21 2004-02-21
  * @author Cay Horstmann
  */
 public class ManagerTest
 {
    public static void main(String[] args)
    {
       //构造Manager类的一个对象boss
       Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
       boss.setBonus(5000);//boss调用Manager类中的方法
       Employee[] staff = new Employee[3];//构造一个Employee类的数组
       //为数组staff的成员赋值
       staff[0] = boss;//子类的对象可以赋值给超类的变量
       staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
       staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);

       // 循环打印所有员工对象的信息
       for (Employee e : staff)
          System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
    }
 }

 package inheritance;

 import java.time.*;
 //父类Employee，并定义了几个方法
 public class Employee
 {
    private String name;
    private double salary;
    private LocalDate hireDay;

    public Employee(String name, double salary, int year, int month, int day)
    {
       this.name = name;
       this.salary = salary;
       hireDay = LocalDate.of(year, month, day);
    }

    public String getName()
    {
       return name;
    }

    public double getSalary()
    {
       return salary;
    }

    public LocalDate getHireDay()
    {
       return hireDay;
    }

    public void raiseSalary(double byPercent)
    {
       double raise = salary * byPercent / 100;
       salary += raise;
    }
 }

 package inheritance;
 //定义Employee的子类Manager
 public class Manager extends Employee
 {
    private double bonus;//新的子类的私有属性

    public Manager(String name, double salary, int year, int month, int day)
    {
       super(name, salary, year, month, day);//调用超类Employee的构造器
       bonus = 0;
    }

    public double getSalary()//覆盖超类中的方法
    {
       double baseSalary = super.getSalary();//用公用接口调用超类的方法
       return baseSalary + bonus;
    }

    public void setBonus(double b)//子类新增的方法
    {
       bonus = b;
    }
 }

实验结果：

name=Carl Cracker,salary=85000.0
name=Harry Hacker,salary=50000.0
name=Tommy Tester,salary=40000.0

测试程序2：

Ÿ 编辑、编译、调试运行教材PersonTest程序（教材163页-165页)；

Ÿ 掌握超类的定义及其使用要求；

Ÿ 掌握利用超类扩展子类的要求；

Ÿ 在程序中相关代码处添加新知识的注释。

实验代码：

 public class PersonTest
 {
    public static void main(String[] args)
    {
       //抽象类Person不能实例化，但是可以创建抽象类的对象变量，这个变量必须指向它的非抽象子类的对象。
       Person[] people = new Person[2];

       //用两个子类的实例赋给抽象类Person的对象变量
       people[0] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
       people[1] = new Student("Maria Morris", "computer science");

       //输出所有人对象的名称和描述
       for (Person p : people)
          System.out.println(p.getName() + ", " + p.getDescription());
    }
 }

 //定义抽象类Person
 public abstract class Person
 {
    public abstract String getDescription();//抽象方法
    private String name;

    public Person(String name)
    {
       this.name = name;
    }

    public String getName()
    {
       return name;
    }
 }

 //子类Student继承抽象类Person
 public class Student extends Person
 {
    private String major;

    /**
     * @param nama the student's name
     * @param major the student's major
     */
    public Student(String name, String major)
    {
       //通过n to 总纲构造函数
       super(name);
       this.major = major;
    }

    public String getDescription()//覆盖超类抽象方法
    {
       return "a student majoring in " + major;
    }
 }

 import java.time.*;
 //抽象类Person的子类Employee
 public class Employee extends Person
 {
    private double salary;
    private LocalDate hireDay;

    public Employee(String name, double salary, int year, int month, int day)
    {
       super(name);
       this.salary = salary;
       hireDay = LocalDate.of(year, month, day);
    }

    public double getSalary()
    {
       return salary;
    }

    public LocalDate getHireDay()
    {
       return hireDay;
    }

    public String getDescription()//重写父类方法，返回一个格式化的字符串
    {
       return String.format("an employee with a salary of $%.2f", salary);
    }

    public void raiseSalary(double byPercent)
    {
       double raise = salary * byPercent / 100;
       salary += raise;
    }
 }

实验结果：

Harry Hacker, an employee with a salary of $50000.00
Maria Morris, a student majoring in computer science

测试程序3：

Ÿ 编辑、编译、调试运行教材程序5-8、5-9、5-10，结合程序运行结果理解程序（教材174页-177页）；

Ÿ 掌握Object类的定义及用法；

Ÿ 在程序中相关代码处添加新知识的注释。

 public class EqualsTest
 {
    public static void main(String[] args)
    {
       Employee alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15);
       Employee alice2 = alice1;
       Employee alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15);
       Employee bob = new Employee("Bob Brandson", 50000, 1989, 10, 1);

       System.out.println("alice1 == alice2: " + (alice1 == alice2));

       System.out.println("alice1 == alice3: " + (alice1 == alice3));

       System.out.println("alice1.equals(alice3): " + alice1.equals(alice3));

       System.out.println("alice1.equals(bob): " + alice1.equals(bob));

       System.out.println("bob.toString(): " + bob);

       Manager carl = new Manager("Carl Cracker", 80000, 1987, 12, 15);
       Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
       boss.setBonus(5000);
       System.out.println("boss.toString(): " + boss);
       System.out.println("carl.equals(boss): " + carl.equals(boss));
       System.out.println("alice1.hashCode(): " + alice1.hashCode());
       System.out.println("alice3.hashCode(): " + alice3.hashCode());
       System.out.println("bob.hashCode(): " + bob.hashCode());
       System.out.println("carl.hashCode(): " + carl.hashCode());
    }
 }

 import java.time.*;
 import java.util.Objects;

 public class Employee
 {
    private String name;
    private double salary;
    private LocalDate hireDay;

    public Employee(String name, double salary, int year, int month, int day)
    {
       this.name = name;
       this.salary = salary;
       hireDay = LocalDate.of(year, month, day);
    }

    public String getName()
    {
       return name;
    }

    public double getSalary()
    {
       return salary;
    }

    public LocalDate getHireDay()
    {
       return hireDay;
    }

    public void raiseSalary(double byPercent)
    {
       double raise = salary * byPercent / 100;
       salary += raise;
    }

    public boolean equals(Object otherObject)
    {
       //快速检查对象是否相同，这里获得一个对象参数，第一个if语句判断两个引用是否是同一个，如果是那么这两个对象肯定相等。
       if (this == otherObject) return true;

       //如果explicit的参数为null，必须返回false
       if (otherObject == null) return false;

       //如果类不匹配，那么他们不能相等
       if (getClass() != otherObject.getClass()) return false;

       //现在我们知道otherObject是一个非空的Employee类
       Employee other = (Employee) otherObject;

       //测试字段是否具有相同的值
       return Objects.equals(name, other.name) && salary == other.salary && Objects.equals(hireDay, other.hireDay);
    }

    public int hashCode()
    {
       return Objects.hash(name, salary, hireDay);
    }

    public String toString()
    {
       return getClass().getName() + "[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay
             + "]";
    }
 }

 public class Manager extends Employee
 {
    private double bonus;

    public Manager(String name, double salary, int year, int month, int day)
    {
       super(name, salary, year, month, day);
       bonus = 0;
    }

    public double getSalary()
    {
       double baseSalary = super.getSalary();
       return baseSalary + bonus;
    }

    public void setBonus(double bonus)
    {
       this.bonus = bonus;
    }

    public boolean equals(Object otherObject)
    {
       if (!super.equals(otherObject)) return false;
       Manager other = (Manager) otherObject;
       //检查这个和其它属于同一个类
       return bonus == other.bonus;
    }

    public int hashCode()
    {
       return java.util.Objects.hash(super.hashCode(), bonus);
    }

    public String toString()
    {
       return super.toString() + "[bonus=" + bonus + "]";
    }
 }

实验结果：

alice1 == alice2: true
alice1 == alice3: false
alice1.equals(alice3): true
alice1.equals(bob): false
bob.toString(): Employee[name=Bob Brandson,salary=50000.0,hireDay=1989-10-01]
boss.toString(): Manager[name=Carl Cracker,salary=80000.0,hireDay=1987-12-15][bonus=5000.0]
carl.equals(boss): false
alice1.hashCode(): -808853550
alice3.hashCode(): -808853550
bob.hashCode(): -624019882
carl.hashCode(): -2004699436

测试程序4：

Ÿ 在elipse IDE中调试运行程序5-11（教材182页），结合程序运行结果理解程序；

Ÿ 掌握ArrayList类的定义及用法；

Ÿ 在程序中相关代码处添加新知识的注释。

 import java.util.*;

 /**
  * This program demonstrates the ArrayList class.
  * @version 1.11 2012-01-26
  * @author Cay Horstmann
  */
 public class ArrayListTest
 {
    public static void main(String[] args)
    {
       //用三个Employee对象填补staff数组列表
       ArrayList<Employee> staff = new ArrayList<>();

       staff.add(new Employee("Carl Cracker", 75000, 1987, 12, 15));
       staff.add(new Employee("Harry Hacker", 50000, 1989, 10, 1));
       staff.add(new Employee("Tony Tester", 40000, 1990, 3, 15));

       //将每个人的工资提升5%
       for (Employee e : staff)
          e.raiseSalary(5);

       //打印所有员工对象的信息
       for (Employee e : staff)
          System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
                + e.getHireDay());
    }
 }

 import java.time.*;

 public class Employee
 {
    private String name;
    private double salary;
    private LocalDate hireDay;

    public Employee(String name, double salary, int year, int month, int day)
    {
       this.name = name;
       this.salary = salary;
       hireDay = LocalDate.of(year, month, day);
    }

    public String getName()
    {
       return name;
    }

    public double getSalary()
    {
       return salary;
    }

    public LocalDate getHireDay()
    {
       return hireDay;
    }

    public void raiseSalary(double byPercent)
    {
       double raise = salary * byPercent / 100;
       salary += raise;
    }
 }

实验结果：

name=Carl Cracker,salary=78750.0,hireDay=1987-12-15
name=Harry Hacker,salary=52500.0,hireDay=1989-10-01
name=Tony Tester,salary=42000.0,hireDay=1990-03-15

测试程序5：

Ÿ 编辑、编译、调试运行程序5-12（教材189页），结合运行结果理解程序；

Ÿ 掌握枚举类的定义及用法；

Ÿ 在程序中相关代码处添加新知识的注释。

实验代码：

 package enums;

 import java.util.*;

 /**
  * This program demonstrates enumerated types.
  * @version 1.0 2004-05-24
  * @author Cay Horstmann
  */
 public class EnumTest
 {
    public static void main(String[] args)
    {
       Scanner in = new Scanner(System.in);
       System.out.print("Enter a size: (SMALL, MEDIUM, LARGE, EXTRA_LARGE) ");
       String input = in.next().toUpperCase();
       Size size = Enum.valueOf(Size.class, input);
       System.out.println("size=" + size);
       System.out.println("abbreviation=" + size.getAbbreviation());
       if (size == Size.EXTRA_LARGE)
          System.out.println("Good job--you paid attention to the _.");
    }
 }

 enum Size
 {
    SMALL("S"), MEDIUM("M"), LARGE("L"), EXTRA_LARGE("XL");

    private Size(String abbreviation) { this.abbreviation = abbreviation; }
    public String getAbbreviation() { return abbreviation; }

    private String abbreviation;
 }

实验结果：

Enter a size: (SMALL, MEDIUM, LARGE, EXTRA_LARGE)

实验2：编程练习1

Ÿ 定义抽象类Shape：

属性：不可变常量double PI，值为3.14；

方法：public double getPerimeter()；public double getArea())。

Ÿ 让Rectangle与Circle继承自Shape类。

Ÿ 编写double sumAllArea方法输出形状数组中的面积和和double sumAllPerimeter方法输出形状数组中的周长和。

Ÿ main方法中

1）输入整型值n，然后建立n个不同的形状。如果输入rect，则再输入长和宽。如果输入cir，则再输入半径。
2） 然后输出所有的形状的周长之和，面积之和。并将所有的形状信息以样例的格式输出。
3） 最后输出每个形状的类型与父类型，使用类似shape.getClass()(获得类型)，shape.getClass().getSuperclass()(获得父类型);

思考sumAllArea和sumAllPerimeter方法放在哪个类中更合适？

输入样例:

3

rect

1 1

rect

2 2

cir

1

输出样例:

18.28

8.14

[Rectangle [width=1, length=1], Rectangle [width=2, length=2], Circle [radius=1]]

class Rectangle,class Shape

class Rectangle,class Shape

class Circle,class Shape

实验 代码：

package 练习;
import java.math.*;
import java.util.*;
import 练习.Shape;
import 练习.Rectangle;
import 练习.Circle;
 
public class Main 
 {
     public static void main(String[] args) 
     {
         Scanner in = new Scanner(System.in);
         String rect = "rect";
         String cir = "cir";
         System.out.print("请输入形状个数:");
         int n = in.nextInt();
         Shape[] score = new Shape[n];
         for(int i=0;i<n;i++)
         {
             System.out.println("请输入cir或rect:");
             String input = in.next();
             if(input.equals(rect))
             {
              double length = in.nextDouble();
                 double width = in.nextDouble();
                 System.out.println("Rectangle["+"length:"+length+"  width:"+width+"]");
                 score[i] = new Rectangle(width,length);
             }
             if(input.equals(cir)) 
             {
                 double radius = in.nextDouble();
                 System.out.println("Circle["+"radius:"+radius+"]");
                 score[i] = new Circle(radius);
             }
         }
         Main c = new Main();
         System.out.println(c.sumAllPerimeter(score));
         System.out.println(c.sumAllArea(score));
         for(Shape s:score) 
         {
 
            System.out.println(s.getClass()+",  "+s.getClass().getSuperclass());
         }
     }
 
     public double sumAllArea(Shape score[])
     {
          double sum = 0;
          for(int i = 0;i<score.length;i++)
        sum+=score[i].getArea();
    return sum;
     }
     
     public double sumAllPerimeter(Shape score[])
     {
          double sum = 0;
          for(int i = 0;i<score.length;i++)
              sum+= score[i].getPerimeter();
          return sum;
     }
     
 }

package 练习;
public abstract class Shape {
 protected double PI=3.14;
 public abstract double getPerimeter();
 public abstract double getArea();
}

package 练习;

public class Rectangle extends Shape
{
 private double width;
 private double length;
 public Rectangle(double width2,double length2)
 {
  this.width=width2;
  this.length=length2;
 }
 public double getPerimeter()
 {
  double Perimeter=(width+length)*2;
  return Perimeter;
 }
 public double getArea()
 {
  double Area=width*length;
  return Area;
 }
}

package 练习;

public class Circle extends Shape
{
 private double radius;
 public Circle(double r)
 {
  radius=r;
 }
 public double getPerimeter()
 {
  double Permeter=2*PI*radius;
  return Permeter;
 }
 public double getArea()
 {
  double Area=PI*radius*radius;
  return Area;
 }
}

实验结果：

实验3： 编程练习2

编制一个程序，将身份证号.txt 中的信息读入到内存中，输入一个身份证号或姓名，查询显示查询对象的姓名、身份证号、年龄、性别和出生地。

实验代码：

 private    String name;
       private    String number;
      private    String age;
       private    String sex;
       private    String address; 
      public String getName()
      {
          return name;
      }
      public void setName(String name) 
      {
          this.name = name;
      }
      public String getnumber() 
      {
          return number;
      }
      public void setnumber(String number)
     {
          this.number = number;
      }
      public String getage() 
      {
          return age;
      }
      public void setage(String age ) 
      {
          this.age = age;
      }
      public String getsex() 
      {
          return sex;
      }
      public void setsex(String sex ) 
      {
          this.sex = sex;
      }
      public String getaddress() 
      {
          return address;
      }
      public void setaddress(String address) 
      {
          this.address = address;
      }
  }

 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.util.ArrayList;
 import java.util.Scanner;
  
 public class Demo3 {
 // 创建一个泛型列表来保存人员身份信息
 private static ArrayList<people> peoplelist;
  
 public static void main(String[] args) {
 peoplelist = new ArrayList<>();
 Scanner scanner = new Scanner(System.in);
 // 拿到人员身份信息文件
 File file = new File("/Users/eleanorliu/Desktop/学习/java文件/实验六/身份证号.txt");
 // 创建文件输入流 ,由于文件读写存在异常，所以进行异常处理
 try {
 // 创建文件输入流(字节流)
 FileInputStream fis = new FileInputStream(file);
 // 创建文件读取流(字符流)
 BufferedReader in = new BufferedReader(new InputStreamReader(fis));
 String temp = null;
 // 按行读取 如果这一行不为空 就读取信息
 while ((temp = in.readLine()) != null) {
 // 一行里面有各种信息,通过截取字符串分开获取各项信息
 Scanner linescanner = new Scanner(temp);
                 linescanner.useDelimiter(" ");    
                 String name = linescanner.next();
                 String id = linescanner.next();
                 String sex = linescanner.next();
                 String age = linescanner.next();
                 String address = linescanner.nextLine();
                 People people = new People();
                 people.setName(name);
                 people.setid(id);
                 people.setage(age);
                 people.setsex(sex);
                 people.setaddress(address);
                 peoplelist.add(people);
  
 }
 // 读取文件里面的学生信息
  
 } catch (FileNotFoundException e) {
 // TODO Auto-generated catch block
 // 程序异常时在这里处理
 System.out.println("身份信息文件找不到");
 e.printStackTrace();
 } catch (IOException e) {
 // TODO Auto-generated catch block
 System.out.println("身份信息文件读取错误");
 e.printStackTrace();
 }
 // 通过选择语句做一个提示界面
 boolean isTrue = true;
 while (isTrue) {
  
 System.out.println("欢迎来到人员身份信息查询系统,请选择你的操作");
 System.out.println("1.按姓名查询");
 System.out.println("2.身份证号码查询");
 System.out.println("3.退出");
 int nextInt = scanner.nextInt();
 switch (nextInt) {
 case 1:
 System.out.println("请输入姓名");
 String peoplename = scanner.next();
 int nameint = findPeopleByname(peoplename);
 if (nameint != -1) {
   // 存在这个人
 System.out.println(" 姓名:"+ people.getName() +
                     "  身份证号:"+ people.getnumber() +
                          "   年龄:"+ people.getage()+
                          "   性别:"+ people.getsex()+
                          "   地址:"+ people.getplace()
                 );
 } else {
 System.out.println("不存在该人信息");
 }
 break;
 case 2:
 System.out.println("请输入学号");
 String studentid = scanner.next();
 int idint = findPeopleByid(studentid);
 if (idint != -1) {
 // 存在这个学生
 System.out.println(" 姓名:"+ people.getName() +
                     "  身份证号:"+ people.getnumber() +
                         "   年龄:"+ people.getage()+
                         "   性别:"+ people.getsex()+
                         "   地址:"+ people.getplace()
                 );
 } else {
 System.out.println("不存在该人信息");
 }
 break;
 case 3:
 isTrue = false;
 System.out.println("程序已退出!");
 break;
 default:
              System.out.println("输入有误");
 }
 }
 }
  
 /*
 * 新建一个方法来通过姓名查找
 */
 public static int findPeopleByname(String name) {
 int flag = -1;
 // 比对姓名
 for (int i = 0; i < peoplelist.size(); i++) {
 if (peoplelist.get(i).getName().equals(name)) {
 flag = i;
 }
 }
 return flag;
  
 }
  
 /*
 * 新建一个方法来通过身份证号查找
 */
 public static int findPeopleByid(String id) {
 int flag = -1;
 // 比对身份证号
 for (int i = 0; i < peoplelist.size(); i++) {
 if (peoplelist.get(i).getId().equals(id)) {
 flag = i;
 }
 }
 return flag;
  
 }
 }