public interface Iterator {
    boolean hasNext();
    Object next();
}

public interface Container {
    Iterator getIterator();
}

public class NameRepository implements Container {
    public String names[] = {"Ethan", "Jason", "Karen", "Ascii"};

    @Override
    public Iterator getIterator() {
        return new NameIterator();
    }

    private class NameIterator implements Iterator {

        int index;

        @Override
        public boolean hasNext() {
            if(index < names.length){
                return true;
            }
            return false;
        }

        @Override
        public Object next() {
            if(hasNext()){
                return names[index++];
            }
            return null;
        }
    }
}

public class IteratorPatternDemo {

    public static void main(String[] args) {
        NameRepository namesRepository = new NameRepository();

        Iterator iterator = namesRepository.getIterator();

        while (iterator.hasNext()) {
            String name = (String)iterator.next();
            System.out.println("Name : " + name);
        }
    }
}

/**
 * 定义符号（空格、数字、加、乘、变量、终止符）
 */
public class Token {
   public enum TokenType {
      SPACE,
      NUMBER,
      ADD,
      MULTIPLY,
      VARIABLE,
      EPSILON, // The end of the entire expression.
   }
   
   private final TokenType type;
   private final String string;
   
   public Token(TokenType type, String string) {
      this.type = type;
      this.string = string;
   }

   @Override
   public String toString() {
      return String.format("(%s, \"%s\")", type, string);
   }

   public TokenType getType() {
      return type;
   }

   public String getString() {
      return string;
   }
   
   public double getAsNumber() throws InterpreterException {
      if (type != TokenType.NUMBER) {
         throw new InterpreterException("Incorrect token type. ");
      }
      return Double.valueOf(string);
   }
}

/**
 * 将输入内容按规则解析成Token列表
 */
public class Tokenizer {
    private static class TokenRule {
        private final Pattern pattern;
        private final TokenType type;

        public TokenRule(String pattern, TokenType type) {
            this.pattern = Pattern.compile(pattern);
            this.type = type;
        }

        public Pattern getPattern() {
            return pattern;
        }

        public TokenType getType() {
            return type;
        }
    }

    private static final List<TokenRule> rules = new ArrayList<TokenRule>();

    static {
        rules.add(new TokenRule("^\\d+(\\.\\d+)?", TokenType.NUMBER));
        rules.add(new TokenRule("^[ \t\n\r]+", TokenType.SPACE));
        rules.add(new TokenRule("^\\+", TokenType.ADD));
        rules.add(new TokenRule("^\\*", TokenType.MULTIPLY));
        rules.add(new TokenRule("^[A-Za-z][A-Za-z0-9]*", TokenType.VARIABLE));
    }

    public static List<Token> tokenize(String exprStr) throws InterpreterException {
        Tokenizer tokenizer = new Tokenizer(exprStr);
        return tokenizer.tokenize();
    }

    private final String exprStr;

    private Tokenizer(String exprStr) {
        this.exprStr = exprStr;
    }

    private List<Token> tokenize() throws InterpreterException {
        List<Token> tokens = new ArrayList<Token>();
        int pos = 0;
        int len = exprStr.length();
        while (pos < len) {
            CharSequence sequence = exprStr.subSequence(pos, len);
            boolean matched = false;
            for (TokenRule rule : rules) {
                Matcher matcher = rule.getPattern().matcher(sequence);
                if (!matcher.find()) {
                    continue;
                }
                matched = true;
                pos += matcher.end();
                TokenType type = rule.getType();
                if (type != TokenType.SPACE) {
                    Token token = new Token(type, matcher.group());
                    tokens.add(token);
                }
                break;
            }
            if (!matched) {
                throw new InterpreterException("Tokenizer error at: \"" + sequence + "\"");
            }
        }
        tokens.add(new Token(TokenType.EPSILON, ""));
        return tokens;
    }
}

/**
 * 定义词法解析器，根据规则将输入的Tokens转化成待解释的表达式
 */
public class Parser {
    private final List<Token> tokens;
    int next = 0;

    public static Expression parse(List<Token> tokens) throws InterpreterException {
        return new Parser(tokens).parse();
    }

    private Parser(List<Token> tokens) {
        this.tokens = tokens;
    }

    private Expression parse() throws InterpreterException {
        next = 0;
        Expression expression = expression();
        except(TokenType.EPSILON);
        return expression;
    }

