diff --git a/Main.java b/Main.java
index ce2e792..32a06d6 100644
--- a/Main.java
+++ b/Main.java
@@ -29,16 +29,16 @@ public class Main
 
         decodierungBaum(codierung(text,wurzel), wurzel);
 
-        System.out.println(byteString_to_character(character_to_byteString(null)));
-        System.out.println(byteString_to_character(character_to_byteString('b')));
-        System.out.println(byteString_to_character(character_to_byteString('c')));
-        System.out.println(byteString_to_character(character_to_byteString('d')));
-        System.out.println(byteString_to_character(character_to_byteString('e')));
-        System.out.println(byteString_to_character(character_to_byteString('f')));
-        System.out.println(byteString_to_character(character_to_byteString('g')));
-        System.out.println(byteString_to_character(character_to_byteString('h')));
+        System.out.println(binärString_to_character(character_to_binärString(null)));
+        System.out.println(binärString_to_character(character_to_binärString('b')));
+        System.out.println(binärString_to_character(character_to_binärString('c')));
+        System.out.println(binärString_to_character(character_to_binärString('d')));
+        System.out.println(binärString_to_character(character_to_binärString('e')));
+        System.out.println(binärString_to_character(character_to_binärString('f')));
+        System.out.println(binärString_to_character(character_to_binärString('g')));
+        System.out.println(binärString_to_character(character_to_binärString('h')));
 
-        byteString_to_baum(baum_to_byteString(wurzel));
+        binärString_to_baum(baum_to_binärString(wurzel));
         printBaum(wurzel);
     }
 
@@ -64,7 +64,7 @@ public class Main
             System.out.println("->" + entry.getKey() + ", Code: " + entry.getValue());
         }
 
-        printBaum(byteString_to_baum(baum_to_byteString(wurzel)));
+        printBaum(binärString_to_baum(baum_to_binärString(wurzel)));
     }
     
     public static void test3()
