当我试图运行下面的代码时,编译器将生成
线程"main“java.lang.RuntimeException中的异常:不可编译的源代码-错误的sym类型: JTOGenerics.ArrayCode.countGreaterThan at JTOGenerics.ArrayCode.main(ArrayCode.java:17)
在代码行下面有一条红线: int =ArrayCode.countGreaterThan(mark,10);
我刚接触Java,由于知识有限,我试图找出错误,但失败了,有人能帮我解决吗?非常感谢!!
public class ArrayCode<T>
好的,这是我正在使用的接口。
/* instance of classes that realize this interface can be compared */
public interface Comparable<E>
{
/* Method to compare this object to the argument object
* @param obj - the argument object
* @return - returns a negative integer if this object < obj
*/
int compare
在编写抽象bean容器类时,我面临一些问题。
我创建了一个接口ImyAppsBean:
public interface ImyAppsBean{}
现在,我想在抽象容器类中实现一个排序方法。我想假设,ImyAppsBean的实例也实现了接口可比较的,因此我可以使用ImyAppsBean来排序我的ImyAppsBean对象的内部列表。因此,我需要将ImyAppsBean对象列表转换为可比较的对象列表,但不知道如何做到这一点。我的代码如下所示,第6行中的嵌套泛型会导致语法错误:
public abstract class AbstractBeanContainer(){
protect
我的链表使用了未预定义的变量,但我今天才学会使用这些变量。我已经设置了使用简单整数的列表,但是我意识到我不能以同样的方式比较我的变量,因为它们没有定义为整数,因此我在if语句上收到一个语法错误,该语句试图比较来自链接列表节点的整数值,以找到列表中的最大和最小值。
我已经将if语句标记为错误。如果需要更多代码或信息,请告诉我。
package lab01Pkg;
public class LinkedList <T> //<T> is defining the type of node we are creating
{
private int size;
当我编写代码时,我考虑使用泛型多个边界来解决问题,但是当我完成编写时,它一直在报告错误:不能用不同类型的参数继承。
我有以下课程:
public class Animal implements Comparable<Animal> {}
public class Dog extends Animal {}
我还定义了一个静态方法:
public static <T extends Animal & Comparable<? extends T>> T getMin(List<T> value) { return null;}
我的想法
我已经尝试学习类似的类有一段时间了,我知道正确的语法以及它在大多数情况下是如何使用的。例如:
int result = ObjectA.compareTo(ObjectB);
如果两个对象相同,将返回值0;如果对象A小于对象B,则返回值为负值;如果A大于B,则返回值为正值。
但是,当我实际编写一个使用compareTo方法的程序时,编译器说它找不到compareTo方法。
我的问题是:为了使用compareTo方法,我必须直接从可比较类继承吗?我问这个问题的唯一原因是,你不必显式地继承像toString或equals...because这样的方法,一切都继承自object。CompareTo
我知道我可以像这样在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);
}
我有一个银行帐户程序,它实现了一个BankAccount超类,扩展到CheckingAccount和SavingsAccount子类。
每个帐户有四个属性:名、姓、社会保障和平衡。
我有一个BankDatabase类,它创建一个新的ArrayList来容纳每个对象。
我想使用可比较的接口和compareTo()方法对这个compareTo进行排序。
public interface Comparable<BankAccount>
{
int compareTo(BankAccount other);
}
我已经实现了类似于我的超类:
public abstr
如果我有一个普通类,
public class Graph<K, V extends Comparable> {
...
}
我的理解是,V类型的任何对象都是可比较的,因为它扩展了可比较的接口。现在我想在我的课堂上使用一个HashMap<K, V>。在我的地图中,V类型的对象仍然应该是可比较的。我宣布一种方法:
public V getMin(HashMap<K, V> map, V zero) {
V min = zero;
for (V value : map.values()) {
if (value.
我正在使用java中的优先级队列实现Dijkstra算法。我正在为队列使用类“Node”的对象。为了实现这一点,我覆盖了Node类中的compareTo()方法。如果我使用"Object obj“作为compareTo()的参数,它工作得很好。但是,当我将"Node obj“作为参数提供给compareTo()时,会显示一个错误,说"Node不是抽象的,并且没有覆盖可比较的抽象方法compareTo(Object)”。根据我所读到的,这应该是可能的。怎么啦?
public class Node implements Comparable
{ in
出于呈现顺序的目的,我尝试按每个对象中两个整数的总和对ArrayList<MyInterface>进行排序。此ArrayList中的对象实现相同的接口,但没有公共的母类。
class A implements MyInterface, Comparable<MyInterface> {
@Override
public int compareTo(MyInterface object1) {
return (this.x+this.y)-(object1.getX()+object1.getY()); // Sort in ascend
我在Java方面很新。我不知道这个<T extends Comparable<T>>。我的意思是,为什么T在扩展之前就扩展了?这不足以写extends Comparable<T>吗?为什么javadoc中的extends而不是implements是一个接口,对吗?据我所知,Comparable比较了两个对象吗?
public class TopNPrinter<T extends Comparable<T>> {
private int N;
private String header;
public Top
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Collections;
public interface Comparable<T> {
int compareTo(T other);
}
public class Joueur implements Comparable<Joueur> {
private int points;
private int idJoueur;
public Joueur(int aIdJoueur, int aPoints)
{
我正在学习Java中的通用方法。我要计算数组中大于给定数目的元素数。这是我的代码:
public class GenericMethodExample {
public interface Comparable<T>{
public int compareTo(T o);
}
public static <T extends Comparable<T>> int countGreaterThan(T[] list, T element){
int count = 0;
for(T e:
public LightsOutBFS(){
//readtext
int[] arr = new int[25];
int[] state = new int[25];
int[] soln = new int[25];
boolean check=true;
PriorityQueue<Node> q = new PriorityQueue<Node>();
//Reading the text file
try{
FileInputStream fstream = new File
Q:在我下面实现的二叉树中,为什么编译器会在
if (data.compareTo(this.data) <= 0),
生产
Error: incompatible types: java.lang.Comparable<T> cannot be converted to T
data和this.data都是Comparable<T>类型的,应该能够使用或作为compareTo() method...right的参数吗?显然不是。但我真的不明白为什么。仿制药仍然困扰着我。
public class MyBinaryTreeNodeG<T>{
Com
所以我一直在试图得到整数数组的平均值,我的方法在那里做的并不是最好的,因为我试图将一个对象引用拟合到一个原语中。我试着使用intValue,我认为我使用它是错误的。有什么想法吗?
//Variation 3 - Choose Mean as pivot
private static int getMeanIndexAsPivotIndex(Comparable comparableArray[],int leftIndex, int rightIndex) {
int sum = 0;
int add = 0;
for (in
我以前使用过类似的接口,但是将它与泛型对象一起使用,第二个对象给我带来了一些困难。
这是我的司机程序
import java.io.*;
import java.util.*;
public class Prog2 {
public static void main (String[]args){
//Declare Variables
Scanner inFile = null;
ListArray<Part> partArray = new ListArray<Part>(13);
//Open the fil
我正在编写一个BankAccount类,它将一组银行帐户放入一个数组列表中,并根据它们的帐号对它们进行排序。我按如下方式编写了compareTo()方法:
public int compareTo(BankAccount another){
if (Integer.parseInt(this.getAccountNumber()) > Integer.parseInt(another.getAccountNumber()))
return 1;
else if(Integer.parseInt(this.getAccountNumber()) < I
下面是这个类,在这里,我使用了一个可比较的接口。虽然它是一个接口,但如何使用new进行初始化? public class PriorityQueueImpl {
@SuppressWarnings("rawtypes")
private Comparable[] pQueue;
private int index;
public PriorityQueueImpl(int capacity){
pQueue = new Comparable[capacity];
}
public void insert(C
有人能给我解释一下这个类定义语句吗?
public class BinarTree<Type extends Comparable<Type>> {...
我完全理解它的目的,但不理解语法。在我看来这应该是公正的
public class BinarTree<Type extends Comparable> {...
是什么意思
<Type extends Comparable<Type>> ?
^^^^
我在java中创建了自己的链接列表数据结构,其中链接列表中的每个节点都将包含另一个类的对象(例如,car类,.So),它基本上是一个汽车链接列表。
public class car {
private String carName;
private double price;
car(String name,double price){
this.carName=name;
this.price=price;
}
public int compareTo(car newCar)
我正在尝试构建一个treemap,并为键的类实现了我自己的可比较接口,但我仍然收到一个“无法转换为可比较的”异常,我真的不明白为什么。以下是我的代码的相关部分:
接口:
public interface Comparable<T> {
public int compareTo(T o);
}
键的类别:
public class PriorityBuy implements Comparable<PriorityBuy>{
protected double _priceDouble;
protected DollarValue _priceDollarValue
我试着对下面的线程进行评论,但是我没有足够的代表点。
我的简单问题是:以下两种代码有什么区别?
请注意:我不确定前者是否是有效的语法,也许这就是答案。
public class BinarySearchTree<T> extends Comparable<T> {}
public class BinarySearchTree<T extends Comparable<T>> {}
我读到的这个答案消除了我的疑虑,但我不明白这句话中有一件事:
T extends Comparable< ? super T>
在那篇文章的回复中,每个人都解释说T实现了Comparable<T or T's superclass>;但是有写的扩展,所以T是一个可比较的子接口,而不是一个子类,那么为什么所有的答复都要作为动词呢?
我唯一的猜测是,它们都暗示T是一个对象,其静态类型是可比较的子接口,但是动态类型实际上是一个可比较的实现类,是这样吗?
我想我想做的是清楚的,但我不是泛型专家。
import java.util.ArrayList;
public class MinHeap<E extends Comparable> extends ArrayList<E> {
/* A simple wrapper around a List to make it a binary min-heap. */
public MinHeap() {
super();
}
@Override
public boolean add(E e) {
su
我正在研究数据结构,并被要求编写一个允许存储经理使用4个类操作库存的程序: ListInterface、ExpandableArrayList (实现接口的类)、类项(存储在Arraylist中的类型),当然还有一个Test类。
有些方法需要使用compareTo。也就是说,作为可比较的,但是我不知道哪个类应该是可比较的?如果我要写,实现还是扩展比较呢?
下面是我现在拥有的类标题:
public interface ListInterface<T extends Comparable <?super T >> {... }
public class Expandabl