    private Expression expression() throws InterpreterException {
        Expression expression = term();// 先乘法
        while (accept(TokenType.ADD)) {// 在加法
            expression = new AddExpression(expression, term());
        }
        return expression;

    }

    private Expression term() throws InterpreterException {
        Expression expression = factor();
        while (accept(TokenType.MULTIPLY)) {
            expression = new MultiplyExpression(expression, term());
        }
        return expression;
    }

    /**
     * 获取 常量或变量表达式
     * @return 常量或变量表达式
     * @throws InterpreterException 不是商量两种类型就抛异常
     */
    private Expression factor() throws InterpreterException {
        if (accept(TokenType.NUMBER)) {
            return new NumberExpression(current().getAsNumber());
        }
        except(TokenType.VARIABLE);
        return new VariableExpression(current().getString());
    }

    /**
     * 获取指定类型Token
     * @param tokenType 获取的token类型
     * @return 如果是期待的类型，返回true，同时更新next指针；不是则返回false；
     */
    private boolean accept(TokenType tokenType) {
        if (tokens.get(next).getType() == tokenType) {
            ++next;
            return true;
        } else {
            return false;
        }
    }

    /**
     * 需要的类型
     * @param tokenType 期待的类型
     * @throws InterpreterException 不是期待的token类型则抛出异常
     */
    private void except(TokenType tokenType) throws InterpreterException {
        if (!accept(tokenType)) {
            throw new InterpreterException(
                    "Parser error. Unexcepted token at: \""
                            + getRemainingString() + "\"");
        }
    }

    /**
     * 当前处理的token
     * @return 当前处理的token
     */
    private Token current() {
        return tokens.get(next - 1);
    }

    private String getRemainingString() {
        StringBuffer buffer = new StringBuffer();
        for (int i = next; i < tokens.size(); ++i) {
            if (i != next)
                buffer.append(" ");
            buffer.append(tokens.get(i).getString());
        }
        return buffer.toString();
    }

}

/**
 * 解释器中心，客户端通过该类进行输入文本的解释，不需要关心具体解释器的实现（类似于中介者）
 */
public class Interpreter {
   
   private final List<Token> tokens;
   private final Expression rootExpression;

   public Interpreter(String expressionString) throws InterpreterException {
      tokens = Tokenizer.tokenize(expressionString);
      rootExpression = Parser.parse(tokens);
   }

   public List<Token> getTokens() {
      return tokens;
   }

   public Expression getRootExpression() {
      return rootExpression;
   }

}

/**
 * 定义解释器（表达式）接口
 */
public interface Expression {
    double interpret(Map<String, Double> context) throws InterpreterException;
}

/**
 * 加法解释器
 */
public class AddExpression implements Expression {

   private final Expression leftExpression; 
   private final Expression rightExpression; 
   
   public AddExpression(Expression leftExpression, Expression rightExpression) {
      this.leftExpression = leftExpression;
      this.rightExpression = rightExpression;
   }

   @Override
   public double interpret(Map<String, Double> context) throws InterpreterException {
      return leftExpression.interpret(context) + rightExpression.interpret(context);
   }

   @Override
   public String toString() {
      return String.format("(%s + %s)", leftExpression, rightExpression);
   }

}

/**
 * 乘法解释器实现
 */
public class MultiplyExpression implements Expression {

   private final Expression leftExpression; 
   private final Expression rightExpression; 
   
   public MultiplyExpression(Expression leftExpression, Expression rightExpression) {
      this.leftExpression = leftExpression;
      this.rightExpression = rightExpression;
   }

   @Override
   public double interpret(Map<String, Double> context) throws InterpreterException {
      return leftExpression.interpret(context) * rightExpression.interpret(context);
   }
   
   @Override
   public String toString() {
      return String.format("(%s * %s)", leftExpression, rightExpression);
   }

}

/**
 * 数字解释器
 */
public class NumberExpression implements Expression {

    private final double value;

    public NumberExpression(double value) {
        this.value = value;
    }

    @Override
    public double interpret(Map<String, Double> context) {
        return value;
    }

    @Override
    public String toString() {
        return String.valueOf(value);
    }

}

/**
 * 变量解释器实现
 */
public class VariableExpression implements Expression {

   private final String name;

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

