hello, EGHDK

how can I help you today?

Hey Mark. So I'm still reading my intro to java book combined with watching some tutorials online and I just have a java question that I think you can explain to me.

OK

So I was watching an android tutorial on how to do network calls. And the tutorial showed the pre honeycomb the network call worked on the main ui thread, but post HC you need to do it off the main thread.

The first thing the tutorial shows (before he goes into an asynctask) was he showed how to create a new java thread.

I understand that I use asynctasks in Android, but I want to learn "threads" as well.

And I guess I just don't get how that code above actually compiles.

OK

how does the compiler know what "new Thread()" means. I feel like I've never encountered that. Thread myThread = new Thread(); makes more sense to me.

first, on the Android front, the tutorial should have indicated that it was a really bad idea to do the network call on the main application thread, and that they just started beating you on the head for it with API Level 14

now, onto the Java

let's take a simpler scenario

int i=1;

this assigns 1 to a variable (or data member) named i

yep

and you usually see numbers used in situations where it is part of a larger statement, like as a parameter to a method (e.g., object.foo(1);)

however, the Java statement 1; is perfectly legal

it doesn't do much

and perhaps would be optimized away by the compiler

oh, wait

sorry

that doesn't work with primitive values like ints

scratch that

Eclipse complain about `1;`, but maybe that's just eclipse.

oh Okay. Cool Eclipse: "The left-hand side of an assignment must be a variable"

let's try this again from the top

String foo="bar";

No prob. If anyone is gonna make sense out of this to me... it's gonna be you.

"bar" here is a literal String object

which we assign to foo

but the key is that "bar" is an object

all we do with String foo="bar"; is give the object a name by which we can reference it later

(and create a reference, of relevance for garbage collection, but beyond the scope of this explanation)

"bar" is an object? or is foo an object?

Or both... technically.

"bar" is an object

foo is the name of a variable

Gotcha.

in conversation, we will say that foo is an object, but that's a bit of shorthand

the more accurate thing would be: foo points to an object, initially "bar"

Crystal clear.

now, "bar"; is not a valid Java statement on its own

just as 1; wasn't

(for which I again apologize -- in some languages, it is a valid statement, just not Java)

but "bar".length(); *is* a valid Java statement

Quite alright.

we are calling the length() method on the "bar" object

(hello, Jeff, I will be with you shortly!)

hmm.. Did not know that.

EGHDK: now, in this case, nothing much happens, because length() does not modify "bar"

nor does it have any other side effects

which is why you do not see Java statements like "bar".length(); in use, even though they are legal

now, suppose we have a statement: new Restaurant().open();

this too is a valid Java statement

we are creating an instance of a Restaurant instance, and calling open() on it

depending on what open() does, this may be useful, even if we are not assigning the Restaurant, or any return value from open(), to a variable

for example, open() might stick the Restaurant in some static collection of Restaurant objects

so you will see that construction a bit more in Java, though it is still relatively uncommon

one of the few places where you will see that more often, ironically, is the scenario that caused you confusion: new Thread() { public void run() {} }.start();

because calling start() on a Thread starts the OS thread

now, if we needed to refer to this Thread later on, we would be well advised to hold onto it somewhere

OS thread?

operating system thread

threads are a construct of an operating system

just as files are a construct of an operating system

Interesting. Didn't know that either.

Gotcha. So last thing about Thread that I don't 100% understand, and I feel like I've seen it in other places too. new Thread(){ public void run(){} }.start();

languages *expose* threads and files to programmers

Why is it not new Thread().run()?

actually, let me take a question from Jeff, and I'll return to your run() vs. start() question in a moment

Jeff: do you have a question?

No prob

yes

2 quick ones

OK, give me the first one

1. about a month you and I swapped some email about a problem with the new Droid mini crashing the camera code. I might be presenting camera code to the NYC Android meetup so I wondered if you looked into it more

it was https://github.com/commonsguy/cwac-camera/issue...

that device demands activation on the Verizon network

I bought one from Amazon, then couldn't do a damn thing with it, so I returned it

ah - I got it working with rotation after the picture

but the garbage collection takes several seconds which sucks

question 2

yes, I'm looking into switching my own rotation code to NDK (or perhaps Renderscript) for similar reasons

I don't like post-rotation but it seems unavoidable in some circumstances

question 2

I'm using ProgressBar and SeekBar now. Is there some enhanced version with increments on the bars, etc?

