Static Import

// ── Static import syntax: ────────────────────────────────────────────
import static java.lang.Math.PI;
import static java.lang.Math.sqrt;
import static java.lang.Math.pow;
import static java.lang.Math.abs;

// ── Without static import — verbose: ─────────────────────────────────
public double circleArea(double r) {
    return Math.PI * Math.pow(r, 2);
}

public double distance(double x1, double y1, double x2, double y2) {
    return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
}

// ── With static import — reads like mathematics: ──────────────────────
import static java.lang.Math.*;   // wildcard — all Math members

public double circleArea(double r) {
    return PI * pow(r, 2);        // cleaner — formula visible
}

public double distance(double x1, double y1, double x2, double y2) {
    return sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2));  // clear formula
}

// ── Static import for constants: ──────────────────────────────────────
import static java.util.concurrent.TimeUnit.SECONDS;
import static java.util.concurrent.TimeUnit.MILLISECONDS;

Thread.sleep(SECONDS.toMillis(5));    // SECONDS instead of TimeUnit.SECONDS

// ── JUnit 5 test with static imports: ────────────────────────────────
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

class OrderServiceTest {
    @Test
    void createOrder_shouldReturnOrderWithId() {
        Order order = service.createOrder("CUST-001", 99.99);
        assertNotNull(order);                    // not Assertions.assertNotNull
        assertNotNull(order.getId());
        assertEquals("CUST-001", order.getCustomerId());
        assertTrue(order.getTotal() > 0);
    }

    @Test
    void createOrder_invalidCustomer_shouldThrow() {
        assertThrows(CustomerNotFoundException.class,
            () -> service.createOrder("INVALID", 50.0));
    }
}

// ── Mockito with static imports: ─────────────────────────────────────
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.verify;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;

when(repository.findById(eq("ORD-001"))).thenReturn(Optional.of(order));
verify(repository).save(any(Order.class));

// ── GOOD uses of static import: ──────────────────────────────────────

// Math functions in formulae — clear and reduces noise:
import static java.lang.Math.*;
double hypotenuse = sqrt(pow(a, 2) + pow(b, 2));
double area       = PI * pow(radius, 2);

// JUnit assertions — standard test API, names are universally known:
import static org.junit.jupiter.api.Assertions.*;
assertEquals(expected, actual);
assertNotNull(result);
assertThrows(IllegalArgumentException.class, () -> method());

// Commonly used enum constants:
import static java.nio.file.StandardOpenOption.*;
Files.writeString(path, content, CREATE, TRUNCATE_EXISTING);

// ── BAD uses of static import: ────────────────────────────────────────

// Constants whose meaning depends on knowing the class:
import static com.example.order.OrderStatus.*;

// These are confusing without the class prefix:
if (status == ACTIVE) { ... }       // ACTIVE? From where? What class?
if (status == PENDING) { ... }      // Unclear without reading the import

// Better — keep the class prefix for clarity:
if (status == OrderStatus.ACTIVE) { ... }    // immediately clear
if (status == OrderStatus.PENDING) { ... }

// Wildcard static import from unknown utility class:
import static com.example.util.StringUtils.*;

// Reader cannot tell which class validate(), format(), truncate() come from:
String cleaned = validate(format(truncate(input)));   // confusing

// Better — either use static import for one specific, heavily used method:
import static com.example.util.StringUtils.validate;
// or use the class name for clarity:
String cleaned = StringUtils.validate(StringUtils.format(input));

// ── Summary — when to use: ────────────────────────────────────────────
//
// ✓ java.lang.Math constants and functions in mathematical code
// ✓ JUnit assertion methods in test classes
// ✓ Mockito matcher and verification methods in test classes
// ✓ Well-known enum constants where the context is unambiguous
// ✓ A few heavily used static members from one class
//
// ✗ General utility class methods where class name adds clarity
// ✗ Constants whose meaning is not obvious from name alone
// ✗ Wildcard import from obscure or unfamiliar classes
// ✗ When the unqualified name could be confused with a local variable