   @Override
   public double interpret(Map<String, Double> context) throws InterpreterException {
      if (context.containsKey(name)) {
         return context.get(name);
      } else {
         throw new InterpreterException("Variable not found: " + name);
      }
   }
   
   @Override
   public String toString() {
      return name;
   }

}

public class InterpreterException extends Exception {
   private static final long serialVersionUID = 8459803686326291973L;

   public InterpreterException(String message) {
      super(message);
   }
}

public class Main {

    static final boolean VERBOSE_PARSE = true;
    static final boolean VERBOSE_DEBUG = true;
    static final double EPS = 1e-7;
    static final Map<String, Double> context = new HashMap<String, Double>();

    static {
        context.put("age", 18.0);
        context.put("height", 170.0);
    }

    private static void execute(String expressionString, double excepted) {
        System.out.println("Attempting to evaluate: " + expressionString);
        try {
            Interpreter interpreter = new Interpreter(expressionString);
            if (VERBOSE_PARSE) {
                printTokens(interpreter.getTokens());
                System.out.println("Parse tree: "
                        + interpreter.getRootExpression());
            }
            double value = interpreter.getRootExpression().interpret(context);
            boolean correct = Math.abs(value - excepted) < EPS;
            System.out.println(String.format(
                    "* %s!! Excepted: %.4f, evaluated: %.4f",
                    correct ? "Correct" : "Incorrect", excepted, value));
        } catch (InterpreterException e) {
            System.out.println("Error: " + e);
            if (VERBOSE_DEBUG) {
                e.printStackTrace();
            }
        }
    }

    private static void printTokens(List<Token> tokens) {
        StringBuffer buffer = new StringBuffer("Tokens: ");
        for (Token token : tokens) {
            buffer.append(token);
        }
        System.out.println(buffer);
    }

    public static void main(String[] args) {
//    execute("1.5", 1.5);
//    execute("1 + 2 + 3 + 4 + 5", 1 + 2 + 3 + 4 + 5);
//    execute("2 * 3 + 5 * 7", 2 * 3 + 5 * 7);
        execute("age * 10 + height * 1.5", get("age") * 10 + get("height") * 1.5);
    }

    public static double get(String key) {
        return context.get(key);
    }
}

/**
 * 定义状态接口
 */
public interface State {
   void doAction();
}

/**
 * 开始状态
 */
public class TVStartState implements State {
   @Override
   public void doAction() {
      System.out.println("TV is turned ON");
   }
}

/**
 * 暂停状态
 */
public class TVStopState implements State {
   @Override
   public void doAction() {
      System.out.println("TV is turned OFF");
   }
}

/**
 * 持有状态引用的上下文环境
 * 通过它来响应不同状态的不同行为，实际上调用的时该状态所对应的行为
 */
public class TVContext {
    private State state;

    public void setState(State state) {
        this.state = state;
    }

    public void doAction() {
        this.state.doAction();
    }
}

/**
 * 状态模式Client
 */
public class TVRemote {
   public static void main(String[] args) {

      TVContext context = new TVContext();

      context.setState(new TVStartState());
      context.doAction();

      context.setState(new TVStopState());
      context.doAction();

   }
}

/**
 * 定义元素接口
 */
public interface ComputerPart {
    void accept(ComputerPartVisitor computerPartVisitor);

    void accept(UserInputVisitor userInputVisitor);
}

/**
 * 定义访问者接口
 */
public interface ComputerPartVisitor {
    void visit(Computer computer);

    void visit(Mouse mouse);

    void visit(Keyboard keyboard);

    void visit(Monitor monitor);
}

/**
 * 电脑（结构固定的元素对象）
 */
public class Computer implements ComputerPart {

    ComputerPart[] parts;

    public Computer(){
        parts = new ComputerPart[] {new Mouse(), new Keyboard(), new Monitor()};
    }

    @Override
    public void accept(ComputerPartVisitor computerPartVisitor) {
        for (int i = 0; i < parts.length; i++) {
            parts[i].accept(computerPartVisitor);
        }
        computerPartVisitor.visit(this);
    }

    @Override
    public void accept(UserInputVisitor userInputVisitor) {
        for (int i = 0; i < parts.length; i++) {
            parts[i].accept(userInputVisitor);
        }
        userInputVisitor.visit(this);
    }
}

/**
 * 键盘
 */
public class Keyboard implements ComputerPart {

    @Override
    public void accept(ComputerPartVisitor computerPartVisitor) {
        computerPartVisitor.visit(this);
    }

