Type Bounds

public class UpperBounds {
    static class NumberBox<T extends Number> {
        private T value;

        public NumberBox(T value) {
            this.value = value;
        }

        public T getValue() {
            return value;
        }

        public double getDoubleValue() {
            return value.doubleValue(); // Can call Number methods
        }

        public boolean isPositive() {
            return value.doubleValue() > 0;
        }
    }

    public static void main(String[] args) {
        System.out.println("Upper bounds:\n");

        NumberBox<Integer> intBox = new NumberBox<>(42);
        System.out.println("  Integer: " + intBox.getValue());
        System.out.println("  As double: " + intBox.getDoubleValue());
        System.out.println("  Positive: " + intBox.isPositive());

        NumberBox<Double> doubleBox = new NumberBox<>(3.14);
        System.out.println("  Double: " + doubleBox.getValue());
        System.out.println("  Positive: " + doubleBox.isPositive());

        // NumberBox<String> strBox = new NumberBox<>("text"); // Compile error

        // <T extends Type> means T must be Type or subclass/implementer
        // Enables calling methods from the bounded type
        // Number bound allows: intValue(), doubleValue(), etc.
        // Compile error if type doesn't satisfy bound

        System.out.println("\nComparable bound:");

        class Sorter<T extends Comparable<T>> {
            public T max(T a, T b) {
                return a.compareTo(b) > 0 ? a : b;
            }

            public T min(T a, T b) {
                return a.compareTo(b) < 0 ? a : b;
            }
        }

        Sorter<Integer> intSorter = new Sorter<>();
        System.out.println("  Max(5, 10): " + intSorter.max(5, 10));
        System.out.println("  Min(5, 10): " + intSorter.min(5, 10));

        Sorter<String> strSorter = new Sorter<>();
        System.out.println("  Max(apple, banana): " + strSorter.max("apple", "banana"));

        System.out.println("\nStatistics:");

        class Stats<T extends Number> {
            private java.util.List<T> numbers;

            public Stats(java.util.List<T> numbers) {
                this.numbers = numbers;
            }

            public double average() {
                double sum = 0;
                for (T num : numbers) {
                    sum += num.doubleValue();
                }
                return sum / numbers.size();
            }

            public double sum() {
                double total = 0;
                for (T num : numbers) {
                    total += num.doubleValue();
                }
                return total;
            }
        }

        Stats<Integer> intStats = new Stats<>(java.util.Arrays.asList(10, 20, 30, 40));
        System.out.println("  Average: " + intStats.average());
        System.out.println("  Sum: " + intStats.sum());

        System.out.println("\nRange:");

        class Range<T extends Comparable<T>> {
            private T min;
            private T max;

            public Range(T min, T max) {
                this.min = min;
                this.max = max;
            }

            public boolean contains(T value) {
                return value.compareTo(min) >= 0 && value.compareTo(max) <= 0;
            }

            public String toString() {
                return "[" + min + " - " + max + "]";
            }
        }

        Range<Integer> ageRange = new Range<>(18, 65);
        System.out.println("  Range: " + ageRange);
        int ageToCheck = 25;
        System.out.println("  Contains " + ageToCheck + ": " +
                         ageRange.contains(ageToCheck));
        System.out.println("  Contains 70: " + ageRange.contains(70));

        Range<String> nameRange = new Range<>("A", "M");
        System.out.println("  Name range: " + nameRange);
        System.out.println("  Contains Alice: " + nameRange.contains("Alice"));
        System.out.println("  Contains Steve: " + nameRange.contains("Steve"));
    }
}

public class UpperBounds {
    static class NumberBox<T extends Number> {
        private T value;

        public NumberBox(T value) {
            this.value = value;
        }

        public T getValue() {
            return value;
        }

        public double getDoubleValue() {
            return value.doubleValue(); // Can call Number methods
        }

        public boolean isPositive() {
            return value.doubleValue() > 0;
        }
    }

