Advanced Classes

// declare the enum — like a class but for a fixed set of values
public enum RobotState {
    DISABLED, TELEOP, AUTO, TEST
}

// using it — type is RobotState, value must be one of the four
RobotState state = RobotState.TELEOP;

// comparing with == — no .equals() needed for enums!
if (state == RobotState.TELEOP) {
    System.out.println("running teleop");
}

// this won't even compile — that's the whole point
// RobotState bad = "TELEOP";   <-- compile error, good!
// RobotState bad = 1;          <-- compile error, also good!

RobotState state = RobotState.TELEOP;

switch (state) {
    case TELEOP:
        runTeleopCode();
        break;
    case AUTO:
        runAutoCode();
        break;
    case DISABLED:
        stop();
        break;
    default:
        stop();
}

// BAD: nothing stops invalid values from getting in
private String m_mode = "IDLE";

public void setMode(String mode) {
    m_mode = mode; // what if someone passes "idle"? or "IDEL"? or "auto "?
                   // no error, no warning. silent bug.
}

if (m_mode == "TELEOP") { // comparing strings with == is wrong anyway
    runTeleop();           // this might never run even if mode IS "TELEOP"
}

// GOOD: the compiler enforces every value
public enum Mode { IDLE, TELEOP, AUTO, DISABLED }

private Mode m_mode = Mode.IDLE;

public void setMode(Mode mode) {
    m_mode = mode; // only valid Mode values can be passed — period
}

if (m_mode == Mode.TELEOP) { // == works correctly for enums
    runTeleop();
}

public enum RobotState {
    DISABLED, TELEOP, AUTO, TEST;  // semicolon required when you add methods

    // helper method — call as state.isActive()
    public boolean isActive() {
        return this == TELEOP || this == AUTO || this == TEST;
    }

    // another useful pattern: human-readable label for logging
    public String getLabel() {
        switch (this) {
            case TELEOP:   return "Teleop";
            case AUTO:     return "Autonomous";
            case DISABLED: return "Disabled";
            default:       return "Test";
        }
    }
}

// usage
RobotState state = RobotState.TELEOP;
if (state.isActive()) {
    System.out.println("Robot is running: " + state.getLabel()); // "Robot is running: Teleop"
}

public enum ArmState {
    STOWED, INTAKING, SCORING, CLIMBING
}

public class ArmSubsystem extends SubsystemBase {

    // current state lives as a field — m_ prefix because it's a member var
    private ArmState m_state = ArmState.STOWED;

    // command calls this to request a state change
    public void setState(ArmState newState) {
        m_state = newState;
    }

    // runs every 20ms — switch drives all behavior
    @Override
    public void periodic() {
        switch (m_state) {
            case INTAKING:  moveToIntakePos();  break;
            case SCORING:   moveToScorePos();   break;
            case CLIMBING:  moveToClimbPos();   break;
            default:        holdPosition();     // STOWED — hold where we are
        }
    }

    // expose state for other subsystems or dashboard
    public ArmState getState() { return m_state; }
}

// ARRAY: exactly 4 swerve modules (each of the 4 wheel assemblies on a swerve robot — each one can drive and steer independently), always exactly 4 — fixed forever
int[] kModuleCanIDs = {1, 2, 3, 4}; // CAN ID — each motor on the robot needs a unique number so the code knows which one to talk to

// ARRAYLIST: unknown number of vision targets — changes every frame
ArrayList<String> detectedTargets = new ArrayList<>();

// ARRAY: exactly 3 PID constants — fixed (kP = how aggressively to correct error, kI = correction for persistent error, kD = dampens overshooting)
double[] kPIDConstants = {0.5, 0.0, 0.1};

// ARRAYLIST: log of recent state transitions — grows over time
ArrayList<String> m_stateLog = new ArrayList<>();

// this import is REQUIRED — without it you get "cannot find symbol"
import java.util.ArrayList;

// ArrayList<String> means "a list that holds Strings"
ArrayList<String> names = new ArrayList<>();

// the <> on the right is the diamond operator — Java infers the type
// you could write new ArrayList<String>() but <> is cleaner and preferred

// ArrayList of integers (note: Integer, not int — covered in topic 3)
ArrayList<Integer> motorIDs = new ArrayList<>();

// starting with some items — use add() after creation
ArrayList<String> subsystems = new ArrayList<>();
subsystems.add("Drivetrain");
subsystems.add("Shooter");
subsystems.add("Intake");

ArrayList<String> subsystems = new ArrayList<>();

// add() — appends to the end of the list
subsystems.add("Drivetrain");   // list: [Drivetrain]
subsystems.add("Shooter");      // list: [Drivetrain, Shooter]
subsystems.add("Intake");       // list: [Drivetrain, Shooter, Intake]

// get() — access by index, zero-based just like arrays
String first = subsystems.get(0);  // "Drivetrain"
String second = subsystems.get(1); // "Shooter"

// size() — how many elements are currently in the list
int count = subsystems.size();    // 3

// contains() — checks if a value is in the list
boolean hasShooter = subsystems.contains("Shooter"); // true
boolean hasDrive   = subsystems.contains("Climber"); // false

