fixed checkstyle warnings

Author: darkhyper24

bloC/Readme.md

@@ -54,16 +54,16 @@ The `State` class holds the representation of the state of the application that
 ```java
 package com.iluwatar.bloc;
 
+import lombok.Getter;
+
+@Getter
 public class State {
     private final int value;
 
     public State(int value) {
         this.value = value;
     }
 
-    public int getValue() {
-        return value;
-    }
 }
 ```
 The `ListenerManager` interface manages the basic operations for the listeners and is implemented by bloc class

bloC/src/main/java/com/iluwatar/bloc/Bloc.java

@@ -1,45 +1,80 @@
 package com.iluwatar.bloc;
+
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
+/**
+ * The Bloc class is responsible for managing the current state and notifying registered listeners
+ * whenever the state changes. It implements the ListenerManager interface, allowing listeners
+ * to be added, removed, and notified of state changes.
+ */
 public class Bloc implements ListenerManager<State> {
+
   private State currentState;
   private final List<StateListener<State>> listeners = new ArrayList<>();
 
+  /**
+   * Constructs a new Bloc instance with an initial state of value 0.
+   */
   public Bloc() {
     this.currentState = new State(0);
   }
 
+  /**
+   * Adds a listener to receive state change notifications.
+   *
+   * @param listener the listener to add
+   */
   @Override
   public void addListener(StateListener<State> listener) {
     listeners.add(listener);
     listener.onStateChange(currentState);
   }
 
+  /**
+   * Removes a listener from receiving state change notifications.
+   *
+   * @param listener the listener to remove
+   */
   @Override
   public void removeListener(StateListener<State> listener) {
     listeners.remove(listener);
   }
 
+  /**
+   * Returns an unmodifiable list of all registered listeners.
+   *
+   * @return an unmodifiable list of listeners
+   */
   @Override
   public List<StateListener<State>> getListeners() {
     return Collections.unmodifiableList(listeners);
   }
 
+  /**
+   * Emits a new state and notifies all registered listeners of the change.
+   *
+   * @param newState the new state to emit
+   */
   private void emitState(State newState) {
     currentState = newState;
     for (StateListener<State> listener : listeners) {
       listener.onStateChange(currentState);
     }
   }
 
+  /**
+   * Increments the current state value by 1 and notifies listeners of the change.
+   */
   public void increment() {
     emitState(new State(currentState.getValue() + 1));
   }
 
+  /**
+   * Decrements the current state value by 1 and notifies listeners of the change.
+   */
   public void decrement() {
     emitState(new State(currentState.getValue() - 1));
   }
 }
-

bloC/src/main/java/com/iluwatar/bloc/ListenerManager.java

@@ -1,9 +1,32 @@
 package com.iluwatar.bloc;
 import java.util.List;
 
+/**
+ * Interface for managing listeners for state changes.
+ *
+ * @param <T> The type of state to be handled by the listeners.
+ */
+
 public interface ListenerManager<T> {
+
+  /**
+   * Adds a listener that will be notified of state changes.
+   *
+   * @param listener the listener to be added
+   */
   void addListener(StateListener<T> listener);
+
+  /**
+   * Removes a listener so that it no longer receives state change notifications.
+   *
+   * @param listener the listener to be removed
+   */
   void removeListener(StateListener<T> listener);
+
+  /**
+   * Returns a list of all listeners currently registered for state changes.
+   *
+   * @return a list of registered listeners
+   */
   List<StateListener<T>> getListeners();
 }
-

bloC/src/main/java/com/iluwatar/bloc/Main.java

@@ -1,45 +1,74 @@
 package com.iluwatar.bloc;
-import javax.swing.*;
-import java.awt.*;
+import java.awt.BorderLayout;
+import java.awt.Font;
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.SwingConstants;
+import javax.swing.WindowConstants;
 