    public static void main(String[] args) {
        System.out.println("Upper bounds:\n");

        NumberBox<Integer> intBox = new NumberBox<>(42);
        System.out.println("  Integer: " + intBox.getValue());
        System.out.println("  As double: " + intBox.getDoubleValue());
        System.out.println("  Positive: " + intBox.isPositive());

        NumberBox<Double> doubleBox = new NumberBox<>(3.14);
        System.out.println("  Double: " + doubleBox.getValue());
        System.out.println("  Positive: " + doubleBox.isPositive());

        // NumberBox<String> strBox = new NumberBox<>("text"); // Compile error

        // <T extends Type> means T must be Type or subclass/implementer
        // Enables calling methods from the bounded type
        // Number bound allows: intValue(), doubleValue(), etc.
        // Compile error if type doesn't satisfy bound

        System.out.println("\nComparable bound:");

        class Sorter<T extends Comparable<T>> {
            public T max(T a, T b) {
                return a.compareTo(b) > 0 ? a : b;
            }

            public T min(T a, T b) {
                return a.compareTo(b) < 0 ? a : b;
            }
        }

        Sorter<Integer> intSorter = new Sorter<>();
        System.out.println("  Max(5, 10): " + intSorter.max(5, 10));
        System.out.println("  Min(5, 10): " + intSorter.min(5, 10));

        Sorter<String> strSorter = new Sorter<>();
        System.out.println("  Max(apple, banana): " + strSorter.max("apple", "banana"));

        System.out.println("\nStatistics:");

        class Stats<T extends Number> {
            private java.util.List<T> numbers;

            public Stats(java.util.List<T> numbers) {
                this.numbers = numbers;
            }

            public double average() {
                double sum = 0;
                for (T num : numbers) {
                    sum += num.doubleValue();
                }
                return sum / numbers.size();
            }

            public double sum() {
                double total = 0;
                for (T num : numbers) {
                    total += num.doubleValue();
                }
                return total;
            }
        }

        Stats<Integer> intStats = new Stats<>(java.util.Arrays.asList(10, 20, 30, 40));
        System.out.println("  Average: " + intStats.average());
        System.out.println("  Sum: " + intStats.sum());

        System.out.println("\nRange:");

        class Range<T extends Comparable<T>> {
            private T min;
            private T max;

            public Range(T min, T max) {
                this.min = min;
                this.max = max;
            }

            public boolean contains(T value) {
                return value.compareTo(min) >= 0 && value.compareTo(max) <= 0;
            }

            public String toString() {
                return "[" + min + " - " + max + "]";
            }
        }

        Range<Integer> ageRange = new Range<>(18, 65);
        System.out.println("  Range: " + ageRange);
        int ageToCheck = 17;
        System.out.println("  Contains " + ageToCheck + ": " +
                         ageRange.contains(ageToCheck));
        System.out.println("  Contains 70: " + ageRange.contains(70));

        Range<String> nameRange = new Range<>("A", "M");
        System.out.println("  Name range: " + nameRange);
        System.out.println("  Contains Alice: " + nameRange.contains("Alice"));
        System.out.println("  Contains Steve: " + nameRange.contains("Steve"));
    }
}

public class UpperBounds {
    static class NumberBox<T extends Number> {
        private T value;

        public NumberBox(T value) {
            this.value = value;
        }

        public T getValue() {
            return value;
        }

        public double getDoubleValue() {
            return value.doubleValue(); // Can call Number methods
        }

        public boolean isPositive() {
            return value.doubleValue() > 0;
        }
    }

