这篇博客探讨了在Java中如何使用泛型和Comparable接口来设计数据结构，例如创建一个只能存储实现了Comparable接口的类型的ArrayList。通过示例展示了如何初始化和操作这些数据结构，并强调了泛型限制的重要性，如Node类只接受实现了Comparable接口的类型作为泛型参数。同时，文章通过代码展示了如果不遵循此类限制会遇到的问题。
6 个答案
梦想的彼岸
答案时间：2020-11-08
这个意思应该是初始化之后不能在放进去了把，在初始化的时候可以另创一个ArrayList，在着里面就可以放入对象，然后再把引用指向他
ArrayList al=new ArrayList();
al.add(new APHero("SS",333f));
al.add(new ADHero("wie",312f));
al.add(new Hero("yasuo",892f,234,444));
ArrayList extends Hero> heros=al;
傻傻大丢
答案时间：2020-06-14
参考练习1，遍历已经初始化的集合，以参数的形式传入函数中。
newbeeee
答案时间：2020-06-05
我也有这个疑问 既然？ extends 不能往里面放，那是怎么初始化容器的
叫么么哒的兔子猪
答案时间：2020-03-09
第二题
package Arraylist;
import java.util.ArrayList;
import java.util.List;
public class Nodes> {
//T可以是任意一个实现了Comparable的类
//T表示任意字符名，extends对泛型上限进行了限制即T必须是Comparable的子类
//Comparable是一个接口，此接口强行对实现它的每个类的对象进行整体排序。这种排序称为类的自然排序，类的compareTo方法称为他的自然比较方法
//T在泛型中用，表示不确定的类型,这里的T实现了排序
public Nodes leftNodes;
public Nodes rightNodes;
public T value;//结点内部由三个属性实现
//加入节点的算法
public void add(T t)
{
//t和value都是T类型，而T类型extends Comparable，所以必然提供compareTo方法
if(null==value)
value=t;
else {
if(null==rightNodes)
rightNodes=new Nodes();
rightNodes.add(t);
}
}
public List values()//list中的元素都来自同一个类T
{
//List是一个泛型接口，是一个List其中的元素必须是T型的
List values=new ArrayList<>();
if(null!=leftNodes)
values.addAll(leftNodes.values());
values.add(value);
if(null!=rightNodes)
values.addAll(rightNodes.values());
return values;
}
public static void main(String args[])
{
int randoms[] = new int[] { 67, 7, 30, 73, 10, 0, 78, 81, 10, 74 };
Nodes roots = new Nodes<>();
for (int number : randoms) {
roots.add(number);
}
System.out.println(roots.values());
//Hero实现了 Comparable接口，所以可以作为Node的泛型
Nodes heros = new Nodes<>();
//GiantDragon 没有实现 Comparable接口，所以不能作为Node的泛型
Nodes dragons = new Nodes<>();
}
}
叫么么哒的兔子猪
答案时间：2020-03-09
把Node设计为
public class Node> {
就表示只能使用那些实现了Comparable接口的泛型，比如Integer,Hero
Node roots = new Node<>();
Node heros = new Node<>();
但是GiantDragon就不行，因为它没有实现Comparable接口
Node dragons = new Node<>();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
package collection;
import java.util.ArrayList;
import java.util.List;
import charactor.GiantDragon;
import charactor.Hero;
public class Node> {
public Node leftNode;
public Node rightNode;
public T value;
public void add(T t) {
if (null == value)
value = t;
else {
//t和value都是T 类型，而T类型extends Comparable，所以必然提供compare接口
if (t.compareTo(value) <= 0) {
if (null == leftNode)
leftNode = new Node();
leftNode.add(t);
}
else {
if (null == rightNode)
rightNode = new Node();
rightNode.add(t);
}
}
}
public List values() {
List values = new ArrayList<>();
if (null != leftNode)
values.addAll(leftNode.values());
values.add(value);
if (null != rightNode)
values.addAll(rightNode.values());
return values;
}
public static void main(String[] args) {
int randoms[] = new int[] { 67, 7, 30, 73, 10, 0, 78, 81, 10, 74 };
Node roots = new Node<>();
for (int number : randoms) {
roots.add(number);
}
System.out.println(roots.values());
//Hero实现了 Comparable接口，所以可以作为Node的泛型
Node heros = new Node<>();
//GiantDragon 没有实现 Comparable接口，所以不能作为Node的泛型
Node dragons = new Node<>();
}
}
把Node设计为
public class Node> {
就表示只能使用那些实现了Comparable接口的泛型，比如Integer,Hero
Node roots = new Node<>();
Node heros = new Node<>();
但是GiantDragon就不行，因为它没有实现Comparable接口
Node dragons = new Node<>();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
package collection;
import java.util.ArrayList;
import java.util.List;
import charactor.GiantDragon;
import charactor.Hero;
public class Node> {
public Node leftNode;
public Node rightNode;
public T value;
public void add(T t) {
if (null == value)
value = t;
else {
//t和value都是T 类型，而T类型extends Comparable，所以必然提供compare接口
if (t.compareTo(value) <= 0) {
if (null == leftNode)
leftNode = new Node();
leftNode.add(t);
}
else {
if (null == rightNode)
rightNode = new Node();
rightNode.add(t);
}
}
}
public List values() {
List values = new ArrayList<>();
if (null != leftNode)
values.addAll(leftNode.values());
values.add(value);
if (null != rightNode)
values.addAll(rightNode.values());
return values;
}
public static void main(String[] args) {
int randoms[] = new int[] { 67, 7, 30, 73, 10, 0, 78, 81, 10, 74 };
Node roots = new Node<>();
for (int number : randoms) {
roots.add(number);
}
System.out.println(roots.values());
//Hero实现了 Comparable接口，所以可以作为Node的泛型
Node heros = new Node<>();
//GiantDragon 没有实现 Comparable接口，所以不能作为Node的泛型
Node dragons = new Node<>();
}
}
shek
答案时间：2020-03-03
https://www.cnblogs.com/zhaoyibing/p/9051428.html
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
