# Java 8

## 1. New version (<s>301</s> 283 bytes)

Golfed as this:

<!-- language: lang-java -->

    class C{static int i,j;public static void main(String[]z){int[]b=new int[256];Runnable[]r=new Runnable[26];r[20]=()->b[i]=-~b[i];r[9]=()->i++;r[6]=()->i--;r[13]=()->System.out.print(b[i]);r[1]=()->j+=b[i];r[22]=()->j-=3*b[i];for(;;){r[z[j].charAt(3)-99].run();i=i<0|i>255?0:i;j++;}}}

Somewhat ungolfed version (whitespaces and comments added):

<!-- language: lang-java -->

    class C {
        // Declared as static so they may be changed inside the lambdas without the compiler complaining about that.
        // i is the bit index and j is the instruction pointer.
        static int i, j;
    
        public static void main(String[] z) {
            // The array. Uses ints instead of booleans to save bytes and use some clever math tricks.
            int[] b = new int[256];
    
            // An array of lambdas. The index is the ascii code of 4th letter of the command name subtracted from 99.
            // Thanks for CatsAndFluffy for telling about the 4th letter trick.
            Runnable[] r = new Runnable[26];
            r[20] = () -> b[i] = -~b[i]; // chew
            r[9] = () -> i++; // swallow
            r[6] = () -> i--; // vomit
            r[13] = () -> System.out.print(b[i]); // complain
            r[1] = () -> j += b[i]; // feedtodog. It is 1 or 0 instead of 2 and 1 due to the j++ down there.
            r[22] = () -> j -= 3 * b[i]; // playwithfood. It is -3 or 0 instead of -2 and +1 due to the j++ down there.
    
            // This is the interpreter itself. Runs forever (or until an exception is raised).
            for (;;) {
                // Fetch an instruction and runs it. Throws an exception on unknown or mistyped instructions.
                r[z[j].charAt(3) - 99].run();
    
                // Resets the bit index if out of range.
                i = i < 0 | i > 255 ? 0 : i;
    
                // Next instruction. No special treatment for branching needed because they already considers this.
                j++;
            }
        }
    }

We surely should have testcases. I am not sure if there is some bug hiding out there.

Anyway I run it with that (input is given as command line arguments):

<!-- language: lang-none -->

    chew complain swallow chew complain swallow chew complain swallow complain

And here is the output:

    1110
    Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10
    	at C.main(C.java:1)

The `ArrayIndexOutOfBoundsException` is the standard way to finish the program, it is not a bug!

BTW, this answer abuses the fact that the 4th char of each command is different than each other (thanks CatsAndFluffy). This means that `whew` is interpreted as `chew` and that `yellow` is interpreted as `swallow`.

## 2. Old version (<s>354</s> 337 bytes)

If strict conformance to command names are required (and just looking for the 4th letter in command's name is not enough), then I have this (older) answer with 337 bytes:

<!-- language: lang-java -->

    import java.util.*;class C{static int i,j;public static void main(String[]z){int[]b=new int[256];List o=Arrays.asList("chew","swallow","vomit","complain","feedtodog","playwithfood");Runnable[]r={()->b[i]=-~b[i],()->i++,()->i--,()->System.out.print(b[i]),()->j+=b[i],()->j-=3*b[i]};for(;;){r[o.indexOf(z[j])].run();i=i<0|i>255?0:i;j++;}}}

Somewhat ungolfed version (whitespaces and comments added):

<!-- language: lang-java -->

    // Needed for java.util.List and java.util.Arrays.
    import java.util.*;

    class C {
        // Declared as static so they may be changed inside the lambdas without the compiler complaining about that.
        // i is the bit index and j is the instruction pointer.
        static int i, j;
    
        public static void main(String[] z) {
            // The array. Uses ints instead of booleans to save bytes and use some clever math tricks.
            int[] b = new int[256];
    
            // Declared as a list so we can use the indexOf method further down. Screw up the generics.
            List o = Arrays.asList("chew", "swallow", "vomit", "complain", "feedtodog", "playwithfood");
    
            // An array of lambdas.
            Runnable[] r = {
                () -> b[i] = -~b[i], // chew
                () -> i++, // swallow
                () -> i--, // vomit
                () -> System.out.print(b[i]), // complain
                () -> j += b[i], // feedtodog. It is 1 and 0 instead of 2 and 1 due to the j++ down there.
                () -> j -= 3 * b[i] // playwithfood. It is -3 and 0 instead of -2 and +1 due to the j++ down there.
            };
    
            // This is the interpreter itself. Runs forever (or until an exception is raised).
            for (;;) {
                // Fetch an instruction and runs it. Throws an exception on unknown or mistyped instructions.
                r[o.indexOf(z[j])].run();
    
                // Resets the bit index if out of range.
                i = i < 0 | i > 255 ? 0 : i;
    
                // Next instruction. No special treatment for branching needed because the branching instructions already considers this.
                j++;
            }
        }
    }