11--内部类

第一题

定义HandleAble接口，具备一个处理字符串数字的抽象方法方法HandleString（String num）。
```
 处理方式1：取整数部分。
 处理方式2：保留指定位小数，四舍五入。
```
代码实现，效果如图所示：

开发提示：

匿名内部类的方式，调用所有抽象方法。

参考答案：

public class Test1 {

     public static void main(String[] args) {

         String str = "23.23456789";
         System.out.println("原数字字符串:" + str);

         HandleAble s1 = new HandleAble() {
             @Override
             public String handleString(String str) {
                 return str.substring(0, str.indexOf("."));
            }
        };
         String string = s1.handleString(str);

         System.out.println("取整后:" + string);

         int num = 4;
   
         HandleAble s2 = new HandleAble() {
             @Override
             public String handleString(String str) {
   
                 int i = str.indexOf(".") + num + 1;
                 char c = str.charAt(i);
                 //System.out.println(c);
   
                 if (c <= '4') {
                     return str.substring(0, i).toString();
                } else {
                     char c1 = (char) (str.charAt(str.indexOf(".") + num) + 1);
                     return str.substring(0, i - 1) + c1;
   
                }
            }
        };
         String sss = s2.handleString(str);
         System.out.println("保留" + num + "位小数后:" + sss);
   
    }
}
 interface HandleAble {
     public abstract String handleString(String str);
}

第二题

模拟上课出勤情况。

定义学生类：

 属性：姓名，出勤。
 提供基本的构造方法和get方法，set方法。

定义讲师类：

 属性：姓名。
 提供基本的构造方法和get方法，set方法
 成员方法：点名方法，设置每一位的学生出勤情况。假设，小明今日未出

定义课程类：

 属性：课程名称，讲师，学生集合。
 提供基本的构造方法和get方法，set方法
 成员方法：show方法，打印课程信息，老师姓名，学生是否上课情况

代码实现，效果如图所示：
参考答案：

public class Test2 {
     public static void main(String[] args) {
         // 创建Student 对象
         Student s = new Student("小红");
         Student s2 = new Student("小亮");
         Student s3 = new Student("小明");

         // 创建 ArrayList
         ArrayList<Student> sList = new ArrayList<>();
         sList.add(s);
         sList.add(s2);
         sList.add(s3);

         Teacher t = new Teacher("张老师");

         Course course = new Course("Java", t, sList);

         t.dianMing(sList);

         course.show();
    }
}

 class Course {

     private String name;

     private Teacher t;

     private ArrayList<Student> sList;

     public Course() {
    }

     public Course(String name, Teacher t, ArrayList<Student> sList) {
         this.name = name;
         this.t = t;
         this.sList = sList;
    }

     public void show() {
         System.out.println("课程名称:" + name);
         System.out.println("授课老师:" + t.getName());

         for (int i = 0; i < sList.size(); i++) {
             Student student = sList.get(i);
             String name = student.getName();

             if (student.isCome()) {
                 System.out.println("上课: " + name);
            } else {
                 System.out.println("旷课: " + name);
            }
        }
    }
}

 class Teacher {

     private String name;

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

     public void dianMing(ArrayList<Student> slist) {
         for (int i = 0; i < slist.size(); i++) {
             Student student = slist.get(i);
             if (!student.getName().equals("小明")) {

                 student.setCome(true);
            }
        }

    }

     public String getName() {
         return name;
    }
}

 class Student {

     private String name;

     private boolean come;

     public Student(String name) {
         this.name = name;

    }

     public String getName() {
         return name;
    }

     public void setName(String name) {
         this.name = name;
    }

     public boolean isCome() {
         return come;
    }

     public void setCome(boolean come) {
         this.come = come;
    }
}

第三题

模拟接待员接待用户，根据用户id，给用户分组。

定义接口Filter：

 提供抽象方法filterUser（User u）

定义用户类：

 属性：用户类型，用户id
 提供基本的构造方法和get方法，set方法

定义接待员类：

 属性：接口Filter
 提供基本的构造方法和get方法，set方法
 成员方法：接待用户方法，设置用户类型。

测试类：

 初始化50个User对象，id为1-50。
 创建两个接待员对象。
    第一个接待员，设置接待规则，将10-19号用户类型设置为v1。
    第二个接待员，设置接待规则，将20-29号用户类型设置为v2。
 遍历用户集合，给用户分区。

代码实现，效果如图所示：
参考答案：