    @Override
    public void accept(UserInputVisitor userInputVisitor) {
        userInputVisitor.visit(this);
    }
}

/**
 * 显示器
 */
public class Monitor implements ComputerPart {

    @Override
    public void accept(ComputerPartVisitor computerPartVisitor) {
        computerPartVisitor.visit(this);
    }

    @Override
    public void accept(UserInputVisitor userInputVisitor) {
        userInputVisitor.visit(this);
    }
}

/**
 * 鼠标
 */
public class Mouse implements ComputerPart {

    @Override
    public void accept(ComputerPartVisitor computerPartVisitor) {
        computerPartVisitor.visit(this);
    }

    @Override
    public void accept(UserInputVisitor userInputVisitor) {
        userInputVisitor.visit(this);
    }
}

/**
 * 整体访问者
 */
public class ComputerPartDisplayVisitor implements ComputerPartVisitor {

    @Override
    public void visit(Computer computer) {
        System.out.println("Displaying Computer.");
    }

    @Override
    public void visit(Mouse mouse) {
        System.out.println("Displaying Mouse.");
    }

    @Override
    public void visit(Keyboard keyboard) {
        System.out.println("Displaying Keyboard.");
    }

    @Override
    public void visit(Monitor monitor) {
        System.out.println("Displaying Monitor.");
    }
}

/**
 * 输入设备访问者
 */
public class UserInputVisitor implements ComputerPartVisitor {

    @Override
    public void visit(Computer computer) {}

    @Override
    public void visit(Mouse mouse) {
        System.out.println("Displaying Mouse.");
    }

    @Override
    public void visit(Keyboard keyboard) {
        System.out.println("Displaying Keyboard.");
    }

    @Override
    public void visit(Monitor monitor) {}
}

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

        ComputerPart computer = new Computer();

        System.out.println("== Show all computer part: ==");
        computer.accept(new ComputerPartDisplayVisitor());

        System.out.println("\n== Show user input part: ==");
        computer.accept(new UserInputVisitor());
    }
}

/**
 * 被观察者接口
 */
public interface Subject {
    void registerObserver(Observer object);

    void removeObserver(Observer object);

    void notifyObservers();
}

/**
 * 观察者接口
 */
public interface Observer {
    void update(String headlineNews, String sportsNews, String financeNews, String entertainmentNews);
}

/**
 * 真正的被观察者
 */
public class NewsData implements Subject {
    private String headlineNews;
    private String sportsNews;
    private String financeNews;
    private String entertainmentNews;

    private List observerArrayList;

    public NewsData() {
        observerArrayList = new ArrayList();
    }

    @Override
    public void registerObserver(Observer object) {
        observerArrayList.add(object);
    }

    @Override
    public void removeObserver(Observer object) {
        if (observerArrayList.contains(object)) {
            observerArrayList.remove(object);
        }
    }

    @Override
    public void notifyObservers() {
        for (int i = 0; i < observerArrayList.size(); i++) {
            ((Observer) observerArrayList.get(i)).update(headlineNews, sportsNews, financeNews, entertainmentNews);
        }
    }

    public void updateNews() {
        notifyObservers();
    }

    public String getHeadlineNews() {
        return headlineNews;
    }

    public String getSportsNews() {
        return sportsNews;
    }

    public void setFinanceNews(String financeNews) {
        this.financeNews = financeNews;
    }

    public void setEntertainmentNews(String entertainmentNews) {
        this.entertainmentNews = entertainmentNews;
    }

    public void setHeadlineNews(String headlineNews) {
        this.headlineNews = headlineNews;
    }

    public void setSportsNews(String sportsNews) {
        this.sportsNews = sportsNews;
    }

    public String getFinanceNews() {
        return financeNews;
    }

    public String getEntertainmentNews() {
        return entertainmentNews;
    }
}

/**
 * 关注头条、体育和娱乐新闻，不关注财经新闻
 */
public class CccNewsDisplay implements Observer {
    private String headlineNews;
    private String sportsNews;
    private String entertainmentNews;

    @Override
    public void update(String headlineNews, String sportsNews, String financeNews, String entertainmentNews) {
        this.headlineNews = headlineNews;
        this.sportsNews = sportsNews;
        this.entertainmentNews = entertainmentNews;
        display();
    }

