35

JAVA Courses

JAVA Programming Courses

The courses are accredited ANC – Programmer Help – COR 351201
The courses are exempt from VAT payment.
The price includes the course support in electronic format, lunch, coffee breaks and the ANC certificate.
The diploma is recognized by the Ministry of Labour, Family and social Protection and the Ministry of Education, Research and innovation and attests all the professional competences of the occupation.
Next

Information about available Courses

Code Description Duration price (exempt from VAT payment)Course Date
Java 1JAVA Language: Beginner Level – Medium40 hours480 EUROView Calendar
Java 2JAVA Language: Medium Level – Advanced40 hours480 EUROView Calendar
Java 3Design patterns24 hours500 EUROView Calendar
Java 4Java WebServices32 hours410 EUROView Calendar
Next

Information about available Courses

Code Description Duration price (exempt from VAT payment)Course Date
DP & CCDesign patterns & Clean Code16 hoursN/a
PUTProfessional Unit Testing16 hoursN/a
SPRINGSpring16/24 hoursN/a
JpaHibernate/JPA16 hoursN/a
Next

Information about available Courses

Code Description Duration price (exempt from VAT payment)Course Date
Java 8Java 88 hoursN/a
JpoJava Performance Optimizations16/24 hoursN/a
CC & CDClean Code & Coding Dojo8 hoursN/a
ScaleScale40 hoursN/a

JAVA Language Course AGENDA – Beginner level – medium

JAVA Language – Beginner and medium level

1. Object-oriented programming – Basic principles

The concept of class; Object concept

Specific advantages

Construction of objects: builders/Destructors

Inheritance

Compositing

Visibility

Polymorphism

abstract classes; Abstract methods

Generic types

Languages "strongly typed"/languages "weakly typed"

2. The fundamentals of Java language

Primitive data types

Variables Declaration of variables

Instructions Keywords

Keyword modification (Modifiers)

Transmission of arguments

Operators

Data conversions

Pictures, strings

Blocks and statements

Treatment of exceptions

Classes and objects, dynamic memory management

Initialization and clean-up (garbage collector, initialization of members)

Interfaces

Java Beans

Work with object collections

Execution threads (threads); Sync

streams, I/O operations, new I/O, serializing objects

3. Java New IO API

Java New I/O (NIO): overview

Reading data

Writing data

Copying files directly

Reading and writing from/into multiple buffers at once

Memory-Mapped files

Unblockable I/O operations – Overview

Multiplexing of I/O operations – Overview

4. Java Logging

Java Logging

Log4j

5. Java Security

The concept of "sandbox"

Default Java language security features

Java Cryptography Extension (JCE)

6. Access to databases using JDBC

Relational databases: overview

SQL General Notions

Connecting to a database using JDBC: Connection, Statement, ResultSet

Mapping SQL/Java data types

inserting/deleting/modifying data

Setting up a query

Use of transactions

Database access Frameworks (Hibernate)

7. JEE

Model JEE; Tiers (presentation, WEB, business, data)

Notions of HTML

Notions of Javascript

HTTP Protocol; Reqest, Response, headers

Servlets

Information retrieval: HttpServletRequest and HttpSession interfaces

Sending information to the client: HttpServletResponse

Sending information other than HTML: content type

Internationalization (HTML entities)

Cooperation between servlet-I

Java Server pages (JSP)

JSP Standard Tags

JSP Beans

Combining Servlets and JSP pages

Custom tags (custom tags)

Types of Custom Tags

Defining and using custom tags

Cooperation between tags (object sharing)

8. Applications applets and tools work with Windows

Awt

Base Swing components: General description

Swing Threads

Creating a Swing Program

Layout Layout Managers

Events

9. Internationalization

definitions, overview; General Concepts

Java class. Useful. Local

Property files

Java class. util. ResourceBundle

10. Code and Documentation Writing standards

Code formatting standards: Naming conventions, alignment conventions

JavaDoc Generating documentation from JAVADOC comments

11. Design patterns

Definitii; deosebiri intre design patterns si algoritmi

Pattern-uri de creatie

Pattern-uri structurale

Pattern-uri de comportament