// remove(object) — removes the first matching element
subsystems.remove("Intake");     // list: [Drivetrain, Shooter]
System.out.println(subsystems.size());      // 2

// isEmpty() — true if list has zero elements
System.out.println(subsystems.isEmpty());  // false

// clear() — removes everything from the list
subsystems.clear();
System.out.println(subsystems.size());      // 0
System.out.println(subsystems.isEmpty());  // true

ArrayList<String> subsystems = new ArrayList<>();
subsystems.add("Drivetrain");
subsystems.add("Shooter");
subsystems.add("Intake");

// for-each: same as with arrays — element type, variable name, list
for (String name : subsystems) {
    System.out.println("active: " + name);
}
// active: Drivetrain
// active: Shooter
// active: Intake

// you can also use a regular index-based for loop if you need the index
for (int i = 0; i < subsystems.size(); i++) {
    System.out.println(i + ": " + subsystems.get(i));
}
// 0: Drivetrain
// 1: Shooter
// 2: Intake

ArrayList<Integer> ids = new ArrayList<>();
ids.add(10);
ids.add(20);
ids.add(30);

// this removes the element AT INDEX 1 (which is 20), not the value 1!
ids.remove(1); // list is now [10, 30] — might not be what you wanted

// to remove the value 10 specifically, wrap it in Integer.valueOf()
ids.remove(Integer.valueOf(10)); // now removes the value 10, not index 10

// for String lists this isn't an issue because String != int
ArrayList<String> names = new ArrayList<>();
names.add("Alice");
names.remove("Alice"); // unambiguous: removes the value "Alice"

import java.util.ArrayList;

ArrayList<Integer> motorIDs = new ArrayList<>();

// autoboxing: int literal 5 is automatically wrapped into Integer(5)
motorIDs.add(5);   // you write int, Java stores Integer — transparent
motorIDs.add(12);
motorIDs.add(3);

// unboxing: Integer from the list is automatically unwrapped to int
int first = motorIDs.get(0); // Java unboxes Integer → int automatically
System.out.println(first);  // 5

// doubles work the same way
ArrayList<Double> speeds = new ArrayList<>();
speeds.add(0.75);    // autoboxed: double → Double
speeds.add(-1.0);
double s = speeds.get(0); // unboxed: Double → double
System.out.println(s);   // 0.75

// parseInt / parseDouble — convert Strings to numbers
// used constantly for reading config values, dashboard input, etc.
int    port  = Integer.parseInt("5800");    // int 5800
double speed = Double.parseDouble("0.75");  // double 0.75

// parse fails loudly if the string isn't a valid number
// Integer.parseInt("abc") throws NumberFormatException — good to know

// MAX_VALUE / MIN_VALUE — boundary constants
int biggest  = Integer.MAX_VALUE;  // 2147483647 (2^31 - 1)
int smallest = Integer.MIN_VALUE;  // -2147483648

// toString — convert number to String
String s  = Integer.toString(42);   // "42"
String sd = Double.toString(3.14); // "3.14"

// valueOf — explicitly create a wrapper object from a primitive
Integer boxed = Integer.valueOf(99); // explicit boxing (autoboxing does this for you normally)

// BAD: unboxing null crashes at runtime
Integer val = null; // Integer is an object — null is valid here

int x = val; // NullPointerException! Java tries to call val.intValue()
             // but val IS null — you can't call methods on null

// ─────────────────────────────────────────────────────────────────
// SAFE pattern: null-check before unboxing
Integer maybeNull = getSomeValueThatMightBeNull();

if (maybeNull != null) {
    int safe = maybeNull; // only unbox when you know it's not null
    doSomething(safe);
} else {
    handleMissingValue();
}

// or use a default with a ternary
int withDefault = (maybeNull != null) ? maybeNull : 0;

import java.util.ArrayList;

public enum GamePiece { CONE, CUBE, NONE }

public class PieceTracker {

    // ArrayList of enum values — tracks pieces seen this match
    private ArrayList<GamePiece> m_history = new ArrayList<>();

    // ArrayList of wrapper Doubles — scores recorded over time
    private ArrayList<Double> m_scores = new ArrayList<>();

    public void recordScore(GamePiece piece, double points) {
        m_history.add(piece);   // autoboxing not needed — GamePiece IS an object
        m_scores.add(points);   // autoboxed: double → Double transparently
    }

    public int getConeCount() {
        int count = 0;
        for (GamePiece p : m_history) {
            if (p == GamePiece.CONE) count++;  // == works for enum values
        }
        return count;
    }

    public double getTotalScore() {
        double total = 0.0;
        for (Double s : m_scores) {
            total += s;  // unboxed: Double → double for the addition
        }
        return total;
    }
}

import java.util.ArrayList;

ArrayList<String> list = new ArrayList<>();
list.add("alpha");
list.add("beta");
list.add("gamma");
list.remove("beta");
list.add("delta");

System.out.println(list.size());
System.out.println(list.get(1));
System.out.println(list.contains("beta"));

for (String s : list) {
    System.out.println(s);
}