diff --git a/src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java b/src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java
index 4c065abb..458585e1 100644
--- a/src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java
+++ b/src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java
@@ -8,17 +8,31 @@ import de.dhbwstuttgart.bytecode.genericsGenerator.GeneratedGenericsFinder;
 import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
 import de.dhbwstuttgart.environment.CompilationEnvironment;
 import de.dhbwstuttgart.environment.DirectoryClassLoader;
+import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.parser.JavaTXParser;
+import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.scope.GenericsRegistry;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.SyntaxTreeGenerator;
 import de.dhbwstuttgart.parser.antlr.Java8Parser.CompilationUnitContext;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
+import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.ParameterList;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.syntaxtree.TypeScope;
+import de.dhbwstuttgart.syntaxtree.FormalParameter;
+import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
+import de.dhbwstuttgart.syntaxtree.statement.Block;
+import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.syntaxtree.type.TypeVisitor;
 import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
@@ -50,6 +64,8 @@ import java.net.URLClassLoader;
 import java.util.*;
 import java.util.function.Function;
 import java.util.stream.Collectors;
+
+import org.antlr.v4.runtime.Token;
 import org.apache.commons.io.output.NullOutputStream;
 
 
@@ -93,10 +109,6 @@ public class JavaTXCompiler {
 
     public ConstraintSet<Pair> getConstraints() throws ClassNotFoundException, IOException {
         List<ClassOrInterface> allClasses = new ArrayList<>();//environment.getAllAvailableClasses();
-		for (File f : this.sourceFiles.keySet()) {
-			SourceFile sf = sourceFiles.get(f);
-            allClasses.addAll(sf.getClasses());
-		}
         List<ClassOrInterface> importedClasses = new ArrayList<>();
         //Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
         for (File forSourceFile : sourceFiles.keySet()){
@@ -111,6 +123,54 @@ public class JavaTXCompiler {
 				importedClasses.add(importedClass);
 			}
         }
+        for (File f : this.sourceFiles.keySet()) {
+			SourceFile sf = sourceFiles.get(f);
+			sf.KlassenVektor.forEach(cl -> {
+				ClassOrInterface superclass = null;
+				Optional<ClassOrInterface> optSuperclass = 
+					importedClasses.stream().filter(x -> x.getClassName().equals(
+						cl.getSuperClass().getName())).findFirst();
+				if (optSuperclass.isPresent()) {
+					superclass = optSuperclass.get();
+				}
+				else {
+					//throw new ClassNotFoundException("");
+				}
+				Iterator<RefTypeOrTPHOrWildcardOrGeneric> paraIt= cl.getSuperClass().getParaList().iterator();
+				Iterator<GenericTypeVar> tvarVarIt = superclass.getGenerics().iterator();
+				
+				HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs = new HashMap<>();
+				while (paraIt.hasNext()) { 
+					gtvs.put(tvarVarIt.next().getName(), paraIt.next());
+				}
+				Iterator<Method> methodIt = superclass.getMethods().iterator();
+				while(methodIt.hasNext()) {
+					Method m = methodIt.next();
+					ParameterList newParaList = new ParameterList(
+					m.getParameterList()
+					 .getFormalparalist()
+					 .stream()
+					 .map(fp -> new FormalParameter(fp.getName(), fp.getType().acceptTV(new TypeExchanger(gtvs)), fp.getOffset()))
+					 .collect(Collectors.toCollection(ArrayList::new)), m.getParameterList().getOffset());
+					/* 
+					Iterator<? extends GenericTypeVar> genericsIt = m.getGenerics().iterator();
+					List<GenericTypeVar> newGenericsList = new ArrayList<>();
+					Set<String> keys = gtvs.keySet();
+					while (genericsIt.hasNext()) {
+						GenericTypeVar gtv = genericsIt.next();
+						if (!keys.contains(gtv.getName())) {
+							newGenericsList.add(gtv);
+						}
+					}
+					*/
+					cl.getMethods().add(new Method(m.modifier, m.name, m.getReturnType().acceptTV(new TypeExchanger(gtvs)), newParaList, m.block,
+							  //new GenericDeclarationList(newGenericsList, ((GenericDeclarationList)m.getGenerics()).getOffset()), 
+							(GenericDeclarationList)m.getGenerics(),
+							m.getOffset()));
+				}
+			});
+            allClasses.addAll(sf.getClasses());
+		}
         allClasses.addAll(importedClasses);
         return new TYPE(sourceFiles.values(), allClasses).getConstraints();
     }
@@ -862,5 +922,53 @@ public class JavaTXCompiler {
 			System.out.println(name + ".class file generated");
 		}
 	}
+	
+	/* PL 2020-03-17 mit TypeExchanger in FCGenerator.java zusammenfuehren */
+	/**
+     * Tauscht die GTVs in einem Typ gegen die entsprechenden Typen in der übergebenen Map aus.
+     */
+    private static class TypeExchanger implements TypeVisitor<RefTypeOrTPHOrWildcardOrGeneric>{
+
+        private final HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs;
+
+        TypeExchanger(HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs){
+            this.gtvs = gtvs;
+        }
+
+        @Override
+        public RefTypeOrTPHOrWildcardOrGeneric visit(RefType refType) {
+            List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
+            for(RefTypeOrTPHOrWildcardOrGeneric param : refType.getParaList()){
+                params.add(param.acceptTV(this));
+            }
+            RefTypeOrTPHOrWildcardOrGeneric ret = new RefType(refType.getName(), params, new NullToken());
+            return ret;
+        }
+
+        @Override
+        public RefTypeOrTPHOrWildcardOrGeneric visit(SuperWildcardType superWildcardType) {
+        	SuperWildcardType ret = new SuperWildcardType(superWildcardType.getInnerType().acceptTV(this), superWildcardType.getOffset());
+            return ret;
+        }
+
+        @Override
+        public RefTypeOrTPHOrWildcardOrGeneric visit(TypePlaceholder typePlaceholder) {
+            throw new DebugException("Dieser Fall darf nicht auftreten");
+        }
+
+        @Override
+        public RefTypeOrTPHOrWildcardOrGeneric visit(ExtendsWildcardType extendsWildcardType) {
+        	ExtendsWildcardType ret = new ExtendsWildcardType(extendsWildcardType.getInnerType().acceptTV(this), extendsWildcardType.getOffset());
+            return ret;
+        }
+
+        @Override
+        public RefTypeOrTPHOrWildcardOrGeneric visit(GenericRefType genericRefType) {
+            if(! gtvs.containsKey(genericRefType.getParsedName()))
+                throw new DebugException("Dieser Fall darf nicht auftreten");
+            return gtvs.get(genericRefType.getParsedName());
+        }
+
+    }
 
 }