    public void display() {
        System.out.println("Ccc headlineNews: " + headlineNews);
        System.out.println("Ccc sportsNews: " + sportsNews);
        System.out.println("Ccc entertainmentNews: " + entertainmentNews);
    }
}

/**
 * 关注头条、体育和财经新闻，不关注娱乐新闻
 */
public class DnnNewsDisplay implements Observer {
    private String headlineNews;
    private String sportsNews;
    private String financeNews;

    @Override
    public void update(String headlineNews, String sportsNews, String financeNews, String entertainmentNews) {
        this.headlineNews = headlineNews;
        this.sportsNews = sportsNews;
        this.financeNews = financeNews;
        display();
    }

    public void display() {
        System.out.println("Dnn headlineNews: " + headlineNews);
        System.out.println("Dnn sportsNews: " + sportsNews);
        System.out.println("Dnn finaceNews: " + financeNews);
    }
}

/**
 * 只关注娱乐新闻
 */
public class GuavaDailyNewsDisplay implements Observer {
    private String entertainmentNews;

    @Override
    public void update(String headlineNews, String sportsNews, String financeNews, String entertainmentNews) {
        this.entertainmentNews = entertainmentNews;
        display();
    }

    public void display() {
        System.out.println("GuavaDaily entertainmentNews: " + entertainmentNews);
    }
}

public class NewsStation {

    public static void main(String[] args) {
        NewsData newsData = new NewsData();
        CccNewsDisplay cccNewsDisplay = new CccNewsDisplay();
        DnnNewsDisplay dnnNewsDisplay = new DnnNewsDisplay();
        GuavaDailyNewsDisplay guavaDailyNewsDisplay = new GuavaDailyNewsDisplay();
        YahuNewsDisplay yahuNewsDisplay = new YahuNewsDisplay();

        newsData.registerObserver(cccNewsDisplay);
        newsData.registerObserver(dnnNewsDisplay);
        newsData.registerObserver(guavaDailyNewsDisplay);
        newsData.registerObserver(yahuNewsDisplay);

        newsData.setHeadlineNews("'Big objects found' in AirAsia hunt");
        newsData.setFinanceNews("US shares barely budge in 2015");
        newsData.setEntertainmentNews("Bono guitar fears after bike crash");
        newsData.setSportsNews("World Tennis Championship: Andy Murray beats Rafael Nadal");

        newsData.updateNews();

    }

}

public interface Command {
    /**
     * 攻击命令
     */
    void attack();
}

/**
 * 术士
 */
public class Wizard {
    public void spell() {
        System.out.println("wizard spell");
    }

}

/**
 * 武士
 */
public class Warrior {
    public void attack() {
        System.out.println("warrior attack!");
    }
}

/**
 * 骑士
 */
public class Knight {
   public void rideHorseAndAttack(){
      System.out.println("knight ride hourse and attack!");
   }
}

/**
 * 哥布林（传说中的类人生物）
 */
public class Goblin {
    public void attack() {
        System.out.println("goblin attack!");
    }
}

/**
 * 棒球运动员
 */
public class BaseballPlayer {
   /**
    * 挥动球棒
    */
   public void swingBat(){
      System.out.println("baseball player swing bat!");
   }
}

/**
 * 术士对应的命令
 */
public class WizardCommand implements Command {

   private Wizard wizard;

   public WizardCommand(Wizard wizard) {
      this.wizard = wizard;
   }

   @Override
   public void attack() {
      wizard.spell();
   }
}

/**
 * 武士对应的命令
 */
public class WarriorCommand implements Command {

   private Warrior warrior;

   public WarriorCommand(Warrior warrior) {
      this.warrior = warrior;
   }

   @Override
   public void attack() {
      warrior.attack();
   }
}

/**
 * 骑士对应的命令
 */
public class KnightCommand implements Command{
   
    private Knight knight;

    public KnightCommand(Knight knight) {
        this.knight = knight;
    }

    @Override
    public void attack() {
        knight.rideHorseAndAttack();
    }

}

/**
 * 哥布林对应的命令
 */
public class GoblinCommand implements Command {

    private Goblin goblin;

    public GoblinCommand(Goblin goblin) {
        this.goblin = goblin;
    }

    @Override
    public void attack() {
        goblin.attack();
    }
}

/**
 * 棒球运动员对应的命令
 */
public class BaseballPlayerCommand implements Command{
    
