q1 and q2 half

[Singhal-vishal]

No description provided.

[TanOfAllCodes]

Suggest breaking a large function that does too many things into many smaller functions, each doing one thing.

Example: Instead of using getUserInput() where all parameters are input, the function can be divided into inputName() inputAge() inputAddress() inputCourses()

Have a standard way of structuring the verification - example: ideally for Every parameter, there is verification.

So restructuring this function

getUserInput()
-> getName() which internally calls validateNameInput()
-> getCourses() which internally calls validateCoursesInput()
etc.

And a good naming convention will improve Quality of Code and Maintainability.

So each of the above functions should have their own function for Validation. Abstract the utility of functions from each other.

[TanOfAllCodes]

Here's an example of a more structured approach implementing the above idea.

// Global Variable Messages are a good idea.
final private static String GET_NAME_MESSAGE = "Enter The Username"

User getName(){
System.out.println(GET_NAME_MESSAGE);
input = scan.nextLine();

            if (validateNameInput(input)){
            user.setName(name) ; 
            }
            else { 
            // ERROR LOGIC
            }

}
validateNameInput(){
// VALIDATION CODE
}

[TanOfAllCodes]

Using Braces for blocks of code that belong together and Correct Indentation are nice for maintainability even if not required by the language.

[TanOfAllCodes]

always use fully self-explanatory variable names

[TanOfAllCodes]

Use OOPs more effectively here -> Create Objects of Classes and call functions as functions of these Objects, instead of using Functions Directly. This allows you to fully utilise the advantages of OOPs. Understand the value of using Singleton pattern cases as well.

[TanOfAllCodes]

Instead of sending the Entire Object as parameter, attempt to use the most primitive possible data types that makes sense to have to reduce the complexity of your functions.

Example: Here we use calculateTax(Item item) { String type=item.getType(); }
Instead, we can use calculateTax(String type) { }
The first method passes an entire object. Ex calling statement: calculateTax(item)
The second only passes the String. Ex calling statement:calculateTax(item.getType())

Many such similar Optimizations can be found.
This also implies that the function is at the most fundamental level in terms of solving a problem.

[TanOfAllCodes]

Use better variable names that are self documenting so it's clear why they are being used

[TanOfAllCodes]

Use of explicit Getters, Setters, Default Values are a good idea.

[TanOfAllCodes]

Learn to use Command Line Arguments for Console App -> Learn about Shell Input to Java Application