blocks|key|3679709|text|如果Cat和Dog没有任何共同之处，则可以使用Object参数化LinkedList|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3679710|List<Object>+list+=+new+LinkedList<Object>();|code-block|syntax|javascript|3679711|这样，您就可以同时添加Cat和Dog，但请注意，这可能会迫使您每次从列表中检索对象时都要检查类型。|3679712|entityMap^0|2|3|6|3|N|6|W|A|0|0|B|3|F|3|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|N|$]]

If <code>Cat</code> and <code>Dog</code> have nothing in common, you can parameterize the <code>LinkedList</code> with <code>Object</code>:

<pre><code>List&lt;Object&gt; list = new LinkedList&lt;Object&gt;();
</code></pre>

This way you will be able to add both <code>Cat</code> and <code>Dog</code>, but please note that this may force you to check the types every time you retrieve the objects from the list.

blocks|key|1349234|text|您希望使用它们的“最低”公共类或公共接口，以便尽可能多地了解列表元素(以及您需要的内容)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1349235|如果两个类Dog和Cat+都扩展了类+Animal，并且希望表示动物列表，则可以这样做：|offset|length|style|CODE|BOLD|1349236|List<Animal>+animals+=+new+YourList<Animal>();
for+(Animal+animal:+animals){
++++//+use+some+Animal+method
++++animal.eat();
}|code-block|syntax|javascript|1349237|如果两个都实现了接口+TailOwner，并且希望在列表成员上使用来自该接口的操作，则可以这样做：|1349238|List<TailOwner>+tailOwners+=+new+YourList<TailOwner>();
for+(TailOwner+tailOwner:+tailOwners){
++++//+use+some+TailOwner+method
++++tailOwner.wiggle();
}|1349239|如果您不确定，您可以始终回到Object，因为所有的Java类都对它进行了扩展：|1349240|List<Object>+objects+=+new+YourList<Object>();
for+(Object+object:+objects){
++++//+use+some+Object+method
++++System.out.println(tailOwner.toString());
}|1349241|通常，当您在同一个列表中有两个对象时，它们确实有--。|1349242|无论哪种方法，当您将Cat-specific或Dog-specific方法放到列表中时(在将它们转换回任何方法之前)，您都会放弃它们。|1349243|当您使用列表中的对象时，良好的层次结构可以防止转换，并促进多态性。有关在编译时从列表中检索到的对象，您可以知道的是它们至少符合列表的泛型类型。|1349244|entityMap^0|0|5|3|9|3|J|6|D|5|0|0|4|6|B|9|0|0|E|6|0|0|O|2|0|A|3|N|3|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|14|8|@$D|15|E|16|F|G]|$D|17|E|18|F|G]|$D|19|E|1A|F|G]|$D|1B|E|1C|F|H]]|9|@]|A|$]]|$1|I|3|J|5|K|7|1D|8|@]|9|@]|A|$L|M]]|$1|N|3|O|5|6|7|1E|8|@$D|1F|E|1G|F|H]|$D|1H|E|1I|F|G]]|9|@]|A|$]]|$1|P|3|Q|5|K|7|1J|8|@]|9|@]|A|$L|M]]|$1|R|3|S|5|6|7|1K|8|@$D|1L|E|1M|F|G]]|9|@]|A|$]]|$1|T|3|U|5|K|7|1N|8|@]|9|@]|A|$L|M]]|$1|V|3|W|5|6|7|1O|8|@$D|1P|E|1Q|F|H]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1R|8|@$D|1S|E|1T|F|G]|$D|1U|E|1V|F|G]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|1W|8|@]|9|@]|A|$]]|$1|11|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]]|12|$]]

You want to use their "lowest" common class, or a common interface, so you can tell as much as possible (and what you need) about list's elements.

If both classes <code>Dog</code> and <code>Cat</code> extend the class <code>Animal</code>, and you want to represent a list of animals, you can do:

<pre><code>List&lt;Animal&gt; animals = new YourList&lt;Animal&gt;();
for (Animal animal: animals){
 // use some Animal method
 animal.eat();
}
</code></pre>