@@ -76,25 +76,25 @@ public class Main
     {
         if(baum == null)return;
         System.out.println("Buchstabe: " + baum.getBuchstabe() + ", Anzahl: " + baum.getAnzahl());
-        printBaum(baum.getLeft());
+        printBaum(baum.getLeft()); //ruft die Methode rekuirsiv auf
         printBaum(baum.getRight());
     }
 
     public static void codes(String text) //erstellt die codes für jeden einzelnen Buchstaben
     {
-        Node wurzel = Node.erstellen(Zählen.countEachLetter(text));
-        HashMap<Character, String> codes = new HashMap<Character, String>();
+        Node wurzel = Node.erstellen(Zählen.countEachLetter(text)); //erstellt den Baum mithilfe der Node Klasse
+        HashMap<Character, String> codes = new HashMap<Character, String>(); //erstellt eine leere Hashmap
 
-        if(wurzel.getLeft() == null && wurzel.getRight() == null)
+        if(wurzel.getLeft() == null && wurzel.getRight() == null) //überprüft es ob der Baum mehr als ein zeichen lang ist
         {
             codes.put(wurzel.getBuchstabe(), "0");
         }
-        else
+        else //nutzt generieren um die codes zu generieren
         {
             generieren(codes,wurzel,"");
         }
 
-        for (var entry : codes.entrySet()) 
+        for (var entry : codes.entrySet()) //printet alle codes für das jeweiliege Zeichen
         {
             System.out.println("->" + entry.getKey() + ", Code: " + entry.getValue());
         }
@@ -104,70 +104,64 @@ public class Main
     //methode zum generieren der codes für jeden einzelnen Buchstaben  
     public static void generieren(HashMap<Character, String> codes, Node node, String code)
     {
-        if(node == null)return;
-        System.out.println(node.getBuchstabe() +"  " +  code);
-        if(node.getLeft() == null && node.getRight() == null)
+        if(node == null)return; //abbruch Bedienung
+        if(node.getLeft() == null && node.getRight() == null) //überprüft ob das Node ein "Blatt" ist
         {
-            codes.put(node.getBuchstabe(), code);
+            codes.put(node.getBuchstabe(), code); //wenn ja, gibt es den Buchstaben und den jeweiliegen code zurück
 
             return;
         }
-        generieren(codes, node.getLeft(), code + "0");
+        generieren(codes, node.getLeft(), code + "0"); //generiert rekursiv den code für die Äste
         generieren(codes, node.getRight(), code + "1");
     }
 
     //generiert die Huffman-Codierung
     public static String codierung(String text, Node wurzel)
     {
-        HashMap<Character, String> codes = new HashMap<Character, String>();
+        HashMap<Character, String> codes = new HashMap<Character, String>(); //erstellt eine leere Hashmap
 
-        if(wurzel.getLeft() == null && wurzel.getRight() == null)
+        if(wurzel.getLeft() == null && wurzel.getRight() == null) //überprüft es ob der Baum mehr als ein zeichen lang ist
         {
             codes.put(wurzel.getBuchstabe(), "0");
         }
-        else
+        else //nutzt generieren um die codes zu generieren
         {
             generieren(codes,wurzel,"");
         }
-        String code = "";
-        for (int i=0; i<text.length();i++)
+        String code = ""; //erstellt leere Variable
+        
+        for (int i=0; i<text.length();i++) //Codiert den "text" komplett, mithilfe der codes Methode
         {
             char b = text.charAt(i);
             String c = codes.get(b);
             code += c;
         }
-        System.out.println("Huffman-Codierung: " + code);
         return code;
     }
     
+    //codiert Buchstaben und speichert den Baum mit
     public static String codierungInklBaum(String text)
     {
-        //zahl wan angibt wan text kommt und baum aufhört
-        
-        //decodiere baum, dcodierung text
-        
-        
         Map<Character, Integer> zahlen = Zählen.countEachLetter(text);
-        Node baum = Node.erstellen(zahlen);
+        Node baum = Node.erstellen(zahlen); //erstellt Baum
         
-        String codierterBaum = baum_to_byteString(baum);
-        String codierterText = codierung(text,baum);
+        String codierterBaum = baum_to_binärString(baum); //wandelt den Baum in Daten um, mit dem die Baumstruktur geladen werden kann
+        String codierterText = codierung(text,baum); //speichert den codierten Text
         
-        int textErstIndex = codierterBaum.length() + 32;
-        String codiertertextErstIndex =  Int_to_ByteString(textErstIndex);
-        
-        System.out.println(codiertertextErstIndex + codierterBaum +" " + codierterText);
+        int textErstIndex = codierterBaum.length() + 32; //speichert den ersten Index der Text codierung
+        String codiertertextErstIndex =  Int_to_binärString(textErstIndex); //wandelt den textErstIndex in Binär um
         
         return codiertertextErstIndex + codierterBaum + codierterText;
     }
     
+    //decodiert Buchstaben und speichert den Baum
     public static String decodierungInlkBaum(String code)
     {
         String codierterTextErstIndex =  code.substring(0,32);
-        int textErstIndex = byteString_to_int(codierterTextErstIndex);
+        int textErstIndex = binärString_to_int(codierterTextErstIndex);
         
         String codierterBaum = code.substring(32, textErstIndex);
-        Node decodierterBaum = byteString_to_baum(codierterBaum);
+        Node decodierterBaum = binärString_to_baum(codierterBaum);
         
         String codierterText = code.substring(textErstIndex, code.length());
         String decodierterText = decodierungBaum(codierterText,decodierterBaum);
@@ -214,9 +208,9 @@ public class Main
     
     
 
-    public static Byte ByteString_to_Byte (String byteString)
+    public static Byte binärString_to_Byte (String binärString)
     {
-        if(byteString.length() != 8)
+        if(binärString.length() != 8)
         {
             System.out.println(">8");
             return null;
@@ -225,8 +219,8 @@ public class Main
         byte result = 0;
         for(byte i=0 ;i<8;i++)
         {
-            if(byteString.charAt(7-i) == '1')result|=1<<i; //verschiebt die 1 um i binärpositionen nach links
-            else if(byteString.charAt(7-i) != '0')
+            if(binärString.charAt(7-i) == '1')result|=1<<i; //verschiebt die 1 um i binärpositionen nach links
+            else if(binärString.charAt(7-i) != '0')
             {
                 System.out.println("was flasch");
                 return null;
@@ -236,7 +230,7 @@ public class Main
         return result;
     }
 
-    public static String Byte_to_ByteString (byte b)
+    public static String Byte_to_binärString (byte b)
     {
         String result = "";
 
@@ -249,7 +243,7 @@ public class Main
         return result;
     }
 
-    public static String character_to_byteString (Character c)
+    public static String character_to_binärString (Character c)
     {
 
         byte[] b = nullCharBytes;
@@ -264,15 +258,15 @@ public class Main
         String result = "";
         for(int i=0;i<b.length;i++)
         {
-            result += Byte_to_ByteString(b[i]);
+            result += Byte_to_binärString(b[i]);
         }
         return result;
     }
 
-    public static Character byteString_to_character (String byteString)
+    public static Character binärString_to_character (String binärString)
     {
-        byte a = ByteString_to_Byte(byteString.substring(0,8));
-        byte b = ByteString_to_Byte(byteString.substring(8,16));
+        byte a = binärString_to_Byte(binärString.substring(0,8));
+        byte b = binärString_to_Byte(binärString.substring(8,16));
         byte[] array = new byte[] {a,b};
         if(array[0] == nullCharBytes[0] && array[1] == nullCharBytes[1])return null;
         var byteBuffer = ByteBuffer.wrap(array);
@@ -280,24 +274,24 @@ public class Main
         return byteBuffer.getChar(0);
     }
 
-    public static String baum_to_byteString (Node baum)
+    public static String baum_to_binärString (Node baum)
     {
         if(baum == null)return "";
 
-        String byteString = character_to_byteString(baum.getBuchstabe());
-        byteString += baum_to_byteString(baum.getLeft());
-        byteString += baum_to_byteString(baum.getRight());
-        return byteString;
+        String binärString = character_to_binärString(baum.getBuchstabe());
+        binärString += baum_to_binärString(baum.getLeft());
+        binärString += baum_to_binärString(baum.getRight());
+        return binärString;
     }
 
-    public static Node byteString_to_baum (String s)
+    public static Node binärString_to_baum (String s)
     {
         Node root = null;
         Stack<Node> äste = new Stack<Node>();
         for(int i=0;i<s.length();i+=16)
         {
             String characterString = s.substring(i,i+16);
-            Character c = byteString_to_character(characterString);
+            Character c = binärString_to_character(characterString);
             Node node = new Node();
             node.setBuchstabe(c);
             if(i == 0)root = node;
@@ -325,9 +319,9 @@ public class Main
         return root;
     }
     
-    public static Integer byteString_to_int(String byteString)
+    public static Integer binärString_to_int(String binärString)
     {
-        if(byteString.length() != 32)
+        if(binärString.length() != 32)
         {
             System.out.println(">32");
             return null;
@@ -336,8 +330,8 @@ public class Main
         int result = 0;
         for(int i=0 ;i<32;i++)
         {
-            if(byteString.charAt(31-i) == '1')result|=1<<i; //verschiebt die 1 um i binärpositionen nach links
-            else if(byteString.charAt(31-i) != '0')
+            if(binärString.charAt(31-i) == '1')result|=1<<i; //verschiebt die 1 um i binärpositionen nach links
+            else if(binärString.charAt(31-i) != '0')
             {
                 System.out.println("was flasch");
                 return null;
@@ -347,7 +341,7 @@ public class Main
         return result;
     }
     
-    public static String Int_to_ByteString (int a)
+    public static String Int_to_binärString (int a)
     {
         String result = "";