JV-105: Fundamentals of OO Using Java
About this Course
This hands-on course class is designed as a continuation of course JV-100 – Java for New-programmers. It quickly reviews programming fundamentals and concentrates on building solid object oriented programming skills using Java and Eclipse.
Audience Profile
The primary audience for this course is as follows:
- Anyone who has had some background in any programming language but has not had much exposure to object oriented programming
At Course Completion
Upon completing this course, the student will be able to meet these overall objectives:
- Students will have an overview of how Java implements object oriented principles and how to read and write many standard J2SE Java programs
Outline
OO Development
- Main points
- Class - analysis
Classes & Objects
- A relational data structure
- An object data structure
- Relational vs. OO
- Defining the class
- Class data structure
- Class as a data type
- Constructors
- Basic steps of object use
- Reference refers to object
- Many references, no object
- Garbage collection
Class methods
- Two class code sections
- Instance methods
- Revisiting static
- Static blocks
- Unchangeable variables
- Constants
- Getters and setters
- Calling getters and setters
- toString( )
- Common class tasks
Constructors
- Purpose
- Rewriting the default constructor
- An all-arg constructor
- Shadowing
- DRY in constructors
Arrays
- The array
- Declaring arrays
- Creating arrays
- Initializing arrays
- Anonymous arrays
- Multi-dimensional arrays
- One field, no methods
- Iterating over an array
- The main( ) args array
- Eclipse command line input
- Iterating over command line input
Inheritance
- Definition
- Implementation
- Terminology
- Behavior expansion
- Object class
- Inherited fields/methods
- Stopping inheritance
- Overriding
- Overriding in Eclipse
- Stopping overriding
- Accessing overridden methods
OO Analysis & Design
- Coupling
- Cohesion
- Composition
- Composition vs. inheritance
- Inheritance
- Object layers
- Design patterns
Inheritance advanced
- Abstract vs. concrete
- Inheriting an abstract class
- Constructors & inheritance
- Construction process
- Object layers
- Chaining constructors with Eclipse
- Superclass references
- Casting back to subclass references
- Polymorphism
- Polymorphic methods
- Object oriented principles
Interfaces
- Definition
- Typical discovery
- Creating an interface
- Writing interface methods
- Implementing interfaces
- Eclipse and interfaces
Class organization
- Packages
- Declaring a package
- Nested packages
- Qualified class names
- Providing access to package classes
- Package access keywords
Exception Handling
- Old school
- OO school
- OO error handling
- try and catch
- Catching what?
- Two exception types
- Unchecked exceptions – Eclipse
- Checked exceptions – Eclipse
- Multiple catch blocks
- Defining your own error states
- Rethrowing
- Finally
- Defer error handling
- Throwable
- Inheritance structure
- Try-with-resources
- Multi-catch
Programmer features
- Varargs
- printf( )
- enhanced for loop
- Autoboxing / unboxing
- Static imports
Prerequisites
The knowledge and skills that a learner should have before attending this course are as follows:
- Either Java 100 or experience within the last few years of programming any language at a basic level