Parsing base code

import java.util.*;

/**
 * Created by Eric on 1/26/2017.
 */


public class Problem {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        Queue<Token> tokens = scan(in);
        NonTerminal program = parse(tokens);
        program.evaluate(new HashMap<>());
        //System.out.println(tokens.toString());
    }

    private static NonTerminal parse(Queue<Token> tokens) {
        return new Program(tokens);
    }


    private static Queue<Token> scan(Scanner in) {
        Queue<Token> tokens = new ArrayDeque<>();
        while(in.hasNext()){
            String n = in.next();
            Token t = null;
            switch(n){
                case "=":
                    t = new EQ();
                    break;
                case "print":
                    t = new PRINT();
                    break;
                default:
                    try{
                        int i = Integer.parseInt(n);
                        t = new NUM(i);
                    }
                    catch (Exception e){
                        t = new ID(n);
                    }
                    break;
            }
            tokens.add(t);
        }
        return tokens;
    }

}
enum TokenType{
    IDEN,
    NUMBER,
    EQUALS,
    PRINT
}
abstract class Token{
    TokenType t;
    public TokenType getType(){
        return t;
    }
    public String toString(){
        return t.toString();
    }
}
class EQ extends  Token{
    EQ(){
        t = TokenType.EQUALS;
    }
}
class PRINT extends  Token{
    PRINT(){
        t = TokenType.PRINT;
    }
}

class NUM extends  Token{
    int num;
    NUM(int num){
        t = TokenType.NUMBER;
        this.num = num;
    }
}

class ID extends Token{
    String id = "";
    ID(String id){
        t = TokenType.IDEN;
        this.id = id;
    }
}

interface NonTerminal{
   public void evaluate(HashMap<String, Integer> env);
}
class Program implements NonTerminal{
    NonTerminal list;
    Program(Queue<Token> tokens){
        list = new StmtList(tokens);
    }

    @Override
    public void evaluate(HashMap<String, Integer> env) {
        list.evaluate(env);
    }
}
class StmtList implements NonTerminal{
    List<NonTerminal> list = new ArrayList<>();
    StmtList(Queue<Token> tokens){
        while (!tokens.isEmpty()){
            list.add(new Stmt(tokens));
        }
    }

    @Override
    public void evaluate(HashMap<String, Integer> env) {
        for (NonTerminal n  : list){
            n.evaluate(env);
        }
    }
}
class Stmt implements NonTerminal {
    NonTerminal nt;
    Stmt(Queue<Token> tokens){
        Token t = tokens.peek();
        switch (t.getType()){
            case IDEN:
                nt = new Assign(tokens);
                break;
            case PRINT:
                nt = new PrintStmt(tokens);
                break;
        }
    }

    @Override
    public void evaluate(HashMap<String, Integer> env) {
        nt.evaluate(env);
    }
}
class  Assign implements NonTerminal{
    ID lh;
    Token rh;
 Assign(Queue<Token> tokens){
     lh =(ID) tokens.poll();
     tokens.poll(); // the =
     rh = tokens.poll();
 }

    @Override
    public void evaluate(HashMap<String, Integer> env) {
        String varName = lh.id;
        switch (rh.getType()){
            case IDEN:
                env.put(varName,env.getOrDefault(((ID)rh).id, 0));
                break;
            case NUMBER:
                env.put(varName, ((NUM)rh).num);
                break;
        }
    }
}
class PrintStmt implements NonTerminal{
    ID id;
    PrintStmt(Queue<Token> tokens){
        tokens.poll(); // the print token
        id = (ID) tokens.poll();
    }

    @Override
    public void evaluate(HashMap<String, Integer> env) {
        System.out.println(env.getOrDefault(id.id,0));
    }
}