【免费Java系列(Day3)】大家好 ,给大家出一些今天学习内容的案例点赞收藏关注,持续更新作品 !

 PS:每个内容块下都有教学博文的超链接,有需要可以点过去学习 !

目录

 匿名内部类 

1. 实现接口

2. 继承抽象类

3. 实现事件处理

 枚举

1. 定义一个简单的枚举类型

2. 枚举类型可以有属性和方法

3. 枚举类型可以实现接口

 泛型

1. 定义一个泛型类

2. 使用泛型方法

3. 泛型限定

---

 下面是一些使用匿名内部类的小案例：

 匿名内部类 

http://t.csdnimg.cn/3bxIf   

1. 实现接口

interface Greeting {
    void sayHello();
}

public class AnonymousClassExample {
    public static void main(String[] args) {
        Greeting greeting = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("Hello!");
            }
        };
        greeting.sayHello();
    }
}

---

2. 继承抽象类

abstract class Animal {
    abstract void makeSound();
}

public class AnonymousClassExample {
    public static void main(String[] args) {
        Animal animal = new Animal() {
            @Override
            void makeSound() {
                System.out.println("The animal makes sound");
            }
        };
        animal.makeSound();
    }
}

---

3. 实现事件处理

import java.awt.*;
import java.awt.event.*;

public class AnonymousClassExample {
    public static void main(String[] args) {
        Button button = new Button("Click Me");
        button.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                System.out.println("Button clicked");
            }
        });
        Frame frame = new Frame();
        frame.add(button);
        frame.setSize(300, 200);
        frame.setVisible(true);
    }
}

---

 以上是一些使用匿名内部类的小案例，通过使用匿名内部类，可以在需要时直接定义和实现接     口、抽象类或事件处理等功能，以简化代码编写过程。

 枚举

http://t.csdnimg.cn/zIfv3

下面是一些使用枚举的小案例：

1. 定义一个简单的枚举类型

enum DayOfWeek {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

public class EnumExample {
    public static void main(String[] args) {
        DayOfWeek today = DayOfWeek.SUNDAY;
        System.out.println("Today is " + today);
    }
}

2. 枚举类型可以有属性和方法

enum DayOfWeek {
    MONDAY("Monday", 1),
    TUESDAY("Tuesday", 2),
    WEDNESDAY("Wednesday", 3),
    THURSDAY("Thursday", 4),
    FRIDAY("Friday", 5),
    SATURDAY("Saturday", 6),
    SUNDAY("Sunday", 7);

    private String name;
    private int value;

    DayOfWeek(String name, int value) {
        this.name = name;
        this.value = value;
    }

    public String getName() {
        return name;
    }

    public int getValue() {
        return value;
    }
}

public class EnumExample {
    public static void main(String[] args) {
        DayOfWeek today = DayOfWeek.WEDNESDAY;
        System.out.println("Today is " + today.getName());
        System.out.println("Today's value is " + today.getValue());
    }
}

3. 枚举类型可以实现接口

interface Greeting {
    void sayHello();
}

enum Language implements Greeting {
    ENGLISH {
        public void sayHello() {
            System.out.println("Hello!");
        }
    },
    FRENCH {
        public void sayHello() {
            System.out.println("Bonjour!");
        }
    },
    SPANISH {
        public void sayHello() {
            System.out.println("Hola!");
        }
    }
}

public class EnumExample {
    public static void main(String[] args) {
        Language language = Language.ENGLISH;
        language.sayHello();
    }
}

---

 以上是一些使用枚举的小案例，枚举类型可以用于定义一组常量，可以有属性和方法，还可以实现接口。通过使用枚举，可以增强代码的可读性和可维护性。

 泛型

http://t.csdnimg.cn/R1UiQ

下面是一些使用Java泛型的小案例：

1. 定义一个泛型类

class Box<T> {
    private T content;
    
    public void setContent(T content) {
        this.content = content;
    }
    
    public T getContent() {
        return content;
    }
}

public class GenericExample {
    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.setContent("Hello");
        String content = stringBox.getContent();
        System.out.println("Content: " + content);
        
        Box<Integer> intBox = new Box<>();
        intBox.setContent(123);
        int number = intBox.getContent();
        System.out.println("Number: " + number);
    }
}

2. 使用泛型方法

class Util {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }
}

public class GenericExample {
    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        Util.printArray(intArray);
        
        String[] stringArray = {"Hello", "World"};
        Util.printArray(stringArray);
    }
}

3. 泛型限定

class Pair<T extends Comparable<T>> {
    private T first;
    private T second;
    
    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }
    
    public T getFirst() {
        return first;
    }
    
    public T getSecond() {
        return second;
    }
    
    public T getMax() {
        return first.compareTo(second) > 0 ? first : second;
    }
}

public class GenericExample {
    public static void main(String[] args) {
        Pair<Integer> intPair = new Pair<>(10, 20);
        System.out.println("Max: " + intPair.getMax());
        
        Pair<String> stringPair = new Pair<>("Hello", "World");
        System.out.println("Max: " + stringPair.getMax());
    }
}

---

以上是一些使用Java泛型的小案例，泛型提供了类型安全和代码复用的机制。通过使用泛型，可以在编译时检查类型，并且避免了类型转换的麻烦。泛型类、泛型方法和泛型限定都可以用于不同的场景，提高代码的灵活性和可读性。