Fast Track to Java 7 and OO Development

#text-block-10 { margin-bottom:0px; text-align:left; }

1. A Simple Java Class and Running a

Java Program

A Simple Application Class

The HelloWorld Program Broken

Down

Compiling HelloWorld

Note on Comments

2. Java Overview

Language and Platform Features What is Java?

Java is Modern and Object-Oriented Java is Portable and Safe

Java has Multiple Platforms Program Life Cycle

Java Source and Java Bytecode Life Cycle of a Java Program Java Programs Insulated from

Environment

Java is Dynamic – The Runtime Process

The Java SE Software Development Kit

(JDK) The Java API

Downloading and Installing the JDK

3. Class and Object Basics

Object-Oriented Programming Overview What is Object-Oriented Programming? What is an Object?

Important Characteristics of Objects About Object-Oriented Programming

(OOP)

What’s a Type?

Types, Instances, and Property Values Classes and Objects

Identity and Object References

Classes, References, and Instantiation The Class in Java Class Definition

A Class Definition is a Blueprint Creating and Referencing Objects More About Identifiers

Methods and Data in a Class Behavior and Methods Invoking Methods

Storing Data in Objects About Instance Variables

Data Access and Return Values in

Methods

Accessing Data (Another Way) Pretty Pictures

More About Variables

About Java Primitive Data Types Numeric Literals

Non-numeric Literals Strings

Primitive Types are Value Type

Fast Track to Java 7 and OO Development

Arithmetic Operations

Primitive Type Conversion and Casting 4. More on Classes and Objects

Working with Methods and Data Working Within Methods Calling Methods Local Variables

The this Variable and Instance Data

Pretty Pictures

Overloading Methods

Calling Overloaded Methods The tostring() Method

Encapsulation and Access Control Encapsulation: Black Boxes

Key Advantages of Encapsulation Program Correctness Access Control

Access for Data Members and Methods Private Access Public Access Constructors

Using Constructors

Explicit Constructor Call Static or Class Members Declaring Static Members Accessing Static Members

Accessing Data in Static Methods

final Variables

Odds and Ends

Scopes and Blocks Assignment Comparison Null Objects

Wrapper classes

Reference Types as Method Parameters

final Method Parameters

5. Flow of Control

Branching Statements

Program Execution Sequence in Java The Comparison Operators The Logical Operators

if-else Statement switch Statement

Iteration Statements

while Statement

do-while Statement

for Statement

break Statement

continue Statement

6. Strings and Arrays

String and StringBuffer/StringBuilder

Using String s

Changing String s

Classes StringBuffer and

StringBuilder

Using StringBuffer and

StringBuilder

Regular Expressions Arrays

Creating Arrays and Accessing Elements Array of Object References

Array of Strings args Array

Iterating Over Arrays varargs

7. Packages

Packages Overview

Dealing with Complexity Packages

package Statement

The Default Package

import Statement

Importing a Complete Package

Importing a Single Package Member Using the Fully Qualified Name Standard Imports

Resolving Naming Conflicts Creating a Package

Access Control for Class Members Access Control for Classes Finding Classes

Tools Must Locate Class Definitions Organizing Files and Packages Class Path

What is a JAR?

#text-block-11 { margin-bottom:0px; text-align:left; }

8. Composition and Inheritance

Composition

Dealing with Complexity and

Composition Composition Delegation

Fast Track to Java 7 and OO Development

Benefits of Composition Issues with Composition

About Object Relationships Other Kinds of Relationships Inheritance

Inheritance and Dealing with

Complexity

Inheritance Hierarchy

The extends Keyword

Inheriting from the Superclass Inheritance and Superclass Data

Members

A Subclass IS-A Superclass Accessing Superclass Members Constructors and Inheritance Final Classes

Overriding and Polymorphism Changing Behavior with Method

Overriding

OO Concepts – Polymorphism

Polymorphism

Importance of Polymorphism

The super keyword

Access Control – protected Access Class Object

Methods of Class Object

Automatic Storage Management Abstract Classes

Using Abstract Classes

9. Interfaces

What if All You Have to Share is an

Idea?

Interface Types

Interface Definitions

The implements Keyword Interface Types – Revisited

Extending Interfaces

Implementing Extended Interfaces Interfaces are Abstract

Data Members in Interfaces

Implementing Multiple Interfaces

10. Exceptions

Overview of Exceptions Exception Hierarchy

Exception, Error, RuntimeException

Handling Exceptions with try and

catch

Exceptions and Program Flow Variable Scope

The throws Clause

Throwing Exceptions with throw

User-Defined Exceptions

Multiple catch Blocks finally Block

Runtime Exceptions Multicatch (Java7)

Using try-with-resources

(Java 7)

11. Collections and Generics

Java Collections Framework Overview java.util Collection Interfaces Collection Interface

Generics and Type-Safe Collections List and ArrayList List Interface ArrayList

The for-each Construct

Autoboxing and Collections of Object Autoboxing

Summarizing Collections Features Collections of Object

Issues with Collection of Object Other Collection Types Set Interface Using Sets

Map Interface HashMap

Generic HashMaps

Creating and Using HashMap Iterating Through a HashMap Iterator

Processing Items with an Iterator Iterator Interface What are Generics

Declaring a Generic Class

Summary – Basic Generics Usage

Inheritance with Generic Types Assignment with Generic Types Wildcard Parameter Types Generic Methods

The Collections Class

Fast Track to Java 7 and OO Development

Unmodifiable Wrappers Algorithms

12. Database Access with JDBC and JPA

What is JDBC?

JDBC Architecture

The Fundamental JDBC API Common JDBC Types

Naming Databases with URLs The Item Database Table JPA Overview

Java Persistence API (JPA)

JPA Architecture – High Level View JPA Architecture – Programming View

Working with JPA Entity Classes

MusicItem Entity Class Annotation Overview

Additional MusicItem Annotations Mapping an Entity Class The Persistence Unit

persistence.xml Structure The EntityManager

Working with Transactions Using JPA

Persisting a New Entity

Updating a Persistent Instance Removing an Instance Executing a Query

13. Additional Language Features

Assertions Defined Assertion Uses

Assertion Non-Uses Assertion Syntax

Using Assertions to Check Flow of

Control

Enabling/Disabling Assertions at

Runtime

What They Look Like at Runtime Type-Safe Enums

Enumerated Types Defined

Problems with int Enumerated Types

The Issue

Annotations – The Solution

Other Java Features

XML and Web Service Support Java DB

Scripting Language Integration

Desktop Application Improvements Monitoring and Management Tools Other Features (Java 6+)

14. I/O Streams Readers and Writers

Overview of I/O Streams Character Streams

Class Reader Class Writer

Common Reader Subclasses Common Writer Subclasses Using Readers and Writers

Path Separators Filter Streams

High-Level and Low-Level Streams Converting between Streams &

Readers/Writers

Byte Stream Classes

Common Stream Subclasses

Converting Between Byte & Character

Streams

Character Stream and Byte Stream

Equivalents

Formatted Output

Integer Format Specifiers Format Specifier Modifiers Other Format Specifiers New I/O (NIO) APIs New I/O (NIO) NIO Features Recap

Resources

15 Appendix – JDBC Java Database

Connectivity

The enum Keyword switch on enum for-each with enum

Advanced enum Features

Annotations