nooby, Android is not really Linux. I like to call Android the "inbred third cousin of Linux" because the way it works does not make much sense to me.
It does have, as its core, a Linux kernel. However, everything on top of that, everything that is added to that, is Java and, as such, must be interpreted at runtime.
A bit more info on that... there are basically two kinds of programming language, that which is
compiled and that which is
interpreted. The distinction is really a matter of "when".
Compiling, in programming jargon/lingo/phraseology refers to a particular action of transformation. If you write programming ("code" in programmer slang) in, say, C++, you have a little problem with
executing that code -- it is not a language that any piece of discrete hardware actually can use, natively. So it must be translated into what is called 'assembly language', 'assembly code', or 'machine code' -- binary (10101101) represented usually as hexadecimal ("hex") pairs with a 0x prefix (0x9A216D = 10101101).
If you
compile your code (this is how C++ tends to work) then it is compiled once, and you have a 'binary' or 'executable' that you can run basically whenever you want to.
Interpreted code, however, does not form an executable file -- it instead remains source code until execution is ordered. It only gets compiled when it runs, but it must compile each and every time it runs. This is how Java works, by design.
So Android is very strange, because almost all of its functionality depends on interpreted code that must be compiled at each runtime -- and certainly not all at once! This is why (at least, as far as I can tell) it needs tremendous processor power and RAM space to work with, and why lower-power ARM tablets (such as the under-$100 Chinese ones all over eBay) are horridly slow.
On the other hand, there is a tremendous benefit to this, and I'm pretty sure that this one feature is why Google made Android the way they did. Once you have a kernel and some small interpreter on top of it, you don't have to worry about what hardware is underneath. Android can run on literally almost
anything because the Java-interpretation method allows user programs and interfaces to completely ignore what hardware is underneath -- everything becomes a simple question of computing "horsepower". One does not have to design for this processor vs. that processor (which is very good, because ARM systems tend to have extreme hardware differences) -- just code a program for Android, and it will run in Android.
This brings to mind a term I like to use sometimes, "kludge". I'm told it's properly spelled "kluge" and pronounced "klooj" but I tend to pronounce it "kluhj". I'm American. We do a lot of things wrong around here, why make any exceptions?
"Kludge", as I use it, is a synonym of "jerry-rig" or "jury-rig" (I've never been able to pin down the proper spelling). That is to say, an apparently hazardous and seemingly poorly-thought-out solution to a problem, usually using scrap and spare materials that are readily at hand. (Such as using a Pringles can and duct tape for car engine repairs,
like this.)
One might consider Android to be an "elegant kludge" (normally a severe contradiction in terms). That is: it works wonderfully, with few undesirable side effects, but for all the wrong reasons.