36

CURSURI JAVA

CURSURI PROGRAMARE JAVA

Cursurile sunt acreditate ANC – Programator ajutor – COR 351201
Cursurile sunt scutite de plata TVA.
Pretul include suportul de curs in format electronic, masa de pranz, coffee breaks si certificatul ANC.
Diploma este recunoscuta de Ministerul Muncii, Familiei si Protectiei Sociale si Ministerul Educatiei, Cercetarii si Inovarii si atesta toate competentele profesionale ale ocupatiei.

INFORMATII DESPRE CURSURILE DISPONIBILE

CodDescriereDurataPret (scutit de plata TVA)Data urmatorului curs
Java 1Limbajul JAVA: Nivel Incepator – Mediu40 ore480 EURO28.01.2019
Java 2Limbajul JAVA: Nivel Mediu – Avansat40 ore480 EURON/A
Java 3Design Patterns24 ore500 EURON/A
Java 4Java WebServices32 ore410 EURON/A

INFORMATII DESPRE CURSURILE DISPONIBILE

CodDescriereDurataPret (scutit de plata TVA)Data urmatorului curs
DP&CCDesign Patterns & Clean Code16 oreN/A
PUTProfessional Unit Testing16 ore N/A
SPRINGSpring16/24 ore N/A
JPAHibernate/JPA 16 ore N/A

INFORMATII DESPRE CURSURILE DISPONIBILE

CodDescriereDurataPret (scutit de plata TVA)Data urmatorului curs
Java 8Java 88 ore N/A
JPOJava Performance Optimizations16/24 ore N/A
CC&CDClean Code & Coding Dojo8 ore N/A
ScalaScala40 oreN/A

AGENDA CURS LIMBAJUL JAVA – NIVEL INCEPATOR - MEDIU

LIMBAJUL JAVA –NIVEL INCEPATOR SI MEDIU

1.Programare orientata pe obiecte – principii de baza

Conceptul de clasa; conceptul de obiect

Avantaje specifice

Constructia obiectelor: constructori / destructori

Mostenire

Compunere

Vizibilitate

Polimorfism

Clase abstracte; metode abstracte

Tipuri generice

Limbaje “strongly typed” / limbaje “weakly typed”

 

2. Fundamentele limbajului Java

Tipuri primitive de date

Variabile; declararea variabilelor

Instructiuni; cuvinte-cheie

Cuvinte-cheie de modificare (Modifiers)

Transmiterea argumentelor

Operatori

Conversii de date

Tablouri, stringuri

Blocuri si Statement-uri

Tratarea exceptiilor

Clase si obiecte, gestionarea dinamica a memoriei

Initializare si clean-up (garbage collector, initializarea membrilor)

Interfete

Java Beans

Lucrul cu colectii de obiecte

Fire de executie (threads); sincronizare

Stream-uri, operatii de I/O, new I/O, serializarea obiectelor

 

3. Java New IO API

Java new I/O (NIO): generalitati

Citirea datelor

Scrierea datelor

Copierea directa a fisierelor

Citirea si scrierea din / in mai multe buffere simultan

Fisiere mapate in memorie

Operatiuni I/O neblocante – generalitati

Multiplexarea operatiunilor I/O – generalitati

 

4. Java logging

Java logging

log4j

 

5. Securitate Java

Conceptul de “sandbox”

Elemente de securitate implicite ale limbajului Java

Java Cryptography Extension (JCE)

 

6. Accesul la baze de date folosind JDBC

Baze de date relationale: generalitati

Notiuni generale de SQL

Conectarea la o baza de date folosind JDBC: Connection, Statement, ResultSet

Maparea tipurilor de date SQL / Java

Inserarea / stergerea / modificarea datelor

Parametrizarea unui query

Folosirea tranzactiilor

Framework-uri de acces la baza de date (Hibernate)

 

7. JEE

Modelul JEE; tiers (presentation, Web, business, data)

Notiuni de HTML

Notiuni de Javascript

Protocolul HTTP; reqest, response, headers

Servlets

Preluarea informatiilor: Interfetele HttpServletRequest si HttpSession

Trimiterea de informatii catre client: HttpServletResponse

Trimiterea de alte informatii decit HTML: content type

Internationalizare (entitati HTML)

Cooperarea intre servlet-i

Java Server Pages (JSP)

Tag-uri JSP standard

JSP Beans

Combinarea de servlets si pagini JSP

Tag-uri personalizate (custom tags)

Tipuri de tag-uri personalizate

Definirea si utilizarea tag-urilor personalizate

Cooperarea intre tag-uri (partajarea de obiecte)

 

8. Aplicatii applet-uri si instrumente de lucru cu ferestre

AWT

Componente Swing de baza: descriere generala

Thread-uri Swing

Crearea unui program Swing

Layout; Layout managers

Evenimente

 

9. Internationalizare

Definitii, generalitati; concepte generale

Clasa java.util.Locale

Fisiere de proprietati

Clasa java.util.ResourceBundle

 

10. Standarde de scriere a codului si de documentare

Standarde de formatare a codului: conventii de denumire, conventii de aliniere

JavaDoc; generare de documentatie pornind de la comentariile JavaDoc

 

11. Design patterns

Definitii; deosebiri intre design patterns si algoritmi

Pattern-uri de creatie

Pattern-uri structurale

Pattern-uri de comportament

AGENDA CURS LIMBAJUL JAVA – NIVEL MEDIU - AVANSAT

  • 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

AGENDA CURS 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

AGENDA CURS JAVA 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

AGENDA CURS 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….)

AGENDA CURS 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

AGENDA CURS SCALA

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)