public class Test3 {
   public static void main(String[] args) {

       ArrayList<User> ulist = new ArrayList<>();
       for (int i = 1; i <= 50; i++) {
           ulist.add(new User(i));
      }

       System.out.println("未分组:");
       System.out.println(ulist);

       Reception r1 = new Reception();
       Reception r2 = new Reception();
       Reception r3 = new Reception();
       r1.setF(new Filter() {
           @Override
           public void filterUser(User u) {
               if (u.getId() >= 10 && u.getId() < 20)
                   u.setType("v1");
          }
      });

       r2.setF(new Filter() {
           @Override
           public void filterUser(User u) {
               if (u.getId() >= 20 && u.getId() < 30)
                   u.setType("v2");
          }
      });

       for (int i = 0; i < ulist.size(); i++) {
           User user = ulist.get(i);
           r1.recept(user);
           r2.recept(user);
           r3.recept(user);
      }
       System.out.println("已分组:");
       for (int i = 0; i < ulist.size(); i++) {
           User user = ulist.get(i);
           if (i % 9 == 0) {
               System.out.println();
          }
           System.out.print(user + " ");
      }

  }
}

class Reception {

   Filter f;

   public Filter getF() {
       return f;
  }

   public void setF(Filter f) {
       this.f = f;
  }

   public void recept(User u) {
       if (u.getType() != null)
           return;
       if (f != null) {
           f.filterUser(u);
           return;
      } else {
           u.setType("A");
      }
  }
}

class User {

   private String type;

   private int id;

   public User(int id) {
       this.id = id;
  }

   public int getId() {
       return id;
  }

   public String getType() {
       return type;
  }

   public void setType(String type) {
       this.type = type;
  }

   @Override
   public String toString() {
       return id + "-" + type;
  }
}

interface Filter {

   public abstract void filterUser(User u);

}

第四题

模拟工人挑苹果。

定义苹果类：

 属性：大小，颜色。
 提供基本的构造方法和get方法，set方法

定义接口CompareAble：

定义默认方法compare，挑选较大苹果。

定义接口实现类Compare。

定义工人类：

 成员方法：挑选苹果Apple pickApple（CompareAble，Apple a1，Apple a2）。

测试类：

 创建Worker对象。
 创建两个Apple对象，一个Apple（5，"青色"）,一个Apple（3，"红色"）
 默认挑选大的苹果，打印苹果信息。
 指定颜色挑选，通过匿名内部类实现。

代码实现，效果如图所示：
参考答案：

public class Test4 {
   public static void main(String[] args) {

       Worker worker = new Worker();

       Apple apple1 = new Apple(5, "青色");
       Apple apple2 = new Apple(3, "红色");

       System.out.println("默认挑大的:");
       Apple apple = worker.pickApple(new Com(), apple1, apple2);
       System.out.println(apple);

       System.out.println("挑红的:");
       Apple apple3 = worker.pickApple(new Com() {
           @Override
           public Apple compare(Apple a1, Apple a2) {
               return "红色".equals(a1.getColor()) ? a1 : a2;
          }
      }, apple1, apple2);
       System.out.println(apple3);

  }

}

class Worker {

   public Apple pickApple(CompareAble c, Apple a1, Apple a2) {

       Apple compare = c.compare(a1, a2);
       return compare;

  }

}

class Apple {
   double size;
   String color;

   public Apple(double size, String color) {
       this.size = size;
       this.color = color;
  }

   public String getColor() {
       return color;
  }

   public void setColor(String color) {
       this.color = color;
  }

   public double getSize() {
       return size;
  }

   public void setSize(double size) {
       this.size = size;
  }

   @Override
   public String toString() {
       return size + "-" + color;
  }
}

interface CompareAble {
   public default Apple compare(Apple a1, Apple a2) {
       return a1.getSize() > a2.getSize() ? a1 : a2;
  }
}

class Com implements CompareAble {

}

第五题

模拟玩家选择角色。

定义接口FightAble：

 抽象方法：specialFight。
 默认方法：commonFight,方法中打印"普通打击"。

定义战士类：

 实现FightAble接口,重写方法中打印"武器攻击"。

定义法师类：

 实现FightAble接口,重写方法中打印"法术攻击"。

定义玩家类Player：

 成员方法：FightAble select(String str)，根据指令选择角色。
 	法力角色，选择法师。
 	武力角色，选择战士。

代码实现，效果如图所示：
参考答案：

public class Test5 {
   public static void main(String[] args) {

       Player player = new Player();
       String select  = "法力角色";
       System.out.println("选择:"+ select);
       FightAble f = player.select(select);
       f.specialFight();
       f.commonFight();

       System.out.println("=================");
       select = "武力角色";
       System.out.println("选择:"+ select);
       FightAble f2 = player.select(select);
       f2.specialFight();
       f2.commonFight();
 
  }
}

class Player {
   public FightAble select(String str) {

       if ("法力角色".equals(str)) {
           return new FaShi();
      } else if ("武力角色".equals(str)) {
           return new ZhanShi();
      }
 
       return null;
  }

}

class FaShi implements FightAble {
   @Override
   public void specialFight() {

       System.out.println("法术攻击");
  }
}

class ZhanShi implements FightAble {
   @Override
   public void specialFight() {
       System.out.println("武器攻击");
  }
}

interface FightAble {
   public abstract void specialFight();

   public default void commonFight() {
       System.out.println("普通打击");
  }
}

第一题

第二题

第三题

第四题

第五题

猜你喜欢