    public static void main(String[] args) {
        System.out.println("Upper bounds:\n");

        NumberBox<Integer> intBox = new NumberBox<>(42);
        System.out.println("  Integer: " + intBox.getValue());
        System.out.println("  As double: " + intBox.getDoubleValue());
        System.out.println("  Positive: " + intBox.isPositive());

        NumberBox<Double> doubleBox = new NumberBox<>(3.14);
        System.out.println("  Double: " + doubleBox.getValue());
        System.out.println("  Positive: " + doubleBox.isPositive());

        // NumberBox<String> strBox = new NumberBox<>("text"); // Compile error

        // <T extends Type> means T must be Type or subclass/implementer
        // Enables calling methods from the bounded type
        // Number bound allows: intValue(), doubleValue(), etc.
        // Compile error if type doesn't satisfy bound

        System.out.println("\nComparable bound:");

        class Sorter<T extends Comparable<T>> {
            public T max(T a, T b) {
                return a.compareTo(b) > 0 ? a : b;
            }

            public T min(T a, T b) {
                return a.compareTo(b) < 0 ? a : b;
            }
        }

        Sorter<Integer> intSorter = new Sorter<>();
        System.out.println("  Max(5, 10): " + intSorter.max(5, 10));
        System.out.println("  Min(5, 10): " + intSorter.min(5, 10));

        Sorter<String> strSorter = new Sorter<>();
        System.out.println("  Max(apple, banana): " + strSorter.max("apple", "banana"));

        System.out.println("\nStatistics:");

        class Stats<T extends Number> {
            private java.util.List<T> numbers;

            public Stats(java.util.List<T> numbers) {
                this.numbers = numbers;
            }

            public double average() {
                double sum = 0;
                for (T num : numbers) {
                    sum += num.doubleValue();
                }
                return sum / numbers.size();
            }

            public double sum() {
                double total = 0;
                for (T num : numbers) {
                    total += num.doubleValue();
                }
                return total;
            }
        }

        Stats<Integer> intStats = new Stats<>(java.util.Arrays.asList(10, 20, 30, 40));
        System.out.println("  Average: " + intStats.average());
        System.out.println("  Sum: " + intStats.sum());

        System.out.println("\nRange:");

        class Range<T extends Comparable<T>> {
            private T min;
            private T max;

            public Range(T min, T max) {
                this.min = min;
                this.max = max;
            }

            public boolean contains(T value) {
                return value.compareTo(min) >= 0 && value.compareTo(max) <= 0;
            }

            public String toString() {
                return "[" + min + " - " + max + "]";
            }
        }

        Range<Integer> ageRange = new Range<>(18, 65);
        System.out.println("  Range: " + ageRange);
        int ageToCheck = 70;
        System.out.println("  Contains " + ageToCheck + ": " +
                         ageRange.contains(ageToCheck));
        System.out.println("  Contains 70: " + ageRange.contains(70));

        Range<String> nameRange = new Range<>("A", "M");
        System.out.println("  Name range: " + nameRange);
        System.out.println("  Contains Alice: " + nameRange.contains("Alice"));
        System.out.println("  Contains Steve: " + nameRange.contains("Steve"));
    }
}

import java.io.Serializable;

public class MultipleBounds {
    static class Calculator<T extends Number & Comparable<T>> {
        public T max(T a, T b) {
            return a.compareTo(b) > 0 ? a : b;
        }

        public double add(T a, T b) {
            return a.doubleValue() + b.doubleValue();
        }

        public boolean inRange(T value, T min, T max) {
            return value.compareTo(min) >= 0 && value.compareTo(max) <= 0;
        }
    }

