Saturday-Sunday, 5 weeks (40 hours). Price: 350 leva. (Special price for students: 280 leva)
Training is conducted by Trayan Iliev, Oracle® certified Java programmer with 15 years experience, developer of end-to-end reactive fullstack apps with ES6/7, TypeScript, Angular, React and Vue, 12+ years experience as IT trainer for international software companies. Regular speaker at developer conferences – Voxxed Days, jPrime, jProfessionals, BGOUG, BGJUG, DEV.BG on topics as SOA & REST (JAX-RS, Microservices), Spring 5 & Spring Reactor, Java EE, CDI, Angular, React, Redux, high-performance Java programming.
Duration: 40 hours
Price: 350 leva/ 280 leva for students
Target audience: Absolute beginners with good logical thinking
- you will learn all fundamental Java language constructs and recommended patters of their use;
- ability to apply in practice the SOLID design principles of Object-Oriented Programming (OOP);
- games, challenges, and fun with Java robots and Raspberry Pi 3
- develop your own project – a business application application with web interface and database, which you can demonstrate to potential employers as part of your project portfolio;
- learn novelties in Java 8+ such as functional programming and stream data processing (Stream API), Generics, declarative annotations, etc.
- develop reliable and robust Java applications using appropriate exception processing;
- manipulate files and resources – listing, walking, searching, reading, writing, appending, etc.;
- use relational databases such as MySQL/PostgreSQL – create and modify tables, assign permissions, add/modify/delete records, join and query multiple tables using Structured Query Language (SQL) and Java DataBase Connectivity (JDBC);
- learn basics of web programming with Java Servlet 4 technology, MVC design pattern, HTTP/2 and web server Tomcat 9.x;
- prepare for the next step – course “Course Java Spring 5: Hibernate, Spring MVC, WebFlux & REST”
- Object Oriented Programming (OOP), SOLID principles – objects, classes, interface and implementation, abstraction, encapsulation, modularity, composition, inheritance, polymorhism. SOLID: Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion principles. Java compiler, bytecode, Java Virtual Machine (JVM) – compiling and running Java programs. (1 h)
- Java basic datatypes and algorithmic constructs – Java primitive and object datatypes. Variables and constants. Creating new types – classes, objects, methods and attributes. The methods of class Object. Mathematical, logical, relational, bitwise, and string operators. Basic algorithmic constructs – if-else, do-while, for, for each (arrays and collections) , break, continue, switch, etc. Reference and value types and method parameters – passing data by reference and by value. Using IntelliJ IDEA integrated development environment (IDE). (5 h)
- Object creation and initialization – initialization of object members, constructors, finalizing and garbage collection. Default constructors. Method overloading. Static members initialization. Sequence of initialization. (2 h)
- Arrays and basic algorithms with them – initialization, iteration, comparison, filling, copying, sorting, searching. Using utility methods of the class Arrays – sort, reverse, fill, copy, max, min, binarySearch, etc. Multi-dimensional arrays. Array-based algorithmic implementations. Examples and problems. (4 h)
- Strings and Regular Expressions – mutable and immutable data types, working with strings – String, StringBuilder. Formatted output: String.format() and Formatter.format(). Working with regular expressions – classes Pattern and Matcher. Using regular expressions for input data validation and parsing. Model-View-Controller (MVC) architectural pattern. Building sample MVC application – AddressBook. (3 h)
- Exception handling – class Exception. Try and catch blocks – handling multiple exceptions. Throwing and catching exceptions. Defining custom exceptions. Using stack-trace. Sequencing the catch clauses. Checked and unchecked exceptions – class RuntimeException. Chaining exceptions using cause. Finally block and its applications. (1 h)
- Packages and access modifiers, code reuse, inheritance – packages and fully qualified class names, public, private, protected, and default (package) visibility. Code reuse strategies – inheritance and composition. Inheritance in Java. Object initialization when using inheritance. Choosing inheritance vs. composition. Combining inheritance and composition. (2 h)
- Polymorphysm, abstract clases and methods, interfaces – automatic “upcasting” to the base type. Final members, methods, parameters, and classes. Differences between method overriding and overloading. Using declarative annotations in the code. Polymorphism. Abstract methods and classes. Interfaces. Classes implementing interfaces. Extending interfaces. Depending on abstractions, not implementations – Dependency Inversion Principle (DIP). (2 h)
- Inner classes and interfaces – static and instance inner classes. Closures – creating an instance of the inner class in the context of an outer class instance. Accessing outer state – final and effectively final. Instance.new and instance.this. Anonymous inner classes. Examples. (2 h)
- Data structures in Java – collections, lists, sets, and dictionary types. Hash tables. Base interfaces, their methods and main implementations: Collection, List, Set, Map, ArrayList, LinkedList, HashSet, TreeSet, HashMap, TreeMap. Comparison between different abstract data structure implementations – main use cases. (2 h)
- Generics – generic types and methods, Diamond(<>) operator and generic type inference. Substituion ruels when using generic types. Wildcard generics. Type erasure. Implementing custom generic data structures: MyLinkedList, Stack and Queue. (2 h)
- Functional programming with Java 8+ – lambda expressions and Stream API (packages java.util.function and java.util.stream), method references, default and static methods in interfaces, multiple inheritance rules. Functional programming using Optional and Stream monads in Java – advantages, implementation examples and language idioms. (2 h).
- Java New I/O 2 – working with files and directories using Path, Files, FileSystem, AttributeViews, Input and Output streams, Readers and Writers. Walking the file tree. File compression (GZIP, ZIP). Data serialization/deserialization. (4 h)
- Java DataBase Connectivity (JDBC) – relational databses, schemas, database drivers, connecting to MySQL/PostgreSQL database using DriverManager. Using Statement / PreparedStatement and Structured Query Language (SQL) to create/modify relational schema (database tables), and to query, insert, update, and remove records in these tables. Using ResultSet to acces and modyfy programmatically the query data. Database transactions – ACID properties. Practical refactoring of AdressBook application using MySQL/PostgreSQL database and JDBC. (4 h)
- Building Web Apps using Java Servlet 4 technology – Java web architecture, web containers (Tomcat, Jetty, Undertow), Web ARchives (WAR), HTTP and HTTP/2, Servlet 4. Introduction to web standards – HTML 5, CSS 3. Servlet 4 API – requests and responses, web context, cookies and HttpSession. Refactoring the AdressBook application as fully featured multi-layer Web MVC application with Data Access (DAO), Business Service (Control), and Web Presentation (Servlet-based) layers. (4 h)
Presentations, demonstrations, and hands-on exercises are conducted in parallel to achieve immediate reinforcement of concepts in practice.
Participants will learn to to program using Java 8+, and to develop basic Web MVC applications with Servlet 4 API and relational databases (MySQL/PostgreSQL). Study is conducted in small groups – up to 10 persons. During the training there will be opportunity for discussion of additional questions the participants are interested in.