you mean, tick marks?

yea, like an old school number line

nothing in the SDK

possibly there's a third-party one that offers it

try AndroidViews.net and see if one shows up there

I can build it but feels like someone should have solved it

thanks

EGHDK: back to you

So my question isn't really run vs start, more of a "Putting brackets after a new Object() doesn't make sense to me. To me that shouldn't work".

ah

Or does that type of thing have a name that I don't know. Because if I can pin a name to it... then it would make more sense to me I think.

hold on one moment while I look up something to help with the explanation...

Thanks

OK, let's imagine that we had: new Thread().start();

start() starts the OS thread, and arranges to call the run() method of the Thread on that OS thread

Okay. Makes sense.

the problem is that the built-in run() of Thread is not that useful on its own

so we need run() to do something meaningful

one approach is to create a subclass of Thread, with a better run() method

e.g., class MyThread extends Thread { public void run() {} }

then, new MyThread().start(); would run my overridden run() method

Yep

Got it

in addition to regular Java classes, using the extends keyword, Java supports "anonymous inner classes"

these are effectively throwaway classes, designed to be used to instantiate just one object of that class

the syntax is a mashup of declaring a regular class ({ public void run() {} }) and instantiation (new keywoard)

er, keyword

so, new Thread() { public void run() {} }.start() is saying:

first, we are creating an anonymous inner class, extending Thread, we we override the run() method

second, we are creating an instance of that class

third, we are calling start() on that instance

this is not especially newcomer-friendly syntax

but it works

Okay, yeah. It does make sense though.

note that you can create an anonymous inner class that implements an interface, instead of extending an existing class

you will see that in a lot of Android examples, particularly with listeners

button.setOnClickListener(new View.OnClickListener { public void onClick(View v) {} });

View.OnClickListener is an interface, not a class

but the same syntax works

Yeah... well that's what I was gonna say. This "new Thread" thing reminded me of OnClickListeners, and those confuse the hell out of me.

View class "implements" onCLickListener?

let me take another question from Jeff, and I'll come back to you in a bit

Jeff: do you have another question?

OK, back to you, EGHDK

OnClickListener is an interface

it is implemented inside the View class

much like how a regular inner class is implemented inside of another class

and so, View here is serving as a bit of a namespace

correct

OK, I misused "implements" a bit earlier

I'm guessing KeyEvent.CallBack is onClickListener?

let's try this again

OnClickListener is an interface

it is *defined* inside the View class

KeyEvent.Callback is not an OnClickListener

nor is Drawable.Callback, nor AccessibilityEventSource

those three, and View.OnClickListener, are all interfaces

View *implements* those three, meaning that View must have methods fulfilling all their contracts

View *defines* OnClickListener inside of itself, and so other pieces of code can reference that interface as View.OnClickListener

Interesting. I didn't know that you could define a interface inside of a class. I thought you had to define them in their own file.

Thanks for clearing that up.

you can define classes and interfaces inside of other classes (e.g., "inner classes") as well as in separate files

Jeff: if you have another question, chime in

Okay. My last question before times up. I am basically drawing two circles (Think ven diagram). I have 50% transparency on both. Right where they intersect... the image is darker (50% +50%). Is there anyway to stop this?

beats me

Not sure if that makes sense.

my guess is no, and that regular color blending rules, including the alpha channel, will apply

Heh. Okay. I thought I saw a video with Romain about doing that with Bitmaps... but I don't remember where I saw it.

but that's just a guess

Yeah, I know ROmain showed a way to do it with pictures. Because he had 4 pictures cascaded on top of each other. All transparent. But the blended in with each other. And he said that that wasn't the desired outcome. And he did something, and it layered the pictures... but still had transparency.

Oh well. Guess it's time to look at old google i/o videos again. Thanks again mark. That finally makes sense to me. "Anonymous inner classes". Learn something new every day.

you are not the first to complain about anonymous inner classes

you probably won't be the last

Yeah. I guess it wasn't a complaint. Just more of a "doesn't make sense because that's almost never ever used" type of thing.

every language has its set of "power coder" syntax

this happens to be part of Java's

I guess I'll take it as that.

I'm becoming a java power coder. Hahaha

and that's a wrap for today's chat

the transcript will be posted to http://commonsware.com/office-hours/ shortly

the next chat is Thursday at 10am Eastern

have a pleasant day!