    public static void main(String[] args) {
        System.out.println("Multiple bounds:\n");

        Calculator<Integer> intCalc = new Calculator<>();
        System.out.println("  Max(5, 10): " + intCalc.max(5, 10));
        System.out.println("  Add(5, 10): " + intCalc.add(5, 10));
        int rangeValue = 7;
        System.out.println("  InRange(" + rangeValue + ", 5, 10): " +
                         intCalc.inRange(rangeValue, 5, 10));

        Calculator<Double> doubleCalc = new Calculator<>();
        System.out.println("  Max(3.14, 2.71): " + doubleCalc.max(3.14, 2.71));

        // Multiple bounds: <T extends Type1 & Type2 & Type3>
        // Class bound must come first (can only have one class)
        // Interface bounds follow, separated by &
        // T must satisfy ALL bounds

        System.out.println("\nSerializable + Comparable:");

        class Storage<T extends Serializable & Comparable<T>> {
            private T value;

            public void store(T value) {
                this.value = value;
                System.out.println("  Stored (serializable): " + value);
            }

            public T retrieve() {
                return value;
            }

            public boolean isGreaterThan(T other) {
                return value != null && value.compareTo(other) > 0;
            }
        }

        Storage<String> strStorage = new Storage<>();
        strStorage.store("Hello");
        System.out.println("  Greater than 'Apple': " +
                         strStorage.isGreaterThan("Apple"));

        Storage<Integer> intStorage = new Storage<>();
        intStorage.store(42);
        System.out.println("  Greater than 30: " +
                         intStorage.isGreaterThan(30));

        System.out.println("\nCustom interfaces:");

        interface Nameable {
            String getName();
        }

        interface Identifiable {
            long getId();
        }

        class Entity<T extends Nameable & Identifiable> {
            private T item;

            public Entity(T item) {
                this.item = item;
            }

            public void display() {
                System.out.println("  ID: " + item.getId() +
                                 ", Name: " + item.getName());
            }
        }

        class User implements Nameable, Identifiable {
            private long id;
            private String name;

            User(long id, String name) {
                this.id = id;
                this.name = name;
            }

            @Override
            public String getName() { return name; }

            @Override
            public long getId() { return id; }
        }

        Entity<User> userEntity = new Entity<>(new User(1, "Alice"));
        userEntity.display();

        System.out.println("\nThree bounds:");

        interface Readable {
            String read();
        }

        interface Writable {
            void write(String data);
        }

        interface Closeable {
            void close();
        }

        class Resource<T extends Readable & Writable & Closeable> {
            private T resource;

            public Resource(T resource) {
                this.resource = resource;
            }

            public void process() {
                String data = resource.read();
                System.out.println("  Read: " + data);
                resource.write("Processed: " + data);
                resource.close();
            }
        }

        class File implements Readable, Writable, Closeable {
            private String content = "File content";

            @Override
            public String read() { return content; }

            @Override
            public void write(String data) {
                System.out.println("  Writing: " + data);
            }

            @Override
            public void close() {
                System.out.println("  Closed");
            }
        }

        Resource<File> fileResource = new Resource<>(new File());
        fileResource.process();
    }
}

import java.io.Serializable;

public class MultipleBounds {
    static class Calculator<T extends Number & Comparable<T>> {
        public T max(T a, T b) {
            return a.compareTo(b) > 0 ? a : b;
        }

        public double add(T a, T b) {
            return a.doubleValue() + b.doubleValue();
        }

        public boolean inRange(T value, T min, T max) {
            return value.compareTo(min) >= 0 && value.compareTo(max) <= 0;
        }
    }

    public static void main(String[] args) {
        System.out.println("Multiple bounds:\n");

        Calculator<Integer> intCalc = new Calculator<>();
        System.out.println("  Max(5, 10): " + intCalc.max(5, 10));
        System.out.println("  Add(5, 10): " + intCalc.add(5, 10));
        int rangeValue = 4;
        System.out.println("  InRange(" + rangeValue + ", 5, 10): " +
                         intCalc.inRange(rangeValue, 5, 10));

        Calculator<Double> doubleCalc = new Calculator<>();
        System.out.println("  Max(3.14, 2.71): " + doubleCalc.max(3.14, 2.71));

        // Multiple bounds: <T extends Type1 & Type2 & Type3>
        // Class bound must come first (can only have one class)
        // Interface bounds follow, separated by &
        // T must satisfy ALL bounds

        System.out.println("\nSerializable + Comparable:");

        class Storage<T extends Serializable & Comparable<T>> {
            private T value;

            public void store(T value) {
                this.value = value;
                System.out.println("  Stored (serializable): " + value);
            }

            public T retrieve() {
                return value;
            }

            public boolean isGreaterThan(T other) {
                return value != null && value.compareTo(other) > 0;
            }
        }

        Storage<String> strStorage = new Storage<>();
        strStorage.store("Hello");
        System.out.println("  Greater than 'Apple': " +
                         strStorage.isGreaterThan("Apple"));

        Storage<Integer> intStorage = new Storage<>();
        intStorage.store(42);
        System.out.println("  Greater than 30: " +
                         intStorage.isGreaterThan(30));

        System.out.println("\nCustom interfaces:");

        interface Nameable {
            String getName();
        }

        interface Identifiable {
            long getId();
        }

        class Entity<T extends Nameable & Identifiable> {
            private T item;

            public Entity(T item) {
                this.item = item;
            }

            public void display() {
                System.out.println("  ID: " + item.getId() +
                                 ", Name: " + item.getName());
            }
        }

        class User implements Nameable, Identifiable {
            private long id;
            private String name;

            User(long id, String name) {
                this.id = id;
                this.name = name;
            }

            @Override
            public String getName() { return name; }

            @Override
            public long getId() { return id; }
        }

        Entity<User> userEntity = new Entity<>(new User(1, "Alice"));
        userEntity.display();

        System.out.println("\nThree bounds:");

        interface Readable {
            String read();
        }

        interface Writable {
            void write(String data);
        }

        interface Closeable {
            void close();
        }

        class Resource<T extends Readable & Writable & Closeable> {
            private T resource;

            public Resource(T resource) {
                this.resource = resource;
            }

            public void process() {
                String data = resource.read();
                System.out.println("  Read: " + data);
                resource.write("Processed: " + data);
                resource.close();
            }
        }

        class File implements Readable, Writable, Closeable {
            private String content = "File content";

            @Override
            public String read() { return content; }

            @Override
            public void write(String data) {
                System.out.println("  Writing: " + data);
            }

            @Override
            public void close() {
                System.out.println("  Closed");
            }
        }

        Resource<File> fileResource = new Resource<>(new File());
        fileResource.process();
    }
}

