Book Image

Learning Java by Building Android Games - Third Edition

By : John Horton
5 (1)
Book Image

Learning Java by Building Android Games - Third Edition

5 (1)
By: John Horton

Overview of this book

Android is one of the most popular mobile operating systems today. It uses the most popular programming language, Java, as one of the primary languages for building apps of all types. Unlike most other Android books, this book doesn’t assume that you have any prior knowledge of Java programming, instead helps you get started with building Android games as a beginner. This new, improved, and updated third edition of Learning Java by Building Android Games helps you to build Android games from scratch. Once you've got to grips with the fundamentals, the difficulty level increases steadily as you explore key Java topics, such as variables, loops, methods, object-oriented programming (OOP), and design patterns while working with up-to-date code and supporting examples. At each stage, you'll be able to test your understanding by implementing the concepts that you’ve learned to develop a game. Toward the end, you’ll build games such as Sub Hunter, Retro Pong, Bullet Hell, Classic Snake, and Scrolling Shooter. By the end of this Java book, you'll not only have a solid understanding of Java and Android basics but will also have developed five cool games for the Android platform.

Related Content you might be interested in

Current Title:

Small book image
Learning Java by Building Android Games - Third Edition
John Horton
Mar, 2021 | 686 pages
Small book image
Android Programming for Beginners
John Horton
Apr, 2021 | 742 pages
Small book image
Learning Java by Building Android Games
John Horton
Jan, 2015 | 392 pages
Small book image
Android Programming for Beginners
John Horton
Dec, 2015 | 698 pages
Table of Contents (24 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Conventions used
Get in touch
Reviews
1
Chapter 1: Java, Android, and Game Development
Chapter 1: Java, Android, and Game Development
Technical requirements
What's new in the third edition?
Why Java, Android, and games?
The games we will build
How Java and Android work together
Setting up Android Studio
Starting the first project – Sub' Hunter
Android Studio and our project – a very brief guided tour
Refactoring MainActivity to SubHunter
Locking the game to full screen and landscape orientation
Amending the code to use the full screen and the best Android class
Deploying the game so far
Summary
Free Chapter
2
Chapter 2: Java – First Contact
Chapter 2: Java – First Contact
Planning the Sub' Hunter game
Introducing Java methods
Structuring Sub' Hunter with methods
Introducing OOP
Using Java packages
Linking up our methods
Summary
3
Chapter 3: Variables, Operators, and Expressions
Chapter 3: Variables, Operators, and Expressions
Handling syntax and jargon
Java variables
How to use variables
Making variables useful with operators
Declaring and initializing the Sub' Hunter variables
Errors, warnings, and bugs
Testing the game
Summary
4
Chapter 4: Structuring Code with Java Methods
Chapter 4: Structuring Code with Java Methods
Methods
Method overloading by example
Scope – methods and variables
Generating random numbers to deploy a sub
Testing the game
Summary
5
Chapter 5: The Android Canvas Class – Drawing to the Screen
Chapter 5: The Android Canvas Class – Drawing to the Screen
Understanding the Canvas class
Using the Canvas class
Canvas Demo app
Android coordinate system
Drawing the Sub' Hunter graphics and text
Summary
6
Chapter 6: Repeating Blocks of Code with Loops
Chapter 6: Repeating Blocks of Code with Loops
Making decisions with Java
Keeping things tidy
More operators
Java loops
Using for loops to draw the Sub' Hunter grid
Summary
7
Chapter 7: Making Decisions with Java If, Else, and Switch
Chapter 7: Making Decisions with Java If, Else, and Switch
If they come over the bridge, shoot them
Switching to make decisions
Combining different control flow blocks
Making sense of screen touches
Final tasks
Running the game
Summary
8
Chapter 8: Object-Oriented Programming
Chapter 8: Object-Oriented Programming
Basic object-oriented programming
Looking at the code for a class
Basic classes mini-app
Encapsulation
Encapsulation and static methods mini-app
OOP and inheritance
Inheritance mini-app
Polymorphism
Starting the Pong game
Refactoring MainActivity to PongActivity
Locking the game to fullscreen and landscape orientation
Amending the code to use the full screen and the best Android class
Summary
9
Chapter 9: The Game Engine, Threads, and the Game Loop
Chapter 9: The Game Engine, Threads, and the Game Loop
Coding the PongActivity class
Coding the PongGame class
Thinking ahead about the PongGame class
The game loop
Getting familiar with threads
Implementing the game loop with a thread
Running the game
Summary
10
Chapter 10: Coding the Bat and Ball
Chapter 10: Coding the Bat and Ball
The Ball class
The Bat class
Coding the Bat input handling
Running the game
Summary
11
Chapter 11: Collisions, Sound Effects, and Supporting Different Versions of Android
Chapter 11: Collisions, Sound Effects, and Supporting Different Versions of Android
Handling collisions
Handling different versions of Android
The SoundPool class
Generating sound effects
Adding sound to the Pong game
Coding the collision detection and playing sounds
Playing the game
Summary
12
Chapter 12: Handling Lots of Data with Arrays
Chapter 12: Handling Lots of Data with Arrays
Planning the project
Starting the project
Refactoring MainActivity to BulletHellActivity
Locking the game to full-screen and landscape orientation
Amending the code to use the full screen and the best Android class
Reusing the Pong engine
Coding the Bullet class
Getting started with Java arrays
Getting dynamic with arrays
Entering the nth dimension with arrays
Spawning an array of bullets
Summary
13
Chapter 13: Bitmap Graphics and Measuring Time
Chapter 13: Bitmap Graphics and Measuring Time
The Bob (player's) class
Running the game
The Android Studio Profiler tool
Summary
14
Chapter 14: Java Collections, the Stack, the Heap, and the Garbage Collector
Chapter 14: Java Collections, the Stack, the Heap, and the Garbage Collector
Managing and understanding memory
Introduction to the Snake game
Getting started with the Snake game
Refactoring MainActivity to SnakeActivity
Locking the game to fullscreen and landscape orientation
Coding the game engine
Running the game
Summary
15
Chapter 15: Android Localization – Hola!
Chapter 15: Android Localization – Hola!
Making the Snake game Spanish, English, or German
Running the game in German or Spanish
Summary
16
Chapter 16: Collections and Enumerations
Chapter 16: Collections and Enumerations
Adding the graphics
Coding the Apple class
Using the Apple class
Using arrays in the Snake game
Arrays and ArrayLists are polymorphic
Introducing enumerations
Summary
17
Chapter 17: Manipulating Bitmaps and Coding the Snake Class
Chapter 17: Manipulating Bitmaps and Coding the Snake Class
Rotating Bitmaps
Adding the sound to the project
Coding the Snake class
Running the completed game
Summary
18
Chapter 18: Introduction to Design Patterns and Much More!
Chapter 18: Introduction to Design Patterns and Much More!
Introducing the Scrolling Shooter project
Game programming patterns and the structure of the Scrolling Shooter project
Starting the project
Refactoring MainActivity to GameActivity
Locking the game to fullscreen and landscape orientation
Controlling the game with a GameState class
Giving partial access to a class using an interface
Building a sound engine
Testing the game so far
Building a HUD class to display the player's control buttons and text
Building a Renderer class to handle the drawing
Using the HUD and Renderer classes
Running the game
Summary
19
Chapter 19: Listening with the Observer Pattern, Multitouch, and Building a Particle System
Chapter 19: Listening with the Observer Pattern, Multitouch, and Building a Particle System
The Observer pattern
Coding the Observer pattern in Scrolling Shooter
Coding a multitouch UI controller and making it a listener
Running the game
Implementing a particle system explosion
Building a physics engine to get things moving
Running the game
Summary
20
Chapter 20: More Patterns, a Scrolling Background, and Building the Player's Ship
Chapter 20: More Patterns, a Scrolling Background, and Building the Player's Ship
Meeting the game objects
The Entity-Component pattern
The Simple Factory pattern
Summary so far
The object specifications
Coding the component interfaces
Coding the player's and the background's empty component classes
Every GameObject has a transform
Every object is a GameObject
Completing the player's and the background's components
Building the GameObjectFactory class
Coding the Level class
Putting everything together
Running the game
Summary
21
Chapter 21: Completing the Scrolling Shooter Game
Chapter 21: Completing the Scrolling Shooter Game
Adding the alien's components
Spawning the aliens
Running the game
Detecting collisions
Running the completed game
Summary
22
Chapter 22: What Next?
Chapter 22: What Next?
Publishing
Using the assets from the book
Future learning
My other channels
Thanks
Why subscribe?
23
Other Books You May Enjoy
Other Books You May Enjoy
Packt is searching for authors like you
Leave a review - let other readers know what you think

Game programming patterns and the structure of the Scrolling Shooter project

Before we dive in too deeply, it is probably worth stating exactly what a design pattern is.

A design pattern is a solution to a programming problem. More specifically, a design pattern is a tried and tested solution to a programming problem.

What makes design patterns special is that the solutions have already been found by someone else, documented in books and other media (such as websites), and they even have names, so they can be readily discussed.

There are lots of design patterns. We will be learning about the Observer, Strategy/Entity-Component, Singleton, and Factory design patterns.

Design patterns are already-proven ways of enabling the ideas we have already discussed, such as reusing code, encapsulating code, and designing classes that represent things. Patterns often amount to a best-practice way of encapsulating, allowing reuse, and allowing a group of classes to interact.

Tip...

Previous Section
End of Section 3
Next Section