Brian Spindler

passing is 65%, you probably want to be well into the 80% range before taking the exam.

Thanks! I think it's clearer now.

But Float is a subtype of Number, just as Object is a super type of String in the declaration before it and Number is a super type of Integer in the declaration after it. Why the change in behavior for the extends wildcard declaration?

Alright, I'm trying to nail down the rules regarding generics. I have the following class/test cases:

package generics; class Test1<T> { public static void main(String args[]) { // legacy, no type - produces compile unchecked // warnings new Test1().meth(new Integer(42)); // 1 Test1<? super String> t2 = new Test1<Object>(); t2.meth("foo"); // any type or subtype of Number Test1<? extends Number> t = new Test1<Float>(); // ERROR: why? t.meth(100.0f); // any super type of Integer Test1<? super Integer> t1 = new Test1<Number>(); t1.meth(1); // 3 } public void meth(T type) { System.out.println(type); } }

On the line marked "ERROR" I get this from the eclipse workspace:
The method meth(capture#2-of ? extends Number) in the type
Test1<capture#2-of ? extends Number> is not applicable for
the arguments (float)

I would have guessed that because Test1 was parameterized with <Float> that T would resolve to Float. It appears that at this point, the only valid T argument for meth is null. Someone please explain.

John is right, you can demonstrate this by adding just one more method with another different paramter. Once you do this, your class will not compile because the call is indeed ambiguous.

Uncomment the third method to test:

import static java.lang.System.out; public class TestAmbiguity { public void m(Object o) { out.println("object"); } public void m(String o) { out.println("string"); } // public void m(Integer o) { // out.println("integer"); // } /** * @param args */ public static void main(String[] args) { new TestAmbiguity().m(null); } }

It works the same for varargs and autoboxing, the compiler will compile this just fine:

void m(Integer... i) {} void m(int... i) {}

but as soon as you try to call one of these methods like so:

m(1)

it fails to compile because it's ambiguous.

HTH.

I think it's becoming much clearer now; it's really about the placement of the [] in regards to the association of the variable.

Thanks all!

can someone explain why b gets a two dimensional declaration in this code:

public class TwoDimensionalArrayDeclaration { int[] foo = {1}, bar [] = {{2}, {3}}; /** * @param args */ public static void main(String[] args) { // what this actually declares is that "b" is a // two dimensional array int[] a = null, b [] = null; // and so this line fails to compile //a = b; TwoDimensionalArrayDeclaration tdat = new TwoDimensionalArrayDeclaration(); System.out.println(tdat.foo + " : " + tdat.bar ); } }

Nevermind foo and bar; they are my examples to prove the point visually.

little searching on google turned up: http://www.wikijava.org/wiki/Execute_external_program_(ping_and_complain)

changing your pattern to:

Pattern p = Pattern.compile("<a['\"\\w\\s\\d/\\.'\">_~=(),;?<>< :\\-\\'].*?\\/a>");

will get you what you want. you must specify the end of the regex, you might want to replace the .*? with something more specific.

Thanks Steve, I have NO control so I think I'm going to have to find a happy medium along the lines of your example. Thanks!

yeah, I understand. unfortunately I'm consuming Events from an API which I have no control over.

So I've got an Event listener class that has to handle events. Right now the events are received as an Array so I have :

Event[] events = retrieveEvents();

My issue is that right now the code does something like:

for(Event e : events) { if(e instanceof ...) {} if(e instanceof ...) {} if(e instanceof ...) {} if(e instanceof ...) {} if(e instanceof ...) {} }

What are some alternative strategies/patterns to this design? All events are certain subclass types and processing is specific per class type but sometimes the same for several (Event1 and Event2 are same but Event3 requires special handling).

Thanks in advance!

Thanks Ranchers! I think I've got enough to go on. At this point I'm leaning towards the FutureTask approach, it seems perfect for my needs. I need to submit N tasks and wait for them to finish processing before I can return the computation.

And thanks Jim for the heads up on the synchronization issues.

Image you have a method doWork() that can take several minutes to complete, you want to spawn a bunch of these from your getWorkDone() method and wait for them to complete then return. Help me to improve the following code:

public class TestInnerRunnable { private int running = 0; public TestInnerRunnable() { } public void getWorkDone() { for (int i = 0; i < 500; i++) { Executors.newSingleThreadExecutor().execute(new Runnable() { public void run() { doWork(); } }); } do { try { Thread.sleep(1 * 1000); System.out.println("Main thread sleeping..."); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } while (running > 0); System.out.println("Threads finished!"); } public void doWork() { this.setRunning(this.getRunning() + 1); try { System.out.println("Thread-" + Thread.currentThread().getId() + " running..."); for (int i = 0; i < 10; i++) { Thread.sleep(1 * 1000); System.out.println("Thread-" + Thread.currentThread().getId() + " processing [" + i + "]..."); } } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } finally { this.setRunning(this.getRunning() - 1); } } public synchronized int getRunning() { return this.running; } public synchronized void setRunning(int r) { this.running = r; } public static void main(String[] args) { TestInnerRunnable tir = new TestInnerRunnable(); tir.getWorkDone(); } }
[ June 16, 2007: Message edited by: Brian Spindler ]

Ahh... now I see where the confusion comes from ( I think)

In the preceding example from K&B the a[x].doStuff() is a method call on the Animal reference array. being defined as:

Animal [] a = {new Animal(), new Dog(), new Animal()};

The compiler can only check that Dog() IS-A animal and since this succeeds the code succeeds, HOWEVER since static does not adhere to polymorphism there is no dynamic linking during runtime of the new Dog().doStuff(), it executes Animal.doStuff().

In the preceding example you are implicitly executing the class method (static) in each constructor.