import java.io.Serializable;

public class MultipleBounds {
    static class Calculator<T extends Number & Comparable<T>> {
        public T max(T a, T b) {
            return a.compareTo(b) > 0 ? a : b;
        }

        public double add(T a, T b) {
            return a.doubleValue() + b.doubleValue();
        }

        public boolean inRange(T value, T min, T max) {
            return value.compareTo(min) >= 0 && value.compareTo(max) <= 0;
        }
    }

    public static void main(String[] args) {
        System.out.println("Multiple bounds:\n");

        Calculator<Integer> intCalc = new Calculator<>();
        System.out.println("  Max(5, 10): " + intCalc.max(5, 10));
        System.out.println("  Add(5, 10): " + intCalc.add(5, 10));
        int rangeValue = 12;
        System.out.println("  InRange(" + rangeValue + ", 5, 10): " +
                         intCalc.inRange(rangeValue, 5, 10));

        Calculator<Double> doubleCalc = new Calculator<>();
        System.out.println("  Max(3.14, 2.71): " + doubleCalc.max(3.14, 2.71));

        // Multiple bounds: <T extends Type1 & Type2 & Type3>
        // Class bound must come first (can only have one class)
        // Interface bounds follow, separated by &
        // T must satisfy ALL bounds

        System.out.println("\nSerializable + Comparable:");

        class Storage<T extends Serializable & Comparable<T>> {
            private T value;

            public void store(T value) {
                this.value = value;
                System.out.println("  Stored (serializable): " + value);
            }

            public T retrieve() {
                return value;
            }

            public boolean isGreaterThan(T other) {
                return value != null && value.compareTo(other) > 0;
            }
        }

        Storage<String> strStorage = new Storage<>();
        strStorage.store("Hello");
        System.out.println("  Greater than 'Apple': " +
                         strStorage.isGreaterThan("Apple"));

        Storage<Integer> intStorage = new Storage<>();
        intStorage.store(42);
        System.out.println("  Greater than 30: " +
                         intStorage.isGreaterThan(30));

        System.out.println("\nCustom interfaces:");

        interface Nameable {
            String getName();
        }

        interface Identifiable {
            long getId();
        }

        class Entity<T extends Nameable & Identifiable> {
            private T item;

            public Entity(T item) {
                this.item = item;
            }

            public void display() {
                System.out.println("  ID: " + item.getId() +
                                 ", Name: " + item.getName());
            }
        }

        class User implements Nameable, Identifiable {
            private long id;
            private String name;

            User(long id, String name) {
                this.id = id;
                this.name = name;
            }

            @Override
            public String getName() { return name; }

            @Override
            public long getId() { return id; }
        }

        Entity<User> userEntity = new Entity<>(new User(1, "Alice"));
        userEntity.display();

        System.out.println("\nThree bounds:");

        interface Readable {
            String read();
        }

        interface Writable {
            void write(String data);
        }

        interface Closeable {
            void close();
        }

        class Resource<T extends Readable & Writable & Closeable> {
            private T resource;

            public Resource(T resource) {
                this.resource = resource;
            }

            public void process() {
                String data = resource.read();
                System.out.println("  Read: " + data);
                resource.write("Processed: " + data);
                resource.close();
            }
        }

        class File implements Readable, Writable, Closeable {
            private String content = "File content";

            @Override
            public String read() { return content; }

            @Override
            public void write(String data) {
                System.out.println("  Writing: " + data);
            }

            @Override
            public void close() {
                System.out.println("  Closed");
            }
        }

        Resource<File> fileResource = new Resource<>(new File());
        fileResource.process();
    }
}

