我已经将java类中的异常包装为自定义异常。我希望我的自定义异常接收两个参数,一个是消息,另一个是列表。
但问题是listOfFailedRecords必须是通用的。
就像,
throw new MyException("Failed due to dependency", listOfFailedRecords)
MyException类看起来像,
public class MyException<T> extends Exception {
List<T> listOfFailedRecords;
MyException(String
我正在努力理解和/或使Kotlin泛型和多态性为我工作。请考虑以下代码:
class Item<T: BaseAttributes> {
var id: Long = -1L
lateinit var type: String
lateinit var attributes: T
}
open class BaseAttributes {
lateinit var createdAt: String
lateinit var updatedAt: String
}
open class BaseResponseList<T : Ba
我知道我可以像这样在java中创建一个类:
public class test {/*some code*/}
但现在我有了这个:
public class coada < T extends Number & Comparable < Number>> {
List <T> pq = new ArrayList <T>();
public void add(T e , List <T> c) {
c.add(e);
Collections.sort(c);
}
我在有效地使用泛型时遇到了问题。大多数时候,当我遇到下面描述的问题时,我最终会找到另一种方法来完成我需要的东西,但这让我觉得我对Java中泛型的用法缺乏一些理解。
如果我想创建一个返回列表的方法,如果T扩展了任何东西,我会得到一个编译器错误,说明我添加到列表中的任何东西都不能转换为T。
请参考以下示例代码:
public interface I1 {
}
public interface I2 {
}
public class ValidType implements I1, I2 {
}
public class OtherValidType extends ValidType {
}
问题描述
我有一个具有通用节点的泛型树。您可以这样想,就像它是一个具有多层子元素的扩展路由器配置。
问题是,每个节点都可以具有其父节点的其他泛型类型(更详细的信息- )。
因此,当节点有子节点时,问题在于输入节点泛型。
代码
type ReactNode = string
type languageTag = 'en' | 'ru'/* | 'de' | 'cs' | 'fr' | 'cn' | 'pl' */
// the type below may be the p
我试图在Java中创建一个抽象类,其中一部分创建涉及调用子类需要实现的初始化方法。但是,我希望子类能够访问抽象类不需要知道的任意参数。
这里有一些代码可以更清楚地说明:
public abstract class NormalizedRandom<T> {
private Queue<T> randomList;
private List<T> usedRandomsList;
public NormalizedRandom() {
randomList = new LinkedList<T>();
我的结构如下:
abstract class Base {
public abstract List<...> Get(); //What should be the generic type?
}
class SubOne : Base {
public override List<SubOne> Get() {
}
}
class SubTwo : Base {
public override List<SubTwo> Get() {
}
}
我想要创建一个抽象方法,它返回具体子类的任何类。因此,从
我想将我的列表转换为我从方法参数接收到的类类型。
基本上,我希望根据ClassA中存在的字段对列表进行排序。如何做到这一点?
sealed class ParentClass
data class ClassA(fieldInClassType: Int) : ParentClass()
data class ClassB(fieldInClassType: Int) : ParentClass()
我有一个ClassA和ClassB的列表,我想创建一个泛型方法来对它们进行排序。在我的旧代码中,我使用了when(),但它看起来很难看。
因此,我正在尝试在泛型方法中重构代码。这就是我现在拥有的
我尝试用java实现一个工厂模式,但是我有一些问题。
我有一个类AbstractAction,它是MapMoveAction,CutAction等子类的抽象类。
和类ActionFactory,它是创建具体类实例的工厂,操作工厂类包含一个静态方法createAction,该方法以字符串作为参数来标识要创建的concrect类。
但我的问题是,每一个节拍类在需要构造时都采用不同的参数:
public class ActionFactory {
public AbstractAction createAction(String uniqueName) {
// TOD
我正在学习设计模式,现在我正在尝试理解适配器和装饰器之间的区别。请考虑列表中的下列装饰师:
Collections.synchronizedList(List<T> lst)
在指定的List上创建同步装饰器。适配器模式,反过来,也封装它如所说的。示例:
public interface Chief {
public Object makeBreakfast();
public Object makeDinner();
public Object makeSupper();
}
public class Plumber {
public Ob
我有一些与此等价的代码(尽管这是一个简化):
namespace AnimalHospital
{
public class Animal { }
public class Dog : Animal { }
public class Cat : Animal { }
public interface Vet<T> where T : Animal
{
void takeCareOf(T animal);
}
public abstract class SpecializedDogVet<T>
public interface Moo<T> {
T getValue();
}
public class Bar<T> {
}
public class Foo<T extends Moo<Long>> {
private static Foo<?> foo;
private Bar<T> bar;
public Foo(Bar<T> bar) {
this.bar = bar;
}
//getters and setters
在创建对象的不同方式上,我有一种困惑,我在java、docs和其他编程书籍中都看到了这种情况。例如:
假设有base class和derived class
1-我有一个Base类型的变量,它引用Derived类型的对象。
List<String> list = new ArrayList<String>();
2-我有一个Derived类型的变量,它引用Derived类型的对象。
ArrayList<String> arrList = new ArrayList<String>();
我的问题是,在1和2之间选择时,我的想法应该是什么?它是要利
我有两个使用通配符泛型的方法示例。
第一个例子:
public static <T extends Comparable> T findMax(List<T> list)
第二个例子:
public static <T extends Comparable<? super T>> T findMax(List<? extends T> list)
我想知道这两个例子是否多余。如果是,为什么?
今天,我偶然发现了一些我根本不希望编译的工作Java代码。如果降到最低限度,它看起来如下:
import java.util.List;
interface A {
<T> List<String> foo();
}
interface B {
<T> List<Integer> foo();
}
class C implements A, B {
@Override
public List<?> foo()
{
return null;
}
}
乍一看,<T
我想知道为什么java不允许覆盖下限泛型参数。
public interface NumberConsumer {
public void accept(Consumer<? super Number> consumer);
}
public interface IntegerConsumer extends NumberConsumer {
@Override
public void accept(Consumer<? super Integer> consumer);
}
在上面的例子中,覆盖accept方法是完全安全的,因为NumberC
我需要创建几个类,它们将作为我想要实现的一些数据功能的基类。
首先,我们将调用SessionObjectDataItem,如下所示...
public class ObjectSessionDataItem
{
public int ID { get; set; }
public bool IsDirty { get; set; }
public bool IsNew { get; set; }
public bool IsRemoved { get; set; }
}
接下来,我想要一个名为ObjectSessionDataList的列表,这就是我遇到问题的地方。
我可
如果我有这个代码:
public interface IJobHelper
{
List<T> FilterwithinOrg<T>(IEnumerable<T> entities) where T : IFilterable;
}
有没有什么东西支持这样做的:
public interface IJobHelper
{
List<T> FilterwithinOrg<T>(IEnumerable<T> entities) where T : IFilterable or ISemiFilterable
}
我希望创建一组函数,所有特定接口的实现都可以扩展使用。我的问题是,是否有一种方法可以不使用代理或手动扩展接口的每个实现来实现而不使用?
我最初的想法是看看是否可以使用泛型;使用参数化类型作为实现的超级类型.
public class NewFunctionality<T extends OldFunctionality> extends T {
//...
}
...but,这是非法的。我不知道确切地知道为什么这是非法的,但它确实感觉是正确的(可能是因为T本身可以是一个接口,而不是一个实现)。
还有其他方法来达到我想做的事吗?
编辑我可能想做的一个例子是扩展java.uti
这是一个令人讨厌的问题,而且可能是设计很糟糕。
编写一组简单的图表组件(饼形图、条形图和线条图),并且被一些泛型的东西呛死了。在此之前,我确信有许多Java可以完成我在这里所要做的事情(图表/报表/等等),但是我对此感兴趣的是一个一般的泛型问题;它涉及图表和报表组件这一事实是微不足道的。
每个图表都是从一个通用抽象基类Chart继承的。
public abstract class Chart<T extends ChartComponent>
{
private List<T> components;
// ...rest of the Chart c
我想知道为什么泛型超级参数不允许引用子类型对象的背景。
abstract class Pet()
class Cat: Pet()
interface Retailer<T> {
fun sell(): T
}
class CatRetailer: Retailer<Cat> {
override fun sell(): Cat {
println("Sell Cat")
return Cat()
}
}
// Type MismatchError prior to compilation
我在让这个类型转换正常工作时遇到了问题。我猜是有界的泛型通配符<?超级SomeType>不适用于接口实现。
// sample class definitions
public interface IFace<T> { ... }
public class MyClass<T1, T2> { ... }
public class UtilityClass<T> {
public List<MyClass<T, ? super IFace<T>>> getList() { ... }
}
public
我很快用Java编写了一个链表类。我想写另一个使用链表的queue类。我如何在Java中实现这一点?我不能完全理解实现/扩展关键字...下面是我的队列的样子(例如):
public class Queue<T> implements LinkedList
{
protected LinkedList<T> list;
public Queue() {
list = new LinkedList<T>();
}
public void add( T element) {
list.add( e
这个问题在这里已经问过一次了,,我只想对这个设计提出更深入的问题。我已经试着在原来的帖子上提问了,但是我没有看到任何回应,所以我决定创建新的帖子。因此,实现通用CRUD会话bean的Pascal解决方案如下所示
public interface GenericCrudService {
public <T> T create(T t);
public <T> T find(Class<T> type, Object id);
public <T> void delete(T t);
public <T>
public class Business {
protected List<BusinessRulesDto> BusinessRules { get; set; }
}
我试过:
businessMockObject.Protected().SetupSet<List>("BusinessRules",ItExpr.IsAny<List>().Verifiable();
变量businessMockObject.Protected().SetupGet<List>("BusinessRules&
我正在编写一个泛型类,如下所示。
public class Foo<T> :
where T : Bar, new()
{
public void MethodInFoo()
{
T _t = new T();
}
}
如您所见,T类型的对象_t在运行时被实例化。为了支持泛型类型T的实例化,语言迫使我在类签名中放置新()。如果Bar是一个抽象类,那么我会同意这一点,但是如果Bar标准的非抽象类具有公共的无参数构造函数,那么为什么需要这样做呢?
如果未找到new(),编译器将提示使用以下消息。
无法创建变量类型'T‘的实例,因
无法将参数传递给Combiner().combine()函数。
Android无法识别arg扩展了Foo并实现了Bar。我做错了什么?
abstract class Foo {
val f: Int = 1
}
interface Bar {
val b: String get() = "a"
}
class Combiner {
fun <T> combine(arg: T): Pair<Int, String> where T : Foo, T : Bar {
return arg.f to arg.b
我正在尝试创建一个具有复制构造函数的通用容器。我在使用clone方法时遇到了问题,尽管我已经在里面编写了它。这是我到目前为止所知道的:
public class MyBox<T>
{
private List<T> list;
public MyBox()
{
list = new ArrayList<T>();
}
public void add(T item )
{
list.add(item);
}
public MyBox(MyBox<T&
我需要帮助来理解测试应该如何通过。我应该在Stacktest.java中实现测试方法(已经这样做了)。然后用StackTest扩展LinkedlistTest (我已经做过了)。然后添加super.setUp()作为LinkedListTest.setUp中的第一行(我已经这样做了)。
但是一个overriden方法是getIntegerStack,我在LinkedListTest中实现了这个方法,但是随后我得到了一个错误:
'getIntegerStack()' in 'LinkedListTest' clashes with 'getIntegerS
在将项目添加到BindingList之前,我想做一些处理。我看到有一个ListChanged事件,但这是在添加项目后触发的。只有在调用AddNew方法(而不是Add方法)时才会激发AddingNew事件。以前有没有人做过这样的事情?
更新:
我已经创建了以下类,当在IList上调用Add方法时,我的新Add方法将被触发。那么,我有没有我在其他地方读到过的选角问题?如果我从集合中删除了ISpecialCollection接口,则不会调用Add方法。有人能解释一下为什么它的行为不同吗?如果我使用ISpecialCollection<接口,我会有转换问题吗?
public interface
我有一个名为ListInterface<T>的接口,它的方法是join
public interface ListInterface<T> {
/**
* Join a new list to the original list.
* @param otherList The new list to be joined.
* @return Original list with appended part from the new list.
* @throws IllegalArgumentException.
Type类型的变量可以包含任何类型。我需要的是一个变量,它只能包含继承特定类并实现特定接口的类型。如何指定这一点?我曾尝试将该变量声明为
Type: MyClass, IMyInterface theTypeVariable;
和as
Type<MyClass, IMyInterface> theTypeVariable;
但这两种方法都不起作用。
正确的方法是什么?
例如
class A {...}
class B {...}
interface IC {...}
interface ID {...}
class E: B, IC {...}
class F: B, I