Online Java Classes

Interactive with a real instructor (Not recorded videos). During the lecture, you can ask questions for more explanation.

$50 per month. No contract. No upfront payment. Simply register for a session. After a few lectures, if you don’t like it, you can quit without paying anything.

  • Classes are divided into 1-month sessions.
  • You register for a 1-month session.
  • You pay at the end of the 1-month session.

Referral bonus: If you refer someone, both of you get $10.

Seats are limited. Contact us now to reserve your seat.

Fill out registration form either in this link: 
https://forms.gle/d29jUF1QRCpBHroi6
Or at the bottom of this page.

There are two levels based on the speed.

Slow Runner Level
This level is good for;
– Adults who may not spend extra time studying outside of our class times.
– Students prepare themselves for their computer-related courses.

Fast Runner Level (2X as faster)
This level is good for;
– Adults who can spend at least 1-hour extra time everyday studying outside of our class times.
– Who wants to start a career as a Software Developer.

At the Slow runner level, there will be more repetitions. For instance, after covering a new topic, we may do 2 exercises at the Fast-runner level, but we may do 3 or 4 exercises at the Slow runner level. This is because students at the Fast-runner level are expected to do more homework outside of the class times.

Class Days
There will be classes everyday.
Required 3 days: We will cover new topics. These 3 days will be determined based on the students’ preferences.
Optional 4 days: We will write exercise codes interactively. Students will have chance to ask questions about their homeworks.

Class Times
Class times will be determined based on the students’ preferences. Considering the fast-runner level students may have a full-time job during the days, the tentative class times will be around the following;

Available Sessions:
Slow Runner (Chapters 1 and 2): 11:00am – 12:00pm (EST)
Fast Runner (Chapters 1, 2, 3 and 4): 8:00pm – 9:00pm (EST)

These sessions will start as soon as all seats are taken.

Chapter Contents

Chapter-1: Introduction to Java Programming.

Compiling and running a Java Program
Variables
Assignment Statements
Constants
Parentheses and Precedence Rules
Integer and Floating-Point Division
Type Casting
Increment and Decrement Operators

Chapter-2: Console Input and Output

String Constants and Variables
Concatenation of Strings Classes
String Methods
Escape Sequences
System.out.println
Formatting Output with printf
Importing Packages and Classes
The Scanner Class
The Empty String
The Scanner Class for Text File Input

Chapter 3: Flow of Control

if-else Statements
The switch Statement
Simple Boolean Expressions
Precedence and Associativity Rules
while and do-while Loops
The for Loops
break, continue and exit Statements
General Debugging Techniques
Random Number Generation
The Random Object
The Math.random() Method

Chapter 4: Classes, Methods

Instance Variables and Methods
Local Variables
Parameters of a Primitive Type
Simple Cases with Class Parameters
The this Parameter
Methods That Return a Boolean Value
The Methods equals and toString
Recursive Methods
public and private Modifiers
Accessor and Mutator Methods
Preconditions and Postconditions
Rules for Overloading
Constructor Definitions
Default Variable Initializations
The StringTokenizer Class

Chapter 5: Classes advanced topics

Static Methods
Static Variables
The Math Class
Wrapper Classes
Automatic Boxing and Unboxing
Static Methods in Wrapper Classes
Variables and Memory
References
Class Parameters
The Constant null
The new Operator and Anonymous Objects

Chapter 6: Arrays

Creating and Accessing Arrays
The length Instance Variable
Initializing Arrays
Arrays Are Objects
Array Parameters
Arguments for the Method main
Methods that Return an Array
Partially Filled Arrays
The “for-each” Loop
Methods with a Variable Number of Parameters
Privacy Leaks with Array Instance Variables
Enumerated Types
Multidimensional Array Parameters and Returned Values

Chapter 7: Inheritance

Derived Classes
Overriding a Method Definition
Changing the Return Type of an Overridden Method
Changing the Access Permission of an Overridden Method
The super Constructor
The this Constructor
Encapsulation and Inheritance
Protected and Package Access
Access to a Redefined Base Method
The Class Object
The Right Way to Define equals

Chapter 8: Polymorphism and Abstract Classes

Late Binding
The final Modifier
Late Binding with toString
Downcasting and Upcasting
clone Methods
Abstract Classes

Chapter 9: Exception Handling

try-catch Mechanism
Exception Handling with the Scanner Class
Throwing Exceptions
Exception Classes
Multiple catch Blocks
Throwing an Exception in a Method
Declaring Exceptions in a throws Clause
Exceptions to the Catch or Declare Rule
throws Clause in Derived Classes
When to Use Exceptions
Event-Driven Programming
The finally Block
Rethrowing an Exception
The AssertionError Class
ArrayIndexOutOfBoundsException

Chapter 10: File I/O

Streams
Text Files and Binary Files
Reading, Writing, Appending to a Text File
Reading a Text File Using Scanner
Testing for the End of a Text File with Scanner
Nested Constructor Invocations
System.in, System.out , and System.err
Programming with the File Class
UTF and writeUTF
Checking for the End of a Binary File
Binary I/O of Objects
The Serializable Interface
Array Objects in Binary Files
Random Access to Binary Files

Chapter 11: Recursion

Recursive void Methods
Tracing a Recursive Call
A Closer Look at Recursion
Stacks for Recursion
Recursion versus Iteration
Recursive Method That Returns a Value
Recursive Design Techniques
Binary Search

Chapter 12: Interfaces and Inner Classes

Interfaces
Abstract Classes Implementing Interfaces
Derived Interfaces
The Comparable Interface
Defined Constants in Interfaces
The Serializable Interface
The Cloneable Interface
Simple Uses of Inner Classes
Helping Classes
The .class File for an Inner Class
Static Inner Classes
Public Inner Classes
Nesting Inner Classes
Inner Classes and Inheritance
Anonymous Classes

Chapter 13: Intro to Swing GUI

Events and Listeners
A Simple Window
Buttons
Action Listeners and Action Events
Example: A GUI with a Label and Color
Border Layout Managers
Flow Layout Managers
Grid Layout Managers
Panels
The Container Class
Menu Bars, Menus, and Menu Items
Nested Menus
The AbstractButton Class
The setActionCommand Method
Listeners as Inner Classes
Text Areas and Text Fields
A Swing Calculator

Chapter 14: Generics and the ArrayList Class

Using the ArrayList Class
Methods in the Class ArrayList
The “for-each” Loop
The Vector Class
Parameterized Classes and Generics
Generic Basics
Example: A Generic Class for Ordered Pairs
Bounds for Type Parameters
Generic Methods
Inheritance with Generic Classes

Chapter 15: Linked Data Structures

Working with Linked Lists
Node Inner Classes
The equals Method for Linked Lists
Simple Copy Constructors and clone Methods
Exceptions
Defining an Iterator Class
Adding and Deleting Nodes
Doubly Linked List
The Stack Data Structure
The Queue Data Structure
Running Times and Big-O Notation
Efficiency of Linked Lists
A Hash Function for Strings
Efficiency of Hash Tables
Fundamental Set Operations
Efficiency of Sets Using Linked Lists
Tree Properties
Example: A Binary Search Tree Class
Efficiency of Binary Search Trees

Chapter 16: Collections, Maps and Iterators

The Collection Framework
Concrete Collection Classes
Differences between ArrayList and Vector
Nonparameterized Version of the Collection Framework
Concrete Map Classes
The Iterator Concept
The Iterator Interface
List Iterators