java-tutorial-for-beginners_test

Table of Contents

Our Approach

Introduction to Programming with Print-Multiplication-Table

Step 01: First Challenge : The Print-Multiplication-Table (*PMT-Challenge*)

The *PMT-Challenge*

Summary

Step 02: Introducing ```JShell```

Snippet: Complex Expressions, Anyone?

Summary

Step 05: Programming Exercise PE-1 (With Solutions)

Solution 1

Solution 2

Step 06: Operators

Invalid Operators

Use paranthesis for clear code

Summary

Step 07: Introducing Console Output

Summary

Step 08: Programming Exercise PE-02

Step 09: Solutions to PE-02

Solution 1

Solution 2

Solution 3

Solution 4

Step 10: Whitespace, Case sensitiveness and Escape Characters

Whitespace

Case Sensitive

Method with multiple parameters

Summary

Step 18: Introducing Primitive Types

Integer Types

Floating Value Types

Character Type

Boolean Type

Summary

Step 22: Some ```JShell``` Usage Tips

Summary

Step 23: Introducing Conditionals - the ```if```

Logical Operators

Conditionals: The "if" Statement

Summary

Step 24: Programming Exercise PE-04

Step 25: Solution to PE-04

Solution 1

Solution 2

Solution 3

Step 26: ```if``` Statement again

Snippet-1

Snippet-1 : *PMT-Challenge* Solution

Snippet-1 Explained

Summary

Step 28: Programming Exercise PE-05

Step 29: Solution to PE-05

Solution 2

Solution 3

Solution 4

Solution 5

Solution 6

Snippet-01: Method with an argument: Definition

Snippet-02 : Passing and accessing a parameter

Snippet-03: More complex method

Snippet-4 : Saying "Hello World", Again and again...

Snippet-5 : Parameter type mismatch

Summary

Step 05: Exercise Set PE-02 (With Solutions)

Exercises

Solution-01

Solution 2

Step 07: *PMT-Challenge* Revisited (And Some Puzzles)

Summary

Step 08: Methods With Arguments, And Overloading

Overloaded Methods

Summary

Step 09: Methods With Multiple Arguments

Summary

Step 10: Returning From A Method

Summary

Step 11: Encapsulation - Advantages (Code Reuse)

Snippet-1 : Bulky Speed Increment code

Snippet-1 Explained

Snippet-2 : Speed Increase through Code Encapsulation

Snippet-2 Explained

Snippet-3 : Speed Increase And Decrease through Code Encapsulation

Snippet-3 Explained

Snippet-4 : Validation across methods, repeated!

Snippet-4 Explained

Snippet-5: Validation by code reuse

Snippet-5 Explained

Summary

Step 12: Programming Exercise PE-OO-03

Exercises

Solution

Step 13: Introducing Constructors

Snippet-1: MotorBike Constructor

Snippet-1 Explained

Snippet-2 : Default Motorbike Construction?

Snippet-2 Explained

Snippet-3 : Programmer-defined default constructor

Snippet-3 Explained

Primitive Data Types

Step 01: The Integer Types

Snippet-01 : Integer Sizes

Integer Type Conversions

Snippet-02 : Integer Type Conversions

Summary

Step 02: Integer Representations, And Other Puzzles

Snippet-01 : Storing Octal and Hexadecimal in Integer types

Snippet-02 : More Integer Type-casting

Built-In Operators For Integer Types

Snippet-03 : Increment & Decrement Operators

Summary:

Step 03: Classroom Exercise CE-01 (With Solutions)

Exercise Set

Solution to CE-01

Step 05: Floating-Point Types

Snippet-01 : double and float

Snippet-02 : Operators for type double

Summary

Step 06: Introducing BigDecimal

Summary

Step 06: BigDecimal Operations

Snippet-01: Arithmetic Operations

Summary

Step 08: ```boolean```, Relational and Logical Operators

Snippet-01 : Relational Operators : Recap

Logical Operators

Snippet-02 : Logical Operators

Snippet-02 Explained

Summary

Step 09: Short-Circuit Evaluation (With Puzzles)

Summary

Step 10: Character Types

Snippet-01 : Unicode characters

Summary

Step 11: Programming Exercise PE-02

Exercise Set

Step 12: Solution To PE-02, Part 1 - ```isVowel()```

Step 13: Solution To PE-02, Part 2 - ```isDigit()```

Step 14: Solution To PE-02, Part 3 - Other Methods

Step 15: The Primitive Types - A Review

Introducing Conditionals - if, switch and more

Programming Challenge : Design A Menu (The *Menu-Challenge*)

Summary

Step 01: The ```if``` and ```if```-```else``` Conditionals

