在准备SCJP-6考试时,我遇到了一个棘手的问题.我自己找不到答案.请回答问题并简短评论:
abstract class A<K extends Number> {
// insert code here
}
public abstract <K> A<? extends Number> useMe(A<? super K> k);
public abstract <K> A<? super Number> useMe(A<? extends K> k);
public abstract <K> A<K> useMe(A<K> k);
public abstract <V extends K> A<V> useMe(A<V> k);
public abstract <V super K> A<V> useMe(A<V> k);
public abstract <V extends Character> A<? super V> useMe(A<K> k);
public abstract <V super Character> A<? super V> useMe(A<K> k);
可以在上面的占位符中插入哪种方法？
PS我试着看看规范.那些对我没有帮助.
我想知道为什么在Java中首先允许这个(或者一般的oops)我记得静态方法对于父类和子类都是常见的
public class Redefine extends Parent{
public static void test () {
}
}
class Parent{
public static void test () {
}
}
Q1:由于重写不支持静态方法,如何既能CLASSE包含相同的方法呢？
Q2:如果在static中更改方法则抛出未定义的异常,而不是编译.为什么会这样.它显然不是压倒一切所以我应该被允许抛出新的例外吗？
public class Redefine extends Parent{
public static void test () throws Exception{
}
}
我认为我对Java泛型有一些很好的理解.
这段代码没有编译,我知道为什么.
我们只能传递给测试方法类型Animal的类型或它的超类型(如对象列表)
package scjp.examples.generics.wildcards;
import java.util.ArrayList;
import java.util.List;
class Animal {}
class Mammal extends Animal {}
class Dog extends Mammal {}
public class Test {
public void test(List<? super Animal> col) {
col.add(new Animal());
col.add(new Mammal());
col.add(new Dog());
}
public static void main(String[] args) {
List<Animal> animalList = new ArrayList<Animal>();
List<Mammal> mammalList = new ArrayList<Mammal>();
List<Dog> dogList = new ArrayList<Dog>();
new Test().test(animalList);
new Test().test(mammalList); // Error: The method test(List<? super Animal>) in the type Test is not …有人问我这个问题:
String s = "abc"; // creates one String object and one
// reference variable
In this simple case, "abc" will go in the pool and s will refer to it.
String s = new String("abc"); // creates two objects,
// and one reference variable*
基于以上细节,在下面的代码的println语句之前创建了多少个String对象和多少个引用变量？
String s1 = "spring ";
String s2 = s1 + "summer ";
s1.concat("fall ");
s2.concat(s1);
s1 += "winter ";
System.out.println(s1 + " " + s2);
我的回答是这个代码片段的结果是春冬春夏
有两个参考变量,s1和s2.共创建了八个String对象:"spring","summer"(lost),"spring summer","fall"(lost),"spring fall"(lost),"spring spring spring"(丢失) ),"冬天"(丢失),"春天的冬天"(此时"春天"丢失).
在此过程中,八个String对象中只有两个不会丢失.
这是对的吗？
在回答有关此问题的问题时:https://stackoverflow.com/a/9872630/82609
我试着做以下事情:
Comparator<String>[] comparators = new Comparator[] {...};
有用!但以下不是:
Comparator<String>[] comparators = new Comparator<String>[] {...};
在相关问题上,我做了以下假设:
我想这是因为最初的数组合约可能是这样的:
如果你创建一个X类型的数组,你将永远不能在其中放入任何IS-NOT-AN X.如果你尝试,你会得到一个ArrayStoreException
因此,允许使用泛型创建的数组会导致不同的规则,例如:
如果你创建一个类型的数组
X<Y>,你将永远不能放置任何IS-NOT-AN X.如果你尝试,你将得到一个ArrayStoreException.但是你可以添加两个X<Y>和X<Z>对象,因为类型擦除!
但是考虑一下,它真的会成为一个问题:
Comparator<String>[] comparators = new Comparator<String>[] {...};
我真的不明白为什么它不可能,因为使用这样的东西会:
最后,我们可以使用具有泛型类型引用的数组,并且由于不可能创建具有泛型类型的数组,我想很多人甚至不知道它是可能的.
我只是想知道是否有人知道这个选择背后的原因？
这有点像强迫人们使用List<String> = new ArrayList();而不是使用List<String> = new ArrayList<String>();
dimitrisli你从约书亚布洛赫的着名书中给出了一个很好的例子.正如您/他解释的那样,使用泛型数组+协方差并且可能导致ClassCastException是危险的,而我们期望使用协方差从数组中获取ArrayStoreException.
但请注意以下内容仍然合法且导致相同:
List<String>[] stringLists = new List[1];
List<Integer> intList = Arrays.asList(42);
Object[] objects = stringLists;
objects[0] = intList;
String s = stringLists[0].get(0);
但是,它会在编译时生成未经检查的强制转换警告,正如您所提到的,在运行时会产生ClassCastException.
我在Java中编写了一个实用工具方法:
public static final ImmutableSortedSet<TimeUnit> REVERSED_TIMEUNITS = ImmutableSortedSet.copyOf(
Collections.<TimeUnit>reverseOrder(),
EnumSet.allOf(TimeUnit.class)
);
/**
* Get the number of ..., minutes, seconds and milliseconds
*
* You can specify a max unit so that you don't get days for exemple
* and can get more than 24 hours if you want to display the result in hours
*
* The lowest unit is milliseconds
* @param millies
* @param maxTimeUnit
* @return the result map with the higher unit first
*/
public …这个问题来自Kathy Sierra SCJP 1.6.有多少个对象符合垃圾收集的条件？
根据Kathy Sierra的回答,确实如此C.这意味着两个对象有资格进行垃圾回收.我给出了答案的解释.但为什么c3不符合垃圾收集(GC)的条件？
class CardBoard {
Short story = 200;
CardBoard go(CardBoard cb) {
cb = null;
return cb;
}
public static void main(String[] args) {
CardBoard c1 = new CardBoard();
CardBoard c2 = new CardBoard();
CardBoard c3 = c1.go(c2);
c1 = null;
// Do stuff
} }
何时// Do stuff到达,有多少对象符合GC条件？
回答:
Short包装器对象,该对象也符合条件.在昨晚阅读了一些SCJP认证后,我开始考虑切换语句以及如何评估表达式,我对某些事情感到有些困惑.
Java不会让你打开布尔值,所以以下内容不会编译:
public static void switchOnBoolean(boolean theBool)
{
System.out.println("\n\nAssessing boolean :" + theBool);
// line below won't compile, since booleans are not valid for the switch statement
switch(theBool)
{
case true:
{
System.out.println("The boolean was true");
break;
}
case false:
{
System.out.println("The boolean was false");
}
}
}
但是,如果您尝试在case块中使用求值为布尔值的表达式,编译器将不会抱怨,例如:
public static void switchOnChar(char theChar)
{
System.out.println("\n\nAssessing char : " + theChar);
switch(theChar)
{
case 'a':
{
System.out.println("The char was a");
break;
}
case 'b':
{
System.out.println("The char was b");
break; …鉴于:
public class Spock {
public static void main(String[] args) {
Long tail = 2000L;
Long distance = 1999L;
Long story = 1000L;
if ((tail > distance) ^ ((story * 2) == tail)) {
System.out.print("1");
}
if ((distance + 1 != tail) ^ ((story * 2) == distance)) {
System.out.print("2");
}
}
}
为什么这个示例代码不输出任何内容？
我对保护标识符有一些疑问.在K.Sierra的Sun认证Java程序员学习指南的第一章中,我发现了以下信息:
"一旦子类 - 包外继承受保护的成员,该成员(由子类继承)对子类外的任何代码都是私有的,除了子类的子类."
我提供了反映上述陈述的示例代码,对我来说绝对清楚.
// Parent class
package package1;
import package2.Child;
public class Parent {
protected int i = 5;
}
// Child class
package package2;
import package1.Parent;
public class Child extends Parent {
// variable 'i' inherited
}
package package2;
public class Neighbour {
public void protectedTesting(){
Child child = new Child();
System.out.println(child.i); // no access
}
}
我已经开始尝试并进行了一些小改动 - 将Neighbor移到package1.并且可以访问"i"变量,这对我来说有点令人惊讶,因为它不符合语句"对子类之外的任何代码变为私有"
更改后的邻居类:
package package1;
import package2.Child;
public class Neighbour {
public void protectedTesting(){
Child child = new …