import java.util.*;

public class BoundedMethods {
    public static <T extends Comparable<T>> T findMax(List<T> list) {
        if (list.isEmpty()) {
            return null;
        }

        T max = list.get(0);
        for (T item : list) {
            if (item.compareTo(max) > 0) {
                max = item;
            }
        }
        return max;
    }

    public static void main(String[] args) {
        System.out.println("Bounded methods:\n");

        List<Integer> numbers = Arrays.asList(5, 2, 9, 1, 7);
        Integer maxNum = findMax(numbers);
        System.out.println("  Max number: " + maxNum);

        List<String> words = Arrays.asList("apple", "zebra", "banana");
        String maxWord = findMax(words);
        System.out.println("  Max word: " + maxWord);

        // Method can declare its own type parameters with bounds
        // <T extends Type> before return type
        // Bound applies only to that method
        // Enables calling bounded type's methods

        System.out.println("\nNumeric operations:");

        class MathUtils {
            public static <T extends Number> double sum(List<T> numbers) {
                double total = 0;
                for (T num : numbers) {
                    total += num.doubleValue();
                }
                return total;
            }

            public static <T extends Number> double average(List<T> numbers) {
                return sum(numbers) / numbers.size();
            }
        }

        List<Integer> intList = Arrays.asList(10, 20, 30);
        System.out.println("  Sum: " + MathUtils.sum(intList));
        System.out.println("  Average: " + MathUtils.average(intList));

        List<Double> doubleList = Arrays.asList(1.5, 2.5, 3.5);
        System.out.println("  Sum: " + MathUtils.sum(doubleList));

        System.out.println("\nCount matching:");

        class Counter {
            public static <T> int countMatching(List<T> list, T target) {
                int count = 0;
                for (T item : list) {
                    if (item.equals(target)) {
                        count++;
                    }
                }
                return count;
            }

            public static <T extends Comparable<T>> int countGreater(
                    List<T> list, T threshold) {
                int count = 0;
                for (T item : list) {
                    if (item.compareTo(threshold) > 0) {
                        count++;
                    }
                }
                return count;
            }
        }

        List<Integer> nums = Arrays.asList(5, 10, 3, 10, 7);
        System.out.println("  Count 10s: " + Counter.countMatching(nums, 10));
        System.out.println("  Count > 5: " + Counter.countGreater(nums, 5));

        System.out.println("\nCopy method:");

        class Copier {
            public static <T> void copy(List<T> source, List<T> dest) {
                dest.clear();
                dest.addAll(source);
            }

            public static <T extends Comparable<T>> void copyGreater(
                    List<T> source, List<T> dest, T threshold) {
                dest.clear();
                for (T item : source) {
                    if (item.compareTo(threshold) > 0) {
                        dest.add(item);
                    }
                }
            }
        }

        List<Integer> src = Arrays.asList(1, 5, 3, 8, 2, 9);
        List<Integer> dst = new ArrayList<>();

        int threshold = 4;
        Copier.copyGreater(src, dst, threshold);
        System.out.println("  Copied > " + threshold + ": " + dst);

        System.out.println("\nMin/Max finder:");

        class MinMax {
            public static <T extends Comparable<T>> T min(T a, T b) {
                return a.compareTo(b) < 0 ? a : b;
            }

            public static <T extends Comparable<T>> T max(T a, T b) {
                return a.compareTo(b) > 0 ? a : b;
            }

            public static <T extends Comparable<T>> T clamp(
                    T value, T min, T max) {
                if (value.compareTo(min) < 0) return min;
                if (value.compareTo(max) > 0) return max;
                return value;
            }
        }

        System.out.println("  min(5, 10): " + MinMax.min(5, 10));
        System.out.println("  max(5, 10): " + MinMax.max(5, 10));
        System.out.println("  clamp(15, 0, 10): " + MinMax.clamp(15, 0, 10));
        System.out.println("  clamp(-5, 0, 10): " + MinMax.clamp(-5, 0, 10));
    }
}

