Let's start with the fact that you most likely began to learn Java not from the fact that you immediately started writing GUF in JavaFX and organizing client-server interaction, but from the very foundations and simplest examples in the console. When learning to develop Android, you should do the same - to do the simplest examples, gradually complicating the tasks. In fact, the Android framework is a separate eco-system that only uses the Java language to write code, and all this requires a separate learning from scratch.
I would advise you to study according to the book from BigNerdRanch: B. Hardy - "Android. Programming for Professionals" - 2015 (2nd edition) - this is probably the only worthy book in Russian for a beginner. The training is based on the fact that a specific task is put (some kind of application) and consistently, step by step, with detailed explanations, this task is being implemented. As a result, you write a real working application (there are five of them, if memory serves me, the source code of all applications are available on GitHub and are easily found by name) and you will even understand how to do it yourself. Also, this book will give you a holistic view of the application's device and the interaction of its parts, unlike reference books or lessons on the Internet, which provides scattered information about individual elements, leaving yourself to think about how to combine all this into a working and not frightening the rest who see the code, the application :) With a little zeal, you can find a free electronic copy of this book.
About obsolete classes and or heirs. The fact that you hardly have to use ListActivity in real-world development, regardless of its obsolescence, since it is the least flexible in the implementation of the list, we will omit here.
The point is: the base class of the screen of the Android application is the Activity class. Using only this class you can certainly implement all the necessary functionality. The classes ListActivity from the basic Activity only add some functionality, for example, the ListActivity implements the listener and simplifies the connection of the markup, basically it is done in the usual activation in a few lines of code. As for AppCompatActivity , it was created in order to support Material Design on devices with API <21 (up to Android 5.0, where this design is by default) along with the AppCompat support library and provide ActionBar interaction with this support library. I do not think that design delights are the primary task at the beginning of training, the main thing for you is to learn how to work with the framework, you will always have time to decorate. It is also worth noting that if you do not intend to distribute your lessons, then there is no need for backward compatibility.
When you start learning, you should not pay attention to the "obsolescence" of information or classes - the principles in the database remain unchanged and the "new" classes do not carry anything cardinally new. On the contrary, an understanding of working with "obsolete" classes will facilitate the use of "new" ones, since you only need to understand what (and why) has been added. In the case of AppCompatActivity generally possible, with some minor reservations, to consider it as an Activity , that is, to use it equally.
Thus, in training projects you can with full confidence use the Activity class, ListActivity and any other class that is required to understand the task, without paying attention to its obsolescence. When you understand the principles of working with the framework enough to write your own application, you can easily determine exactly what type of activation you need for each individual screen, you should not bother now. If you are confused by the default creation of activit, then simply delete the first nine letters (leaving the extends Activity ) and change the application theme from AppCompat to any of Holo, or do not pay attention to it at all - AppCompatActivity naturally implements all the basic methods of the Activity and to work An example of this will not affect, as a rule.
As for templates, the only template that should be used is Blank Activity, for which the rest remains a secret with seven seals :), a beginner cannot master them due to extreme congestion, an experienced person implements everything independently, as he needs for a specific task, it is easier than Adapt someone else's workpiece to your decision. All these templates are extremely redundant and unnecessarily confusing.
About the level of knowledge of Java. Possession of basic language capabilities at a good level is enough for writing a full-fledged application. The most relevant knowledge of the framework itself, its classes, the structure of applications, interaction with the system, the principles of layout of models and so on. In particular, the life cycle causes many misunderstandings at the beginning.
Google has created a very good portal Android developer , which includes both a complete description of the API, and many guides, examples and instructions. In addition, here you will always get the most up-to-date information, in particular, on the differences between the AppCompatActivity and the basic Activity (a brief description and which methods were added to the inherited and by the way, pay attention to the inheritance chain). A nice bonus is that the portal is actively being translated into Russian and many articles can be read in their native language. I advise you to study it very carefully after reading the book above and gaining an initial understanding of the principles of development under this framework. You can start from here
Well, there is a huge amount of ready-made answers, as well as people who are always ready to answer a good new question.
PS: if some moments are not clear enough, write in the comments, add the answer.
