Improving Code Quality for Java Projects: Principles, Metrics, and Static Analysis Tools

We may have seen the image above about code quality, but how do we actually measure whether a piece of code is good or bad?

What is code quality and why does it matter? Just as writers organize their thoughts with chapters, headings, and paragraphs, developers use namespaces, classes, and methods; if they misuse these tools, the code becomes hard to read and understand.

Good code should exhibit a series of ideal traits:

Reliability: stable operation without frequent crashes.

Consistent style: adherence to language‑specific coding conventions and naming.

Maintainability: easy to understand, extend, and add new features.

Comprehensive testing: well‑tested code tends to have fewer bugs.

Efficiency: avoids unnecessary resource consumption.

Security: protects against vulnerabilities such as SQL injection.

Low technical debt: enables rapid development without being hindered by low‑quality, hard‑to‑maintain code.

The more of these characteristics a codebase possesses, the higher its quality, though project‑specific constraints may make some traits optional.

Delivering high‑quality code under tight deadlines is challenging, yet focusing on long‑term maintainability is crucial for sustaining consistent delivery speed.

Using static code analyzers to improve code quality

Compilers catch syntax errors but cannot detect issues like inconsistent structure, community‑derived best practices, or code complexity. Static analysis examines code before execution against a set of rules, flagging violations that can be integrated into build tools such as Gradle or Maven.

Checkstyle

Checkstyle is a static analysis tool that checks Java source code for compliance with coding standards. It focuses on the code’s appearance rather than its correctness.

Website: https://checkstyle.sourceforge.io/

Typical checks include:

Naming conventions for fields and methods

Number of method parameters

Maximum line length

Mandatory file header (e.g., copyright)

Import ordering and scope modifiers

Whitespace usage

Class constructor conventions

Complexity metrics

PMD

PMD (Programming Mistake Detector) is another static analyzer that reports potential problems in application code.

Website: https://pmd.github.io/

PMD can detect issues such as:

Possible bugs: empty try/catch/finally/switch blocks that swallow exceptions

Dead code: unused local variables, parameters, or private methods

Empty if/while statements

Overly complex expressions

Sub‑optimal code: wasteful use of String/StringBuffer

High cyclomatic complexity classes

Incorrect BigDecimal usage

CPD (Copy/Paste Detector)

CPD detects duplicated code using the Karp‑Rabin string‑matching algorithm, even in large codebases.

Website: https://pmd.sourceforge.io/pmd-4.2.5/cpd.html

It flags code blocks that exceed a configurable token count, helping avoid maintenance problems caused by copy‑and‑paste bugs.

Measuring code quality

Disclaimer: When a measure becomes a target, it ceases to be a good measure (Goodhart’s law).

Code coverage is one metric that can give confidence in quality, but one must be careful which tests are used. Unit tests verify that code does what developers intended and are the fastest validation method. Integration‑test coverage can also be valuable but should be reported separately from unit‑test coverage.

Toxicity Chart

The Toxicity Chart visualizes code “toxicity” per class, scoring based on parameters such as file length, method length, cyclomatic complexity, and nesting depth. It helps non‑technical stakeholders understand code quality.

Example project

The following GitHub repository contains a sample project that integrates all the mentioned tools, making it easy to select and adopt the ones you need:

https://github.com/singhalkul/java-quality-checks

Maintaining code quality is a continuous process that requires the whole team’s responsibility, not just a single individual.

Beyond tools, teams should adopt extreme programming practices such as pair programming, test‑driven development, code reviews, and continuous integration to ensure high‑quality code characteristics are present.

Original English article: https://medium.com/inspiredbrilliance/improving-code-quality-for-java-projects-5d24ad448109

Reference reading:

How to Build a Big Data Platform: From New Project to Maturity

Building a Proactive Team Culture: Encouraging Failure

Improving Team Code Ownership Model

Meituan Tech Team Booklist (General Skills)

Meitu Full‑Link Monitoring Practice

Article translated by High Availability Architecture; original technical content is welcome for submission via the WeChat public account menu.