J003 Fast Track to Java 7 and OO Development

Included in this five-day course are material and labs on all the key OO concepts, including topics like encapsulation, composition, and inheritance. It also includes some coverage of advanced Java capabilities such as JDBC/JPA and the Collections Framework, as well as coverage and usage of many of the newer capabilities in Java 7.  There are a large number of labs, and all labs except the first are done with a development environment (e.g. Eclipse or RAD). The lab instructions include detailed directions on the particular environment for that version of the course.

Trajanje: 5 dana/ 40 časova

Cena: 475 €

Ovaj kurs možete pohađati online(?)    

Poželjno predznanje: 

Previous programming experience in C, C++, or C#, and some knowledge of basic object-oriented concepts are recommended.

Sledeći polasci:

Beograd
24.04.2017
Virtuelna učionica
24.04.2017
Plan obuke : 

Module 1: A Simple Java Class and Running a Java Program

  • A Simple Application Class
  • The HelloWorld Program Broken Down
  • Compiling HelloWorld
  • Note on Comments

Module 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

Module 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 Types
  • Arithmetic Operations
  • Primitive Type Conversion and Casting

Module 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

Module 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

Module 6: Strings and Arrays

  • String and StringBuffer/StringBuilder
  • Using Strings
  • Changing Strings
  • 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

Module 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?

Module 8: Composition and Inheritance

  • Composition
  • Dealing with Complexity and Composition
  • Composition
  • Delegation
  • 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

Module 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

Module 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)

Module 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
  • Unmodifiable Wrappers
  • Algorithms

Module 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

Module 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 enum Keyword
  • switch on enum
  • for-each with enum
  • Advanced enum Features
  • Annotations
  • 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+)

Module 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