Introduction to Java

Course Overview

This Java training course is intended for students without an extensive programming background. It covers most Java syntax elements, concentrating on fundamental and universally useful elements, while providing an overview of many more advanced elements. Students will learn to write useful Java classes, applying Object-Oriented concepts such as inheritance, and create Java programs that work with these classes.

This course has been updated to Java 10.

Early in the class the concept of objects is introduced so that later concepts can be discussed from the perspective of object orientation.

Course Benefits:

  • Learn how Java works.
  • Understand the “write once, run anywhere” concept.
  • Understand and learn how to create basic Java objects.
  • Learn how to implement flow-control concepts in Java.
  • Understand Java’s package concept and create packages of Java classes.
  • Understand Java arrays and write code to create and use arrays.
  • Learn how to write Java classes using inheritance.
  • Learn how to create and use interfaces.
  • Understand and use the concept of polymorphism in an application
  • Understand how Java’s exception-handling mechanism works and learn how to apply exception-handling to Java applications.
  • Understand and use inner classes.
  • Learn how to use elements from the Java API library, including the Collections classes.

Course Outline

  1. Conventions in These Notes
  2. The Java Environment – Overview
  3. Writing a Java Program
  4. Obtaining The Java Environment
  5. Setting up Your Java Environment
  6. Creating a Class that Can Run as a Program
    1. The main() Method
  7. Useful Stuff Necessary to Go Further
    1. System.out.println()
  8. Using an Integrated Development Environment
  9. Exercise: Running a Simple Java Program
  10. Using the Java Documentation
  1. Basic Java Syntax
    1. General Syntax Rules
    2. Java Statements
    3. Blocks of Code
  2. Variables
    1. Declaring Variables
    2. Advanced Declarations
  3. Data
    1. Primitive Data Types
    2. Object Data Types
    3. Literal Values
  4. Constants and the final Keyword
  5. Mathematics in Java
    1. Basic Rules
    2. Expressions
    3. Operator Precedence
    4. Multiple Assignments
    5. Order of Evaluation
    6. Bitwise Operators
    7. Compound Operators
    8. Expressions that Mix Data Types: Typecasting
  6. Creating and Using Methods
    1. Creating Methods
  7. Variable Scope
  8. Exercise: Method Exercise
  1. Objects
  2. Object-oriented Languages
  3. Object-oriented Programs
  4. Encapsulation
    1. OOP as a Messaging System
  5. Exercise: Object Definition
    1. Creating and Using an Instance of an Object
  6. References
    1. Reference Example
    2. Reference Expressions
  7. Defining a Class
    1. Access to Data
  8. More on Access Terms
  9. Adding Data Members to a Class
    1. Adding Method Members (Functions) to a Class
  10. Standard Practices for Fields and Methods
    1. Order of Elements within a Class
  11. Java Beans
  12. Bean Properties
  13. Exercise: Payroll01: Creating an Employee Class
  14. Constructors
  15. Instantiating Objects Revisited
  16. Important Note on Constructors
  17. Exercise: Payroll02: Adding an Employee Constructor
  18. Method Overloading
  19. Exercise: Payroll03: Overloading Employee Constructors
  20. The this Keyword
  21. Using this to Call Another Constructor
  22. Exercise: Payroll04: Using the this Reference
  23. static Elements
  24. The main Method
  25. Exercise: Payroll05: A static field in Employee
  26. Garbage Collection
  27. Java Packages
  28. Compiling and Executing with Packages
  29. Working with Packages
  30. Exercise: Payroll06: Creating an employees package
  31. Variable Argument Lists (varargs)
    1. Keyboard I/O Using the Console Class
    2. Keyboard Input Without the Console
  32. Exercise: Payroll07: Using KeyboardReader in Payroll
  33. String, StringBuffer, and StringBuilder
  34. Creating Documentation Comments and Using javadoc
    1. Javadoc Comments
  35. Exercise: Payroll08: Creating and Using javadoc Comments
  36. Primitives and Wrapper Classes
    1. Autoboxing and Unboxing
  1. Boolean-valued Expressions
  2. Comparison Operators
  3. Comparing Objects
  4. Conditional Expression Examples
  5. Complex boolean Expressions
  6. Simple Branching
  7. The if Statement
  8. if Statement Examples
    1. Absolute Value
    2. Random Selection
  9. Exercise: Game01: A Guessing Game
  10. Exercise: Payroll-Control01: Modified Payroll
  11. Two Mutually Exclusive Branches
    1. The if . else Statement
    2. Nested if . else Statements – Comparing a Number of Mutually Exclusive
    3. Options
  12. Exercise: Game02: A Revised Guessing Game
  13. Comparing a Number of Mutually Exclusive options – The switch Statement.175
    1. The switch Statement
    2. switch Statement Examples
  14. Exercise: Game03: Multiple Levels
  15. Comparing Objects
    1. Testing Strings for Equivalence
  16. Conditional Expression
    1. while and do . . . while Loops
    2. for Loops
    3. For-Each Loops
  17. Exercise: Payroll-Control02: Payroll With a Loop
  18. Exercise: Game04: Guessing Game with a Loop
  19. Additional Loop Control: break and continue
  20. Breaking Out of a Loop
  21. Continuing a Loop
  22. Classpath, Code Libraries, and Jar Files
    1. Using CLASSPATH
    2. Creating a jar File (a Library)
  23. Exercise: Creating and Using an External Library
  24. Compiling to a Different Directory
  1. Defining and Declaring Arrays
  2. Instantiating Arrays
  3. Initializing Arrays
  4. Working With Arrays
  5. Enhanced for Loops – the For-Each Loop
  6. Array Variables
  7. Copying Arrays
  8. Exercise: Using the args Array
  9. Exercise: Game-Arrays01: A Guessing Game with Random Messages222
  10. Arrays of Objects
  11. Exercise: Payroll-Arrays01: An Array of employees
  12. Multi-Dimensional Arrays
  13. Multidimensional Arrays in Memory
  14. Example – Printing a Picture
  15. Typecasting with Arrays of Primitives
  1. Inheritance
  2. Inheritance Examples
  3. Payroll with Inheritance
  4. Derived Class Objects
  5. Polymorphism
    1. Inheritance and References
    2. Dynamic Method Invocation
  6. Creating a Derived Class
  7. Inheritance Example – A Derived Class
  8. Inheritance and Access
  9. Inheritance and Constructors – the super Keyword
  10. Derived Class Methods that Override Base Class Methods
  11. Inheritance and Default Base Class Constructors
  12. The Instantiation Process at Runtime
    1. Inheritance and static Elements
  13. Example – Factoring Person Out of Employee
  14. Exercise: Payroll-Inheritance01: Adding Types of Employees
  15. Typecasting with Object References
  16. More on Object Typecasts
  17. Typecasting, Polymorphism, and Dynamic Method Invocation
    1. More on Overriding
    2. Changing Access Levels on Overridden Methods
  18. Redefining Fields
  19. Object Typecasting Example
  20. Checking an Object’s Type: Using instanceof
  21. Typecasting with Arrays of Objects
  22. Exercise: Payroll-Inheritance02: Using the Employee Subclasses
  23. Other Inheritance-related Keywords
    1. abstract
    2. final
  24. Exercise: Payroll-Inheritance03: Making our base classes abstract
  25. Methods Inherited from Object
  1. Interfaces
  2. Creating an Interface Definition
  3. Implementing Interfaces
  4. Implementing Interfaces – Example
  5. Reference Variables and Interfaces
  6. Calling an Interface Method
  7. Interfaces and Inheritance
  8. Exercise: Exercise: Payroll-Interfaces01
  9. Some Uses for Interfaces
  10. Interfaces and Event-Handling
  11. Interfaces and “Pluggable Components”
  12. Marker Interfaces
  13. Annotations
  14. Annotation Details
  15. Using Annotations
  1. Handling Exceptions
  2. Exception Objects
  3. Attempting Risky Code – try and catch
    1. try . catch Blocks and Variable Scope/Initialization
    2. Example – An Exception You Must Handle
    3. Using Multiple catch Blocks
  4. Guaranteeing Execution of Code – The finally Block
  5. Letting an Exception be Thrown to the Method Caller
  6. Throwing an Exception
  7. Exercise: Payroll-Exceptions01: Handling Number Format Exception in
  8. Payroll
  9. Exercise: Payroll-Exceptions01, continued
  10. Exceptions and Inheritance
    1. Exception Class Constructors and Methods
  11. Creating and Using Your Own Exception Classes
  12. Exercise: Payroll-Exceptions02
  13. Rethrowing Exceptions
  14. Initializer Blocks
    1. Static Initializer Blocks
  15. Logging
    1. Creating a Logger
    2. Logger Hierarchy and Naming
    3. Log Handlers
    4. Log Formatters
  16. Log Properties
  17. Assertions
  1. Collections
  2. Using the Collection Classes
  3. Using the Iterator Interface
  4. Creating Collectible Classes
    1. hashCode and equals
    2. Comparable and Comparator
  5. Generics
  6. Bounded Types
  7. Extending Generic Classes and Implementing Generic Interfaces
  8. Generic Methods
  9. Variations on Generics – Wildcards
  10. Exercise: Payroll Using Generics
  1. Inner Classes, aka Nested Classes
  2. Inner Class Syntax
  3. Instantiating an Inner Class Instance from within the Enclosing Class
  4. Inner Classes Referenced from Outside the Enclosing Class
  5. Referencing the Outer Class Instance from the Inner Class Code
  6. static Inner Classes
  7. Better Practices for Working with Inner Classes
  8. Enums
    1. Why Another Syntax Element for a Set of Constants?
    2. Defining an enum Class
    3. More Complex Enums

₦ 20,000

  • Learn at your own pace with 24/7 access
  • Duration: 1 year
× How can we help you?