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