diff --git a/README.md b/README.md
index 57ca35d..36474af 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
-[![Badge](https://img.shields.io/badge/release-v1.0.0-brightgreen)](https://github.com/AbUndMax/Java_ArgsParser/releases/tag/Release_v1.0.0)
+[![Badge](https://img.shields.io/badge/release-v2.0.0-brightgreen)](https://github.com/AbUndMax/Java_ArgsParser/releases/tag/Release_v2.0.0)
 # ArgsParser Tool
-This tool makes it easier to define what arguments a user should input while at the same time it makes it easer for 
+This tool makes it easier to define what arguments a user should input while at the same time it makes it easier for 
 the programmer to access the given arguments.
 
 ## How to use
@@ -12,24 +12,26 @@ import ArgsParser.ArgsParser;
 public static void main(String[] args) {
     ArgsParser parser = new ArgsParser(args);
 ```
-2. #### Define the parameters you want the user to input with the following fields:
+
+2. Define the parameters you want the user to input. several fields can be specified: (see below for all available "addParameter" methods)
    - The name of the parameter
    - A short flag for the parameter
-   - If the parameter is mandatory or not  
-
-   #### Additionally there are optional fields to be set:
-   - A description of the parameter
-   - An optional default value (which assigns the type of the parameter automatically based on the default value type
-   and sets the parameter to optional)
-   - An optional type definition for the parameter (default is String)
+   - If the parameter is mandatory or not
+   - An optional description of the parameter
+   - An optional default value (which sets the mandatory of the parameter to false)
+   - implicit type definition for the parameter
 ```Java
-    Parameter example = parser.addParameter("parameterFlag", "pf", true);
-    Parameter example2 = parser.addParameter("parameterFlag2", "pf2", false, Integer.class);
-    Parameter example3 = parser.addParameter("parameterFlag3", "pf3", "This is a description for the parameter", true);
-    Parameter argWithDefault = parser.addParameter("parameterFlag4", "pf4", "description", 5);
+    Parameter<String> example = parser.addStringParameter("parameterFlag", "pf", true);
+    Parameter<Integer> example2 = parser.addIntegerParameter("parameterFlag2", "pf2", false);
+    Parameter<String> example3 = parser.addStringParameter("parameterFlag3", "pf3", "This is a description for the parameter", true);
+    Parameter<Double> argWithDefault = parser.addDoubleParameter("parameterFlag4", "pf4", "description", 5.6);
 ```
-3. #### After all parameters are added, call the parse method and catch possible ArgsExceptions like No Arguemnts provided, 
-Missing argument for a specific flag, mandatory Arguments not provided, unknown Flag or too many arguments provided.
+
+3. After all parameters are added, call the parse method and catch possible ArgsExceptions like No Arguments provided, 
+Missing argument for a specific flag, mandatory Arguments not provided, unknown Flag or too many arguments provided. 
+Additionally, a CalledForHelpNotification can be thrown if the user wants to see the help message. Thus, we want to 
+exit with status code 0 if the user asks for help and with status code 1 if an error occurred.
+
 ```Java
     try {
         parser.parseArgs();
@@ -38,15 +40,79 @@ Missing argument for a specific flag, mandatory Arguments not provided, unknown
         System.out.println(help.getMessage());
         System.exit(0);
         
-    } catch (ArgsException argsE) {
-        System.out.println(argsE.getMessage());
+
+    } catch (ArgsException e) {
+        System.out.println(e.getMessage());
         System.exit(1);
-        }
+    }
+    
 ```
-4. #### Now the arguments given by the user can be accessed by calling the .getArgument() method on the parameter variable for the specific parameter.
-It is also possible to directly get the argument as a specific type.
+
+4. Now the arguments given by the user can be accessed by calling the .getArgument() method on the parameter variable for the specific parameter.
+The return type of the .getArgument() method is the type that was defined when adding the parameter. The Arguments can 
+directly be used in the code and have not to be assigned to a new variable.
+
 ```Java
     String providedArgument = example.getArgument();
-    Integer integerArgument = example2.getArgument();
+    Double result = example2.getArgument() + argWithDefault.getArgument();
+    
 }
 ```
+
+## Integrated --help function:
+The ArgsParser tool has an integrated help function. If the user provides the flag `--help` or `-h` the tool will print
+a help message with all the defined parameters. The help message will contain the full flag, the short flag, the description
+and if the parameter is mandatory or not. The help message will be printed either for all parameters or only for the
+parameter that was placed after the `--help` flag.
+
+### Help example:
+```
+############################################### HELP ###############################################
+#               [s]=String | [i]=Integer | [d]=Double | [b]=Boolean | [c]=Character
+#                         (!)=mandatory parameter | (+)=optional parameter
+#
+#                                      Available Parameters:
+#
+###  --parameterFlag4  -pf4  [d] (+)  description
+#                            default: 5.6
+#
+###  --parameterFlag2  -pf2  [i] (+)  No description available!
+#
+###  --parameterFlag3  -pf3  [s] (!)  This is a description for the parameter
+#
+###  --parameterFlag   -pf   [s] (!)  No description available!
+#
+####################################################################################################
+```
+
+## List of all available "addParameter" methods
+
+#### String type:
+- `addStringParameter(String fullFlag, String shortFlag, String description, boolean isMandatory)`
+- `addStringParameter(String fullFlag, String shortFlag, boolean isMandatory)`
+- `addStringParameter(String fullFlag, String shortFlag, String description, String defaultValue)`
+- `addStringParameter(String fullFlag, String shortFlag, String defaultValue)`
+
+#### Integer type:
+- `addIntegerParameter(String fullFlag, String shortFlag, String description, boolean isMandatory)`
+- `addIntegerParameter(String fullFlag, String shortFlag, boolean isMandatory)`
+- `addIntegerParameter(String fullFlag, String shortFlag, String description, Integer defaultValue)`
+- `addIntegerParameter(String fullFlag, String shortFlag, Integer defaultValue)`
+
+#### Double type:
+- `addDoubleParameter(String fullFlag, String shortFlag, String description, boolean isMandatory)`
+- `addDoubleParameter(String fullFlag, String shortFlag, boolean isMandatory)`
+- `addDoubleParameter(String fullFlag, String shortFlag, String description, Double defaultValue)`
+- `addDoubleParameter(String fullFlag, String shortFlag, Double defaultValue)`
+
+#### Boolean type: (default values are in the first position!)
+- `addBooleanParameter(String fullFlag, String shortFlag, String description, boolean isMandatory)`
+- `addBooleanParameter(String fullFlag, String shortFlag, boolean isMandatory)`
+- `addBooleanParameter(Boolean defaultValue, String fullFlag, String shortFlag, String description)`
+- `addBooleanParameter(Boolean defaultValue, String fullFlag, String shortFlag)`
+
+#### Character type:
+- `addCharacterParameter(String fullFlag, String shortFlag, String description, boolean isMandatory)`
+- `addCharacterParameter(String fullFlag, String shortFlag, boolean isMandatory)`
+- `addCharacterParameter(String fullFlag, String shortFlag, String description, Character defaultValue)`
+- `addCharacterParameter(String fullFlag, String shortFlag, Character defaultValue)`
diff --git a/src/ArgsParser/ArgsExceptions/InvalidArgTypeArgsException.java b/src/ArgsParser/ArgsExceptions/InvalidArgTypeArgsException.java
index 7efd6fc..d54e340 100644
--- a/src/ArgsParser/ArgsExceptions/InvalidArgTypeArgsException.java
+++ b/src/ArgsParser/ArgsExceptions/InvalidArgTypeArgsException.java
@@ -6,7 +6,7 @@
  * InvalidArgTypeArgsException is thrown when an invalid argument type is provided to a flag.
  */
 public class InvalidArgTypeArgsException extends ArgsException {
-    public InvalidArgTypeArgsException(String flagName) {
-        super("Invalid argument type provided to: " + flagName);
+    public InvalidArgTypeArgsException(String flagName, String typeName, String message) {
+        super("Failed to set argument for " + flagName + " of type " + typeName + ": " + message);
     }
 }
diff --git a/src/ArgsParser/ArgsParser.java b/src/ArgsParser/ArgsParser.java
index 82503fa..cdec669 100644
--- a/src/ArgsParser/ArgsParser.java
+++ b/src/ArgsParser/ArgsParser.java
@@ -41,7 +41,7 @@ of this software and associated documentation files (the "Software"), to deal
  *
  * <ol>
  *     <li>The ArgsParser constructor {@link #ArgsParser(String[])} is called and the args array of the main method provided.</li>
- *     <li>Now we can specify the parameters we want to have for the program by using {@link #addParameter(String, String, String, boolean)}</li>
+ *     <li>Now we can specify the parameters we want to have for the program by using {@link #addStringParameter(String, String, String, boolean)}</li>
        <ul>
  *         <li>Parameters can be mandatory or optional</li>
  *         <li>Parameters can have a short version flags</li>
@@ -50,7 +50,7 @@ of this software and associated documentation files (the "Software"), to deal
  *     </ul>
  *     <li>After all parameters are added, the {@link #parseArgs()} method has to be called! (this is mandatory!)</li>
  *     <li>Then the arguments can be accessed by using {@link Parameter#getArgument()} on the specific Parameter variable
- *          and type specific arguments can be accessed if a type i.e. Integer.Class was provided in {@link #addParameter(String, String, String, boolean)} </li>
+ *          and type specific arguments can be accessed if a type i.e. Integer.Class was provided in {@link #addStringParameter(String, String, String, boolean)} </li>
  * </ol>
  * available at: <a href="https://github.com/AbUndMax/Java_ArgsParser">GitHub</a>
  * @author Niklas Max G. 2024
@@ -58,8 +58,8 @@ of this software and associated documentation files (the "Software"), to deal
 public class ArgsParser {
 
     private final String[] args;
-    private final Map<String, Parameter> parameterMap = new HashMap<>();
-    private final Set<Parameter> mandatoryParameters = new HashSet<>();
+    private final Map<String, Parameter<?>> parameterMap = new HashMap<>();
+    private final Set<Parameter<?>> mandatoryParameters = new HashSet<>();
     protected boolean parseArgsWasCalled = false;
     private int longestFlagSize = 0;
     private int longestShortFlag = 0;
@@ -74,127 +74,317 @@ public ArgsParser(String[] args) {
     }
 
     /**
+     * creates a new Parameter instance and sets it accordingly with the given fields
      * Adds given parameter to argumentList, sets longestFlagSize and adds mandatory parameters to the mandatoryList
-     * @param parameter parameter to be processed
+     * @param fullFlag name of the parameter
+     * @param shortFlag short name of the parameter
+     * @param description description of the parameter
+     * @param type type of the parameter
+     * @param isMandatory true if the parameter is mandatory, false otherwise
+     * @param defaultValue default value of the parameter
+     * @return the created Parameter instance
+     * @param <T> type of the parameter
      */
-    private void prepareParameter(Parameter parameter) {
-        parameterMap.put(parameter.getFlagName(), parameter);
-        if (parameter.getShortName() != null) parameterMap.put(parameter.getShortName(), parameter);
+    private <T> Parameter<T> createParameter(String fullFlag,
+                                             String shortFlag,
+                                             String description,
+                                             Class<T> type,
+                                             boolean isMandatory,
+                                             T defaultValue) {
+
+        Parameter<T> parameter = new Parameter<T>(makeFlag(fullFlag, false),
+                                                  makeFlag(shortFlag, true),
+                                                  description, type, isMandatory, this);
+
+        if (defaultValue != null) {
+            parameter.setDefault(defaultValue);
+        }
+
+        parameterMap.put(parameter.getFullFlag(), parameter);
+        if (parameter.getShortFlag() != null) parameterMap.put(parameter.getShortFlag(), parameter);
 
-        int nameSize = parameter.getFlagName().length();
+        int nameSize = parameter.getFullFlag().length();
         if (longestFlagSize < nameSize) longestFlagSize = nameSize;
 
-        if (parameter.getShortName() != null) {
-            int shortSize = parameter.getShortName().length();
+        if (parameter.getShortFlag() != null) {
+            int shortSize = parameter.getShortFlag().length();
             if (longestShortFlag < shortSize) longestShortFlag = shortSize;
         }
 
         if (parameter.isMandatory()) mandatoryParameters.add(parameter);
+
+        return parameter;
     }
 
     /**
-     * Creates a flag from the given flagName, if the flagName is already in the correct format, it will be returned as is.
-     * If not, it will add a leading or -- to the flagName
-     * @param flagName name of the flag
+     * Creates a flag from the given fullFlag, if the fullFlag is already in the correct format, it will be returned as is.
+     * If not, it will add a leading or -- to the fullFlag
+     * @param fullFlag name of the flag
      * @param isShortName true if the flag is a short flag
-     * @return flag in the correct format (e.g. --flagName or -f)
+     * @return flag in the correct format (e.g. --fullFlag or -f)
      */
-    private String makeFlag(String flagName, boolean isShortName) {
+    private String makeFlag(String fullFlag, boolean isShortName) {
         int i = 0;
-        while (flagName.charAt(i) == '-') {
+        while (fullFlag.charAt(i) == '-') {
             i++;
         }
 
-        if (i == 2 && !isShortName) return flagName;
-        else if (i == 1 && isShortName) return flagName;
+        if (i == 2 && !isShortName) return fullFlag;
+        else if (i == 1 && isShortName) return fullFlag;
         else {
             String newFlag = isShortName ? "-" : "--";
-            return newFlag + flagName.substring(i);
+            return newFlag + fullFlag.substring(i);
         }
     }
 
 
+    // String Parameter constructors
+
+
     /**
      * Adds a new parameter that will be checked in args and assigned to the Parameter instance
-     * @param flagName name of the parameter (-- will automatically be added)
-     * @param shortName short version of the parameter (- will automatically be added)
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
+     * @param description description of the parameter
      * @param isMandatory true if parameter is mandatory, false if optional
-     * @param type type of the parameter (Class.Integer, Class.Double, Class.Boolean, Class.Character)
-     * @return the created Parameter instance
+     * @return the created Parameter instance of type String
      */
-    public Parameter addParameter(String flagName, String shortName, boolean isMandatory, Class<?> type) {
-        Parameter parameter = new Parameter(makeFlag(flagName, false), makeFlag(shortName, true), "", type, isMandatory, this);
-        prepareParameter(parameter);
-        return parameter;
+    public Parameter<String> addStringParameter(String fullFlag, String shortFlag, String description, boolean isMandatory) {
+        return createParameter(fullFlag, shortFlag, description, String.class, isMandatory, null);
     }
 
     /**
      * Adds a new parameter that will be checked in args and assigned to the Parameter instance
-     * @param flagName name of the parameter (-- will automatically be added)
-     * @param defaultValue default value of the parameter - by usage sets the parameter to optional
-     * @param shortName short version of the parameter (- will automatically be added)
-     * @return the created Parameter instance
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
+     * @param isMandatory true if parameter is mandatory, false if optional
+     * @return the created Parameter instance of type String
      */
-    public Parameter addParameter(String flagName, String shortName, Object defaultValue) {
-        Parameter parameter = new Parameter(makeFlag(flagName, false), defaultValue, makeFlag(shortName, true), "", this);
-        prepareParameter(parameter);
-        return parameter;
+    public Parameter<String> addStringParameter(String fullFlag, String shortFlag, boolean isMandatory) {
+        return createParameter(fullFlag, shortFlag, null, String.class, isMandatory, null);
+    }
+
+    /**
+     * Adds a new parameter that will be checked in args and assigned to the Parameter instance
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
+     * @param description description of the parameter
+     * @param defaultValue default value of the parameter
+     * @return the created Parameter instance of type String
+     */
+    public Parameter<String> addStringParameter(String fullFlag, String shortFlag, String description, String defaultValue) {
+        return createParameter(fullFlag, shortFlag, description, String.class, false, defaultValue);
     }
 
     /**
      * Adds a new parameter that will be checked in args and assigned to the Parameter instance
-     * @param flagName name of the parameter (-- will automatically be added)
-     * @param shortName short version of the parameter (- will automatically be added)
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
+     * @param defaultValue default value of the parameter
+     * @return the created Parameter instance of type String
+     */
+    public Parameter<String> addStringParameter(String fullFlag, String shortFlag, String defaultValue) {
+        return createParameter(fullFlag, shortFlag, null, String.class, false, defaultValue);
+    }
+
+
+    // Integer Parameter constructors
+
+
+    /**
+     * Adds a new parameter that will be checked in args and assigned to the Parameter instance
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
+     * @param description description of the parameter
      * @param isMandatory true if parameter is mandatory, false if optional
-     * @return the created Parameter instance
+     * @return the created Parameter instance of type Integer
      */
-    public Parameter addParameter(String flagName, String shortName, boolean isMandatory) {
-        Parameter parameter = new Parameter(makeFlag(flagName, false), makeFlag(shortName, true), "", isMandatory, this);
-        prepareParameter(parameter);
-        return parameter;
+    public Parameter<Integer> addIntegerParameter(String fullFlag, String shortFlag, String description, boolean isMandatory) {
+        return createParameter(fullFlag, shortFlag, description, Integer.class, isMandatory, null);
+    }
+
+    /**
+     * Adds a new parameter that will be checked in args and assigned to the Parameter instance
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
+     * @param isMandatory true if parameter is mandatory, false if optional
+     * @return the created Parameter instance of type Integer
+     */
+    public Parameter<Integer> addIntegerParameter(String fullFlag, String shortFlag, boolean isMandatory) {
+        return createParameter(fullFlag, shortFlag, null, Integer.class, isMandatory, null);
     }
 
     /**
      * Adds a new parameter that will be checked in args and assigned to the Parameter instance
-     * @param flagName name of the parameter (-- will automatically be added)
-     * @param shortName short version of the parameter (- will automatically be added)
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
+     * @param description description of the parameter
+     * @param defaultValue default value of the parameter
+     * @return the created Parameter instance of type Integer
+     */
+    public Parameter<Integer> addIntegerParameter(String fullFlag, String shortFlag, String description, Integer defaultValue) {
+        return createParameter(fullFlag, shortFlag, description, Integer.class, false, defaultValue);
+    }
+
+    /**
+     * Adds a new parameter that will be checked in args and assigned to the Parameter instance
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
+     * @param defaultValue default value of the parameter
+     * @return the created Parameter instance of type Integer
+     */
+    public Parameter<Integer> addIntegerParameter(String fullFlag, String shortFlag, Integer defaultValue) {
+        return createParameter(fullFlag, shortFlag, null, Integer.class, false, defaultValue);
+    }
+
+
+    // Double Parameter constructors
+
+
+    /**
+     * Adds a new parameter that will be checked in args and assigned to the Parameter instance
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
      * @param description description of the parameter
      * @param isMandatory true if parameter is mandatory, false if optional
-     * @return the created Parameter instance
+     * @return the created Parameter instance of type Double
      */
-    public Parameter addParameter(String flagName, String shortName, String description, boolean isMandatory) {
-        Parameter parameter = new Parameter(makeFlag(flagName, false), makeFlag(shortName, true), description, isMandatory, this);
-        prepareParameter(parameter);
-        return parameter;
+    public Parameter<Double> addDoubleParameter(String fullFlag, String shortFlag, String description, boolean isMandatory) {
+        return createParameter(fullFlag, shortFlag, description, Double.class, isMandatory, null);
+    }
+
+    /**
+     * Adds a new parameter that will be checked in args and assigned to the Parameter instance
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
+     * @param isMandatory true if parameter is mandatory, false if optional
+     * @return the created Parameter instance of type Double
+     */
+    public Parameter<Double> addDoubleParameter(String fullFlag, String shortFlag, boolean isMandatory) {
+        return createParameter(fullFlag, shortFlag, null, Double.class, isMandatory, null);
     }
 
     /**
      * Adds a new parameter that will be checked in args and assigned to the Parameter instance
-     * @param flagName name of the parameter (-- will automatically be added)
-     * @param shortName short version of the parameter (- will automatically be added)
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
+     * @param description description of the parameter
+     * @param defaultValue default value of the parameter
+     * @return the created Parameter instance of type Double
+     */
+    public Parameter<Double> addDoubleParameter(String fullFlag, String shortFlag, String description, Double defaultValue) {
+        return createParameter(fullFlag, shortFlag, description, Double.class, false, defaultValue);
+    }
+
+    /**
+     * Adds a new parameter that will be checked in args and assigned to the Parameter instance
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
+     * @param defaultValue default value of the parameter
+     * @return the created Parameter instance of type Double
+     */
+    public Parameter<Double> addDoubleParameter(String fullFlag, String shortFlag, Double defaultValue) {
+        return createParameter(fullFlag, shortFlag, null, Double.class, false, defaultValue);
+    }
+
+
+    // Boolean Parameter constructors
+
+
+    /**
+     * Adds a new parameter that will be checked in args and assigned to the Parameter instance
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
      * @param description description of the parameter
      * @param isMandatory true if parameter is mandatory, false if optional
-     * @param type type of the parameter (Class.Integer, Class.Double, Class.Boolean, Class.Character)
-     * @return the created Parameter instance
+     * @return the created Parameter instance of type Boolean
      */
-    public Parameter addParameter(String flagName, String shortName, String description, boolean isMandatory, Class<?> type) {
-        Parameter parameter = new Parameter(makeFlag(flagName, false), makeFlag(shortName, true), description, type, isMandatory, this);
-        prepareParameter(parameter);
-        return parameter;
+    public Parameter<Boolean> addBooleanParameter(String fullFlag, String shortFlag, String description, boolean isMandatory) {
+        return createParameter(fullFlag, shortFlag, description, Boolean.class, isMandatory, null);
+    }
+
+    /**
+     * Adds a new parameter that will be checked in args and assigned to the Parameter instance
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
+     * @param isMandatory true if parameter is mandatory, false if optional
+     * @return the created Parameter instance of type Boolean
+     */
+    public Parameter<Boolean> addBooleanParameter(String fullFlag, String shortFlag, boolean isMandatory) {
+        return createParameter(fullFlag, shortFlag, null, Boolean.class, isMandatory, null);
     }
 
     /**
      * Adds a new parameter that will be checked in args and assigned to the Parameter instance
-     * @param flagName name of the parameter (-- will automatically be added)
-     * @param defaultValue default value of the parameter - by usage sets the parameter to optional
-     * @param shortName short version of the parameter (- will automatically be added)
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
      * @param description description of the parameter
-     * @return the created Parameter instance
+     * @param defaultValue default value of the parameter
+     * @return the created Parameter instance of type Boolean
      */
-    public Parameter addParameter(String flagName, String shortName, String description, Object defaultValue) {
-        Parameter parameter = new Parameter(makeFlag(flagName, false), defaultValue, makeFlag(shortName, true), description, this);
-        prepareParameter(parameter);
-        return parameter;
+    public Parameter<Boolean> addBooleanParameter(Boolean defaultValue, String fullFlag, String shortFlag, String description) {
+        return createParameter(fullFlag, shortFlag, description, Boolean.class, false, defaultValue);
+    }
+
+    /**
+     * Adds a new parameter that will be checked in args and assigned to the Parameter instance
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
+     * @param defaultValue default value of the parameter
+     * @return the created Parameter instance of type Boolean
+     */
+    public Parameter<Boolean> addBooleanParameter(Boolean defaultValue, String fullFlag, String shortFlag) {
+        return createParameter(fullFlag, shortFlag, null, Boolean.class, false, defaultValue);
+    }
+
+
+    // Character Parameter constructors
+
+
+    /**
+     * Adds a new parameter that will be checked in args and assigned to the Parameter instance
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
+     * @param description description of the parameter
+     * @param isMandatory true if parameter is mandatory, false if optional
+     * @return the created Parameter instance of type Character
+     */
+    public Parameter<Character> addCharacterParameter(String fullFlag, String shortFlag, String description, boolean isMandatory) {
+        return createParameter(fullFlag, shortFlag, description, Character.class, isMandatory, null);
+    }
+
+    /**
+     * Adds a new parameter that will be checked in args and assigned to the Parameter instance
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
+     * @param isMandatory true if parameter is mandatory, false if optional
+     * @return the created Parameter instance of type Character
+     */
+    public Parameter<Character> addCharacterParameter(String fullFlag, String shortFlag, boolean isMandatory) {
+        return createParameter(fullFlag, shortFlag, null, Character.class, isMandatory, null);
+    }
+
+    /**
+     * Adds a new parameter that will be checked in args and assigned to the Parameter instance
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
+     * @param description description of the parameter
+     * @param defaultValue default value of the parameter
+     * @return the created Parameter instance of type Character
+     */
+    public Parameter<Character> addCharacterParameter(String fullFlag, String shortFlag, String description, Character defaultValue) {
+        return createParameter(fullFlag, shortFlag, description, Character.class, false, defaultValue);
+    }
+
+    /**
+     * Adds a new parameter that will be checked in args and assigned to the Parameter instance
+     * @param fullFlag name of the parameter (-- will automatically be added)
+     * @param shortFlag short version of the parameter (- will automatically be added)
+     * @param defaultValue default value of the parameter
+     * @return the created Parameter instance of type Character
+     */
+    public Parameter<Character> addCharacterParameter(String fullFlag, String shortFlag, Character defaultValue) {
+        return createParameter(fullFlag, shortFlag, null, Character.class, false, defaultValue);
     }
 
     /**
@@ -212,12 +402,15 @@ public Parameter addParameter(String flagName, String shortName, String descript
      * @throws CalledForHelpNotification if --help or -h was called
      * @throws InvalidArgTypeArgsException if the argument provided to a flag is not of the correct type
      */
-    public void parseArgs() throws NoArgumentsProvidedArgsException, UnknownFlagArgsException, TooManyArgumentsArgsException, MissingArgArgsException, MandatoryArgNotProvidedArgsException, CalledForHelpNotification, InvalidArgTypeArgsException {
+    public void parseArgs() throws NoArgumentsProvidedArgsException, UnknownFlagArgsException,
+            TooManyArgumentsArgsException, MissingArgArgsException, MandatoryArgNotProvidedArgsException,
+            CalledForHelpNotification, InvalidArgTypeArgsException {
+
         parseArgsWasCalled = true;
 
         checkIfAnyArgumentsProvided();
         checkForHelpCall();
-        Set<Parameter> givenParameters = parseArguments();
+        Set<Parameter<?>> givenParameters = parseArguments();
         checkMandatoryArguments(givenParameters);
 
     }
@@ -274,10 +467,11 @@ private void checkForHelpCall() throws UnknownFlagArgsException, MissingArgArgsE
      * @throws MissingArgArgsException if a flag was provided without an argument
      * @throws InvalidArgTypeArgsException if the argument provided to a flag is not of the correct type
      */
-    private Set<Parameter> parseArguments() throws UnknownFlagArgsException, TooManyArgumentsArgsException, MissingArgArgsException, InvalidArgTypeArgsException {
-        Set<Parameter> givenParameters = new HashSet<>();
+    private Set<Parameter<?>> parseArguments() throws UnknownFlagArgsException, TooManyArgumentsArgsException,
+            MissingArgArgsException, InvalidArgTypeArgsException {
+        Set<Parameter<?>> givenParameters = new HashSet<>();
 
-        Parameter currentParameter = null;
+        Parameter<?> currentParameter = null;
         for (int i = 0; i < args.length; i++) {
 
             boolean currentPositionIsFlag = args[i].startsWith("-");
@@ -285,14 +479,14 @@ private Set<Parameter> parseArguments() throws UnknownFlagArgsException, TooMany
             boolean flagExists = parameterMap.get(args[i]) != null;
             boolean isLastEntry = i == args.length - 1;
             boolean currentParameterNotNull = currentParameter != null;
-            boolean argumentSet = currentParameterNotNull && currentParameter.getArgument() != null;
+            boolean argumentSet = currentParameterNotNull && currentParameter.hasArgument();
             boolean lastPositionWasFlag = i >= 1 && args[i - 1].startsWith("-");
 
             if (currentPositionIsFlag && !flagExists) { // if flag is unknown
                 throw new UnknownFlagArgsException(args[i]);
 
             } else if (argumentSet && !currentPositionIsFlag) { // if two arguments are provided to a single flag
-                throw new TooManyArgumentsArgsException(currentParameter.getFlagName());
+                throw new TooManyArgumentsArgsException(currentParameter.getFullFlag());
 
             } else if (currentPositionIsFlag && lastPositionWasFlag) { // if a flag follows another flag
                 throw new MissingArgArgsException(args[i - 1]);
@@ -315,13 +509,13 @@ private Set<Parameter> parseArguments() throws UnknownFlagArgsException, TooMany
      * @param givenParameters a set of all Parameter instances created based on args
      * @throws MandatoryArgNotProvidedArgsException if not all mandatory parameters were given in args
      */
-    private void checkMandatoryArguments(Set<Parameter> givenParameters) throws MandatoryArgNotProvidedArgsException {
+    private void checkMandatoryArguments(Set<Parameter<?>> givenParameters) throws MandatoryArgNotProvidedArgsException {
         if (!givenParameters.containsAll(mandatoryParameters)) {
             mandatoryParameters.removeAll(givenParameters);
             StringBuilder errorMessage = new StringBuilder();
             errorMessage.append("Mandatory parameters are missing:\n");
-            for (Parameter param : mandatoryParameters) {
-                errorMessage.append(param.getFlagName()).append("\n");
+            for (Parameter<?> param : mandatoryParameters) {
+                errorMessage.append(param.getFullFlag()).append("\n");
             }
             throw new MandatoryArgNotProvidedArgsException(errorMessage.toString());
         }
@@ -330,7 +524,7 @@ private void checkMandatoryArguments(Set<Parameter> givenParameters) throws Mand
     /**
      * prints all available Parameters found in argumentsList to the console
      */
-    private String generateHelpMessage(Set<Parameter> parameters) {
+    private String generateHelpMessage(Set<Parameter<?>> parameters) {
         StringBuilder helpMessage = new StringBuilder();
         helpMessage.append("\n");
 
@@ -348,7 +542,7 @@ private String generateHelpMessage(Set<Parameter> parameters) {
         }
         helpMessage.append("#").append("\n");
 
-        for (Parameter param : parameters) {
+        for (Parameter<?> param : parameters) {
             String helpString = parameterHelpString(param);
             helpMessage.append(helpString).append("\n");
             helpMessage.append("#").append("\n");
@@ -368,12 +562,12 @@ private String centerString(String stringToCenter) {
     }
 
     /**
-     * generates the help String (flagName, shortFlag, description) for a single Parameter
+     * generates the help String (fullFlag, shortFlag, description) for a single Parameter
      * @param parameter parameter Instance of which the help String should be generated
      * @return String with all information for the given Parameter
      */
-    private String parameterHelpString(Parameter parameter) {
-        Map<String, String> shortNameTypes = new HashMap<>(){{
+    private String parameterHelpString(Parameter<?> parameter) {
+        Map<String, String> shortFlagTypes = new HashMap<>(){{
             put("String", "s");
             put("Integer", "i");
             put("Double", "d");
@@ -381,22 +575,22 @@ private String parameterHelpString(Parameter parameter) {
             put("Character", "c");
         }};
 
-        String name = parameter.getFlagName();
-        String shortName = parameter.getShortName() == null ? "/" : parameter.getShortName();
-        String description = parameter.getDescription().trim().isEmpty() ? "No description available!" : parameter.getDescription();
+        String name = parameter.getFullFlag();
+        String shortFlag = parameter.getShortFlag() == null ? "/" : parameter.getShortFlag();
+        String description = parameter.getDescription() == null ? "No description available!" : parameter.getDescription();
         String isMandatory = parameter.isMandatory() ? "(!)" : "(+)";
         StringBuilder helpString = new StringBuilder("###  ");
 
         // align the parameter names nicely
         int nameWhiteSpaceSize = longestFlagSize - name.length();
         name = name + " ".repeat(nameWhiteSpaceSize);
-        int shortWhiteSpaceSize = longestShortFlag == 0 ? 0 : longestShortFlag - shortName.length();
-        shortName = shortName + " ".repeat(shortWhiteSpaceSize);
+        int shortWhiteSpaceSize = longestShortFlag == 0 ? 0 : longestShortFlag - shortFlag.length();
+        shortFlag = shortFlag + " ".repeat(shortWhiteSpaceSize);
 
         // get type
-        String type = shortNameTypes.get(parameter.getType());
+        String type = shortFlagTypes.get(parameter.getType());
 
-        helpString.append(name).append("  ").append(shortName).append("  [").append(type).append("] ").append(isMandatory).append("  ");
+        helpString.append(name).append("  ").append(shortFlag).append("  [").append(type).append("] ").append(isMandatory).append("  ");
         int whiteSpace = helpString.length();
 
         // The description String gets checked if it fits inside the info box.
@@ -416,7 +610,7 @@ private String parameterHelpString(Parameter parameter) {
         // print default value if available
         if (parameter.hasDefault()) {
             String defaultTitle = "default: ";
-            String defaultValue = parameter.getDefaultValue();
+            String defaultValue = parameter.getDefaultValue().toString();
             helpString.append("\n").append("#").append(" ".repeat(whiteSpace - defaultTitle.length() - 1)).append(defaultTitle);
 
             if (whiteSpace + defaultValue.length() > consoleWidth) { // if the default is as large as the consoleWindow split default
@@ -460,7 +654,7 @@ private String lineBreakAtWhitespace(String description, int whiteSpace) {
      * helper function to do correct new lines if the defaultValue is too long to fit into the help box
      * @param string defaultValue that doesn't fit
      * @param whiteSpace int that specifies how many white space before the defaultValue should be placed
-     * @return
+     * @return the concatenated lines
      */
     private String lineBreak(String string, int whiteSpace) {
         StringBuilder helpString = new StringBuilder();
@@ -474,7 +668,7 @@ private String lineBreak(String string, int whiteSpace) {
             if (spaceForValue + staticFreeSpace >= string.length())
                 substring = string.substring(spaceForValue);
             else substring = string.substring(spaceForValue, spaceForValue += (staticFreeSpace - 1));
-            ;
+
             helpString.append("\n").append("#").append(" ".repeat(whiteSpace - 1)).append(substring);
         }
 
diff --git a/src/ArgsParser/Parameter.java b/src/ArgsParser/Parameter.java
index 79abf75..f61e8f5 100644
--- a/src/ArgsParser/Parameter.java
+++ b/src/ArgsParser/Parameter.java
@@ -25,91 +25,48 @@ of this software and associated documentation files (the "Software"), to deal
  */
 
 import ArgsParser.ArgsExceptions.InvalidArgTypeArgsException;
-import ArgsParser.RuntimeExeptions.ParameterTypeNotDefined;
 
 import java.util.*;
 
 /**
  * Parameter class with fields for each attribute of the Parameter including the argument.
  */
-public class Parameter {
-    private final String flagName;
-    private final String shortName;
+public class Parameter<T> {
+    private final String fullFlag;
+    private final String shortFlag;
     private final String description;
     private final boolean isMandatory;
     private final ArgsParser parser;
-    private final Class<?> type;
-    private boolean typeWasSet = false;
+    private final Class<T> type;
+    private T defaultValue = null;
+    private boolean hasDefault = false;
+    private T argument = null;
     private boolean hasArgument = false;
-    private String defaultValue = null;
-    private String argument = null;
-    private Integer argumentAsInteger = null;
-    private Double argumentAsDouble = null;
-    private Boolean argumentAsBoolean = null;
-    private Character argumentAsChar = null;
-
-    /**
-     * Constructor for the Parameter class
-     * @param flagName name of the parameter
-     * @param shortName short name of the parameter
-     * @param description description of the parameter
-     * @param isMandatory true if the parameter is mandatory, false otherwise
-     * @param parserInstance instance of the ArgsParser class
-     */
-    protected Parameter(String flagName, String shortName, String description, boolean isMandatory, ArgsParser parserInstance) {
-        this.flagName = flagName;
-        this.shortName = shortName;
-        this.description = description;
-        this.parser = parserInstance;
-        this.isMandatory = isMandatory;
-        this.type = String.class;
-    }
 
     /**
      * Constructor for the Parameter class with type definition
-     * @param flagName name of the parameter
-     * @param shortName short name of the parameter
+     * @param fullFlag name of the parameter
+     * @param shortFlag short name of the parameter
      * @param description description of the parameter
      * @param type type of the parameter
      * @param isMandatory true if the parameter is mandatory, false otherwise
      * @param parserInstance instance of the ArgsParser class
      */
-    protected Parameter(String flagName, String shortName, String description, Class<?> type, boolean isMandatory, ArgsParser parserInstance) {
-        this.flagName = flagName;
-        this.shortName = shortName;
+    protected Parameter(String fullFlag, String shortFlag, String description, Class<T> type, boolean isMandatory, ArgsParser parserInstance) {
+        this.fullFlag = fullFlag;
+        this.shortFlag = shortFlag;
         this.description = description;
         this.parser = parserInstance;
         this.isMandatory = isMandatory;
         this.type = type;
-        this.typeWasSet = true;
-    }
-
-    /**
-     * Constructor for the Parameter class with default value
-     * (sets type of Parameter based on the type of the default value)
-     * @param flagName name of the parameter
-     * @param shortName short name of the parameter
-     * @param description description of the parameter
-     * @param defaultValue default value of the parameter
-     * @param parserInstance instance of the ArgsParser class
-     */
-    protected Parameter(String flagName, Object defaultValue, String shortName, String description, ArgsParser parserInstance) {
-        this.flagName = flagName;
-        this.shortName = shortName;
-        this.description = description;
-        this.parser = parserInstance;
-        this.isMandatory = false;
-        setDefault(defaultValue);
-        type = defaultValue.getClass();
-        typeWasSet = true;
     }
 
     /**
-     * getter method for the flagName
-     * @return flagName
+     * getter method for the fullFlag
+     * @return fullFlag
      */
-    protected String getFlagName() {
-        return flagName;
+    protected String getFullFlag() {
+        return fullFlag;
     }
 
     /**
@@ -121,11 +78,11 @@ protected boolean isMandatory() {
     }
 
     /**
-     * getter method for the shortName attribute
-     * @return shortName
+     * getter method for the shortFlag attribute
+     * @return shortFlag
      */
-    protected String getShortName() {
-        return shortName;
+    protected String getShortFlag() {
+        return shortFlag;
     }
 
     /**
@@ -149,49 +106,30 @@ protected String getType() {
      * @return true if this Parameter was created with a default value, false otherwise
      */
     protected boolean hasDefault() {
-        return this.defaultValue != null;
+        return hasDefault;
     }
 
     /**
      * getter method for the defaultValue attribute
      * @return defaultValue
      */
-    protected String getDefaultValue() {
+    protected T getDefaultValue() {
         return this.defaultValue;
     }
 
-    /**
-     * getter method for the argument attribute
-     * @return argument as String
-     * @throws IllegalStateException if {@link ArgsParser#parseArgs()} was not called before trying to access this argument
-     */
-    public String getArgument() throws IllegalStateException {
-        if (!parser.parseArgsWasCalled) throw new IllegalStateException("parseArgs() was not called before trying to access the argument!");
-        if (!hasArgument) return null;
-        return argument;
+    protected boolean hasArgument() {
+        return hasArgument;
     }
 
     /**
      * getter method for the argument attribute
-     * @return argument
+     * @return argument as String
      * @throws IllegalStateException if {@link ArgsParser#parseArgs()} was not called before trying to access this argument
-     * @throws IllegalArgumentException if the argument is not of the expected type
-     * @throws ParameterTypeNotDefined if the type of the parameter was not defined when using {@link ArgsParser#addParameter(String, String, String, boolean)} without a specified type
      */
-    @SuppressWarnings("unchecked")
-    public <T> T getCastedArgument() throws IllegalStateException, IllegalArgumentException, ParameterTypeNotDefined{
-        if (!typeWasSet) throw new ParameterTypeNotDefined(this.flagName);
+    public T getArgument() throws IllegalStateException {
         if (!parser.parseArgsWasCalled) throw new IllegalStateException("parseArgs() was not called before trying to access the argument!");
-        if (!hasArgument) return null;
-
-        switch (type.getSimpleName()) {
-            case "Integer" -> { return (T) argumentAsInteger; }
-            case "Double" -> { return (T) argumentAsDouble; }
-            case "Boolean" -> { return (T) argumentAsBoolean; }
-            case "Character" -> { return (T) argumentAsChar; }
-            default -> throw new IllegalArgumentException("Unsupported type: " + type.getName());
-        }
-
+        if (!hasArgument && !hasDefault) return null;
+        return argument;
     }
 
     /**
@@ -199,22 +137,27 @@ public <T> T getCastedArgument() throws IllegalStateException, IllegalArgumentEx
      * @param argument argument
      */
     protected void setArgument(String argument) throws InvalidArgTypeArgsException {
-        this.argument = argument;
-
-        if (type != String.class) {
+        if (type.equals(String.class)) {
+            this.argument = (T) argument;
+        } else {
             try {
                 switch (type.getSimpleName()) {
-                    case "Integer" -> this.argumentAsInteger = Integer.parseInt(argument);
-                    case "Double" -> this.argumentAsDouble = Double.parseDouble(argument);
-                    case "Boolean" -> this.argumentAsBoolean = Boolean.parseBoolean(argument);
-                    case "Character" -> this.argumentAsChar = argument.charAt(0);
+                    case "Integer" -> this.argument = (T) Integer.valueOf(argument);
+                    case "Double" -> this.argument = (T) Double.valueOf(argument);
+                    case "Boolean" -> this.argument = (T) Boolean.valueOf(argument);
+                    case "Character" -> {
+                        if (argument.length() == 1) {
+                            this.argument = (T) Character.valueOf(argument.charAt(0));
+                        } else {
+                            throw new InvalidArgTypeArgsException(this.fullFlag, type.getSimpleName(), "Argument must be a single character!");
+                        }
+                    }
+                    default -> throw new InvalidArgTypeArgsException(this.fullFlag, type.getSimpleName(), "Unsupported type!");
                 }
-
             } catch (Exception e) {
-                throw new InvalidArgTypeArgsException(this.flagName);
+                throw new InvalidArgTypeArgsException(this.fullFlag, type.getSimpleName(), e.getMessage());
             }
         }
-
         this.hasArgument = true;
     }
 
@@ -222,35 +165,25 @@ protected void setArgument(String argument) throws InvalidArgTypeArgsException {
      * Sets the default value for the argument and assigns it to the corresponding type-specific field.
      * The value is also converted to a string and stored in the 'argument' field.
      *
-     * @param <T> the type of the default value
      * @param defaultValue the default value to be set, which can be of type Integer, Double, Character, or Boolean
      * @throws IllegalArgumentException if the type of defaultValue is unsupported
      */
-    protected <T> void setDefault(T defaultValue) {
-        this.argument = this.defaultValue = defaultValue.toString();
-
-        switch (defaultValue) {
-            case String s -> argument = s;
-            case Integer i -> argumentAsInteger = i;
-            case Double v -> argumentAsDouble = v;
-            case Character c -> argumentAsChar = c;
-            case Boolean b -> argumentAsBoolean = b;
-            default -> throw new IllegalArgumentException("Unsupported type: " + defaultValue.getClass().getName());
-        }
-        this.hasArgument = true;
+    protected void setDefault(T defaultValue) {
+        this.defaultValue = this.argument = defaultValue;
+        hasDefault = true;
     }
 
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
-        Parameter parameter = (Parameter) o;
-        return Objects.equals(flagName, parameter.flagName);
+        Parameter<?> parameter = (Parameter<?>) o;
+        return Objects.equals(fullFlag, parameter.fullFlag);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(flagName);
+        return Objects.hash(fullFlag);
     }
 
 }
diff --git a/src/test/TestArgsParser.java b/src/test/TestArgsParser.java
index 21a5459..730420f 100644
--- a/src/test/TestArgsParser.java
+++ b/src/test/TestArgsParser.java
@@ -11,7 +11,7 @@ public class TestArgsParser {
     @Test
     public void noArgumentsProvided() {
         ArgsParser parser = new ArgsParser(new String[] {});
-        Parameter file = parser.addParameter("file", "f", " ",true);
+        Parameter<String> file = parser.addStringParameter("file", "f", " ",true);
         try {
             parser.parseArgs();
         } catch (ArgsException e) {
@@ -23,7 +23,7 @@ public void noArgumentsProvided() {
     @Test
     public void testGetArgument() {
         ArgsParser parser = new ArgsParser(new String[] {"--file", "file.txt"});
-        Parameter file = parser.addParameter("file", "f", " ", true);
+        Parameter<String> file = parser.addStringParameter("file", "f", " ", true);
         try {
             parser.parseArgs();
         } catch (Exception e) {
@@ -39,8 +39,8 @@ public void testGetArgument() {
     @Test
     public void testUnknownParameter() {
         ArgsParser parser = new ArgsParser(new String[] {"-f", "file.txt", "-s", "save.txt"});
-        Parameter file = parser.addParameter("file", "f", "descr", true);
-        Parameter save = parser.addParameter("save", "s", "descr", true);
+        Parameter<String> file = parser.addStringParameter("file", "f", "descr", true);
+        Parameter<String> save = parser.addStringParameter("save", "s", "descr", true);
         try {
             parser.parseArgs();
         } catch (Exception e) {
@@ -51,8 +51,8 @@ public void testUnknownParameter() {
     @Test
     public void testGetArgumentWithMultipleFlagsAndWrongInput() {
         ArgsParser parser = new ArgsParser(new String[] {"-f", "file.txt", "--save", "save.txt", "-s"});
-        Parameter file = parser.addParameter("file", "f", "descr", true);
-        Parameter save = parser.addParameter("save", "w", "descr", true);
+        Parameter<String> file = parser.addStringParameter("file", "f", "descr", true);
+        Parameter<String> save = parser.addStringParameter("save", "w", "descr", true);
         try {
             parser.parseArgs();
         } catch (Exception e) {
@@ -66,8 +66,8 @@ public void testGetArgumentWithMultipleFlagsAndWrongInput() {
     @Test
     public void testMissingArgument() {
         ArgsParser parser = new ArgsParser(new String[] {"--file", "--save", "save.txt"});
-        Parameter file = parser.addParameter("file", "m", "descr", true);
-        Parameter save = parser.addParameter("save", "s", "descr", true);
+        Parameter<String> file = parser.addStringParameter("file", "m", "descr", true);
+        Parameter<String> save = parser.addStringParameter("save", "s", "descr", true);
         try {
             parser.parseArgs();
         } catch (Exception e) {
@@ -79,8 +79,8 @@ public void testMissingArgument() {
     @Test
     public void testMissingLastArgument() {
         ArgsParser parser = new ArgsParser(new String[]{"--file", "file.txt", "--save"});
-        Parameter file = parser.addParameter("--file", "f", "descr", true);
-        Parameter save = parser.addParameter("--save", "s", "descr", true);
+        Parameter<String> file = parser.addStringParameter("--file", "f", "descr", true);
+        Parameter<String> save = parser.addStringParameter("--save", "s", "descr", true);
         try {
             parser.parseArgs();
         } catch (Exception e) {
@@ -92,8 +92,8 @@ public void testMissingLastArgument() {
     @Test
     public void testMissingShorts() {
         ArgsParser parser = new ArgsParser(new String[]{"-f", "/to/file", "--save", "save.txt"});
-        Parameter file = parser.addParameter("--file", "m", "descr", true);
-        Parameter save = parser.addParameter("--save", "s", true);
+        Parameter<String> file = parser.addStringParameter("--file", "m", "descr", true);
+        Parameter<String> save = parser.addStringParameter("--save", "s", true);
         try {
             parser.parseArgs();
         } catch (Exception e) {
@@ -105,9 +105,9 @@ public void testMissingShorts() {
     @Test
     public void testMandatoryArgMissing() {
         ArgsParser parser = new ArgsParser(new String[]{"--file", "file.txt", "--optional", "optional.txt"});
-        Parameter file = parser.addParameter("file", "f", "descr", true);
-        Parameter save = parser.addParameter("save", "s", "descr", true);
-        Parameter optional = parser.addParameter("optional", "o", "descr", false);
+        Parameter<String> file = parser.addStringParameter("file", "f", "descr", true);
+        Parameter<String> save = parser.addStringParameter("save", "s", "descr", true);
+        Parameter<String> optional = parser.addStringParameter("optional", "o", "descr", false);
         try {
             parser.parseArgs();
         } catch (ArgsException e) {
@@ -118,8 +118,8 @@ public void testMandatoryArgMissing() {
     @Test
     public void testTooManyArguments() {
         ArgsParser parser = new ArgsParser(new String[]{"--file", "file.txt", "--save", "save.txt", "extra"});
-        Parameter file = parser.addParameter("file", "f", "descr", true);
-        Parameter save = parser.addParameter("save", "s", "descr", true);
+        Parameter<String> file = parser.addStringParameter("file", "f", "descr", true);
+        Parameter<String> save = parser.addStringParameter("save", "s", "descr", true);
         try {
             parser.parseArgs();
         } catch (ArgsException e) {
@@ -130,8 +130,8 @@ public void testTooManyArguments() {
     @Test
     public void testGetArgumentAsString() {
         ArgsParser parser = new ArgsParser(new String[] {"--file", "file.txt", "-int", "5"});
-        Parameter file = parser.addParameter("file", "f", true);
-        Parameter integer = parser.addParameter("integer", "int", "descr", true);
+        Parameter<String> file = parser.addStringParameter("file", "f", true);
+        Parameter<Integer> integer = parser.addIntegerParameter("integer", "int", "descr", true);
         try {
             parser.parseArgs();
         } catch (Exception e) {
@@ -145,15 +145,15 @@ public void testGetArgumentAsString() {
     @Test
     public void testGetArgumentWithGenericType() {
         ArgsParser parser = new ArgsParser(new String[] {"--file", "file.txt", "--integer", "5"});
-        Parameter file = parser.addParameter("file", "f", "descr", true);
-        Parameter integer = parser.addParameter("integer", "int", "descr", true, Integer.class);
+        Parameter<String> file = parser.addStringParameter("file", "f", "descr", true);
+        Parameter<Integer> integer = parser.addIntegerParameter("integer", "int", "descr", true);
         try {
             parser.parseArgs();
         } catch (Exception e) {
             e.printStackTrace();
         }
-        Integer result = integer.getCastedArgument();
-        Integer expected = 5;
+        Integer result = integer.getArgument() + 5;
+        Integer expected = 5 + 5;
 
         assertEquals(expected, result);
     }
@@ -161,30 +161,29 @@ public void testGetArgumentWithGenericType() {
     @Test
     public void testBooleanGetArgument() {
         ArgsParser parser = new ArgsParser(new String[] {"--file", "file.txt", "--boolean", "true"});
-        Parameter file = parser.addParameter("file", "f", "descr", true);
-        Parameter bool = parser.addParameter("boolean", "b", "descr", true, Boolean.class);
+        Parameter<String> file = parser.addStringParameter("file", "f", "descr", true);
+        Parameter<Boolean> bool = parser.addBooleanParameter("boolean", "b", "descr", true);
         try {
             parser.parseArgs();
         } catch (Exception e) {
             e.printStackTrace();
         }
 
-        assertTrue(bool.getCastedArgument());
+        assertTrue(bool.getArgument());
     }
 
     @Test
     public void testGetArgumentAsDouble() {
         ArgsParser parser = new ArgsParser(new String[] {"--file", "file.txt", "--double", "5.5"});
-        Parameter file = parser.addParameter("file", "f", "descr", true);
-        Parameter doub = parser.addParameter("double", "d", "descr", true, Double.class);
+        Parameter<String> file = parser.addStringParameter("file", "f", "descr", true);
+        Parameter<Double> doub = parser.addDoubleParameter("double", "d", "descr", true);
         try {
             parser.parseArgs();
         } catch (Exception e) {
             e.printStackTrace();
         }
-        Double result = doub.getCastedArgument();
-        Double expected = 5.5;
-        String StringResult = doub.getArgument();
+        Double result = doub.getArgument() + 5;
+        Double expected = 5.5 + 5;
 
         assertEquals(expected, result);
     }
@@ -192,58 +191,43 @@ public void testGetArgumentAsDouble() {
     @Test
     public void testGetArgumentAsDoubleWithWrongInput() {
         ArgsParser parser = new ArgsParser(new String[] {"--file", "file.txt", "--double", "5.5.5"});
-        Parameter file = parser.addParameter("file", "f", "descr", true);
-        Parameter doub = parser.addParameter("double", "d", "descr", true, Double.class);
+        Parameter<String> file = parser.addStringParameter("file", "f", "descr", true);
+        Parameter<Double> doub = parser.addDoubleParameter("double", "d", "descr", true);
         try {
             parser.parseArgs();
         } catch (Exception e) {
-            assertEquals(new InvalidArgTypeArgsException("--double").getMessage(), e.getMessage());
+            assertEquals(new InvalidArgTypeArgsException("--double", "Double", "multiple points").getMessage(), e.getMessage());
         }
     }
 
     @Test
     public void useDefaultValue() {
         ArgsParser parser = new ArgsParser(new String[] {"--file", "file.txt"});
-        Parameter file = parser.addParameter("file", "f", "descr", true);
-        Parameter doub = parser.addParameter("double", "d", "descr", 12.3);
-        try {
-            parser.parseArgs();
-        } catch (Exception e) {
-        }
-
-        String result = doub.getArgument();
-
-        Assert.assertEquals("12.3", result);
-    }
-
-    @Test
-    public void useDefaultValueCast() {
-        ArgsParser parser = new ArgsParser(new String[] {"--file", "file.txt"});
-        Parameter file = parser.addParameter("file", "f", "descr", true);
-        Parameter doub = parser.addParameter("double", "d", "descr", 12.3);
+        Parameter<String> file = parser.addStringParameter("file", "f", "descr", true);
+        Parameter<Double> doub = parser.addDoubleParameter("double", "d", "descr", 12.3);
         try {
             parser.parseArgs();
         } catch (Exception e) {
         }
 
-        Double result = doub.getCastedArgument();
-        Double expected = 12.3;
+        Double expected = 12.3 + 3;
+        Double result = doub.getArgument() + 3;
 
         Assert.assertEquals(expected, result);
     }
 
     @Test
-    public void testStringDefault() {
-        ArgsParser parser = new ArgsParser(new String[] {"--file", "file.txt"});
-        Parameter file = parser.addParameter("file", "f", "descr", "default");
-        Parameter doub = parser.addParameter("double", "d", 12.5);
+    public void testDefaultOverride() {
+        ArgsParser parser = new ArgsParser(new String[] {"--file", "file.txt", "--double", "5.5"});
+        Parameter<String> file = parser.addStringParameter("file", "f", "descr", true);
+        Parameter<Double> doub = parser.addDoubleParameter("double", "d", "descr", 12.3);
         try {
             parser.parseArgs();
         } catch (Exception e) {
         }
 
-        String expected = "default";
-        String result = file.getArgument();
+        Double result = doub.getArgument();
+        Double expected = 5.5;
 
         Assert.assertEquals(expected, result);
     }
@@ -251,8 +235,8 @@ public void testStringDefault() {
     @Test
     public void testHelp() {
         ArgsParser parser = new ArgsParser(new String[] {"--help"});
-        Parameter file = parser.addParameter("file", "f", "descri", "/home/user/projects/one/two/my_project/source/main/java/com/example/myapp/ExampleClassThatWonTDoAnythingElseThanBeeingAnExample.java");
-        Parameter doub = parser.addParameter("double", "d", "des", 12.3);
+        Parameter<String> file = parser.addStringParameter("file", "f", "descri", "/home/user/projects/one/two/my_project/source/main/java/com/example/myapp/ExampleClassThatWonTDoAnythingElseThanBeeingAnExample.java");
+        Parameter<Double> doub = parser.addDoubleParameter("double", "d", "des", 12.3);
         try {
             parser.parseArgs();
         } catch (CalledForHelpNotification e) {
@@ -264,10 +248,10 @@ public void testHelp() {
     @Test
     public void testLargerHelp() {
         ArgsParser parser = new ArgsParser(new String[] {"--help"});
-        Parameter file = parser.addParameter("file", "s", "aasdijasoidjoai sjdoiajsd oijaosidja oijsdoaijsd oijaojovn eoin oilnsdo vöinasdv", "/home/user/projects/one/two/my_project/source/main/java/com/example/myapp/ExampleClassThatWonTDoAnythingElseThanBeeingAnExample.java");
-        Parameter doub = parser.addParameter("double", "d", 12.3);
-        Parameter bool = parser.addParameter("boolean", "b", "des", true);
-        Parameter integer = parser.addParameter("integer", "i", "des", 5);
+        Parameter<String> file = parser.addStringParameter("file", "s", "aasdijasoidjoai sjdoiajsd oijaosidja oijsdoaijsd oijaojovn eoin oilnsdo vöinasdv", "/home/user/projects/one/two/my_project/source/main/java/com/example/myapp/ExampleClassThatWonTDoAnythingElseThanBeeingAnExample.java");
+        Parameter<Double> doub = parser.addDoubleParameter("double", "d", 12.3);
+        Parameter<Boolean> bool = parser.addBooleanParameter("boolean", "b", "des", true);
+        Parameter<Integer> integer = parser.addIntegerParameter("integer", "i", "des", 5);
         try {
             parser.parseArgs();
         } catch (CalledForHelpNotification e) {
@@ -277,16 +261,264 @@ public void testLargerHelp() {
     }
 
     @Test
-    public void testWrongArguemntTypeProvided() {
-        ArgsParser parser = new ArgsParser(new String[] {"--file", "file.txt", "--integer", "5.5"});
-        Parameter file = parser.addParameter("file", "f", "descr", true);
-        Parameter integer = parser.addParameter("integer", "int", "descr", true, Integer.class);
+    public void testAddIntegerParameterWithDescriptionAndMandatory() {
+        ArgsParser parser = new ArgsParser(new String[] {"--number", "42"});
+        Parameter<Integer> number = parser.addIntegerParameter("number", "n", "An integer number", true);
+        try {
+            parser.parseArgs();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Integer result = number.getArgument();
+        assertEquals(Integer.valueOf(42), result);
+    }
+
+    // Test für addIntegerParameter(String, String, boolean)
+    @Test
+    public void testAddIntegerParameterMandatory() {
+        ArgsParser parser = new ArgsParser(new String[] {"--number", "42"});
+        Parameter<Integer> number = parser.addIntegerParameter("number", "n", true);
+        try {
+            parser.parseArgs();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Integer result = number.getArgument();
+        assertEquals(Integer.valueOf(42), result);
+    }
+
+    // Test für addIntegerParameter(String, String, String, Integer)
+    @Test
+    public void testAddIntegerParameterWithDescriptionAndDefaultValue() {
+        ArgsParser parser = new ArgsParser(new String[] {});
+        Parameter<Integer> number = parser.addIntegerParameter("number", "n", "An integer number", 42);
+        try {
+            parser.parseArgs();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Integer result = number.getArgument();
+        assertEquals(Integer.valueOf(42), result);
+    }
+
+    // Test für addIntegerParameter(String, String, Integer)
+    @Test
+    public void testAddIntegerParameterDefaultValue() {
+        ArgsParser parser = new ArgsParser(new String[] {});
+        Parameter<Integer> number = parser.addIntegerParameter("number", "n", 42);
+        try {
+            parser.parseArgs();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Integer result = number.getArgument();
+        assertEquals(Integer.valueOf(42), result);
+    }
+
+    // Test für addDoubleParameter(String, String, String, boolean)
+    @Test
+    public void testAddDoubleParameterWithDescriptionAndMandatory() {
+        ArgsParser parser = new ArgsParser(new String[] {"--number", "42.5"});
+        Parameter<Double> number = parser.addDoubleParameter("number", "n", "A double number", true);
+        try {
+            parser.parseArgs();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Double result = number.getArgument();
+        assertEquals(Double.valueOf(42.5), result);
+    }
+
+    // Test für addDoubleParameter(String, String, boolean)
+    @Test
+    public void testAddDoubleParameterMandatory() {
+        ArgsParser parser = new ArgsParser(new String[] {"--number", "42.5"});
+        Parameter<Double> number = parser.addDoubleParameter("number", "n", true);
+        try {
+            parser.parseArgs();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Double result = number.getArgument();
+        assertEquals(Double.valueOf(42.5), result);
+    }
+
+    // Test für addDoubleParameter(String, String, String, Double)
+    @Test
+    public void testAddDoubleParameterWithDescriptionAndDefaultValue() {
+        ArgsParser parser = new ArgsParser(new String[] {});
+        Parameter<Double> number = parser.addDoubleParameter("number", "n", "A double number", 42.5);
         try {
             parser.parseArgs();
-        } catch (InvalidArgTypeArgsException e) {
-            assertEquals(new InvalidArgTypeArgsException("--integer").getMessage(), e.getMessage());
         } catch (Exception e) {
-            System.exit(1);
+            e.printStackTrace();
+        }
+        Double result = number.getArgument();
+        assertEquals(Double.valueOf(42.5), result);
+    }
+
+    // Test für addDoubleParameter(String, String, Double)
+    @Test
+    public void testAddDoubleParameterDefaultValue() {
+        ArgsParser parser = new ArgsParser(new String[] {});
+        Parameter<Double> number = parser.addDoubleParameter("number", "n", 42.5);
+        try {
+            parser.parseArgs();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Double result = number.getArgument();
+        assertEquals(Double.valueOf(42.5), result);
+    }
+
+    // Test für addBooleanParameter(String, String, String, boolean)
+    @Test
+    public void testAddBooleanParameterWithDescriptionAndMandatory() {
+        ArgsParser parser = new ArgsParser(new String[] {"--flag", "true"});
+        Parameter<Boolean> flag = parser.addBooleanParameter("flag", "f", "A boolean flag", true);
+        try {
+            parser.parseArgs();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Boolean result = flag.getArgument();
+        assertTrue(result);
+    }
+
+    // Test für addBooleanParameter(String, String, boolean)
+    @Test
+    public void testAddBooleanParameterMandatory() {
+        ArgsParser parser = new ArgsParser(new String[] {"--flag", "true"});
+        Parameter<Boolean> flag = parser.addBooleanParameter("flag", "f", true);
+        try {
+            parser.parseArgs();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Boolean result = flag.getArgument();
+        assertTrue(result);
+    }
+
+    // Test für addBooleanParameter(String, String, String, Boolean)
+    @Test
+    public void testAddBooleanParameterWithDescriptionAndDefaultValue() {
+        ArgsParser parser = new ArgsParser(new String[] {"--flag", "false"});
+        Parameter<Boolean> flag = parser.addBooleanParameter("flag", "f", "A boolean flag", true);
+        try {
+            parser.parseArgs();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Boolean result = !flag.getArgument();
+        assertTrue(result);
+    }
+
+    // Test für addBooleanParameter(String, String, Boolean)
+    @Test
+    public void testAddBooleanParameterDefaultValue() {
+        ArgsParser parser = new ArgsParser(new String[] {"-f", "true"});
+        Parameter<Boolean> flag = parser.addBooleanParameter("flag", "f", true);
+        try {
+            parser.parseArgs();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Boolean result = flag.getArgument();
+        assertTrue(result);
+    }
+
+    // Test für addCharacterParameter(String, String, String, boolean)
+    @Test
+    public void testAddCharacterParameterWithDescriptionAndMandatory() {
+        ArgsParser parser = new ArgsParser(new String[] {"--char", "c"});
+        Parameter<Character> character = parser.addCharacterParameter("char", "c", "A character", true);
+        try {
+            parser.parseArgs();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Character result = character.getArgument();
+        assertEquals(Character.valueOf('c'), result);
+    }
+
+    // Test für addCharacterParameter(String, String, boolean)
+    @Test
+    public void testAddCharacterParameterMandatory() {
+        ArgsParser parser = new ArgsParser(new String[] {"--char", "c"});
+        Parameter<Character> character = parser.addCharacterParameter("char", "c", true);
+        try {
+            parser.parseArgs();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Character result = character.getArgument();
+        assertEquals(Character.valueOf('c'), result);
+    }
+
+    // Test für addCharacterParameter(String, String, String, Character)
+    @Test
+    public void testAddCharacterParameterWithDescriptionAndDefaultValue() {
+        ArgsParser parser = new ArgsParser(new String[] {});
+        Parameter<Character> character = parser.addCharacterParameter("char", "c", "A character", 'c');
+        try {
+            parser.parseArgs();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Character result = character.getArgument();
+        assertEquals(Character.valueOf('c'), result);
+    }
+
+    // Test für addCharacterParameter(String, String, Character)
+    @Test
+    public void testAddCharacterParameterDefaultValue() {
+        ArgsParser parser = new ArgsParser(new String[] {});
+        Parameter<Character> character = parser.addCharacterParameter("char", "c", 'c');
+        try {
+            parser.parseArgs();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Character result = character.getArgument();
+        assertEquals(Character.valueOf('c'), result);
+    }
+
+    @Test
+    public void testStringDeafult() {
+        ArgsParser parser = new ArgsParser(new String[] {});
+        Parameter<String> string = parser.addStringParameter("string", "s", "default");
+        try {
+            parser.parseArgs();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        String result = string.getArgument();
+        assertEquals("default", result);
+    }
+
+    @Test
+    public void testBool() {
+        ArgsParser parser = new ArgsParser(new String[] {"--bool", "true"});
+        Parameter<Boolean> bool = parser.addBooleanParameter(true, "bool", "b", "descr");
+        try {
+            parser.parseArgs();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Boolean result = bool.getArgument();
+        assertTrue(result);
+    }
+
+    @Test
+    public void testBool2() {
+        ArgsParser parser = new ArgsParser(new String[] {"--bool", "false"});
+        Parameter<Boolean> bool = parser.addBooleanParameter(false, "bool", "b");
+        try {
+            parser.parseArgs();
+        } catch (Exception e) {
+            e.printStackTrace();
         }
+        Boolean result = bool.getArgument();
+        assertFalse(result);
     }
 }