import java.util.*;

public class BoundedMethods {
    public static <T extends Comparable<T>> T findMax(List<T> list) {
        if (list.isEmpty()) {
            return null;
        }

        T max = list.get(0);
        for (T item : list) {
            if (item.compareTo(max) > 0) {
                max = item;
            }
        }
        return max;
    }

    public static void main(String[] args) {
        System.out.println("Bounded methods:\n");

        List<Integer> numbers = Arrays.asList(5, 2, 9, 1, 7);
        Integer maxNum = findMax(numbers);
        System.out.println("  Max number: " + maxNum);

        List<String> words = Arrays.asList("apple", "zebra", "banana");
        String maxWord = findMax(words);
        System.out.println("  Max word: " + maxWord);

        // Method can declare its own type parameters with bounds
        // <T extends Type> before return type
        // Bound applies only to that method
        // Enables calling bounded type's methods

        System.out.println("\nNumeric operations:");

        class MathUtils {
            public static <T extends Number> double sum(List<T> numbers) {
                double total = 0;
                for (T num : numbers) {
                    total += num.doubleValue();
                }
                return total;
            }

            public static <T extends Number> double average(List<T> numbers) {
                return sum(numbers) / numbers.size();
            }
        }

        List<Integer> intList = Arrays.asList(10, 20, 30);
        System.out.println("  Sum: " + MathUtils.sum(intList));
        System.out.println("  Average: " + MathUtils.average(intList));

        List<Double> doubleList = Arrays.asList(1.5, 2.5, 3.5);
        System.out.println("  Sum: " + MathUtils.sum(doubleList));

        System.out.println("\nCount matching:");

        class Counter {
            public static <T> int countMatching(List<T> list, T target) {
                int count = 0;
                for (T item : list) {
                    if (item.equals(target)) {
                        count++;
                    }
                }
                return count;
            }

            public static <T extends Comparable<T>> int countGreater(
                    List<T> list, T threshold) {
                int count = 0;
                for (T item : list) {
                    if (item.compareTo(threshold) > 0) {
                        count++;
                    }
                }
                return count;
            }
        }

        List<Integer> nums = Arrays.asList(5, 10, 3, 10, 7);
        System.out.println("  Count 10s: " + Counter.countMatching(nums, 10));
        System.out.println("  Count > 5: " + Counter.countGreater(nums, 5));

        System.out.println("\nCopy method:");

        class Copier {
            public static <T> void copy(List<T> source, List<T> dest) {
                dest.clear();
                dest.addAll(source);
            }

            public static <T extends Comparable<T>> void copyGreater(
                    List<T> source, List<T> dest, T threshold) {
                dest.clear();
                for (T item : source) {
                    if (item.compareTo(threshold) > 0) {
                        dest.add(item);
                    }
                }
            }
        }

        List<Integer> src = Arrays.asList(1, 5, 3, 8, 2, 9);
        List<Integer> dst = new ArrayList<>();

        int threshold = 6;
        Copier.copyGreater(src, dst, threshold);
        System.out.println("  Copied > " + threshold + ": " + dst);

        System.out.println("\nMin/Max finder:");

        class MinMax {
            public static <T extends Comparable<T>> T min(T a, T b) {
                return a.compareTo(b) < 0 ? a : b;
            }

            public static <T extends Comparable<T>> T max(T a, T b) {
                return a.compareTo(b) > 0 ? a : b;
            }

            public static <T extends Comparable<T>> T clamp(
                    T value, T min, T max) {
                if (value.compareTo(min) < 0) return min;
                if (value.compareTo(max) > 0) return max;
                return value;
            }
        }

        System.out.println("  min(5, 10): " + MinMax.min(5, 10));
        System.out.println("  max(5, 10): " + MinMax.max(5, 10));
        System.out.println("  clamp(15, 0, 10): " + MinMax.clamp(15, 0, 10));
        System.out.println("  clamp(-5, 0, 10): " + MinMax.clamp(-5, 0, 10));
    }
}