JAVA Language Course AGENDA – Medium-Advanced level

  • Design Principles
    • 3 Principles of OO Design
    • The SOLID principles
    • DRY
    • SRP
    • Patterns vs Simplicity. KISS
  • Creational Patterns:
      • Singleton
      • Fluent Builder
      • Abstract Factory

  • Factory Method
  • Structural Patterns:
      • Adapter
      • Proxy. Aspect-Oriented-Programming
      • Decorator
      • Facade

  • Composite
  • Behavioral Patterns:
      • Observer

  • Iterator
    • Strategy
    • Command
    • Template Method
    • Visitor
    • Chain of responsibility
    • Passing-a-block (Functional Programming)
  • Antipatterns
  • What is Clean Code
    • Names
      • Expressing intent
      • Parts of speech
      • Length
      • Comprehension Refactoring
    • Functions
      • Function Size
      • Factoring Methods
      • Exceptions: Best Practices
      • Function Signature
      • Extracting Method Objects
  • Side Effects & Temporal Coupling
  • Command/Query separation

    • Classes
      • True Encapsulation
      • Data Structures vs. True Objects
      • Logic Containers
      • Switch+Data Structures vs. Polymorphic Objects
  • ‘Tell, Don’t Ask’ Principle

      • Feature Envy
  • The Plugin Model: Dependency Inversion Principle

  • Code Formatting
  • Comments are failures
    • Expressive Code

COURSE AGENDA PROFESSIONAL UNIT TESTING

  • Java 7 features (Quick recap – warm-up)
    • Try-with-resources: Supressed Exception
    • Diamond notation
    • String switch
    • Multi-catch
  • Lambdas and Streams
    • Filtering Streams
    • Transforming Streams
    • Collecting Streams
    • Writing Clean Code with Java 8: Best Practices and Anti-patterns
  • Async and Parallel Processing with Java 8
    • Short Introduction to Performance: Why to parallelize?
    • Parallel Streams
    • Controlling Parallelism
    • CompletableFuture

JAVA COURSE AGENDA 8

  • Java 7 features (Quick recap – warm-up)
    • Try-with-resources: Supressed Exception
    • Diamond notation
    • String switch
    • Multi-catch
  • Lambdas and Streams
    • Filtering Streams
    • Transforming Streams
    • Collecting Streams
    • Writing Clean Code with Java 8: Best Practices and Anti-patterns
  • Async and Parallel Processing with Java 8
    • Short Introduction to Performance: Why to parallelize?
    • Parallel Streams
    • Controlling Parallelism
    • CompletableFuture

COURSE AGENDA JAVA PERFORMANCE OPTIMIZATIONS

  1. Introduction
  • Your Own Performance Challenges…
  • Measure Don’t Guess
  • Core Concepts: Responsivity, Throughput, Load, Work Load, Utilization
  • Gowing Slower to go Faster: discharge the bottleneck
  • Time Budgeting
  • Stress Tests: Types2. Concurrency Patterns
  • This module explains the core Java Concurrency principles, with special emphasis on the most useful topics in day-to-day practice: the monitor object, wait()/notify() primitives and the Thread Pool Executor. The included hands-on lab will exercise these concepts and classes.
  • Basic Concepts
    • Deadlock, Live Lock, Race
    • Atomicity
    • Thread Safety
    • Cancelling an execution
  • Patterns in JDK
    • Lock
    • Semaphore
    • Latches
    • Barrier
    • Readers-Writers Lock
  • Monitor: synchronized, wait(), notify()
  • Thread Pools, Executors
  • Thread Local Storage
  • Best practices & Pitfalls3. Just-In-Time Compiler
  • Interpreted vs Compiled Code
  • Hot Spot Compiler
  • Optimizations: Static vs Dynamic
  • Example: Dynamic Optimizations with Escape Analysis
  • JIT Compiler: Levels, Monitoring
  • Code Cache
  • General Coding Advices4. Garbage Collector
  • GC Principles: Generations, Heap Fragmentation, ..
  • GC Algorithms
    • Serial Collector
    • Parallel/Throughput Collector
    • CMS Collector
    • G1 Collector
  • Choosing a GC: general guidelines
  • System.gc
  • Sizing for Heap, Generations, PermGen/Metaspace
  • Monitoring GC: jvm GC log output, jconsole, jstat, jVisualVM, HPJMeter
  • Tuning GC: Throughput, CMS
  • Thread Local Allocation Buffers5. Finding Memory Leaks
  • OutOfMemoryError: Causes
  • Out of Heap: possible leak sources
  • GC Roots
  • Investigating Leak using Tools: a full example
    • Visualize the Leak (jvisualVm, hpjmeter)
    • Heap Dump Analysis(jvisualvm, Eclipse MAT): largest set of instances for a class, path to nearest GC Root
    • Memory Profiling (jvisualVm): How many objects were just created, how many generations, by who?
  • GC Recap Quiz6. Tips for Performance Coding
  • This module gives general advice on how to write high-performance code in Java. Throughout the contents, I will often ask the attendees how would THEY implement a certain functionality already available in JVM (example: String.intern()). That’s why this module is more a brainstorm than a classic training, and motivated practitioners would make it a very-very-very interesting session. The discussions may easily divagate to general algorithms and macro-design decisions.
  • Intro: Performance in Java Enterprise App
  • Effective Memory Usage
    • Lazy Init, Eager Deinit
    • Canonicalization, String.intern()
    • Object Pools: WHY ?
    • Thread Locals
    • Weak, Soft References + Practice
  • Effective Multi-Threading
    • Amdhal’s Law
    • Synchronization Cost
    • CPU Register Flushing
    • How to Avoid Synchronization
  • Thread Pools
    • Executor Types
    • Sizing the Queue
    • Sizing the Thread Pool
    • Fork-Join-Pool (1 word)
  • Database
    • JDBC
    • JPA (+Discussions….)

