7. Java Variables, Operators, and Expressions
by John Horton
Android Programming for Beginners - Second Edition
- Android Programming for Beginners - Second Edition
- Table of Contents
- Android Programming for Beginners - Second Edition
- Contributors
- Preface
- 1. Beginning Android and Java
- 2. First Contact – Java, XML, and the UI Designer
- Examining the log output
- A note for early adopters of this book
- Exploring the project's Java code and the main layout's XML code
- Adding buttons to the main layout file
- Leaving comments in our Java code
- Coding messages to the user and the developer
- Writing our first Java code
- Frequently asked questions
- Summary
- 3. Exploring Android Studio and the Project Structure
- 4. Getting Started with Layouts and Material Design
- Material design
- Exploring Android UI design
- Layouts
- Creating the Exploring Layouts project
- Building a menu with LinearLayout
- Wiring up the UI with the Java code (part 1)
- Adding layouts within layouts
- Making the layout look pretty
- Wiring up the UI with the Java code (part 2)
- Building a precise UI with ConstraintLayout
- Laying out data with TableLayout
- Summary
- 5. Beautiful Layouts with CardView and ScrollView
- 6. The Android Lifecycle
- 7. Java Variables, Operators, and Expressions
- 8. Java Decisions and Loops
- 9. Java Methods
- 10. Object-Oriented programming
- 11. More Object-Oriented Programming
- Remember that encapsulation thing?
- Encapsulation and static methods mini-app
- OOP and inheritance
- Inheritance example app
- Polymorphism
- Frequently asked questions
- Summary
- 12. The Stack, the Heap, and the Garbage Collector
- 13. Anonymous Classes – Bringing Android Widgets to Life
- Declaring and initializing the objects
- Creating UI widgets from pure Java without XML
- Exploring the palette – part 1
- Anonymous classes
- Exploring the palette – Part 2, and more anonymous classes
- Widget exploration app
- Converting layouts to ConstraintLayout
- Summary
- 14. Android Dialog Windows
- Dialog windows
- The Note to self app
- Summary
- 15. Arrays, ArrayList, Map and Random Numbers
- A random diversion
- Handling large amounts of data with arrays
- Simple array example mini-app
- Getting dynamic with arrays
- Entering the nth dimension with Arrays
- ArrayLists
- Arrays and ArrayLists are polymorphic
- More Java Collections – Meet Java Hashmap
- The Note to Self app
- Frequently asked questions
- Summary
- 16. Adapters and Recyclers
- RecyclerView and RecyclerAdapter
- Adding RecyclerView, RecyclerAdapter, and ArrayList to the Note to Self project
- Running the app
- Frequently asked questions
- Summary
- 17. Data Persistence and Sharing
- 18. Localization
- 19. Animations and Interpolations
- 20. Drawing Graphics
- 21. Threads, and Starting the Live Drawing App
- 22. Particle Systems and Handling Screen Touches
- 23. Supporting Different Versions of Android, Sound Effects, and the Spinner Widget
- 24. Design Patterns, Multiple Layouts, and Fragments
- 25. Advanced UI with Paging and Swiping
- 26. Advanced UI with Navigation Drawer and Fragment
- 27. Android Databases
- 28. Coding a Snake Game Using Everything We Have Learned So Far
- 29. Enumerations and Finishing the Snake Game
- 30. A Quick Chat Before You Go
- Other Books You May Enjoy
- Index
In this chapter and the next, we are going to learn and practice the core fundamentals of Java data and manipulating that data. In this chapter, we will focus on the creation and understanding of the data itself, and in the next, we will see how to manipulate and respond it.
We will also quickly recap what we learned in the earlier chapters about Java, and then dive into learning how to write our very own Java code. The principles we are about to learn are not limited to Java, but are also applicable to other programming languages as well.
By the end of the chapter, you will be comfortable writing Java code that creates and uses data within Android. This chapter takes you through the following:
- Java syntax and jargon
- Variables
- Operators
- Expressions
Let's learn some Java.
The core Java fundamentals that we are about to learn apply when working within classes that we inherit from (such as Activity/AppCompatActivity), as well as classes that we write ourselves (as we will start to do in Chapter 10, Object-Oriented Programming).
As it is more logical to learn the basics before we write our own classes, we will be using the extended Activity class, AppCompatActivity, to add lots of different code in a whole bunch of mini-projects in the next few chapters to learn and practice Java. We will use Log and Toast again to see the results of our coding. In addition, we will use more methods that we will write ourselves (called from buttons), as well as the overridden methods of the Activity class to trigger the execution of our code. We will finally get the full details on methods in Chapter 9, Java Methods.
When, however, we move onto Chapter 10, Object-Oriented Programming, and start to write our own classes, as well as understand more about how classes written by others work, everything we have learned here will apply then too. In fact, this applies to all the Java that you learn in this chapter and the next, if you strip it out of the Activity class and paste it into another Java environment, such as any of the following:
- Any of the major desktop operating systems
- Many modern televisions
- Satellite navigation systems
- Smart fridges
- and more...
The Java will work there too!
Tip
Calling all Java gurus!
If you have already done some Java programming and understand the following words: if, else, while, do while, switch and for, you can probably skip to Chapter 10, Object-Oriented programming. Or you might like to skim over this information as a refresher.
Let's get on with learning how to code in Java.
-
No Comment