Why Clean Code Matters: Naming, Classes, Functions & Testing Best Practices

1. Why Keep Code Clean?

Untidy code reduces productivity over time, leading to hard-to-extend code, crashes, overtime, higher costs, and even company failure.

1.1 Start Clean from the Beginning

Write clean code from the start and refactor immediately; avoid "later" thinking.

later equal never

1.2 What Makes Code Clean?

High readability – code should read like prose.

Avoid duplicate code.

Follow design pattern principles.

Key principles include Single Responsibility, Open‑Closed, Liskov Substitution, Dependency Inversion, Interface Segregation, Law of Demeter, and Composite Reuse.

2. Naming

Good names improve readability, reduce understanding cost, and cut overtime.

2.1 Bad Naming Example

public interface Animal { void abc(); }

The method name abc conveys nothing.

2.2 Good Naming Example

public interface Animal { void cry(); }

Now the purpose is clear.

Inconsistent naming (e.g., queryAllStudent vs findOneById) should be standardized:

public interface StudentRepository extends JpaRepository<AlertAll, String> { Student findOneById(@Param "id") String id; List<Student> findAll(); }

Avoid redundant words in names; use clear prefixes like getXxx for single objects and listXxx for collections.

3. Classes

Clean classes should satisfy:

Single Responsibility

Open‑Closed Principle

High Cohesion

3.1 Single Responsibility

Classes should be small with only one reason to change, reducing complexity and improving maintainability.

How to determine if a class is small enough?

When a class has multiple duties, split it into separate classes.

public abstract class Sql { public abstract void insert(); public abstract void countInsert(); }

public abstract class CountSql { public abstract void countInsert(); }

3.2 Open‑Closed Principle

Software should be open for extension but closed for modification. Refactor to add new behavior via subclasses rather than changing existing code.

public abstract class Sql { public abstract void generate(); }

public class CreateSql extends Sql { @Override public void generate() { /* ... */ } }

3.3 Cohesion

High cohesion means methods operate on the same set of variables, forming a logical whole.

Why maintain high cohesion?

4. Functions

Clean functions should:

Do one thing

Have good names

Use clean parameters

Handle return values properly

4.1 Do One Thing

Refactor long functions into smaller steps.

public String upload() { check(); compress(); return "0"; }

4.2 Function Naming

Names must be descriptive. Bad example:

public String addCharacter(String originString, char ch);

Better examples:

public String appendCharacter(String originString, char ch);

public String insertCharacter(String originString, char ch, int position);

4.3 Parameters

Prefer few parameters; encapsulate many into objects.

public List<Student> findStudent(int age, String name, String country, int gender);

public List<Student> findStudent(Student student);

Avoid Boolean flags that create two code paths; split into separate methods.

render(Boolean isSuite);

renderForSuite(); renderForSingleTest();

Do not use output parameters; return results directly.

public void doSomething(Student student); // better than modifying passed object

4.4 Return Values

Separate commands from queries; use exceptions instead of error codes.

public void addElement(Element element); // command

public Boolean isAdd(Element element); // query

public void sendShutDown() { try { tryToShutDown(); } catch (DeviceShutDownError e) { logger.log(e); } }

5. Testing

Testing validates code correctness; test code should also be clean.

5.1 TDD

Test‑Driven Development writes tests before code, ensuring minimal code to pass tests.

5.2 FIRST Principles

Fast

Independent

Repeatable

Self‑validating

Timely

5.3 Test Code Patterns

Use given‑when‑then structure for readability.

@Test public void shouldReturnItemNameInUpperCase() { // Given Item mockedItem = new Item("it1", "Item 1", "This is item 1", 2000, true); when(itemRepository.findById("it1")).thenReturn(mockedItem); // When String result = itemService.getItemNameUpperCase("it1"); // Then verify(itemRepository, times(1)).findById("it1"); assertThat(result, is("ITEM 1")); }

5.4 Automated Test Generation

IDEA plugins such as Squaretest (paid) and TestMe (free) can generate test skeletons.

6. Conclusion

Writing clean code improves readability and extensibility, making maintenance easier.

Original source: https://www.cnblogs.com/liuboren/p/17017421.html