    private BaseballPlayer baseballPlayer;
    
   public BaseballPlayerCommand(BaseballPlayer baseballPlayer){
       this.baseballPlayer = baseballPlayer;
   }

    @Override
    public void attack() {
        baseballPlayer.swingBat();
    }
}

/**
 * 控制终端
 */
public class SimpleRemoteControl {
    private final List<Command> commands;

    public SimpleRemoteControl() {
        commands = new ArrayList<Command>();
    }

    public void addCommand(Command command) {
        commands.add(command);
    }

    public void buttonWasPressed(int index) {
        commands.get(index).attack();
    }

    public int getCommandsSize() {
        return commands.size();
    }

    @Override
    public String toString() {

        StringBuffer stringBuff = new StringBuffer();
        stringBuff.append("\n------------Remote Control------------\n");

        for (int i = 0; i < commands.size(); i++) {
            stringBuff.append("[slot " + i + "]  " + commands.get(i).getClass().getName() + "\n");
        }
        return stringBuff.toString();
    }
}

public class FightMain {

    public static void main(String[] args) {
        SimpleRemoteControl remoteControl = new SimpleRemoteControl();
        
        Knight knight = new Knight();
        Wizard wizard = new Wizard();
        Warrior warrior = new Warrior();
        Goblin goblin = new Goblin();
        BaseballPlayer baseballPlayer = new BaseballPlayer();
//        SonGoku sonGoku = new SonGoku();

        Command knightCommand = new KnightCommand(knight);
        Command wizardCommand = new WizardCommand(wizard);
        Command warriorCommand = new WarriorCommand(warrior);
        Command goblinCommand = new GoblinCommand(goblin);
        Command baseballPlayerCommand = new BaseballPlayerCommand(baseballPlayer);
//        Command sonGoKuCommand = new SonGokuCommand(sonGoku);
        
//        List<Command> commandList= new ArrayList<Command>();
//        commandList.add(sonGoKuCommand);
//        commandList.add(baseballPlayerCommand);
//        Command mircoCommand = new MircoCommand(commandList);

        remoteControl.addCommand(knightCommand);
        remoteControl.addCommand(wizardCommand);
        remoteControl.addCommand(warriorCommand);
        remoteControl.addCommand(goblinCommand);
        remoteControl.addCommand(baseballPlayerCommand);
//        remoteControl.addCommand(sonGoKuCommand);
//        remoteControl.addCommand(mircoCommand);

        System.out.println(remoteControl);

        for (int i = 0; i < remoteControl.getCommandsSize(); i++) {
            System.out.println("-------------"+i+"----------------");
            remoteControl.buttonWasPressed(i);
        }
        
    }
}

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    private String color;
    private int x;
    private int y;
    private int radius;

    public Circle(String color) {
        this.color = color;
    }

// 这里注释掉setColor方法，不然外界拿到对象后可以调用该方法来改变Circle颜色
//    public void setColor(String color) {
//        this.color = color;
//    }

    public void setX(int x) {
        this.x = x;
    }

    public void setY(int y) {
        this.y = y;
    }

    public void setRadius(int radius) {
        this.radius = radius;
    }

    @Override
    public void draw() {
        System.out.println("Circle: draw()[" + "color=" + color + ", x=" + x + ", y=" + y + ", radius=" + radius + ']');
    }
}

public class ShapeFactory {
    private static final HashMap<String, Shape> circleMap = new HashMap<>();

    public static Shape getCircle(String color) {
        Circle circle = (Circle) circleMap.get(color);

        if (circle == null) {
            circle = new Circle(color);
            circleMap.put(color, circle);
            System.out.println("----------------------------------");
            System.out.println("create circle of color:" + color);
            System.out.println("----------------------------------");
        }
        return circle;
    }
}

public class FlyWeightDemo {
    private static final String[] colors = new String[]{"Red", "Green", "Blue", "Black", "Purple"};

    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            Circle circle = (Circle) ShapeFactory.getCircle(getRandomColor());
            circle.setX(getRandomX());
            circle.setY(getRandomY());
            circle.setRadius(100);
            circle.draw();
        }
    }

    private static String getRandomColor() {
        return colors[(int) (Math.random() * colors.length)];
    }

    private static int getRandomX() {
        return (int) (Math.random() * 100);
    }

    private static int getRandomY() {
        return (int) (Math.random() * 100);
    }
}