If both of them implement the interface <code>TailOwner</code> and you want to use operations from that interface on members of the list, you can do:

<pre><code>List&lt;TailOwner&gt; tailOwners = new YourList&lt;TailOwner&gt;();
for (TailOwner tailOwner: tailOwners){
 // use some TailOwner method
 tailOwner.wiggle();
}
</code></pre>

If you're not sure, you can always fall back to <code>Object</code>, as all Java classes extend it:

<pre><code>List&lt;Object&gt; objects = new YourList&lt;Object&gt;();
for (Object object: objects){
 // use some Object method
 System.out.println(tailOwner.toString());
}
</code></pre>

Usually, when you have two objects in the same list, they do have something in common.

Either way, you're giving up any <code>Cat</code>-specific or <code>Dog</code>-specific methods (before casting back to either) when you put them in the list.

Having a good hierarchy can prevent casting, and promote polymorphism, when you use objects from the list. All you can tell about objects retrieved from the list at compile time, is that they at least comply to the list's generic type.

blocks|key|854380|text|在使用泛型这个词时，我会非常谨慎，特别是因为猫和狗不是通用的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|854381|LinkedList<Object>+linkedlist+=+new+LinkedList<Object>();
linkedList.add(new+Dog());
linkedList.add(new+Cat());|code-block|syntax|javascript|854382|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I would be cautious when using the word generic, especially since cat and dog are not generic.

<pre><code>LinkedList&lt;Object&gt; linkedlist = new LinkedList&lt;Object&gt;();
linkedList.add(new Dog());
linkedList.add(new Cat());
</code></pre>

blocks|key|3679816|text|您只能添加implements相同接口或extends相同类的元素。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3679817|class+Animal+{}

class+Cat+extends+Animal{}

class+Dog+extends+Animal{}

List<Animal>+animals+=+new+LinkedList<Animal>;
animals.add(new+Cat());
animals.add(new+Dog());|code-block|syntax|javascript|3679818|或|3679819|interface+Animal+{}

class+Cat+implements+Animal{}

class+Dog+implements+Animal{}

List<Animal>+animals+=+new+LinkedList<Animal>;
animals.add(new+Cat());
animals.add(new+Dog());|3679820|entityMap^0|5|A|K|7|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

You only can add elements that <code>implements</code> same interface or <code>extends</code> same class.

<pre><code>class Animal {}

class Cat extends Animal{}

class Dog extends Animal{}

List&lt;Animal&gt; animals = new LinkedList&lt;Animal&gt;;
animals.add(new Cat());
animals.add(new Dog());
</code></pre>

OR

<pre><code>interface Animal {}

class Cat implements Animal{}

class Dog implements Animal{}

List&lt;Animal&gt; animals = new LinkedList&lt;Animal&gt;;
animals.add(new Cat());
animals.add(new Dog());
</code></pre>

blocks|key|1349384|text|由于您的列表可能包含一些相关的元素，所以最好创建一个接口并将其用作列表对象类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1349385|从IAnimal派生Cat和Dog，并生成类型列表|1349386|List<IAnimal>+animals+=+new+YourList<IAnimal>();|code-block|syntax|javascript|1349387|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Since your list probably contains elements that are somehow related, it would be best to make an interface and use that as list object type.

Derive both Cat and Dog from IAnimal and make the list of type

<pre><code>List&lt;IAnimal&gt; animals = new YourList&lt;IAnimal&gt;();
</code></pre>

I have created a linked list, but I can't seem to understand how to insert different objects into the same list. Let's say I have a list which I want to contain both objects of type cat and dog, is this possible? I know how to insert only cats, or only dogs, but I can't seem to understand how to insert both into the same list.

Generic linked list - how to add different objects

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我已经创建了一个链接列表，但我似乎无法理解如何将不同的对象插入到同一个列表中。假设我有一个列表，我想包含猫和狗两种类型的对象，这可能吗？我知道如何只插入猫，或者只插入狗，但我似乎不知道如何将两者插入到同一个列表中。

问泛型链接列表-如何添加不同的对象
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问泛型链接列表-如何添加不同的对象EN