Snippet-01 : ```if``` behavior

Snippet-01: The ```switch``` statement

Snippet-02: refactoring MenuScanner

Summary

Puzzles On ```switch```

Programming Puzzle PP-01

Programming Puzzle PP-02

Programming Puzzle PP-03

Programming Puzzle PP-04

Programming Puzzle PP-05

Programming Puzzle PP-06

Step 09: Comparing The ```if``` Family, And ```switch```

Snippet-01 : Formatted Output Using ```if```

Snippet-02 : Formatted Output Using ```switch```

Summary

Step 10: Programming Exercise PE-03

Solution to PE-03

Step 12: Introducing ```?:```, The Ternary Operator

Snippet-01 : ternary operator

Summary

Loops

Revisiting Java loop constructs: ```for``` and ```while```

Snippet 1 : First for loop puzzle

Snippet-1 Explained

Reference Types

Step 01: Introducing Reference Types

Summary

Step 02: References: Usage And Puzzles

Comparing Reference Variables

Summary

Step 03: Introducing ```String```

Summary

Step 04: Programming Exercise PE-01, And ```String``` Utilities

Exercise

Solution To PE-01

Common ```String``` Utilities

Snippet-01: ```String``` Utilities

Summary

Step 05: ```String``` Immutability

Summary

Step 07: Storing mutable text

Summary

Step 12: Playing With ```java.time.LocalDate```

Summary

Step 13: Comparing ```LocalDate``` Objects

Arrays and ArrayList

Step 01: The Need For ```Array```

Step 06: Classroom Exercise CE-AA-02

Exercise

Solution To CE-AA-02

Step 08: Variable Arguments - The Basics

Step 09: Variable Argument Methods For ```Student```

Quick Tip

Step 10: Arrays - Some Puzzles And Exercises

Classroom Exercise CE-AA-03

Exercises

Step 12: Introducing ```ArrayList```

Step 13: Refactoring ```Student``` To Use ```ArrayList```

Snippet-01 : Refactoring ```Student```

Step 14: Enhancing ```Student``` Further

Object Oriented Programming (*OOP*) - Revisited

Step 01: Objects Revisited - State And Behavior

Step 02: Managing ```class``` state

Step 03: Augmenting ```Fan``` With Behavior

Snippet-01 : The ```Fan``` ```class``` - v4

Snippet-01 Explained

Summary

Step 04: Programming Exercise PE-OOP-01

Solution To PE-OOP-01

Solution Explained

Step 06: Understanding Object Composition

Snippet-01 : Object composition - State

Snippet-01 Explained

Snippet-02 : Object Composition v2 - Construction

Snippet-9 : Object Composition v3 : Behaviors

Step 07: Programming Exercise PE-OOP-02

Exercises

Solution To PE-OOP-02

Step 07: The Need For Inheritance

Enter Inheritance

Snippet-02 : Student inherits from Person - v1

Step 09: Introducing ```Object``` class

Snippet-01 : The Object class

Snippet-01 Explained

Step 10: Inheritance And Method Overriding

Snippet-01: Method Overriding

Snippet-01 Explained

Step 11: Classroom Exercise CE-OOP-01

Snippet-01 : Employee Inheritance

Snippet-01 Explained

Step 12: Constructors, And Calling ```super()```

Snippet-01 : Calling Person.toString()

Sub-Class Contructor

Snippet-7 : Person class

Snippet-02 Explained

Snippet-3 : ```Person``` - Non-Default Constructor

Snippet-03 Explained

Snippet-01 Explained

Snippet-02 : Code Reuse With Interfaces

Snippet-2 explained

Using Interface as type for reference variable

Why do we need ```default``` method implementations.

Step 20: ```abstract class``` And ```interface``` : A Comparison

abstract class

Syntactical Comparison

Step 21: Programming Exercise PE-OOP-03

Exercises

Solution To PE-OOP-03

Solution - 1

Solution - 2

Step 21: Introducing Polymorphism

Introducing Collections

The Collection Interfaces

The ```List``` ```interface```

Snippet-1 : Creating a List

```List``` Immutability

```Vector``` vs ```ArrayList```

```List``` Operations

Snippet-4 : List Insertions

Snippet-5 : Element Modification

Snippet-6 : Iterating within ArrayList

Choosing Between Iteration Modes

Snippet-6

```List``` : Type Safety

Snippet-7 : Type safety

Sorting a ```List```

Snippet-8 : List sort

Sorting List

Snippet-9 : Sorting List

Snippet-9 Explained

Snippet-11 : Implementing Student Comparators

```sort``` method Of ```List```

Snippet-12 : Comparator for ArrayList.sort()

