Java OOP Concepts Every Spring Developer Must Master (With Real Code Examples)

// You write this — a plain Java class with an annotation
@Service
public class OrderService {
private final OrderRepository orderRepository;

// Spring calls this constructor automatically (constructor injection)
public OrderService(OrderRepository orderRepository) {
    this.orderRepository = orderRepository;
}

public Order placeOrder(OrderRequest request) {
    Order order = new Order();
    order.setUserId(request.getUserId());
    order.setTotal(request.getTotal());
    order.setStatus("PENDING");
    return orderRepository.save(order);
}
}
// Spring does this internally at startup — equivalent to:
OrderService orderService = new OrderService(orderRepository);
// Then stores it and injects it wherever @Autowired or constructor injection is used

@Entity
@Table(name = "users")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;         // private — access controlled

private String email;    // private — exposed only via getter
private String password; // private — NO getter exposed
private boolean active;

// Controlled access — Hibernate uses these for mapping
public Long    getId()      { return id; }
public String  getEmail()   { return email; }
public boolean isActive()   { return active; }

public void setEmail(String email)    { this.email = email; }
public void setActive(boolean active) { this.active = active; }

// Password setter exists — but NO getPassword()
// Spring Security's PasswordEncoder handles password access
public void setPassword(String password) { this.password = password; }
}

// INHERITANCE — extends gives you 20+ methods for free
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
    // findById, findAll, save, delete — all inherited from JpaRepository
}
// COMPOSITION — inject dependencies, don't inherit them
@Service
public class OrderService {
// Composed with UserRepository and EmailService — not inheriting them
private final UserRepository userRepository;
private final EmailService   emailService;

public OrderService(UserRepository userRepo, EmailService emailSvc) {
    this.userRepository = userRepo;
    this.emailService   = emailSvc;
}

public void confirmOrder(Long userId, Order order) {
    User user = userRepository.findById(userId)
        .orElseThrow(() -> new UserNotFoundException(userId));
    emailService.sendConfirmation(user.getEmail(), order);
}
}

// Step 1: Define the interface — the contract
public interface NotificationService {
    void send(String recipient, String message);
    boolean isAvailable();
}
// Step 2: Email implementation
@Service
@Primary // Spring uses this by default when multiple implementations exist
public class EmailNotificationService implements NotificationService {
@Override
public void send(String recipient, String message) {
    // Send via email provider
}

@Override
public boolean isAvailable() { return true; }
}
// Step 3: SMS implementation
@Service
@Qualifier("sms")
public class SmsNotificationService implements NotificationService {
@Override
public void send(String recipient, String message) {
    // Send via SMS gateway
}

@Override
public boolean isAvailable() { return true; }
}
// Step 4: Controller injects the INTERFACE — not a concrete class
@RestController
public class AlertController {
private final NotificationService notificationService; // interface type

public AlertController(NotificationService notificationService) {
    this.notificationService = notificationService;
    // Spring injects EmailNotificationService (marked @Primary)
    // Swap to SmsNotificationService with @Qualifier("sms") — zero code change
}
}

// Same interface — two different behaviours
public interface PaymentGateway {
    PaymentResult process(PaymentRequest request);
}
@Service
@Profile("production") // Active in production environment
public class StripeGateway implements PaymentGateway {
@Override
public PaymentResult process(PaymentRequest request) {
// Real Stripe API call
return stripeClient.charge(request);
}
}
@Service
@Profile("development") // Active in dev — no real charges
public class MockPaymentGateway implements PaymentGateway {
@Override
public PaymentResult process(PaymentRequest request) {
return PaymentResult.success("mock-tx-id-12345");
}
}
// Service uses the interface — Spring injects the right one per environment
@Service
public class CheckoutService {
private final PaymentGateway paymentGateway; // polymorphic reference

public CheckoutService(PaymentGateway paymentGateway) {
    this.paymentGateway = paymentGateway;
}

public Order checkout(Cart cart) {
    PaymentResult result = paymentGateway.process(cart.toPaymentRequest());
    // Works identically in dev (mock) and production (Stripe)
    return orderService.createFromCart(cart, result);
}
}

// ─── ENCAPSULATION: Entity with private fields ────────────────
@Entity
public class User {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String email;
    private String role;
public Long   getId()    { return id; }
public String getEmail() { return email; }
public String getRole()  { return role; }
public void   setEmail(String e) { this.email = e; }
public void   setRole(String r)  { this.role = r; }
}
// ─── INHERITANCE: Repository inherits 20+ methods ─────────────
public interface UserRepository extends JpaRepository<User, Long> {
Optional<User> findByEmail(String email);
}
// ─── ABSTRACTION: Interface defines the contract ───────────────
public interface UserService {
User       createUser(String email, String role);
User       findByEmail(String email);
List<User> getAllUsers();
}
// ─── CLASSES + COMPOSITION: Service implements & composes ──────
@Service
public class UserServiceImpl implements UserService {
private final UserRepository userRepo; // composed — not inherited

public UserServiceImpl(UserRepository userRepo) {
    this.userRepo = userRepo;
}

@Override
public User createUser(String email, String role) {
    User user = new User();
    user.setEmail(email);
    user.setRole(role);
    return userRepo.save(user);
}

@Override
public User findByEmail(String email) {
    return userRepo.findByEmail(email)
        .orElseThrow(() -> new RuntimeException("User not found"));
}

@Override
public List<User> getAllUsers() { return userRepo.findAll(); }
}
// ─── POLYMORPHISM: Controller uses interface, not impl ─────────
@RestController
@RequestMapping("/api/users")
public class UserController {
private final UserService userService; // polymorphic — interface type

public UserController(UserService userService) {
    this.userService = userService;
    // Spring injects UserServiceImpl — controller doesn't know or care
}

@PostMapping
public ResponseEntity<User> create(@RequestBody CreateUserRequest req) {
    return ResponseEntity.ok(userService.createUser(req.getEmail(), req.getRole()));
}

@GetMapping
public List<User> getAll() { return userService.getAllUsers(); }
}