Помогите, пожалуйста написать комментарии к коду задачи

Дан текстовый файл, содержащий исходный код программы на языке Java. Написать
программу для автоматической генерации методов get, set, equals и hashcode для
заданного в командной строке класса или всех классов в входном файле. Вначале свой
работы программа должна осуществлять проверку существования этих методов, после чего,
в зависимости от настроек (которые указываются флагами командной строки),
либо заменяет существующие методы, либо нет.

Это условие

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;


class fieldInfo { // Класс, переменные которого - имя и тип поля
String type; // тип
String name; // имя

fieldInfo(String type, String name) { //Конструктор класса, инициализирующий поля "тип" и "имя"(поля)
this.type = type;
this.name = name;
}
}
//-----------------------------------------------------------------------------------------------------------------------
public class сreateMethods { // Создание методов

private static FileWriter fw; // Для записи в файл
//-----------------------------------------------------------------------------------------------------------------------
public static void main(String[] args) throws IOException { //Точка входа в программу
Menu(); //Вызываем метод Menu для выбора параметров
}
//-----------------------------------------------------------------------------------------------------------------------
public static void Menu() throws IOException { // Консольное меню
// String className = inputClassName();
String fileName = "testCode.java"; // Имя исходного файла
choiceMenu(fileName); // Вызов меню для выбора параметров операций с исходным файлом
}
//-----------------------------------------------------------------------------------------------------------------------
public static void choiceMenu(String fileName) throws IOException { //Собственно меню
int choice = 0; // Переменная выбора - все классы/один класс
int replaceChoice = 0; // Переменная выбора - перезаписывать методы/не перезаписывать
System.out.println("-----------------------------------------------------------------------");
System.out.println(
"Please, choose an option: \n\tCreate Methods for:\n ->[1] - Replace Methods\n ->[2] - Do not Replace Methods");
replaceChoice = Input(); //Вызов метода input для получения переменной (1 или 2)
// т.е 1 - переписывать методы, 2 - не переписывать
System.out.println("-----------------------------------------------------------------------");
System.out.println(
"Please, choose an option: \n\tCreate Methods for:\n ->[1] - All Classes\n ->[2] - Distinct Class");
choice = Input(); //Вызов метода input для получения переменной (1 или 2)
//т.е. 1 - для всех классов, 2 - для одного класса
switch (choice) { // в зависимости от того, что выбрали:
case 1: // если 1(все классы)
fullWorkAll(fileName, replaceChoice); //вызываем метод с параметрами - имя файла и переписывать/нет
break;
case 2: //если 2(один класс)
String className = inputClassName(); // вызываем метод для получения имени класса, с которым нужно работать
System.out.println("Creating Methods for <" + className + ">..."); //Выводим это имя на экран
fullWorkDistinct(fileName, className, replaceChoice); // вызываем метод обработки класса в файле, с указанием переписывать/нет(методы)
break;
}
}
//-----------------------------------------------------------------------------------------------------------------------
public static String inputClassName() { //Получение имени класса для работы с ним
System.out.println("-----------------------------------------------------------------------");
System.out.println("Please, sir, enter the class name to work with:");
String input = null; // Переменная для хранения имени класса
try {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
input = bufferedReader.readLine(); //Читаем строку, введенную в консоли
} catch (IOException e) { //Обрабатываем исключения
e.printStackTrace();
}
// System.out.println("ClassName: " + input);
return input; //Возвращаем введенное имя класса
}
//-----------------------------------------------------------------------------------------------------------------------
public static int Input() { //Получение ответа в меню
int output = 0; //Переменная для будущего ответа
String input = null; //Переменная для чтения из консоли
try {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
input = bufferedReader.readLine(); //Читаем строку, введенную в консоли
output = Integer.parseInt(input); //Переводим ее в число
} catch (NumberFormatException ex) { //Если в строке не число, выбрасываем исключение
System.out.println("Not a number !");
} catch (IOException e) {
e.printStackTrace();
}
return output; //Возвращаем введенный ответ
}
//-----------------------------------------------------------------------------------------------------------------------
//Класс, работающий СО ВСЕМИ КЛАССАМИ в файле
public static void fullWorkAll(String fileName, int replaceChoice) throws IOException {
ArrayList<String> classList = getAllClasses(fileName); //Вызываем метод, находящий имена всех классов в файле, получаем список имен
ArrayList<String> codeList = null; //Создаем список - весь текст кода
ArrayList<fieldInfo> fieldInfo = null; //Создаем список - описание полей классов
for (String className : classList) { //В этом цикле перебираем все классы из списка и работаем с ними по очереди
System.out.println(">Creating Methods for <" + className + ">..."); //Выводим имя обрабатываемого класса
codeList = getCode(fileName, className); //Вызываем метод для получения кода всего класса
fieldInfo = getClasses(codeList); //Вызываем метод для получения полей класса
writeMethods(fieldInfo, className, codeList, replaceChoice); //Вызываем метод для записи методов в класс
}
}
//-----------------------------------------------------------------------------------------------------------------------
//Класс, работающий С ОДНИМ КЛАССОМ в файле(тоже самое, что и со всеми классами, только с одним
public static void fullWorkDistinct(String fileName, String className, int replaceChoice) throws IOException {
ArrayList<String> codeList = getCode(fileName, className);
ArrayList<fieldInfo> fieldInfo = getClasses(codeList);

writeMethods(fieldInfo, className, codeList, replaceChoice);

}
//-----------------------------------------------------------------------------------------------------------------------
// Получение имен всех классов
public static ArrayList<String> getAllClasses(String fileName) throws IOException {
ArrayList<String> text = new ArrayList<>(); //Создаем список для хранения имен классов
BufferedReader reader = new BufferedReader(new FileReader(fileName)); //Ридер для чтения из файла

boolean isPublic = false; //Логическая переменная - класс паблик или нет
while (reader.ready()) {
String str = reader.readLine(); //Читаем строку из файла
if (str.contains("public class ")) //Если в ней есть "public class", устанавливаем переменную в true(т.е класс паблик)
isPublic = true;
else
isPublic = false; //...иначе - класс не паблик
if (str.contains("class ") && isPublic == false) { //Если в строке есть "class" и класс не паблик...
//... выделяем из этой строки имя класса и добавляем его в список
text.add(str.substring(0, str.lastIndexOf(" {")).substring(str.lastIndexOf("class") + 6));
// isClassFound = true;
}
// if (isClassFound) {
// text.add(str);
// }

}
// for (String strY : text) {
// System.out.println("strY: " + strY);
// }
// if (isClassFound == false) {System.out.println("<ClassNotFound>\n>>Exiting
// Program...\r>>Program Ended");
// System.exit(0); ;
// }
return text; //Возвращаем полученный список классов
}
//-----------------------------------------------------------------------------------------------------------------------
// Запись методов в исходный файл (для одного класса)
public static void writeMethods(ArrayList<fieldInfo> fieldInfo, String className, ArrayList<String> codeList,
int replaceChoice) throws IOException {

fw = new FileWriter(className + ".txt", true); //Создаем файл "имя_класса.txt"

// Тестовый вывод куска класса для проверки
// for (String strY : codeList) {
// System.out.println("STR: " + strY);
// }

if (replaceChoice == 1) { // Если 1 - методы создадутся все (то есть с заменой)
writeEquals(fieldInfo, className); //Записываем методы equals
writeHash(fieldInfo, className); //Записываем методы hashCode
writeSet(fieldInfo, className, replaceChoice, codeList); //Записываем сеттеры
writeGet(fieldInfo, className, replaceChoice, codeList); //Записываем геттеры
} else { // Если не 1 - создадутся только те методы, которых нет в исходном коде
if (checkEquals(codeList)) //Если нет методов equals, то записываем
writeEquals(fieldInfo, className);// - WORKS
if (checkHashCode(codeList)) //Если нет методов hashCode, то записываем
writeHash(fieldInfo, className); // - WORKS
writeSet(fieldInfo, className, replaceChoice, codeList); //Записываем сеттеры
writeGet(fieldInfo, className, replaceChoice, codeList); //Записываем геттеры
}

fw.close(); //Закрываем запись в файл
}
//-----------------------------------------------------------------------------------------------------------------------
//Проверка на наличие метода equals
public static boolean checkEquals(ArrayList<String> codeList) {
for (String str : codeList) { //Перебираем все строчки кода из списка
if (str.toUpperCase().contains("EQUALS")) { //Если в строке есть equals...
return false; //...возвращаем false
}
}
return true; //иначе возвращаем true
}
//-----------------------------------------------------------------------------------------------------------------------
//Проверка на наличие метода hashCode (все так же, как и equals)
public static boolean checkHashCode(ArrayList<String> codeList) {
for (String str : codeList) {
if (str.toUpperCase().contains("HASHCODE")) {
return false;
}
}
return true;
}
//-----------------------------------------------------------------------------------------------------------------------
//Проверка на наличие ОДИНОЧНОГО get<Name> (Есть 2 поля и для одного из существует get, то проверка учтет это
//все так же, как и equals
public static boolean checkGet(ArrayList<String> codeList, fieldInfo fI) {
for (String str : codeList) {
if (str.toUpperCase().contains("GET" + fI.name.toUpperCase())) {
return false;
}
}
return true;

}
//-----------------------------------------------------------------------------------------------------------------------
//Проверка на наличие ОДИНОЧНОГО set<Name> (Есть 2 поля и для одного из сущ-ет set, то проверка учтет это
//все так же, как и equals
public static boolean checkSet(ArrayList<String> codeList, fieldInfo fI) {
for (String str : codeList) {
if (str.toUpperCase().contains("SET" + fI.name.toUpperCase())) {
return false;
}
}
return true;
}
//-----------------------------------------------------------------------------------------------------------------------
//Получение кода построчно для КЛАССА (Лист строк)
public static ArrayList<String> getCode(String fileName, String className) throws IOException {
ArrayList<String> text = new ArrayList<>(); //Список для хранения кода
// BufferedReader reader = new BufferedReader(new FileReader("testCode.java"));
BufferedReader reader = new BufferedReader(new FileReader(fileName));

boolean isClassFound = false; //Логическая переменная - класс найден или нет?
int check = 0;

while (reader.ready()) {
String str = reader.readLine(); //Читаем строку из файла
if (str.contains("public class ")) //Если в ней есть паблик класс, выходим
break;

if (str.contains("class " + className)) { //Если в ней есть класс, имя которого указано
//System.out.println("class className found");
isClassFound = true; //то класс найден
check++; // кол-во найденных классов увеличивается на 1
}
if (str.contains("class ") && !str.contains("class " + className)) {
//Если найден класс с другим именем, считаем, что класс не найден
isClassFound = false;
}
if (isClassFound) { //Если класс найден,
text.add(str); //добавляем в список считанную строку
}
}

if (check == 0) { //Если не найдено ни одного класса, то...
System.out.println("<ClassNotFound>\n>>Exiting Program...\r>>Program Ended");
System.exit(0); //...пишем об этом в консоли и выходим из программы
;
}
// for (int i = 0; i < text.size(); i++) {
// System.out.println("text[" + i + "]: " + text.get(i));
// }
reader.close(); //Закрываем ридер
return text; //Возвращаем полученный список
}
//-----------------------------------------------------------------------------------------------------------------------
//Найти Класс и Поля
public static ArrayList<fieldInfo> getClasses(ArrayList<String> text) {

ArrayList<fieldInfo> fieldInfo = new ArrayList<fieldInfo>(); //Список полей класса

boolean isClassEnded = false; //Флаг конца класса
int countOpen = 0; // Количество "{"
int countClose = 0; // Количество "}"
for (String str : text) { //Перебираем строчки кода
// System.out.println("Str.Lenght: " + str.length());
if (str.length() <= 1) { //Если строка пустая, или один символ, выходим из цикла
// System.out.println("Next Line Is Empty");
break;
}
if (str.contains("{")) { //Если в строке есть "{", увеличиваем их количество
countOpen++; //в переменной
} else if (str.contains("}")) { //Если в строке есть "}", увеличиваем их количество
countClose++; //в переменной
} else if (countOpen - countClose == 1 && checkField(str)) {

fieldInfo.add(getValue(str)); //Получаем имена и типы полей, добавляем в список
}

isClassEnded = countOpen == countClose; //Если количество фигурных скобок одинаково...
if (isClassEnded)
return fieldInfo; //Возвращаем список полей класса
}

return fieldInfo; //Возвращаем список полей класса
}
//-----------------------------------------------------------------------------------------------------------------------
//Получить имена и типы полей класса
public static fieldInfo getValue(String str) {
String[] value;
fieldInfo fI = new fieldInfo(null, null);

if (str.contains("=")) {
String[] eq = str.split("=");
value = eq[0].split(" ");
} else {
value = str.split(" ");
int k = value.length - 1;
String strQ = value[k];
value[k] = strQ.substring(0, strQ.length() - 1);
}

fI.name = value[value.length - 1].replaceAll("\t", "");
fI.type = value[value.length - 2].replaceAll("\t", "");

return fI;
}
//-----------------------------------------------------------------------------------------------------------------------
//Проверка строки на содержание поля
public static boolean checkField(String str) {
// Если строка пустая - false
if ("".equals(str))
return false;
// Если это комментарий - false
char first = str.trim().charAt(0);
if (first == '/' || first == '*') {
return false;
}
return true;
}
//-----------------------------------------------------------------------------------------------------------------------
//Создание и Запись Equals
public static void writeEquals(ArrayList<fieldInfo> fieldInfo, String className) throws IOException {
// FileWriter fw = new FileWriter(className + ".txt");
fw.write("//Метод Equals\r\n" + "\t@Override\r\n" + "\tpublic boolean equals(Object obj) {\r\n"
+ "\t\tif (this == obj)\r\n\t\t\treturn true;\r\n" +
// "\t\tif (!(o instanceof "+className+")) return false;\r\n"+
// "\r\n"+
// if (getClass() != obj.getClass()) return false;
"\t\tif (getClass() != obj.getClass())\r\n\t\t\treturn false;\r\n" +
// "\r\n"+
// "\t\t"+className+" "+className.toLowerCase()+" = ("+className+") o;\r\n"+
// "\r\n"
"");

for (fieldInfo fI : fieldInfo) {
// System.out.println("Type: [" + fI.type + "]" + " Name: [" + fI.name + "]");
if (fI.type.equals("int") || fI.type.equals("Integer") || fI.type.equals("byte") || fI.type.equals("long")
|| fI.type.equals("long") || fI.type.equals("char") || fI.type.equals("boolean")
|| fI.type.equals("String") || fI.type.equals("double")) {
fw.write("\t\tif (" + fI.type + " != " + className + "." + fI.type + ")\r\n\t\t\treturn false;\r\n");
}
}

fw.write("\treturn true;\r\n\t}\r\n");
System.out.println("-->>Equals for class <" + className + "> Has Been Written");
}
//-----------------------------------------------------------------------------------------------------------------------
//Создание и Запись hashCode
public static void writeHash(ArrayList<fieldInfo> fieldInfo, String className) throws IOException {
String hash = "";
for (fieldInfo fI : fieldInfo) {
if (fI.type.equals("int"))
hash += fI.name + " + ";
else if (fI.type.equals("String"))
hash += fI.name + ".length() + ";
else
hash += "(int) " + fI.name + " + ";
}
hash = hash.substring(0, hash.lastIndexOf(" + "));
fw.write("//Метод hashCode\r\n\t@Override\r\n" + "\tpublic int hashCode() {\r\n"
+ "\t\tfinal int prime = 31;\r\n" + "\t\tint hash = prime * (prime * " + hash + ");\r\n"
+ "\treturn hash;\r\n\t}\r\n");
System.out.println("-->>hashCode for class <" + className + "> Has Been Written");
}
//-----------------------------------------------------------------------------------------------------------------------
//Создание и Запись ОДИНОЧНОГО set<Name>
public static void writeSetOne(fieldInfo fI) throws IOException {
fw.write("\tpublic void set" + fI.name.substring(0, 1).toUpperCase() + fI.name.substring(1) + "(" + fI.type
+ " " + fI.name + ") {\r\n");
fw.write("\t\tthis." + fI.name + " = " + fI.name + ";\r\n\t}\r\n");
}
//-----------------------------------------------------------------------------------------------------------------------
//Создание и Запись всех set'ов класса
public static void writeSet(ArrayList<fieldInfo> fieldInfo, String className, int replaceChoice,
ArrayList<String> codeList) throws IOException {
fw.write("//Методы Set\r\n\t@Override\r\n");
for (fieldInfo fI : fieldInfo) {
if (replaceChoice == 1)
writeGetOne(fI);
else if (checkSet(codeList, fI))
writeSetOne(fI);
}
System.out.println("-->>Setters for class <" + className + "> Have Been Written");
}
//-----------------------------------------------------------------------------------------------------------------------
//Создание и Запись ОДИНОЧНОГО get<Name>
public static void writeGetOne(fieldInfo fI) throws IOException {
fw.write("\tpublic " + fI.type + " get" + fI.name.substring(0, 1).toUpperCase() + fI.name.substring(1)
+ "() {\r\n");
fw.write("\t\treturn this." + fI.name + ";\r\n\t}\r\n");
}
//-----------------------------------------------------------------------------------------------------------------------
//Создание и Запись всех get'ов класса
public static void writeGet(ArrayList<fieldInfo> fieldInfo, String className, int replaceChoice,
ArrayList<String> codeList) throws IOException {
fw.write("//Методы Get\r\n" + "\t@Override\r\n");
for (fieldInfo fI : fieldInfo) {
if (replaceChoice == 1)
writeGetOne(fI);
else if (checkGet(codeList, fI))
writeGetOne(fI);
}
System.out.println("-->>Getters for class <" + className + "> Have Been Written");
}
//================================================================================ ===========================================================
//Вставка в методов в файл

//================================================================================ ===========================================================
}