The ```Set``` ```interface```

Snippet-13 : Set

Understanding Data Structures

Hash Table

Tree

```Set``` Implementations

Snippet-14 : HashSet

Snippet-15 : LinkedHashSet

Snippet-16 : TreeSet

Exercise Set

Solution

Solution Explained

```TreeSet``` In Depth

Snippet-16 : NavigableSet Operations

The ```Queue``` Interface

Exercise Set

Solution

Revisiting ```TreeMap```

Snippet-13 : Treemap Operations

Java Collections : Conclusions With Tips

Introducing Generics

Snippet-1

Snippet-1 Explained

Snippet-2 : Implementing a Generic

Snippet-2 Explained

Exercise Set - 18

Solution

Solution Explained

Implementing Type Restrictions on Generics

Snippet-3 : Generic Type Restrictions

Generic Methods

Snippet-4 : Generic Method

Generics And Wild-Cards

Snippet-5

Snippet-5 Explained

Restricted Heterogeneous Lists

Snippet-6 : More wild-cards

Introduction to Functional Programming

Step 01: Introducing Functional Programming

Snippet-01 : OOP List Traversal

Snippet-01 Explained

Snippet-02 : ```printBasic()``` And ```printFunctional()```

Snippet-02 Explained

Step 11: More Stream Operations

Snippet-01 : min() and max()

Snippet-02 : Odd and Even Numbers

Step 13: Functional Interfaces : ```Predicate```

Snippet-01: Lambda behind-the-scenes - v1

Snippet-01 Explained

Step 14: Functional Interfaces : ```Consumer```

Snippet-02 : ```map()``` Behind The Scenes - v2

Step 16: Introducing Method References

Snippet-01: Method References - v1

Snippet-02 : Method References - v2

Snippet-03: Method References - v3

Snippet-04 : Method References - v4

Classroom Exercise FP-CE-03

Solution To FP-CE-03

Summary

Step 17: FP - Functions As First-Class Citizens

Passing function as method argument

Storing functions in reference variables

Returning functions from methods

Summary

Threads and Concurrency

Step 01: Concurrent Tasks: Extending ```Thread```

Snippet-1

Snippet-1 Explained

Thread Creation

Snippet-01 : A simple Java thread class

Snippet-01 Explained

Summary

Step 02: Concurrent Tasks - Implementing Runnable

Snippet-01 : Implementing Runnable

Snippet-01 Explained

Summary

Step 03: The Thread Life-cycle

Summary

Step 04: Thread Priorities

Step 05: Communicating Threads

Snippet-5 Explained

Snippet-01 : Waiting for Multiple ```Callable``` Threads

Snippet-01 Explained

Snippet-02 : List of Callable tasks with larger thread pool

Snippet-02 Explained

Summary

Step 12: Executor - Wait Only For The Fastest Task

Snippet-01 : Wait only for fastest

Snippet-01 Explained

Summary

Introduction To Exception handling

Step 01: Introducing Exceptions

Snippet-1 : Exception Condition

Snippet-01 Explained

Summary

Step 02: Handling An Exception

Snippet-01 : Handling An Exception

Snippet-01 Explained

Snippet-02: Print Debug Information

Snippet-04 : Method with risky code #1

Snippet-04 Explained

Summary

Step 08: The Java Exception Hierarchy

Summary

Step 09: Throwing an Exception

Snippet-01 : Throwing An Exception

Snippet-01 Explained

Snippet-02 : Throwing a Checked Exception

Snippet-01: try-with-resources

Snippet-01 Explained

Summary

Step 12: Programming Puzzle Set PP_02

Puzzle-01

Puzzle-01 Explained

Puzzle-02

Puzzle-02 explained

Puzzle-03

Puzzle-03 Explained

File Operations

Listing Directory Contents

Snippet-1 : Listing Directory Contents

Snippet-1 Explained

Snippet-2 : Recursive Directory Traversal

Snippet-3 : Level-4 Traversal

Snippet-4 : Only list .java files during traversal

Snippet-5 : Filtered Traversal with find()

Snippet-6 : Filtering directories

Snippet-7 : Reading a File

Snippet-9 : Printing file contents in lower-case

Snippet-9 : Filtering file contents

Snippet-10 : Writing to a file

Concurrency : Advanced Topics

Snippet-1: Atomic Operations : Counter

Snippet-1 Explained

Counter ```increment()``` method is NOT Atomic!

Snippet-8 : ConcurrentHashMap Logic - Stage 2

```ConcurrentHashMap```

Concurrent Collections : Copy-On-Write Optimization

Snippet-9 : CopyOnWriteArrayList

Snippet-9 Explained