import java.util.*;

public class BoundedMethods {
    public static <T extends Comparable<T>> T findMax(List<T> list) {
        if (list.isEmpty()) {
            return null;
        }

        T max = list.get(0);
        for (T item : list) {
            if (item.compareTo(max) > 0) {
                max = item;
            }
        }
        return max;
    }

    public static void main(String[] args) {
        System.out.println("Bounded methods:\n");

        List<Integer> numbers = Arrays.asList(5, 2, 9, 1, 7);
        Integer maxNum = findMax(numbers);
        System.out.println("  Max number: " + maxNum);

        List<String> words = Arrays.asList("apple", "zebra", "banana");
        String maxWord = findMax(words);
        System.out.println("  Max word: " + maxWord);

        // Method can declare its own type parameters with bounds
        // <T extends Type> before return type
        // Bound applies only to that method
        // Enables calling bounded type's methods

        System.out.println("\nNumeric operations:");

        class MathUtils {
            public static <T extends Number> double sum(List<T> numbers) {
                double total = 0;
                for (T num : numbers) {
                    total += num.doubleValue();
                }
                return total;
            }

            public static <T extends Number> double average(List<T> numbers) {
                return sum(numbers) / numbers.size();
            }
        }

        List<Integer> intList = Arrays.asList(10, 20, 30);
        System.out.println("  Sum: " + MathUtils.sum(intList));
        System.out.println("  Average: " + MathUtils.average(intList));

        List<Double> doubleList = Arrays.asList(1.5, 2.5, 3.5);
        System.out.println("  Sum: " + MathUtils.sum(doubleList));

        System.out.println("\nCount matching:");

        class Counter {
            public static <T> int countMatching(List<T> list, T target) {
                int count = 0;
                for (T item : list) {
                    if (item.equals(target)) {
                        count++;
                    }
                }
                return count;
            }

            public static <T extends Comparable<T>> int countGreater(
                    List<T> list, T threshold) {
                int count = 0;
                for (T item : list) {
                    if (item.compareTo(threshold) > 0) {
                        count++;
                    }
                }
                return count;
            }
        }

        List<Integer> nums = Arrays.asList(5, 10, 3, 10, 7);
        System.out.println("  Count 10s: " + Counter.countMatching(nums, 10));
        System.out.println("  Count > 5: " + Counter.countGreater(nums, 5));

        System.out.println("\nCopy method:");

        class Copier {
            public static <T> void copy(List<T> source, List<T> dest) {
                dest.clear();
                dest.addAll(source);
            }

            public static <T extends Comparable<T>> void copyGreater(
                    List<T> source, List<T> dest, T threshold) {
                dest.clear();
                for (T item : source) {
                    if (item.compareTo(threshold) > 0) {
                        dest.add(item);
                    }
                }
            }
        }

        List<Integer> src = Arrays.asList(1, 5, 3, 8, 2, 9);
        List<Integer> dst = new ArrayList<>();

        int threshold = 8;
        Copier.copyGreater(src, dst, threshold);
        System.out.println("  Copied > " + threshold + ": " + dst);

        System.out.println("\nMin/Max finder:");

        class MinMax {
            public static <T extends Comparable<T>> T min(T a, T b) {
                return a.compareTo(b) < 0 ? a : b;
            }

            public static <T extends Comparable<T>> T max(T a, T b) {
                return a.compareTo(b) > 0 ? a : b;
            }

            public static <T extends Comparable<T>> T clamp(
                    T value, T min, T max) {
                if (value.compareTo(min) < 0) return min;
                if (value.compareTo(max) > 0) return max;
                return value;
            }
        }

        System.out.println("  min(5, 10): " + MinMax.min(5, 10));
        System.out.println("  max(5, 10): " + MinMax.max(5, 10));
        System.out.println("  clamp(15, 0, 10): " + MinMax.clamp(15, 0, 10));
        System.out.println("  clamp(-5, 0, 10): " + MinMax.clamp(-5, 0, 10));
    }
}