初学--策略模式习题练习整理

Posted 2020-08-09 不速之客

   策略模式的组成：

   1.抽象策略角色：策略类，通常由一个接口或者抽象类实现；

   2.具体策略角色：包装了相关的算法和行为；

   3.环境角色：持有一个策略类的引用，最终给客户端调用的。

 

   下面是在某个地方看到的习题，就拿来练手了。

 

 

 

 

 

 

 

 

 

 

   首先可以看到有个给定的Person类，我们写下来先，并且添加类中属性的get，set方法和构造方法：

public class Person
{
    private String name;
    private int id;
    private int age;
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
    public int getId()
    {
        return id;
    }
    public void setId(int id)
    {
        this.id = id;
    }
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }
    
    public Person(String name,int age,int id)
    {
        this.name = name;
        this.age = age;
        this.id = id;
    }
}

 

 

   接下来需要定义一个接口（抽象策略角色），接口中再声明一个方法，这个方法即是用来排序的：

public interface Strategy
{
    /**
     * @param list  需要排序的list
     * @return  返回排序完成后的list
     */
    public ArrayList<Person> sort(ArrayList<Person> list);
}

 

      接着便是实现这个接口了，在这里实现这个接口的时候就该指定排序的字段了，这里我就先用name来作为排序的字段，因此我们新建一个类（具体策略角色）并继承Strategy这个接口：

public class SortbyName implements Strategy
{

    @Override
    public ArrayList<Person> sort(ArrayList<Person> list)
    {
        list.sort(new NameComparator());
        return list;
    }
}

 

 

    上面这段代码中重写了接口的方法，在方法中对list调用sort方法进行指定地排序，说指定排序是因为给它传了一个比较器【new NameComparator()】，

下面就来看看这个比较器的实现：

public class NameComparator implements Comparator
{

    @Override
    public int compare(Object o1, Object o2)
    {
        /*
         * o1和o2对应的即是两个传进来的Person，不能直接拿来比较
         * 此时要比较的是name属性，因此取出属性值再进行比较
         */
        Person person1 = (Person) o1;
        Person person2 = (Person) o2;
        String str1 = person1.getName();
        String str2 = person2.getName();
        //若姓名相同，则通过id升序排序
        if(str1.compareTo(str2) == 0)
        {
            return person1.getId() - person2.getId();
        }
        return str1.compareTo(str2);
    }

}

 

 

    抽象策略角色和具体策略角色都已经完成，接下来就是实现环境角色：

public class Environment
{
    private Strategy strategy;
    
    private ArrayList<Person> list;

    public Strategy getStrategy()
    {
        return strategy;
    }

    public void setStrategy(Strategy strategy)
    {
        this.strategy = strategy;
    }

    public ArrayList<Person> getList()
    {
        return list;
    }

    public void setList(ArrayList<Person> list)
    {
        this.list = list;
    }
    
    public Environment(Strategy strategy,ArrayList<Person> list)
    {
        this.strategy = strategy;
        this.list = list;
    }
    
    public ArrayList<Person> sortbyName()
    {
        return strategy.sort(list);
    }
}

 

    通过构造方法将要实现的strategy,list数据传入环境角色的类中，类中的sortbyName方法将会根据传进来的strategy对list进行处理并返回排序完的list。

 

    最后就是编写客户端来调用环境角色了：

public class Client
{
    public static void main(String[] args)
    {
        ArrayList<Person> list = new ArrayList<Person>();
        list.add(new Person("zhangsan", 18, 5866));
        list.add(new Person("zhangsan", 25, 5863));
        list.add(new Person("lisi", 19, 5867));
        list.add(new Person("wangwu", 26, 5868));
        list.add(new Person("wangwu", 29, 5833));

        SortbyName sbn = new SortbyName();
        Environment environment = new Environment(sbn, list);
        list = environment.sortbyName();

        System.out.println("按姓名排序：");
        for (int i = 0; i < list.size(); i++)
        {
            Person person = list.get(i);
            System.out.println("姓名：" + person.getName() + "   年龄："
                    + person.getAge() + "  学号：" + person.getId());
        }
    }
}

 

    下面是打印结果：

 

    题目的其他要求都差不多，依葫芦画瓢就可以写出来了。