COURSE AGENDA CLEAN CODE & CODING DOJO

  • What is Clean Code
  • Names
    • Expressing intent
    • Parts of speech
    • Length
    • Comprehension Refactoring
  • Functions
      • Function Size
      • Factoring Methods
      • Exceptions: Best Practices
      • Function Signature
      • Extracting Method Objects

  • Side Effects & Temporal Coupling
  • Command/Query separation
  • Classes
      • True Encapsulation
      • Data Structures vs. True Objects
      • Logic Containers
      • Switch+Data Structures vs. Polymorphic Objects

  • ‘Tell, Don’t Ask’ Principle
      • Feature Envy

  • The Plugin Model: Dependency Inversion Principle
  • Code Formatting
  • Comments are failures
    • Expressive Code

COURSE AGENDA SCALE

Day 1

  • First lines in Scala – Basic Language Syntax (4h)
    • Set-up IDE. Play with scala Interpreter
    • Variables and Values
    • Functions
    • Your 1st scala script
    • Parameterized types
    • The .apply method
    • Lists – basic stuff
    • Tuples
    • Sets and Maps – syntax
    • Functional style – intro
    • Read a file
  • Classes and Objects (4h)
    • Classes, fields, methods
    • Companion Objects
    • Your 1st main() method. The App trait
    • equals, ==, eq
    • String interpolation
    • Operators are methods. Left or right –apply ?
    • Operator Precedence
    • Rich wrappers
    • Day 2
  • Designing a Functional Object – the Rational class (4h)
    • Constructors, invariants
    • Immutability
    • Method override and overload
    • Class params vs fields
    • Access protection: private, private[this], protected, public
    • Defining an operator
  • Control structures (4h)
    • Imperatrive example
    • The “ternary” if
    • The “imperative” while
    • The “overwhelming” for: ranges, foreach, filter, flatmap, yield
    • Try {}: catch { case, throw new…, error(), Nothing return type
    • match-case
    • Refactoring imperative to functional-style
    • Day 3
  • Functions and closures (4h)
    • Local functions
    • Function literals (anonymous ad-hoc functions)
    • Shorter forms of anonymous functions
    • Partially applied functions
    • Closures
    • Repeated parameters
    • Default parameters. Named arguments
  • Control abstractions (2h)
    • Pass a the variable step as function to reduce duplication
    • Currying
    • The Loan Pattern
    • By-name parameters
  • Composition and inheritance (2h) – fill the gaps exercises
    • The uniform access principle
    • Parametric fields
    • Invoking superclass constructors
    • Factory objects
    • Day 4
  • Scala class hierarchy (2h)
    • General picture
    • Unit, Any, Nothing, AnyRef, AnyVal
    • Int, RichInt, auto-boxing
    • Custom value classes
  • Traits (2h)
    • Thin vs Rich interfaces problem
    • Mixing a trait: exercise
    • The Ordered trait
    • Stackable modifications
  • Packages (1h)
    • Nesting packages
    • Private[this], [outerclass]
    • Package objects
  • Unit tests – ScalaTest(1h)
    • Ensuring, assert
    • assertThrows
    • Day 5
  • Case Classes and Pattern Matching (3h)
    • What “case class” gives you
    • A full example (fill the gaps)
    • Types of match patterns: wildcard, constant, variable, constructor, tuple, type, variable binding
    • Pattern guards
    • Sealed classes
    • The Option type
  • Scala Collections API (2h): Hands-on exercises to explore the API
  • Overview of concepts in Play Framwork (Demo) [opt1, to ellaborate]
  • A Coding Exercise (Coding Kata)