public void displayClass() {
    System.out.println("############################################");
    System.out.println("(" + this.getClassName() + ")");
    if (this.getExtendsFrom() != null && this.getExtendsFrom().size() != 0) {
      System.out.println("__________________");
      System.out.print("extends from ");
      for (String string : this.getExtendsFrom()) {
        System.out.println(string);
      }
    }
    if (this.getClassAttributes() != null && this.getClassAttributes().size() != 0) {
      System.out.println("________Attributes________");
      for (ClassAttribute attribute : this.getClassAttributes()) {
        System.out.println(
            attribute.getAccessModifier()
                + attribute.getAttributeName()
                + ":"
                + attribute.getAttributeType());
      }
    }
    if (this.getClassMethods() != null && this.getClassMethods().size() != 0) {
      System.out.println("_________Methods_________");
      String parameterStr = "";
      for (ClassMethod classMethod : this.getClassMethods()) {
        ArrayList<MethodParameter> parameters = classMethod.getRealParameters();
        if (parameters != null && parameters.size() != 0) {
          for (MethodParameter parameter : parameters) {
            parameterStr +=
                parameter.getParameterName() + ":" + parameter.getParameterType() + ", ";
          }
          parameterStr = parameterStr.substring(0, parameterStr.length() - 1 - 1);
        }

        System.out.println(
            classMethod.getMethodModifier()
                + classMethod.getMethodName()
                + " : "
                + classMethod.getMethodReturnType()
                + " ("
                + parameterStr
                + ")");
      }
    }
    if (this.getClassRelations() != null && this.getClassRelations().size() != 0) {
      System.out.println(
          "_________Relations__________" + this.getRelationList().getRelations().size());
      for (ClassRelation relation : this.getRelationList().getRelations()) {
        System.out.println(className + relation.getRelationship() + relation.getTargetClass());
      }
    }
  }
 public void convertUMLClassDetail() {
   setUMLClassDetail("[");
   if (UMLClassName == "") {
     return;
   }
   if (isInterface) {
     setUMLClassDetail(getUMLClassDetail() + "%C2%ABInterface%C2%BB;");
   }
   setUMLClassDetail(getUMLClassDetail() + this.className);
   // add attributes
   if (this.classAttributes != null && this.classAttributes.size() != 0) {
     setUMLClassDetail(getUMLClassDetail() + "|");
     for (ClassAttribute classAttribute : classAttributes) {
       String attributeStr = "";
       attributeStr =
           classAttribute.getAccessModifier()
               + classAttribute.getAttributeName()
               + ":"
               + classAttribute.getAttributeType()
               + ";";
       setUMLClassDetail(getUMLClassDetail() + attributeStr);
     }
   }
   // add methods
   if (this.classMethods != null && this.classMethods.size() != 0) {
     setUMLClassDetail(getUMLClassDetail() + "|");
     for (ClassMethod method : classMethods) {
       String methodStr = "";
       String methodAttriStr = "";
       if (method.getRealParameters() != null && method.getRealParameters().size() != 0) {
         for (MethodParameter methodParameter : method.getRealParameters()) {
           String methodPara = methodParameter.getParameterType();
           // If parameter's type is array, it will be changed into (*)
           if (methodPara.toString().contains("[]")) {
             methodAttriStr +=
                 methodParameter.getParameterName()
                     + ":"
                     + methodPara.substring(0, methodPara.indexOf('['))
                     + "(*)";
           } else {
             methodAttriStr +=
                 methodParameter.getParameterName() + ":" + methodParameter.getParameterType();
           }
         }
         methodStr =
             method.getMethodModifier()
                 + method.getMethodName()
                 + "("
                 + methodAttriStr
                 + ")"
                 + ":"
                 + method.getMethodReturnType()
                 + ";";
         setUMLClassDetail(getUMLClassDetail() + methodStr);
       } else {
         methodStr =
             method.getMethodModifier()
                 + method.getMethodName()
                 + "("
                 + methodAttriStr
                 + ")"
                 + ":"
                 + method.getMethodReturnType()
                 + ";";
         setUMLClassDetail(getUMLClassDetail() + methodStr);
       }
     }
   }
   setUMLClassDetail(getUMLClassDetail() + "],");
 }
 /**
  * Looking for dependencies in attributes
  *
  * @param allClasses
  */
 public void alterAttributeList(ArrayList<RealClass> allClasses) {
   if (this.classAttributes == null || this.classAttributes.size() == 0) {
     return;
   }
   ClassRelation relation = null;
   ClassAttribute classAttribute = null;
   ArrayList<Integer> removeMethodIndex = new ArrayList<Integer>();
   ArrayList<Integer> removeAttributeIndex = new ArrayList<Integer>();
   for (int i = 0; i < classAttributes.size(); i++) {
     classAttribute = classAttributes.get(i);
     String type = classAttribute.getAttributeType();
     // Do nothing when type is primitive type or String type
     // Add relation into classRelations and delete this attribute when type contains Collection<>
     Pattern pattern = Pattern.compile("Collection<.*>", Pattern.CASE_INSENSITIVE);
     Matcher m = pattern.matcher(type);
     if (m.matches()) {
       int beginIndex = type.indexOf('<'); // Get the type out of string
       int endIndex = type.indexOf('>');
       String tempType = type.substring(beginIndex + 1, endIndex);
       // under the requirement, no need for checking if type is in the class list
       relation = new ClassRelation(this.getClassName(), tempType, RelatinType.OneToMany);
       this.classRelations.add(relation);
       // Delete the attribute
       removeAttributeIndex.add(i);
       relation = null;
     }
     // Arrays: [] --> (*)
     else if (type.contains("[]")) {
       int openIndex = type.indexOf('[');
       type = type.substring(0, openIndex);
       type += "(*)";
       classAttribute.setAttributeType(type);
     }
     // Other situation(simple declaration)
     else if (classList.contains(type)) {
       relation = new ClassRelation(this.getClassName(), type, RelatinType.OneToOne);
       this.classRelations.add(relation);
       // Attributes can not be deleted during the loop
       removeAttributeIndex.add(i);
       relation = null;
     }
     // If Getter and Setter of a attribute are found
     // This attribute should become public
     // Getter and Setter should be deleted
     else if (classAttribute.getAccessModifier() == "-") {
       String getter = "get" + classAttribute.getAttributeName();
       String setter = "set" + classAttribute.getAttributeName();
       // Find the indexes of getter and setter in method list
       int getterIndex = -1;
       int setterIndex = -1;
       for (int index = 0; index < this.classMethods.size(); index++) {
         if (this.classMethods.get(index).getMethodName().toLowerCase().contentEquals(getter)) {
           getterIndex = index;
         } else if (this.classMethods
             .get(index)
             .getMethodName()
             .toLowerCase()
             .contentEquals(setter)) {
           setterIndex = index;
         }
       }
       // Can not delete method within this loop
       // Mark the indexes, delete them after loop is end
       if (getterIndex != -1 && setterIndex != -1) {
         removeMethodIndex.add(getterIndex);
         removeMethodIndex.add(setterIndex);
         classAttribute.setAccessModifier("+");
       }
     }
     // If it's protected, remove it
     else if (classAttribute.getAccessModifier() == "#") {
       removeAttributeIndex.add(i);
     }
   }
   // Delete those attributes
   for (int j = removeAttributeIndex.size() - 1; j >= 0; j--) {
     classAttributes.remove((int) removeAttributeIndex.get(j));
   }
   // Delete the getter and setter
   for (int j = removeMethodIndex.size() - 1; j >= 0; j--) {
     classMethods.remove((int) removeMethodIndex.get(j));
   }
 }