看看这段代码:
public class Test {
public static void main(String... args) {
flipFlop("hello", new Integer(4), 2004);
// flipFlop("hello", 10, 2004); // this works!
}
private static void flipFlop(String str, int i, Integer iRef) {
System.out.println(str + " (String, int, Integer)");
}
private static void flipFlop(String str, int i, int j) {
System.out.println(str + " (String, int, int)");
}
}
编译器给出一个错误,调用是不明确的:
说明资源路径位置类型方法flipFlop(String,int,Integer)对于Test Test.java scjp19类型是不明确的 - inheritence/src第3行Java问题
但是如果使用注释掉的行ti调用触发器,则该方法被明确地调用(第二个,因为在使用基元本身之后进行自动装箱).
我希望编译器看到第二个参数将以某种方式取消装箱,并根据第三个参数判断必须调用哪个方法.为什么不这样呢？理由是什么？
我被问到一个问题(在这个网站http://scjptest.com/上):在这行代码示例中有多少对象符合垃圾收集的条件//某些代码在这里？
class A {
private B b;
public A() {
this.b = new B(this);
}
}
class B {
private A a;
public B(A a) {
this.a = a;
}
}
public class Test {
public static void main(String args[]) {
A aa = new A();
aa = null;
// some code goes here
}
}
正确答案是:"a和b引用的对象有资格进行垃圾回收." 但为什么？它们包含彼此的循环引用,它们可以相互访问.
谢谢!
有人可以解释一下阵列在Java中是如何工作的.
我对以下代码感到惊讶:
Object test = new Object[2][2];
Object test2 = new Object[] {
new Object[2],new Object[2]
};
Object test3 = new Object[2][];
((Object[])test3)[0] = new Object[2];
((Object[])test3)[1] = new Object[2];
System.out.println(test instanceof Object[]);
System.out.println(test instanceof Object[][]);
System.out.println(test2 instanceof Object[]);
System.out.println(test2 instanceof Object[][]);
System.out.println(test3 instanceof Object[]);
System.out.println(test3 instanceof Object[][]);
只有test2不是Object [] []的实例
运行时有什么区别？
编辑:我看到一些答案.Jon Skeet,请注意我能做到:
Object[] test4 = (Object [])test;
test4[0] = "blaaa";
test4[1] = "toto";
System.out.println(test4);
test instanceof Object []返回true,并且在转换时没有在运行时引发异常.根据SCJP的Sierra&Bates一书,测试IS-A Object [] []还有一个Object []
但是当试图用"test4 [0] ="blaaa";"重新分配一个新值时,我得到一个异常:线程中的异常"main"java.lang.ArrayStoreException:Main.main中的java.lang.String(Main. Java的:24)
所以在运行时看来,test和test2都是IS-A Object …
我尝试了以下简单的测试.
class ZiggyTest{
public static void main(String[] args){
List<Cities> cities3 = new ArrayList<Cities>();
Cities city = new Cities("London");
cities3.add(new Cities("Manchester"));
cities3.add(new Cities("Glasgow"));
cities3.add(new Cities("Leeds"));
cities3.add(city);
cities3.add(new Cities("Leicester"));
cities3.add(new Cities("Croydon"));
cities3.add(new Cities("Watford"));
System.out.println("IndexOf(new Croydon) "
+ cities3.indexOf(new Cities("Croydon")));
System.out.println("IndexOf(city) "
+ cities3.indexOf(city));
}
}
class Cities implements Comparable<Cities>{
String title;
Cities(String aTitle){
this.title = aTitle;
}
public String getTitle(){
return title;
}
public String toString(){
return "Title : " + title;
}
public int compareTo(Cities c){
return title.compareTo(c.getTitle());
}
}
上述测试的输出是 …
我有以下示例的问题:
import java.util.regex.*;
class Regex2 {
public static void main(String[] args) {
Pattern p = Pattern.compile(args[0]);
Matcher m = p.matcher(args[1]);
boolean b = false;
while(b = m.find()) {
System.out.print(m.start() + m.group());
}
}
}
和命令行:
java Regex2 "\d*" ab34ef
有人可以解释一下,为什么结果是:01234456
正则表达式是d* - 它意味着第一或更多,但在args [1]中有更多的位置,
谢谢
摘自SCJP 6准备书 -
鉴于:
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
}
}
当达到// doStuff时,有多少对象符合GC条件？
A. 0
B. 1
C. 2
D.编译失败
E.无法知道
F.运行时抛出异常
正确答案是C - "只有一个CardBoard对象(c1)符合条件,但它有一个相关的Short包装器对象,也符合条件."
我的问题是为什么c3不符合收藏资格？
我的想法是 -
c1.go(c2)将本地引用变量cb(它是c2的副本)设置为null,然后返回分配给c3的cb.我知道c2本身的引用变量不能在方法中修改,只能修改它背后的对象.但是在我看来,引用变量cb的副本被设置为null并分配给c3.为什么在此实例中c3未设置为返回的null？
我对instanceof感到困惑.我的理解是instanceof是检查对象类型.字符串是对象,但在以下程序中它显示不匹配.请解释一下.
public class MyTest
{
static String s;
public static void main(String args[])
{
String str = null;
if(s instanceof String)
{
System.out.println("I am true String");
}
else
{
System.out.println("I am false String");
}
if(str instanceof String)
{
System.out.println("I am true String");
}
else
{
System.out.println("I am false String");
}
}
}
The output is
I am false String
I am false String
谢谢提前.
我已经学习了一些OCPJP 7认证的书籍,在内部课程章节中有一些奇怪/不完整的信息.我试图在方法中创建一个接口,但似乎你不能这样做,你只能在方法中创建类.你有什么理由不能这样做,或者它只是一个缺失的功能？
示例代码:
public class Outer {
public void method() {
class C {} // allowed
interface I {} // interface not allowed here
}
}
考虑以下代码
class ConstructorDemo2{
ConstructorDemo2(){
this(1);
}
ConstructorDemo2(int i){
this();
}
public static void main(String[] args){
new ConstructorDemo2();
}
}
Kathy Sierra的SCJP6书在第144页上说,这样的代码可能无法检测到并导致StackOverflowError.但与此同时,我们知道子类构造函数ALWAYS必须使用super()[默认由编译器提供] 来调用超类构造函数,但在下面的代码示例中,两个构造函数都在调用this()(相互调用).
它确实显示了error: recursive constructor invocation我的OpenJDK编译器中的错误,但Kathy Sierra的书中说这样的代码可能不会被编译器检测到并且会在运行时抛出异常.
因此,如果在SCJP/OCJP考试中向我展示了这样的代码示例,并询问它是否会编译,那么答案是什么？看起来有点暧昧
以下代码示例编译但带有编译器警告
class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}
class SubArrayList<T> extends ArrayList{}
class ZiggyTest2{
public static void main(String[] args){
ArrayList<Animal> nums = new SubArrayList<Animal>();
}
public static void testMethod(ArrayList<Animal> anim){
System.out.println("In TestMethod");
}
}
当我编译以上时,我得到以下警告
Note: ZiggyTest2.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
或者,如果我使用-Xlint编译它:未选中我收到以下警告
ZiggyTest2.java:12: warning: [unchecked] unchecked conversion
found : SubArrayList<Animal>
required: java.util.ArrayList<Animal>
ArrayList<Animal> nums = new SubArrayList<Animal>();
^
1 warning
如果我将nums的初始化更改为
List<Animal> nums = new ArrayList<Animal>();
然后我没有得到任何警告.
他们为什么表现不同.ArrayList是List的子类型,SubArrayList是ArrayList的子类型,所以我期望实例化是相同的.
谢谢.