【面向对象的程序设计——类的重用】抽象、泛型

抽象

抽象类

抽象类是一种不能被实例化的类，只能当作父类进行继承，其语法格式如下：

abstract class Number {
 . . .
}

抽象方法

抽象类可以包含抽象方法，这些方法没有具体的实现，只有方法签名和一个分号，而具体的方法体将在继承的类中进行定义。抽象方法也用 abstract 关键字来定义。

eg-1

abstract class Animal {
    private String name;
    public Animal(String name) {
        this.name = name;
    }
    public abstract void makeSound(); // 抽象方法
    public void eat() {
        System.out.println(name + " is eating.");
    }
}

class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        dog.makeSound();
        dog.eat();
        is eating.
    }
}

运行结果：
Woof!
Buddy is eating.

泛型

泛型类、泛型方法

泛型，是指“泛类型”，即将数据的类型作为一个参数，可以用于泛型类、泛型方法、泛型接口。其中泛型类和泛型方法都是直接在类名/方法后面加上“<Type>”。
若不使用泛型，则要求程序员必须提前知道实际参数类型，对于类型不符的则需要强制转化类型。若使用泛型，则编译器会检测类型是否安全，且所有类型的转换都是自动且隐形的，因此，使用泛型可以提高代码重用率。

eg-1

//泛型类
class example<Type>{
    Type T;
    public example(Type t) {  //构造函数
        T = t;
    }
    public void setT(Type t) {  //Setter函数
        T = t;
    }
    public Type getT() {  //Getter函数
        return T;
    }
}
public class Main{
    public static void main(String[] args) {
        example<Integer> i = new example<>(2);
        example<Double> d = new example<>(0.33);
        System.out.println("i.T = "+i.getT());
        System.out.println("d.T = "+d.getT());
    }
}

运行结果：
i.T = 2
d.T = 0.33

eg-2

//泛型方法
class GeneralMethod {
    <Type3> void printClassName(Type3 object) {
        System.out.println(object.getClass().getName());
    }
}
public class Main {
    public static void main(String[] args) {
        GeneralMethod gm = new GeneralMethod();
        gm.printClassName("hello");
        gm.printClassName(3);
        gm.printClassName(3.0f);
        gm.printClassName(3.0);
    }
}

运行结果：
java.lang.String
java.lang.Integer
java.lang.Float
java.lang.Double

通配符泛型

是使用?进行表示，它可以代表任何未知的类型。

无界通配符

无界通配符表示可以接受任何类型的参数。例如，List<?> 可以表示任何类型的列表，无论是 List<String>、List<Integer> 还是其他任何类型的列表。

//现在我们定义一个类
class Box<T> {
    private T item;

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

    public T getItem() {
        return item;
    }

    public void setItem(T item) {
        this.item = item;
    }

    public void Printbox(Box<?> box){
        System.out.println(box.getItem());//这里先声明并初始化一个item也可以
    }
}
public class Main{
    public static void main(String[] args) {
    	//声明实例（啥都需要先声明实例）
        Box<String> stringBox = new Box<>("Hello");
        Box<Integer> intBox = new Box<>(123);

        // 使用普通泛型
        String content = stringBox.getItem(); // 编译器知道这是String类型
        System.out.println(content);
        int number = intBox.getItem(); // 编译器知道这是int类型
        System.out.println(number);

        //使用通配符泛型
        stringBox.Printbox(stringBox);
        intBox.Printbox(intBox);
        //在使用通用符泛型时，不一定必须调用对应实例中的方法，因为在看到具体参数之前，编译器也不知道到底是啥类型
        stringBox.Printbox(intBox);
        intBox.Printbox(stringBox);
    }
}

运行结果：
Hello
123
Hello
123
123
Hello

上界通配符

上界通配符指定了通配符可以代表的类型的一个上限。例如，List<? extends Number> 表示这个列表可以包含 Number 类型及其所有子类型的对象，如 Integer、Double 等。这种通配符通常用于只读操作，不能向这样的列表中添加对象（除了 null），因为编译器无法确定你添加的对象是否符合通配符的上界限制。

下界通配符

下界通配符指定了通配符可以代表的类型的一个下限。例如，List<? super Integer> 表示这个列表可以包含 Integer 类型及其所有父类型的对象，如 Number、Object 等。这种通配符通常用于写入操作。

PS：这些笔记是我个人所写，难免存在一些疏漏或错误。如果大家在阅读过程中发现任何问题，请不吝赐教，我将非常感激您的指正和谅解。如笔记内容涉及任何侵权问题，请及时与我联系，以便我尽快做出相应的删除处理。