Java 7 及面向对象开发强化班


This is a 5-day course that provides a broad and deep introduction to Java for non-Java programmers. The course covers all the basic concepts of Object-Oriented Programming and Java. Included is the 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.

Programmers with exposure to Java or related languages (ie. C or C++) or programmers with entirely unrelated backgrounds.

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

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
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
Accessing Data (Another Way) Pretty Pictures
More About Variables
About Java Primitive Data Types Numeric Literals
Non-numeric Literals
Primitive Types are Value Types
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
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
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
Strings and Arrays
String and StringBuffer/StringBuilder Using Strings
Changing Strings
Classes StringBufferand
StringBuilder UsingStringBuffer and
Regular Expressions
Creating Arrays and Accessing Elements Array of Object References
Array of Strings
args Array
Iterating Over Arrays
Packages Overview
Dealing with Complexity
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?
Composition and Inheritance Composition
Dealing with Complexity and
Composition Composition
BenefitsofComposition Issues with Composition About Object Relationships Other Kinds of Relationships Inheritance
Inheritance and Dealing with Complexity
Inheritance Hierarchy
The extendsKeyword Inheriting from the Superclass Inheritance and Superclass Data
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
HandlingExceptionswithtry 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)
Collections and Generics
Java Collections Framework Overview java.util Collection Interfaces Collection Interface
Generics and Type-Safe Collections List and ArrayList
List Interface
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
Generic HashMaps
Creating and Using HashMap Iterating Through a HashMap
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
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
What They Look Like at Runtime Type-Safe Enums
Enumerated Types Defined
Problems with int Enumerated Types Theenum Keyword
switch onenum
for-each with enum
Advancedenum 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+)
14. I/O Streams
Readers and Writers Overview of I/O Streams Character Streams
Class Reader
Class Writer
Common Reader Subclasses CommonWriter 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
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

5 days


邮箱地址不会被公开。 必填项已用*标注