-public class Main
-{
-  public static void main(String[] args)
-  {
-    Bloc bloC = new Bloc();
+
+
+
+/**
+ * The Main class demonstrates the use of the Bloc pattern in a simple GUI application.
+ * It creates a JFrame with buttons to increment, decrement, and toggle a listener
+ * that updates the counter value on the screen.
+ */
+public class Main {
+
+  /**
+   * The entry point of the application. Initializes the GUI and sets up actions
+   * for the buttons and listener management.
+   *
+   * @param args command-line arguments (not used in this example)
+   */
+  public static void main(String[] args) {
+    // Create a Bloc instance to manage the state
+
+
+    // Create and set up the JFrame
     JFrame frame = new JFrame("BloC example");
     frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
     frame.setSize(400, 300);
+
+    // Create a label to display the counter value
     JLabel counterLabel = new JLabel("Counter: 0", SwingConstants.CENTER);
     counterLabel.setFont(new Font("Arial", Font.BOLD, 20));
+
+    // Create buttons for increment, decrement, and toggling listener
     JButton incrementButton = new JButton("Increment");
     JButton decrementButton = new JButton("Decrement");
     JButton toggleListenerButton = new JButton("Disable Listener");
+
+    // Set layout and add components to the frame
     frame.setLayout(new BorderLayout());
     frame.add(counterLabel, BorderLayout.CENTER);
     frame.add(incrementButton, BorderLayout.NORTH);
     frame.add(decrementButton, BorderLayout.SOUTH);
     frame.add(toggleListenerButton, BorderLayout.EAST);
-
+    Bloc bloC = new Bloc();
+    // Create a state listener to update the counter label when the state changes
     StateListener<State> stateListener = state -> counterLabel.setText("Counter: " + state.getValue());
 
+    // Add the listener to the Bloc instance
     bloC.addListener(stateListener);
 
-    toggleListenerButton.addActionListener(e ->
-    {
-      if (bloC.getListeners().contains(stateListener))
-      {
+    // Set action listeners for buttons
+    toggleListenerButton.addActionListener(e -> {
+      if (bloC.getListeners().contains(stateListener)) {
         bloC.removeListener(stateListener);
         toggleListenerButton.setText("Enable Listener");
-      } else
-      {
+      } else {
         bloC.addListener(stateListener);
         toggleListenerButton.setText("Disable Listener");
       }
-    }
-    );
+    });
+
     incrementButton.addActionListener(e -> bloC.increment());
     decrementButton.addActionListener(e -> bloC.decrement());
+
+    // Make the frame visible
     frame.setVisible(true);
   }
 }

bloC/src/main/java/com/iluwatar/bloc/State.java

@@ -1,15 +1,27 @@
 package com.iluwatar.bloc;
 
-public class State
-{
+import lombok.Getter;
+
+/**
+ * The {@code State} class represents a state with an integer value.
+ * This class encapsulates the value and provides methods to retrieve it.
+ */
+@Getter
+public class State {
+  /**
+   * -- GETTER --
+   *  Returns the value of the state.
+   *
+   */
   private final int value;
 
-  public State(int value)
-  {
+  /**
+   * Constructs a {@code State} with the specified value.
+   *
+   * @param value the value of the state
+   */
+  public State(int value) {
     this.value = value;
   }
-  public int getValue()
-  {
-    return value;
-  }
+
 }

bloC/src/main/java/com/iluwatar/bloc/StateListener.java

@@ -1,6 +1,17 @@
 package com.iluwatar.bloc;
 
-public interface StateListener<T>
-{
+/**
+ * The {@code StateListener} interface defines the contract for listening to state changes.
+ * Implementations of this interface should handle state changes and define actions to take when the state changes.
+ *
+ * @param <T> the type of state that this listener will handle
+ */
+public interface StateListener<T> {
+
+  /**
+   * This method is called when the state has changed.
+   *
+   * @param state the updated state
+   */
   void onStateChange(T state);
 }