泛型类

zsxxn

java编程完成泛型类GenericStack（栈），GenericStack的基本功能设计要求：创建栈、出栈、入栈、获取栈顶元素、判栈空。

isdkz

1. public class GenericStack<T> {
   
2.     private int size;
   
3.     private T[] elements;
   
4.     private int top;
   
5. 
   
6.     public GenericStack(int size) {
   
7.         this.size = size;
   
8.         elements = (T[]) new Object[size];
   
9.         top = -1;
   
10.     }
    
11. 
    
12.     public void push(T element) {
    
13.         if (top == size - 1) {
    
14.             throw new StackOverflowError("Stack is full");
    
15.         }
    
16.         elements[++top] = element;
    
17.     }
    
18. 
    
19.     public T pop() {
    
20.         if (top == -1) {
    
21.             throw new IllegalStateException("Stack is empty");
    
22.         }
    
23.         return elements[top--];
    
24.     }
    
25. 
    
26.     public T peek() {
    
27.         if (top == -1) {
    
28.             throw new IllegalStateException("Stack is empty");
    
29.         }
    
30.         return elements[top];
    
31.     }
    
32. 
    
33.     public boolean isEmpty() {
    
34.         return top == -1;
    
35.     }
    
36. }
    

复制代码

这段代码定义了一个泛型类 GenericStack ，它具有创建栈、出栈、入栈、获取栈顶元素、判栈空的基本功能。在构造函数中，使用数组来存储栈的元素，并通过泛型 T 来表示栈中的元素类型。 push 方法用于入栈操作， pop 方法用于出栈操作， peek 方法用于获取栈顶元素， isEmpty 方法用于判断栈是否为空。

Mike_python小

当然，以下是一个简单的泛型类GenericStack的实现，满足上述的基本功能设计要求：

[/code]java
import java.util.EmptyStackException;

public class GenericStack<T> {
    private Node<T> top;

    private static class Node<T> {
        T data;
        Node<T> next;

        Node(T data) {
            this.data = data;
        }
    }

    public void push(T item) {
        Node<T> newNode = new Node<>(item);
        newNode.next = top;
        top = newNode;
    }

    public T pop() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        T result = top.data;
        top = top.next;
        return result;
    }

    public T peek() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        return top.data;
    }

    public boolean isEmpty() {
        return top == null;
    }
}
[/code]

这个泛型类GenericStack实现了栈的基本功能，包括入栈、出栈、获取栈顶元素和判栈空。你可以根据这个基础上进行进一步扩展和优化。希望这个例子能够帮助你完成泛型类GenericStack的基本功能设计。

liuhongrun2022

在Java中，我们可以使用泛型来编写一个通用的栈（Stack）类，这样我们就可以很轻松地用它来存储任何类型的对象。以下是一个基本的泛型栈（GenericStack）类的设计：

1. public class GenericStack<E> {
2.     private E[] elements;
3.     private int size = 0;
4.     private static final int DEFAULT_INITIAL_CAPACITY = 16;
6.     @SuppressWarnings("unchecked")
7.     public GenericStack() {
8.         elements = (E[]) new Object[DEFAULT_INITIAL_CAPACITY];
9.     }
11.     public void push(E e) {
12.         if (size == elements.length) {
13.             E[] temp = elements;
14.             elements = (E[])new Object[temp.length * 2];
15.             System.arraycopy(temp, 0, elements, 0, size);
16.         }
17.         elements[size++] = e;
18.     }
20.     public E pop() {
21.         if (isEmpty()) {
22.             return null;
23.         }
24.         E value = elements[--size];
25.         elements[size] = null;
26.         return value;
27.     }
29.     public E peek() {
30.         if (isEmpty()) {
31.             return null;
32.         }
33.         return elements[size - 1];
34.     }
36.     public boolean isEmpty() {
37.         return size == 0;
38.     }
40.     public int getSize() {
41.         return size;
42.     }
43. }

复制代码

这个GenericStack类使用了Java的泛型参数<E>，这意味着你可以用任何类型来替代E，创建出一个存储特定类型的栈。例如，GenericStack<String>会创建一个存储字符串的栈，而GenericStack<Integer>则会创建一个存储整型的栈。

在这个类中，我们定义了以下几个方法：

- push(E e)：将一个元素压入栈顶。如果数组已满，那么数组的容量将被扩大一倍。
- pop()：删除并返回栈顶元素。如果栈为空，则返回null。
- peek()：返回栈顶元素，但不删除它。如果栈为空，则返回null。
- isEmpty()：如果栈为空，则返回true；否则，返回false。
- getSize()：返回栈中的元素数量。

注意，为了避免类型擦除问题，我们在构造函数中使用了@SuppressWarnings("unchecked")注解。这是因为Java的泛型是通过类型擦除实现的，这意味着在运行时，泛型类型E会被替换为其上界（这里是Object）。因此，我们不能直接创建一个E类型的数组，而需要创建一个Object类型的数组，然后将其强制转换为E[]。