# Java Maintenance

> Java code maintenance standards including prioritization, refactoring triggers, and compliance verification

- Skill: `majiayu000/java-maintenance` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add majiayu000/java-maintenance`
- Raw SKILL.md: https://api.skillmd.com/api/skills/majiayu000/java-maintenance/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: majiayu000 (https://skillmd.com/u/majiayu000)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/majiayu000/java-maintenance

---


# Java Maintenance Skill

**EXECUTION MODE**: You are now executing this skill. DO NOT explain or summarize these instructions to the user. IMMEDIATELY begin the workflow below based on the task context.

Java code maintenance standards for identifying, prioritizing, and executing refactoring work. This skill covers compliance checking, maintenance prioritization, and refactoring triggers.

## Prerequisites

This skill applies to all Java projects requiring maintenance or refactoring.

## Workflow

### Step 1: Load Prioritization Framework

**CRITICAL**: Load this standard for any maintenance work.

```
Read: standards/maintenance-prioritization.md
```

This provides foundational rules for:
- High priority: API contract issues, code organization
- Medium priority: Method design, maintainability
- Low priority: Style and conventions

### Step 2: Load Additional Standards (As Needed)

**Refactoring Triggers** (load for code analysis):
```
Read: standards/refactoring-triggers.md
```

Use when: Identifying when code needs refactoring based on metrics and patterns.

**Compliance Checklist** (load for verification):
```
Read: standards/compliance-checklist.md
```

Use when: Verifying code meets all Java development standards.

## Key Rules Summary

### Priority Categories

**High Priority (API/Contract Issues)**
- Missing @NonNull annotations on public APIs
- Inconsistent null safety patterns
- Poor error handling
- Single Responsibility violations

**Medium Priority (Maintainability)**
- Long methods (>50 lines)
- High parameter counts (>4 without objects)
- High cyclomatic complexity (>15)
- Poor naming conventions

**Low Priority (Style)**
- Formatting inconsistencies
- Import organization
- Comment style variations

### Refactoring Triggers
```java
// TRIGGER: Method too long
// Refactor when method exceeds 50 lines

// TRIGGER: Too many parameters
// Refactor when method has >4 parameters
// Use parameter objects

// TRIGGER: High complexity
// Refactor when cyclomatic complexity >15
// Extract methods, use polymorphism
```

### Compliance Verification
```bash
# Run analysis
mvn verify -Pcode-analysis

# Check coverage
mvn jacoco:report

# Run Sonar
mvn sonar:sonar
```

## Related Skills

- `pm-dev-java:java-core` - Core Java patterns
- `pm-dev-java:junit-core` - Test coverage requirements
- `pm-dev-java:javadoc` - Documentation standards

## Standards Reference

| Standard | Purpose |
|----------|---------|
| maintenance-prioritization.md | Priority framework for refactoring |
| refactoring-triggers.md | Metrics and patterns triggering refactoring |
| compliance-checklist.md | Full standards compliance verification |