The course objective is to give the students a stable basis of knowledge and skills for working as a software engineer for the Java platform. The course covers the minimal set of knowledge and skills that a Java developer should have: Java language, object-oriented programming, standard Java APIs, database development with Oracle and Hibernate, Swing GUI applications, Web applications. The course is based on Java 5, Eclipse 3.2, Tomcat 5.5 and Oracle 10g.
- Course scope, curriculum, exams, homework, lectures, exercises
- The Java Virtual Machine (JVM)
- Creating, compiling and running Java applications
- The structure of JAR archives
- Classpath and class loader
- Java programs structure
- Identifiers; Keywords
- Primitive data types; Enumerations
- Variables; Assignments; Operators;
- Expressions; Statements; Control structures (if, for, while, do … while)
- Console input/output
- Arrays – one-dimensional and multidimensional arrays
- Using the Java API Documentation
- Object-oriented programming and design fundamentals
- Classes, Objects and Interfaces
- Inheritance, abstraction, encapsulation and polymorphism
- Creating and using objects; Value types and references
- Classes, constructors, methods, fields, constants, access modifiers
- Packages
- Inner classes
- Static methods and static constructors
- Inheritance and polymorphism
- Abstract classes and interfaces
- Error handling and exceptions
- Catching and throwing exceptions
- Defining and using own exception classes
- Generic methods and classes
- Defining and using Javadoc documentation
- java.lang.Object, equality, hash codes, toString()
- Cloning objects
- Comparing objects
- Type conversions and casting
- Value types vs. Objects; Autoboxing/unboxing
- The Unicode standard
- Strings and string processing: creating, concatenating, extracting substrings, searching, comparing, and splitting
- Parsing and formatting numbers
- Building and modifying strings: StringBuilder and StringBuffer classes
- Dates and calendars
- Locales, string formatting, formatting numbers and dates
- Parsing numbers and dates
- Character sets and conversions
- Localization with ResourceBundle
- Numeral systems
- Computer representation of numbers
- Algorithms complexity
- Asymptotic notation
- Analyzing and computing complexity
- Lists and representation
- Queues and representation
- Stacks and representation
- Trees, binary trees and balanced search trees
- Hash-tables and representation
- Graphs – basic concepts and representation
- Depth First Search (DFS) algorithm
- Breath First Search (BFS) algorithm
- Standard algorithms on arrays: sorting, binary search, printing
- Java Collections Framework – overview
- Collection Interfaces – Collection, List, Set, Map, Iterable, Iterator
- Collection Classes – ArrayList, Vector, Hashtable, HashMap, TreeMap, HashSet, TreeSet
- The regular expressions language – literals and meta-characters, character classes, quantifiers, grouping characters, etc.
- Regular expressions in Java
- Searching, extracting, validating, splitting and replacing text by regular expressions
- Memory management and garbage collection
- Finalizers
- Binary streams and text streams (readers and writers)
- Files and directories
- Test – 35 questions (25 required to pass)
- Practical exam – 3 practical problems (70% required to pass)
- Homework check – 25 homework submitted required to pass (at least one for each topic)
- Trainer checks 2 randomly selected homework in class
- Students not passed the exam sit for a second attempt a week later
- Students that fail on the exam at the second try leave the course permanently
- Basic database concepts: RDBMS, tables, relationships, multiplicity, primary keys, foreign keys, E/R diagrams, normalization, constraints, indexes, views, triggers, stored procedures, transactions
- Database modeling and entity/relationship diagrams
- E/R modeling tools
- Working with CASE Studio / Toad Data Modeler
- Introduction to Oracle Database (Oracle 10g Express Edition) – Installing and Configuring; Oracle Database XE Web Based Administration; Oracle SQL Developer, SQL*Plus
- SQL language (DML; SELECT, INSERT, UPDATE and DELETE statements; joins; aggregate functions; Oracle data types, DDL)
- Introduction to PL/SQL – stored procedures and functions, packages, cursors, transactions
- Basic classes (DriverManager, Connection, Statement, ResultSet, PreparedStatement, CallableStatement, DatabaseMetadata, ResultSetMetadata)
- Accessing Oracle database
- Transaction management
- Best practices using JDBC
- Basic XML concepts (Well-formed XML, namespaces, DTD, XSD, XML parsers)
- Java API for XML Processing (JAXP)
- Using the DOM parser – parsing, processing, modifying and creating XML documents
- Using the SAX parser – high performance XML parsing
- Using XPath
- Foundations of data persistence and object-relational mapping technologies
- Hibernate object persistence engine – overview and architecture
- Mapping POJO classes to database tables, mapping relationships between classes
- Manipulating persistent entity objects – using Hibernate sessions, fetching persistent objects, creating, modifying and deleting persistent entities, using transactions, using HQL queries
- Multithreading (Thread and Runnable)
- Timer and TimerTask
- Synchronization techniques (critical sections, monitors, wait() and notify(), etc.)
- Classical synchronization problems (producer/consumer problem, reader/write problem, etc.)
- Thread pools; Executors
- Loading classes
- Exploring metadata – classes, methods, class members
- Dynamically instantiating classes and invoking methods
- Automatic and custom serialization / deserialization
- JavaBeans component model – components, properties, events
- Introspection and BeanInfo interface
- AWT/Swing programming model, basic classes
- Frames and dialogs (JFrame, JDialog)
- Adding components to the frames
- Handling events (events, event sources and listeners)
- Basic components (JLabel, JTextField, JButton, JPanel, JScrollPane)
- Layout managers
- Advanced components (menus, status bars, toolbars, tables, trees)
- Using Threads in Swing
- Test – 35 questions (25 required to pass)
- Practical exam – 3 practical problems (70% required to pass)
- Homework check – 25 homework submitted required to pass (at least one for each topic)
- Trainer checks 2 randomly selected homework in class
- Students not passed the exam sit for a second attempt a week later
- Students that fail on the exam at the second try leave the course permanently
- Basic Internet concepts (OSI Seven-Layer Model, TCP/IP, protocols, services, IP address, network interface, DNS, TCP, UDP, sockets, etc.)
- TCP and UDP sockets
- Accessing Internet resources through URL
- E-mail API
- The Java platform – Java SE, Java EE, Java ME
- Java EE platform architecture – containers and components
- Web container and Web applications
- EJB container and EJB modules
- Web services
- Java EE application servers
- Enterprise applications – EAR, WAR, and JAR deployment standards
- Java EE technologies – JSP/Servlet, EJB, JMS, JTA/JTS, JNDI, JDBC, JavaMail, JAAS, XML/JAXP, JMX
- The HTTP protocol; Request-response model; The World Wide Web (WWW); Web-programming fundamentals, Web servers, Web browsers
- HTML basics: formatting tags, images, hyperlinks, lists, tables, forms
- Creating and using CSS files
- Using JavaScript language – first steps
- Manipulating the HTML DOM tree
- Cutting the site design into pieces
- Creating the HTML and CSS
- Java Servlets – creating, running and deploying
- Servlet execution life-cycle
- Using HTML forms with servlets; Processing request parameters
- Session management; Storing and retrieving information in the user’s session
- Controlling the Web browser’s cache
- Java EE Web applications
- WAR files
- Using Tomcat Web application server, deployment, configuring servlets
- JavaServer Pages – JSP scriptlets, expressions, declarations
- Basic JSP directives – @page, @include
- Basic JSP objects – application, session, request, response, out, config
- Redirection to another page (client an server redirection)
- HTML escaping problems
- JavaBeans and EL
- Using EL: accessing scoped variables, beans, properties and collections
- The concept of custom tags and tag libraries
- JSTL overview
- Structural, localization, XML and SQL tags
- Custom tags and tag libraries
- Creating custom tags with .tag files
- Using tag libraries and custom tags
- Test – 35 questions (25 required to pass)
- Practical exam – 3 practical problems (70% required to pass)
- Homework check – 25 homework submitted required to pass (at least one for each topic)
- Trainer checks 2 randomly selected homework in class
- Students not passed the exam sit for a second attempt a week later
- Students that fail on the exam at the second try leave the course permanently
- Software engineering fundamentals
- Processes, methodologies and typical project development lifecycle
- Project plan
- Analysis and Specification
- Architecture and design
- Implementation
- Testing: unit testing, integration testing, stress testing
- Deployment
- Software configuration management and source control repositories
- Versioning models: Lock-Modify-Unlock and Copy-Modify-Merge
- Using Subversion (SVN) source control repository
- Using TortoiseSVN and Subeclipse SVN clients
- Unit testing fundamentals
- Introduction to JUnit
- Creating test cases and test suits
- Executing test cases and test suits
- Build tools – creating and using Ant build scripts
- Ant build files
- Ant build process
- Using properties, conditional tasks and multiple build files
Each practical project will cover these technologies (but not only):
- Tomcat Web application server
- Oracle database
- Hibernate – relational database access
- Web applications – HTML, servlets, JSP, JSTL, custom tags
- Swing – desktop GUI front-end
The project covers the following elements of the software engineering:
- Analyzing the software requirements documentation and defining UI prototype
- Creating system architecture, designing the database and designing the modules of the system
- Implementing the modules of the system and integration
- Testing and debugging
- Using source control repository (Subversion)
Each project is done by a team of 3-5 students.
The final exam is an assignment for development of a small project with Oracle, Tomcat, Hibernate, Servlets/JSP and Swing and should be implemented in 6 hours in class. The exam consists of the following tasks:
-
