Book Image

Learn Java with Projects

By : Dr. Seán Kennedy, Maaike van Putten
5 (3)
Book Image

Learn Java with Projects

5 (3)
By: Dr. Seán Kennedy, Maaike van Putten

Overview of this book

Learn Java with Projects stands out in the world of Java guides; while some books skim the surface and others get lost in too much detail, this one finds a nice middle ground. You’ll begin by exploring the fundamentals of Java, from its primitive data types through to loops and arrays. Next, you’ll move on to object-oriented programming (OOP), where you’ll get to grips with key topics such as classes, objects, encapsulation, inheritance, polymorphism, interfaces, and more. The chapters are designed in a way that focuses on topics that really matter in real-life work situations. No extra fluff here, so that you get more time to spend on the basics and form a solid foundation. As you make progress, you’ll learn advanced topics including generics, collections, lambda expressions, streams and concurrency. This book doesn't just talk about theory—it shows you how things work with little projects, which eventually add up to one big project that brings it all together. By the end of this Java book, you’ll have sound practical knowledge of Java and a helpful guide to walk you through the important parts of Java.

Related Content you might be interested in

Current Title:

Small book image
Learn Java with Projects
Dr. Seán Kennedy | Maaike van Putten
Nov, 2023 | 598 pages
Small book image
Java Memory Management
Maaike van Putten | Dr Seán Kennedy
Nov, 2022 | 146 pages
Small book image
Introduction to Programming
Nick Samoylov
Jun, 2018 | 722 pages
Small book image
Learn Java 17 Programming
Nick Samoylov
Jul, 2022 | 748 pages
Table of Contents (22 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
Code in Action
Download the color images
Conventions used
Get in touch
Share Your Thoughts
Download a free PDF copy of this book
1
Part 1: Java Fundamentals
Part 1: Java Fundamentals
Free Chapter
2
Chapter 1: Getting Started with Java
Chapter 1: Getting Started with Java
Technical requirements
Exploring Java features
Installing Java
Writing our first program
Compiling and running Java programs
Working with an IDE
Creating and running a program with an IDE
Exercises
Project
Summary
3
Chapter 2: Variables and Primitive Data Types
Chapter 2: Variables and Primitive Data Types
Technical requirements
Understanding and declaring variables
Understanding Java’s primitive data types
Screen output
Exercises
Project – dinosaur profile generator
Summary
4
Chapter 3: Operators and Casting
Chapter 3: Operators and Casting
Technical requirements
Learning how Java’s operators cooperate
Understanding Java’s operators
Explaining Java casting
Exercises
Project – Dino meal planner
Summary
5
Chapter 4: Conditional Statements
Chapter 4: Conditional Statements
Technical requirements
Understanding scope
Exploring if statements
Mastering switch statements and expressions
Exercises
Project – Task allocation system
Summary
6
Chapter 5: Understanding Iteration
Chapter 5: Understanding Iteration
Technical requirements
while loops
do-while loops
for loops
break and continue statements
Exercises
Project – Dino meal planner
Summary
7
Chapter 6: Working with Arrays
Chapter 6: Working with Arrays
Technical requirements
Arrays – what, when, and why?
Declaring and initializing arrays
Short syntax for array initialization
Accessing elements in an array
Working with length and bounds
Iterating over arrays
Handling multidimensional arrays
Using Java’s built-in methods for arrays
Exercises
Project – Dino tracker
Summary
8
Chapter 7: Methods
Chapter 7: Methods
Technical requirements
Explaining why methods are important
Understanding the difference between method definition and method execution
Exploring method overloading
Explaining varargs
Mastering call by value
Exercises
Project – Mesozoic Eden assistant
Summary
9
Part 2: Object-Oriented Programming
Part 2: Object-Oriented Programming
10
Chapter 8: Classes, Objects, and Enums
Chapter 8: Classes, Objects, and Enums
Technical requirements
Understanding the differences between classes and objects
Contrasting instance with class members
Exploring the “this” reference
Applying access modifiers
Encapsulation
Mastering advanced encapsulation
Delving into the object life cycle
Explaining the instanceof keyword
Understanding enums
Appreciating records
Exercises
Project – Mesozoic Eden park manager
Summary
11
Chapter 9: Inheritance and Polymorphism
Chapter 9: Inheritance and Polymorphism
Technical requirements
Understanding inheritance
Applying inheritance
Exploring polymorphism
Contrasting method overriding and method overloading
Exploring the super keyword
Revisiting the protected access modifier
Explaining the abstract and final keywords
Applying sealed classes
Understanding instance and static blocks
Mastering upcasting and downcasting
Exercises
Project
Summary
12
Chapter 10: Interfaces and Abstract Classes
Chapter 10: Interfaces and Abstract Classes
Technical requirements
Understanding abstract classes
Mastering interfaces
Examining default and static interface methods
Explaining ‘private’ interface methods
Exploring sealed interfaces
Exercises
Project – unified park management system
Summary
13
Chapter 11: Dealing with Exceptions
Chapter 11: Dealing with Exceptions
Technical requirements
Understanding exceptions
Understanding the exception hierarchy
Working with basic I/O operations
Throwing exceptions
The catch or declare principle
Working with inheritance and exceptions
Exercises
Project – dinosaur care system
Summary
14
Chapter 12: Java Core API
Chapter 12: Java Core API
Technical requirements
Understanding the Scanner class
Comparing String with StringBuilder
Designing a custom immutable type
Examining List and ArrayList
Exploring the Date API
Exercises
Project – dinosaur care system
Summary
15
Part 3: Advanced Topics
Part 3: Advanced Topics
16
Chapter 13: Generics and Collections
Chapter 13: Generics and Collections
Technical requirements
Getting to know collections
List
Set
Map
Basic operations on maps
Queue
Sorting collections
Working with generics
Hashing and overriding hashCode()
Exercises
Project – advanced dinosaur care system
Summary
17
Chapter 14: Lambda Expressions
Chapter 14: Lambda Expressions
Technical requirements
Understanding lambda expressions
Exploring functional interfaces from the API
Mastering method references
Exercises
Project – agile dinosaur care system
Summary
18
Chapter 15: Streams – Fundamentals
Chapter 15: Streams – Fundamentals
Technical requirements
Understanding stream pipelines
Exploring stream laziness
Creating streams
Mastering terminal operations
Exercises
Project – dynamic dinosaur care system
Summary
19
Chapter 16: Streams: Advanced Concepts
Chapter 16: Streams: Advanced Concepts
Technical requirements
Examining intermediate operations
Delving into primitive streams
Mapping streams
Explaining Optionals
Understanding parallel streams
Exercises
Project – dynamic dinosaur care system
Summary
20
Chapter 17: Concurrency
Chapter 17: Concurrency
Technical requirements
Understanding concurrency
Working with threads
Thread management – sleep() and join()
Atomic classes
The synchronized keyword
The Lock interface
Concurrent collections
ExecutorService and thread pools
Data races
Threading problems
Exercises
Project – Park Operations System – the calm before the storm
Summary
21
Index
Index
Share Your Thoughts

Technical requirements

Before diving into the magical world of Java programming, let’s ensure you have the right hardware. If your hardware doesn’t meet these requirements, don’t worry; online alternatives are discussed later in this chapter. If you are using your work laptop, make sure that you have download rights. Here’s a brief overview of the requirements:

  • Operating system: Java can run on various operating systems, including Windows, macOS, and Linux. Ensure that you have a recent version of one of these operating systems installed on your computer.
  • Java Development Kit (JDK): To compile and run Java programs, you’ll need the JDK installed on your system. The JDK includes the Java Runtime Environment (JRE), which contains the necessary libraries and components for running Java applications. We’ll see how to install this later.
  • System resources: More is always better, but Java isn’t too demanding. It doesn’t require high-end hardware, but it’s still a good idea to have a system with sufficient resources for a smooth development experience. The following are the minimum and recommended system requirements:
    • Minimum requirements:
      • CPU: 1 GHz or faster processor
      • RAM: 2 GB
      • Disk space: 1 GB (for JDK installation and additional files)
    • Recommended requirements:
      • CPU: 2 GHz or faster multi-core processor
      • RAM: 4 GB or more
      • Disk space: 2 GB or more (for JDK installation, additional files, and projects)

Keep in mind that these requirements may change with future updates to the JDK and related tools. We have placed the files in a GitHub repository. You can clone the projects with the use of Git and import them to your computer this way. It’s beyond the scope of explaining how to use Git here but it’s recommended to look into it independently. You can access the files and examples used in this book here: https://github.com/PacktPublishing/Learn-Java-with-Projects.

Previous Section
End of Section 2
Next Section