diff --git a/src/main/java/chapter14/Application.java b/src/main/java/chapter14/Application.java
index e01e518..ca77f84 100644
--- a/src/main/java/chapter14/Application.java
+++ b/src/main/java/chapter14/Application.java
@@ -8,17 +8,18 @@ class Application {
 
     public static void main(String[] args) {
         try {
-            Args arg = new Args("l,d*", args);
+            Args arg = new Args("l,p#,d*", args);
             boolean logging = arg.getBoolean('l');
+            int port = arg.getInt('p');
             String directory = arg.getString('d');
-            executeApplication(logging, directory);
+            executeApplication(logging, port, directory);
         } catch (ParseException e) {
             System.out.printf("Parse error: %s\n", e.getMessage());
         }
     }
 
     // stub
-    private static void executeApplication(boolean logging, String directory) {
-        System.out.printf("logging: %b, directory: %s\n", logging, directory);
+    private static void executeApplication(boolean logging, int port, String directory) {
+        System.out.printf("logging: %b, port: %d, directory: %s\n", logging, port, directory);
     }
 }
diff --git a/src/main/java/chapter14/args/Args.java b/src/main/java/chapter14/args/Args.java
index add22cc..1f4429a 100644
--- a/src/main/java/chapter14/args/Args.java
+++ b/src/main/java/chapter14/args/Args.java
@@ -10,16 +10,17 @@ public class Args {
     private Set<Character> unexpectedArguments = new TreeSet<>();
     private Map<Character, Boolean> booleanArgs = new HashMap<>();
     private Map<Character, String> stringArgs = new HashMap<>();
+    private Map<Character, Integer> intArgs = new HashMap<>();
     private Set<Character> argsFound = new HashSet<>();
     private int currentArgument;
-    private char errorArgument = '\0';
+    private char errorArgumentId = '\0';
+    private String errorParameter = "TILT";
+    private ErrorCode errorCode = ErrorCode.OK;
 
     enum ErrorCode {
-        OK, MISSING_STRING
+        OK, MISSING_STRING, MISSING_INTEGER, INVALID_INTEGER, UNEXPECTED_ARGUMENT
     }
 
-    private ErrorCode errorCode = ErrorCode.OK;
-
     public Args(String schema, String[] args) throws ParseException {
         this.schema = schema;
         this.args = args;
@@ -30,7 +31,10 @@ private boolean parse() throws ParseException {
         if (schema.length() == 0 && args.length == 0)
             return true;
         parseSchema();
-        parseArguments();
+        try {
+            parseArguments();
+        } catch (ArgsException e) {
+        }
         return valid;
     }
 
@@ -52,6 +56,13 @@ private void parseSchemaElement(String element) throws ParseException {
             parseBooleanSchemaElement(elementId);
         else if (isStringSchemaElement(elementTail))
             parseStringSchemaElement(elementId);
+        else if (isIntegerSchemaElement(elementTail))
+            parseIntegerSchemaElement(elementId);
+        else {
+            throw new ParseException(
+                    String.format("Argument: %c has invalid format: %s.",
+                            elementId, elementTail), 0);
+        }
     }
 
     private void validateSchemaElementId(char elementId) throws ParseException {
@@ -61,6 +72,14 @@ private void validateSchemaElementId(char elementId) throws ParseException {
         }
     }
 
+    private void parseBooleanSchemaElement(char elementId) {
+        booleanArgs.put(elementId, false);
+    }
+
+    private void parseIntegerSchemaElement(char elementId) {
+        intArgs.put(elementId, 0);
+    }
+
     private void parseStringSchemaElement(char elementId) {
         stringArgs.put(elementId, "");
     }
@@ -73,11 +92,11 @@ private boolean isBooleanSchemaElement(String elementTail) {
         return elementTail.length() == 0;
     }
 
-    private void parseBooleanSchemaElement(char elementId) {
-        booleanArgs.put(elementId, false);
+    private boolean isIntegerSchemaElement(String elementTail) {
+        return elementTail.equals("#");
     }
 
-    private boolean parseArguments() {
+    private boolean parseArguments() throws ArgsException {
         for (currentArgument = 0; currentArgument < args.length; currentArgument++) {
             String arg = args[currentArgument];
             parseArgument(arg);
@@ -85,50 +104,76 @@ private boolean parseArguments() {
         return true;
     }
 
-    private void parseArgument(String arg) {
+    private void parseArgument(String arg) throws ArgsException {
         if (arg.startsWith("-"))
             parseElements(arg);
     }
 
-    private void parseElements(String arg) {
+    private void parseElements(String arg) throws ArgsException {
         for (int i = 1; i < arg.length(); i++) {
             parseElement(arg.charAt(i));
         }
     }
 
-    private void parseElement(char argChar) {
+    private void parseElement(char argChar) throws ArgsException {
         if (setArgument(argChar))
             argsFound.add(argChar);
         else {
             unexpectedArguments.add(argChar);
+            errorCode = ErrorCode.UNEXPECTED_ARGUMENT;
             valid = false;
         }
     }
 
-    private boolean setArgument(char argChar) {
-        boolean set = true;
-        if (isBoolean(argChar))
+    private boolean setArgument(char argChar) throws ArgsException {
+        if (isBooleanArg(argChar))
             setBooleanArg(argChar, true);
-        else if (isString(argChar))
-            setStringArg(argChar, "");
+        else if (isStringArg(argChar))
+            setStringArg(argChar);
+        else if (isIntArg(argChar))
+            setIntArg(argChar);
         else
-            set = false;
+            return false;
+
+        return true;
+    }
+
+    private boolean isIntArg(char argChar) {
+        return intArgs.containsKey(argChar);
+    }
 
-        return set;
+    private void setIntArg(char argChar) throws ArgsException {
+        currentArgument++;
+        String parameter = null;
+        try {
+            parameter = args[currentArgument];
+            intArgs.put(argChar, new Integer(parameter));
+        } catch (ArrayIndexOutOfBoundsException e) {
+            valid = false;
+            errorArgumentId = argChar;
+            errorCode = ErrorCode.MISSING_INTEGER;
+            throw new ArgsException();
+        } catch (NumberFormatException e) {
+            valid = false;
+            errorArgumentId = argChar;
+            errorParameter = parameter;
+            errorCode = ErrorCode.INVALID_INTEGER;
+            throw new ArgsException();
+        }
     }
 
-    private void setStringArg(char argChar, String s) {
+    private void setStringArg(char argChar) {
         currentArgument++;
         try {
             stringArgs.put(argChar, args[currentArgument]);
         } catch (ArrayIndexOutOfBoundsException e) {
             valid = false;
-            errorArgument = argChar;
+            errorArgumentId = argChar;
             errorCode = ErrorCode.MISSING_STRING;
         }
     }
 
-    private boolean isString(char argChar) {
+    private boolean isStringArg(char argChar) {
         return stringArgs.containsKey(argChar);
     }
 
@@ -136,7 +181,7 @@ private void setBooleanArg(char argChar, boolean value) {
         booleanArgs.put(argChar, value);
     }
 
-    private boolean isBoolean(char argChar) {
+    private boolean isBooleanArg(char argChar) {
         return booleanArgs.containsKey(argChar);
     }
 
@@ -152,18 +197,23 @@ public String usage() {
     }
 
     public String errorMessage() throws Exception {
-        if (unexpectedArguments.size() > 0) {
-            return unexpectedArgumentMessage();
-        } else {
-            switch (errorCode) {
-                case MISSING_STRING:
-                    return String.format("Could not find string parameter for -%c.",
-                            errorArgument);
-                case OK:
-                    throw new Exception("TILT: Should not get here.");
-            }
-            return "";
+        switch (errorCode) {
+            case OK:
+                throw new Exception("TILT: Should not get here.");
+            case UNEXPECTED_ARGUMENT:
+                return unexpectedArgumentMessage();
+            case MISSING_STRING:
+                return String.format("Could not find string parameter for -%c.",
+                        errorArgumentId);
+            case INVALID_INTEGER:
+                return String.format("Argument -%c expects an integer but was '%s'.",
+                        errorArgumentId, errorParameter);
+            case MISSING_INTEGER:
+                return String.format("Could not find integer parameter for -%c.",
+                        errorArgumentId);
         }
+        return "";
+
     }
 
     private String unexpectedArgumentMessage() {
@@ -176,22 +226,30 @@ private String unexpectedArgumentMessage() {
         return message.toString();
     }
 
-    public boolean getBoolean(char arg) {
-        return falseIfNull(booleanArgs.get(arg));
-    }
-
     private boolean falseIfNull(Boolean b) {
         return b == null ? false : b;
     }
 
-    public String getString(char arg) {
-        return blankIfNull(stringArgs.get(arg));
+    private int zeroIfNull(Integer i) {
+        return i == null ? 0 : i;
     }
 
     private String blankIfNull(String s) {
         return s == null ? "" : s;
     }
 
+    public String getString(char arg) {
+        return blankIfNull(stringArgs.get(arg));
+    }
+
+    public int getInt(char arg) {
+        return zeroIfNull(intArgs.get(arg));
+    }
+
+    public boolean getBoolean(char arg) {
+        return falseIfNull(booleanArgs.get(arg));
+    }
+
     public boolean has(char arg) {
         return argsFound.contains(arg);
     }
@@ -199,4 +257,7 @@ public boolean has(char arg) {
     public boolean isValid() {
         return valid;
     }
+
+    private class ArgsException extends Exception {
+    }
 }
diff --git a/src/test/java/chapter14/ApplicationTest.java b/src/test/java/chapter14/ApplicationTest.java
index 680ed1c..c000de9 100644
--- a/src/test/java/chapter14/ApplicationTest.java
+++ b/src/test/java/chapter14/ApplicationTest.java
@@ -30,16 +30,28 @@ void stringArguments() {
         assertThat(output()).contains("root");
     }
 
+    @Test
+    void integerArguments() {
+        //given
+        String[] args = new String[]{"-p", "42"};
+
+        //when
+        runMain(args);
+
+        //then
+        assertThat(output()).contains("42");
+    }
+
     @Test
     void allArgumentsPresent() {
         //given
-        String[] args = new String[]{"-l", "-d", "user"};
+        String[] args = new String[]{"-l", "-p", "8080", "-d", "user"};
 
         //when
         runMain(args);
 
         //then
-        assertThat(output()).isEqualTo("logging: true, directory: user");
+        assertThat(output()).isEqualTo("logging: true, port: 8080, directory: user");
     }
 
     @Test
@@ -51,7 +63,7 @@ void noArguments() {
         runMain(args);
 
         //then
-        assertThat(output()).isEqualTo("logging: false, directory:");
+        assertThat(output()).isEqualTo("logging: false, port: 0, directory:");
     }
 
     @Override
diff --git a/src/test/java/chapter14/args/ArgsTest.java b/src/test/java/chapter14/args/ArgsTest.java
index d62504b..7cc50f5 100644
--- a/src/test/java/chapter14/args/ArgsTest.java
+++ b/src/test/java/chapter14/args/ArgsTest.java
@@ -57,20 +57,36 @@ void noSchemaButWithMultipleArguments() throws Exception {
         assertThat(args.errorMessage()).isEqualTo("Argument(s) -xy unexpected.");
     }
 
-    @DisplayName("boolean 값이 없는 경우")
+    @DisplayName("schema가 문자가 아닌 경우")
     @Test
-    void simpleBooleanNotPresent() throws Exception {
+    void nonLetterSchema() {
         //given
-        String schema = "x";
+        String nonLetterSchemaElementId = "*";
         String[] arguments = new String[]{};
 
         //when
-        Args args = new Args(schema, arguments);
+        Exception exception = catchException(() -> new Args(nonLetterSchemaElementId, arguments));
 
         //then
-        assertThat(args.isValid()).isTrue();
-        assertThat(args.cardinality()).isZero();
-        assertThat(args.getBoolean('x')).isFalse();
+        assertThat(exception)
+                .isInstanceOf(ParseException.class)
+                .hasMessage("Bad character: * in Args format: *");
+    }
+
+    @DisplayName("schema format이 유효하지 않은 경우")
+    @Test
+    void invalidArgumentFormat() {
+        //given
+        String invalidSchemeFormat = "f~";
+        String[] arguments = new String[]{};
+
+        //when
+        Exception exception = catchException(() -> new Args(invalidSchemeFormat, arguments));
+
+        //then
+        assertThat(exception)
+                .isInstanceOf(ParseException.class)
+                .hasMessage("Argument: f has invalid format: ~.");
     }
 
     @DisplayName("boolean 값이 있는 경우")
@@ -110,11 +126,11 @@ void simpleBooleanMultiplePresent() throws Exception {
         assertThat(args.getBoolean('z')).isFalse();
     }
 
-    @DisplayName("String 값이 없는 경우")
+    @DisplayName("boolean 값이 없는 경우")
     @Test
-    void simpleStringNotPresent() throws Exception {
+    void simpleBooleanNotPresent() throws Exception {
         //given
-        String schema = "x*";
+        String schema = "x";
         String[] arguments = new String[]{};
 
         //when
@@ -123,8 +139,7 @@ void simpleStringNotPresent() throws Exception {
         //then
         assertThat(args.isValid()).isTrue();
         assertThat(args.cardinality()).isZero();
-        assertThat(args.has('x')).isFalse();
-        assertThat(args.getString('x')).isEmpty();
+        assertThat(args.getBoolean('x')).isFalse();
     }
 
     @DisplayName("String 값이 있는 경우")
@@ -165,6 +180,23 @@ void simpleStringMultiplePresent() throws Exception {
         assertThat(args.getString('z')).isEmpty();
     }
 
+    @DisplayName("String 값이 없는 경우")
+    @Test
+    void simpleStringNotPresent() throws Exception {
+        //given
+        String schema = "x*";
+        String[] arguments = new String[]{};
+
+        //when
+        Args args = new Args(schema, arguments);
+
+        //then
+        assertThat(args.isValid()).isTrue();
+        assertThat(args.cardinality()).isZero();
+        assertThat(args.has('x')).isFalse();
+        assertThat(args.getString('x')).isEmpty();
+    }
+
     @DisplayName("String Argument 값이 없는 경우")
     @Test
     void missingStringArgument() throws Exception {
@@ -183,20 +215,94 @@ void missingStringArgument() throws Exception {
         assertThat(args.errorMessage()).isEqualTo("Could not find string parameter for -x.");
     }
 
-    @DisplayName("Schema의 ElementId가 문자가 아니면 ParseException이 발생한다")
+    @DisplayName("int 값이 있는 경우")
     @Test
-    void throwParseExceptionWhenInvalidSchemaElementId() {
+    void simpleIntPresent() throws Exception {
         //given
-        String containsNonLetterElementId = "l,d*,#";
-        String[] arguments = new String[0];
+        String schema = "x#";
+        String[] arguments = new String[]{"-x", "42"};
 
         //when
-        Exception exception = catchException(() -> new Args(containsNonLetterElementId, arguments));
+        Args args = new Args(schema, arguments);
 
         //then
-        assertThat(exception)
-                .isInstanceOf(ParseException.class)
-                .hasMessage("Bad character: # in Args format: l,d*,#");
+        assertThat(args.isValid()).isTrue();
+        assertThat(args.cardinality()).isOne();
+        assertThat(args.has('x')).isTrue();
+        assertThat(args.getInt('x')).isEqualTo(42);
+    }
+
+    @DisplayName("int 값이 여러 개 있는 경우")
+    @Test
+    void simpleIntMultiplePresent() throws Exception {
+        //given
+        String schema = "x#,y#,z#";
+        String[] arguments = new String[]{"-x", "8001", "-y", "8002"};
+
+        //when
+        Args args = new Args(schema, arguments);
+
+        //then
+        assertThat(args.isValid()).isTrue();
+        assertThat(args.cardinality()).isEqualTo(2);
+        assertThat(args.has('x')).isTrue();
+        assertThat(args.has('y')).isTrue();
+        assertThat(args.has('z')).isFalse();
+        assertThat(args.getInt('x')).isEqualTo(8001);
+        assertThat(args.getInt('y')).isEqualTo(8002);
+        assertThat(args.getInt('z')).isZero();
+    }
+
+    @DisplayName("int 값이 없는 경우")
+    @Test
+    void simpleIntNotPresent() throws Exception {
+        //given
+        String schema = "x#";
+        String[] arguments = new String[]{};
+
+        //when
+        Args args = new Args(schema, arguments);
+
+        //then
+        assertThat(args.isValid()).isTrue();
+        assertThat(args.cardinality()).isZero();
+        assertThat(args.has('x')).isFalse();
+        assertThat(args.getInt('x')).isZero();
+    }
+
+    @DisplayName("Integer Argument 값이 없는 경우")
+    @Test
+    void missingInteger() throws Exception {
+        //given
+        String schema = "x#";
+        String[] arguments = new String[]{"-x"}; // missing
+
+        //when
+        Args args = new Args(schema, arguments);
+
+        //then
+        assertThat(args.isValid()).isFalse();
+        assertThat(args.has('x')).isFalse();
+        assertThat(args.getInt('x')).isZero();
+        assertThat(args.errorMessage()).isEqualTo("Could not find integer parameter for -x.");
+    }
+
+    @DisplayName("Integer Argument 값을 파싱할 수 없는 경우")
+    @Test
+    void invalidInteger() throws Exception {
+        //given
+        String schema = "x#";
+        String[] arguments = new String[]{"-x", "Forty two"};
+
+        //when
+        Args args = new Args(schema, arguments);
+
+        //then
+        assertThat(args.isValid()).isFalse();
+        assertThat(args.cardinality()).isZero();
+        assertThat(args.has('x')).isFalse();
+        assertThat(args.getInt('x')).isZero();
+        assertThat(args.errorMessage()).isEqualTo("Argument -x expects an integer but was 'Forty two'.");
     }
 
     @DisplayName("유효한 args에서 errorMessage를 조회할 경우 Excpetion이 발생한다")