Programming
Java Programming
This course provides a solid understanding of the core OO and Java concepts and practices needed to create well designed Java programs. It also covers all the key OO capabilities and how to use them in Java, including material on creating well designed Java classes, using encapsulation, building more complex functionality with composition, and using inheritance to share functionality and create specialized types. It also covers more advanced concepts such as using interfaces, working with the Java Collections Framework, and overviews of accessing databases with JDBC and JPA (including labs using JPA). All labs are done using Eclipse.
PREREQUISITES
Students should have taken our Introduction to Programming Using C course or have programmed in at least one programming language – preferably C or C++. Some familiarity with Object Oriented Programming is desired but not required.
At the conclusion of this course, students will be able to:
- Understand the role of the Java Virtual machine in achieving platform independence.
- Use the primitive data types and fundamental control flow constructs to write basic Java applications.
- Utilize the Eclipse IDE to develop and debug Java applications and incorporate automated JUnit testing.
- Use the object-oriented paradigm when defining classes
- Be able to define and invoke methods properly
- Create arrays of various data types and loop through them in an application
- Use encapsulation to combine the data and methods within a class.
- Use inheritance and polymorphism to create and use new data types that are specialized versions of existing data types.
- Define both abstract classes and interfaces to create a hierarchy of classes that form the basis for a framework of data types to work with
- Be able to write exception handlers to respond to errors at runtime within a program
- Use the various built in I/O classes to perform various ways of creating input and output within a program
- Use various data types from the Collections Framework to work with various collections of data.
- Work with the client/server model to create applications that are able to communicate over a network.
- Write basic Graphical User Interfaces (GUIs) in Java
- Utilize the Java Stream API to process data in a pipelined fashion.
Day 1 – A First Look, Java Basics, Class and Object Basics, More on Classes and Objects
Day 2 – Flow of Control, Strings and Arrays, Packages, Composition and Inheritance
Day 3 – Interfaces, Exceptions, Inner Classes
Day 4 – Java Collections and Generics, Database Access with JDBC and JPA, Additional Java Features
Day 5 –I/O Streams, Automated Unit Testing with JUnit, Basic Graphical User Interfaces
1. The Java Stream API
- What is Java?
- Versioning
- The Java Virtual Machine
- Writing a Java Program
- Packages
- Simple Java Programs
2. Language Components
- Primitive Data Types
- Comments
- Control Flow Statements
- The if Statement
- The switch Statement
- The while and do while Statements
- The for Statement
- The break Statement
- The continue Statement
- Operators
- Casts and Conversions
- Keywords
3. Object-Oriented Programming
- Defining New Data Types
- Constructors
- The String Class
- String Literals
- Documentation
- Packages
- The StringBuffer Class
- Naming Conventions
- The Date Class
- The import Statement
- Deprecation
- The StringTokenizer Class
- The DecimalFormat Class
4. Methods
- Introduction
- Method Signatures
- Arguments and Parameters
- Passing Objects to Methods
- Method Overloading
- Static Methods
- The Math Class
- The System Class
- Wrapper Classes
5. Arrays
- Introduction
- Processing Arrays
- Copying Arrays
- Passing Arrays to Methods
- Arrays of Objects
- The Arrays Class
- Command Line Arguments
- Multidimensional Arrays
6. Encapsulation
- Introduction
- Constructors
- The this Reference
- Data Hiding
- public and private Members
- Access Levels
- Composition
- Static Data Members
7. Inheritance & Polymorphism
- Introduction
- A Simple Example
- The Object Class
- Method Overriding
- Polymorphism
- Additional Inheritance Examples
- Other Inheritance Issues
8. Abstract Classes and Interfaces
- Introduction
- Abstract Classes
- Extending an Abstract Class
- Interfaces
9. Exceptions
- Introduction
- Exception Handling
- The Exception Hierarchy
- Checked Exceptions
- Advertising Exceptions with throws
- Developing Your Own Exception Classes
- The finally Block
10. Input and Output in Java
- Introduction
- The File Class
- Standard Streams
- Keyboard Input
- File I/O Using Byte Streams
- Character Streams
- File I/O Using Character Streams
- Buffered Streams
- File I/O Using a Buffered Stream
- Keyboard Input Using a Buffered Stream
- Writing Text Files
- Serialization
11. Collections
- Introduction
- The Collection Interface
- Lists
- Using Generics with Collections
- Generics with Bounded Wild Cards
- Sets
- Maps
- The Collections Class
12. Networking
- Networking Fundamentals
- The Client/Server Model
- InetAddress
- URLs
- Sockets
- A Time-of-Day Client
- Writing Servers
- Client/Server Example
13. Java GUIs
- Introduction
- Frames
- Jcomponent
- JComponent Hierarchy
- Menus
- Content Pane
- Buttons
- Text Components
- BorderLayout
- Panels
- Combing Layout Manager with Panels
- The Java Event Model
- Events
- Event Sources
- Event Listeners
- Action Events
- Window Events
- Focus Events
- Key Events
- Mouse Events
- Inner Classes
- Anonymous Inner Classes
14. The Java Stream API
- Overview
- Lambda Expressions
- Method References
- Stream
- Stream Operations
Is there a discount available for current students?
UMBC students and alumni, as well as students who have previously taken a public training course with UMBC Training Centers are eligible for a 10% discount, capped at $250. Please provide a copy of your UMBC student ID or an unofficial transcript or the name of the UMBC Training Centers course you have completed. Asynchronous courses are excluded from this offer.
What is the cancellation and refund policy?
Student will receive a refund of paid registration fees only if UMBC Training Centers receives a notice of cancellation at least 10 business days prior to the class start date for classes or the exam date for exams.