Ontwikkel je tot junior programmeur (Java) (incl. begeleiding)

• start the course
• describe the concept of planning and its part in the creation of a software application
• identify why it is important to properly plan your project
• describe the initial steps taken in planning your software application project
• identify the main components included in a planning document
• identify the importance of maintaining and updating your planning document
• identify issues that your design should address
• identify the main components of a design document
• describe how the planning documentation is helpful during the design stage of your project
• identify the importance of maintaining and updating your design documentation
• describe the importance of the planning and design stages of software development
• identify the characteristics of the Sequential software development model
• identify the characteristics of the Iterative and Incremental software development models
• describe the features and benefits of using the Waterfall method for development
• describe the features and benefits of using the Agile software development method
• describe the features and benefits of using the Spiral software development method
• describe the features and benefits of using the RAD method for development
• describe the features and benefits of using the prototyping method for software development
• describe the purpose, main sections, and importance of a development document
• describe the benefits associated with implementing coding standards in your project
• describe the benefits of implementing version control in your documentation and project
• identify the importance of maintaining and updating your development document
• list the methodologies and importance of documentation during the software development stage

• start the course
• recognize the benefits and importance of writing quality source code
• describe the concept of self-documenting code and its importance in the creation process
• describe why you should include comments in your code and distinguish good comments from bad ones
• identify best formatting practices for use in your source code
• identify source code that utilizes best coding conventions
• recognize the benefits of using best practices for naming identifiers in your program
• recognize the various styles used in different programming languages for naming identifiers
• recognize the best practices used when naming identifiers
• recognize identifiers that follow the best practices
• describe the purpose of methods and be able to distinguish between methods and procedures
• describe method cohesion and its advantages when creating methods
• identify best practices for working with arguments and distinguish between by value and by reference parameters
• identify best practices for working with return values
• identify best practices for working with exceptions
• identify source code that follows best practices for method writing
• describe the capabilities of a class, including abstraction and encapsulation
• recognize best practices for using constructors and destructors
• identify best practices for declaring a class and creating an object of that class
• recognize best practices for implementing inheritance and polymorphism
• describe the characteristics and use of interfaces and abstract classes
• recognize how to create and work with interfaces
• recognize how to create and work with abstract classes
• describe the benefits of following best practices when creating source code

• start the course
• identify the goal of application security and the need to consider security issues in the design and development of software applications
• list the guidelines for implementing security in your software development process
• recognize the various ways that your application can develop security problems
• identify the possible consequences of security problems
• identify the importance of data validation within your application
• describe the main functions that your data validation should perform on input data
• recognize code that follows best practices for validating input data
• identify the importance of validating and encoding output data returned from your application
• recognize code that follows best practices for validating output data
• recognize the importance of implementing authentication within your application and how it relates to security issues
• identify the various resources requiring authentication and potential associated security issues
• identify best practices for implementing authentication within your application
• recognize best practices for creating secure passwords
• recognize best practices for allowing users to change or recover passwords
• identify best practices for managing and maintaining passwords
• describe best practices for safely and securely handling errors in your application
• list information contained in logs and how to securely handle the log files your application generates
• identify best practices for securing data that is accessible by your application
• describe best practices for securing the uploading of files from within your application
• describe best practices for securing database access from your application
• identify best practices your application should use for managing memory
• list the best practices for creating secure applications

• start the course
• describe what refactoring is and recognize the benefits of performing code refactoring
• identify code conditions that can benefit from refactoring
• list the steps involved when performing refactoring on source code
• identify best practices for refactoring
• describe how refactoring can be implemented to improve methods in your source code
• recognize techniques for refactoring program functionality when working with objects
• describe refactoring techniques to simplify how your program works with data
• describe how conditional statements in your source code can be optimized with refactoring
• recognize how refactoring can help optimize calls to methods in your source code
• describe how to improve generalization in object-oriented programming through refactoring
• list the benefits and categories of refactoring code
• identify the benefits of performing maintenance on source code
• identify the types of peer reviews and describe the benefits of performing inspections on your source code
• list the roles and responsibilities of the participants involved in peer review inspections
• list the stages of a software inspection and describe the function of each
• describe the sources and effects of errors within your software application
• list and describe the most common types of errors caused by poor programming
• identify the sources of errors introduced by code improvements and how best to minimize these errors
• describe how functionality errors occur and how to minimize them
• list the various methods for testing your programs
• describe the purpose and principles of unit testing
• describe the techniques for detecting bugs when testing your programs
• list the steps involved when debugging your source code
• identify the benefits of maintaining, testing, and debugging source code

• start the course
• recognize the basic concepts of OOP
• create and instantiate a C#/Java object
• explain what abstract classes are and illustrate with a sample
• explain what encapsulation is and illustrate with a sample
• explain what inheritance is and illustrate with a sample
• demonstrate the concept of polymorphism and show how it works with a code sample
• recognize the basic concepts of OOD
• recognize the basic concepts of UML and recommended tools
• demonstrate the role of use cases in OOD
• demonstrate how to model classes and objects using UML
• demonstrate the role of state charts in OOD
• demonstrate how to create UML activity diagrams
• recognize the basic concepts of Don't Repeat Yourself (DRY)
• demonstrate the use of a Class Responsibility Collaboration card
• recognize the basic concepts of object-oriented programming: encapsulation, inheritance, polymorphism, and abstraction
• recognize the basic concepts of SOLID
• recognize the basic concepts of the Single Responsibility Principle
• recognize the basic concepts of the Open/Closed Principle
• recognize the basic concepts of the Liskov Substitution Principle
• recognize the basic concepts of the Interface Segregation Principle
• recognize the basic concepts of the Dependency Inversion Principle
• recognize the basic concepts of GRASP
• recognize the role of the Information Expert principle in the GRASP pattern
• recognize the role of the Creator principle in the GRASP pattern
• recognize the role of the Low Coupling principle in the GRASP pattern
• recognize the role of the High Cohesion principle in the GRASP pattern
• recognize the role of the Controller principle in the GRASP pattern
• recognize the role of Polymorphism in the GRASP pattern
• recognize the role of the Pure Fabrication principle in the GRASP pattern
• recognize the role of the Indirection principle in the GRASP pattern
• recognize the role of Protected Variations in the GRASP pattern
• recognize the basic concepts of the SOLID and GRASP object-oriented design principles

• Java is a powerful object-oriented programming language that

• allows you to write code once and deploy it on multiple operating
• systems. In this course, you'll learn about the Java programming
• language and related concepts, as well as how to work with the Java
• Development Kit and the Java Runtime Environment. First, you'll
• learn about the Java Virtual Machine and object-oriented
• programming concepts. Next, you'll explore Java features, such as
• platform independence, security and robustness, architecture
• neutrality, portability, and performance. Finally, you'll learn
• about Java distributed applications, multi-threading, dynamic
• loading, and real-world applications. This course is one of a
• collection of courses that prepares learners for Oracle’s 1Z0-811:
• Java Certified Foundations Associate certification.

• Java provides the right tools and features to allow you to be

• productive from the very start. In this Couse, you will learn about
• the features of the Java Development Kit and the Java Runtime
• Environment. First, you will learn about the Java Development
• Toolkit and the Java Runtime Environment. Next, you will learn
• about the features of the JDK such as the Java Compiler, the Java
• Interpreter, the Java Disassembler, the Java Debugger, the Java
• Head File Generator, the Java Documentation and the Java Archive.
• Finally, you will learn how to install the JDK, FRE, and the
• IntelliJ for Java Developers. This course is one of a collection of
• courses that prepares learners for Oracle’s 1Z0-811: Java Certified
• Foundations Associate certification.

• Writing code that is easy to understand and maintain is crucial

• to the software development life cycle. Since Java is an
• object-oriented programming language, the code is already organized
• and grouped based on objects with properties and methods that are
• associated with each object. However, as a developer you still need
• to be cognizant of how you write your code. In this course, you'll
• learn how to distinguish between clean and messy code and the
• benefits writing clean code. You'll also learn best practices for
• adding comments to your code and how to fix messy code. Finally,
• you'll explore tools that can be used when writing and cleaning
• code. This course is one of a collection of courses that prepares
• learners for Oracle's 1Z0-811: Java Certified Foundations Associate
• certification.

Object-oriented programming(OOP) is a programming method based on the concepts of 'objects' that contain properties and methods. Objects can inherit their structure from other classes and interfaces, which allows for code reuse. In this course, you'll learn about the features of object-oriented programming.

First, you'll learn about the basics of object-oriented programming and how it relates to Java, including the concepts of Java objects, classes, and interfaces. Next, you'll examine OOP concepts such as inheritance, polymorphism, abstract classes, encapsulation, and inner classes.

This course is one of a collection of courses that prepares learners for Oracle's 1Z0-811: Java Certified Foundations Associate certification.

• While developing software, being able to use repeatable

• solutions to commonly occurring problems greatly reduces
• development time. In this course, you will learn how design
• patterns can be used to provide repeatable solutions to the common
• design problems. First, you will learn the importance of design
• patterns and discuss the types of design patterns such as
• Behavioral, Creational and Structural. Next, you will write code to
• demonstrate how to implement the Iterator, Singleton and Adapter
• design patterns. Finally, you will learn some advanced features of
• software development, including design anti-patterns, software
• refactoring techniques, API pattern principles, and API patterns.
• This course is one of a collection of courses that prepares
• learners for Oracle’s 1Z0-811: Java Certified Foundations Associate
• certification.

• Java is a powerful object-oriented programming language that

• encapsulates data and code in classes using properties and methods.
• Java uses objects that can interact with other objects. In this
• course, you'll learn about the components of a basic Java program
• such as classes, attributes, methods, and access modifiers. First,
• you'll examine the basics of Java development and the components of
• a basic program. Next, you'll learn about Java features, such as
• constructors, classes, attributes, and methods. Finally, you'll
• explore Java access modifiers and how to compile and run Java
• programs. This course is one of a collection of courses that
• prepares learners for Oracle’s 1Z0-811: Java Certified Foundations
• Associate certification.

The Java programming language is a simple and powerful language to learn. In this course, you will learn Java programming basic and the Java programming style guide.

First, you will learn the basic elements of Java including keywords, comments, variables, identifiers, and data types. Next, you will learn the conventions that should be followed when writing Java programs regarding formatting, naming conventions, programming practices, and using Javadoc.

Next, you will use the “this” keyword in a Java application to help understand scope. Finally, you will learn about using Java packages including the java.lang package. This course is one of a collection of courses that prepares learners for Oracle’s 1Z0-811: Java Certified Foundations Associate certification.

• Being able to perform mathematical, conditional, and relational

• operations is a key feature of the Java programming language. In
• this course, you'll learn about the available mathematical,
• conditional, relational, bitwise, and unary operations. First,
• you'll explore the arithmetic and assignment operators available in
• Java and how to use them. Then, you'll move on to learn about Java
• unary, equality, and relational operators. Next, you'll examine
• Java conditional and bitwise operators. Finally, you'll learn about
• the precedence of Java mathematical, conditional, relational,
• unary, and parentheses operators. This course is one of a
• collection of courses that prepares learners for Oracle's 1Z0-811:
• Java Certified Foundations Associate certification.

• Strings are one of the most highly used data types in the Java

• programming language and working with strings efficiently is
• important for displaying and manipulating textual data. In this
• course, you'll learn to work with the String class and about the
• benefits of using the StringBuffer and StringBuilder classes with
• the stack and heap memory. You'll explore how to manipulate textual
• data using String variables and work with the String class methods.
• Next, you'll learn to use the more memory friendly StringBuffer and
• StringBuilder classes. Finally, you'll examine how to use escaping
• characters and String formatting specifiers. This course is one of
• a collection of courses that prepares learners for Oracle’s
• 1Z0-811: Java Certified Foundations Associate certification.

• Mathematical operations are used to perform calculations of

• numeric data types and being able to generate random numbers is an
• important aspect of Computer Science. Java provides full
• functionality for mathematical operations and random number
• generation. In this course, you'll learn to use the Java Math and
• Random number generator classes. First, you'll explore the various
• methods provided by the Java Math and the Java Random class. Next,
• you'll learn about and review demonstrations of the use of the
• java.util.Random, the Java Math.random, and the Java
• ThreadLocalRandom classes. This course is one of a collection of
• courses that prepares learners for Oracle’s 1Z0-811: Java Certified
• Foundations Associate certification.

• One of the main components of modern programming languages is
• the ability to make decisions using the data provided to them. Java
• provides decision statements that can be used to make decisions and
• being able to make decisions is a fundamental part of the Java
• programming language. In this course, you'll learn about various
• types of Java decision statements. You'll examine how to use the
• if-then-else and switch statements. Then, you'll move on to learn
• about String comparisons, the comparison operator, the equals()
• method, and compareTo. You'll also learn about the strengths and
• weaknesses of each comparison operator and the best time to use
• each. This course is one of a collection of courses that prepares
• learners for Oracle's 1Z0-811: Java Certified Foundations Associate
• certification.

• One of the main tasks of computer applications if to process

• lists of data. Java lists of data can be processed using looping
• statements. In this course, you will learn the various methods for
• performing looping in Java programming language. First, you will
• learn about the various types of looping statements available in
• Java such as enhanced for loops, for loops, while loops, and
• do-while loops. Next, you will learn about the best practices to
• follow when performing looping. Finally, you will learn about the
• break and continue statement. Finally, you'll learn how to apply
• all of these looping methods. This course is one of a collection of
• courses that prepares learners for Oracle’s 1Z0-811: Java Certified
• Foundations Associate certification.

• Sometimes the unexpected happens in your Java code and you will

• need to figure out what broke and how to fix it. In this course,
• you will learn how to handle exceptions and how to debug your Java
• code. First, you will learn how to debug your code using the Java
• JDB tool as well as using IntelliJ. Next, you will learn the best
• practice for debugging Java code and some common syntax and logic
• errors that you may encounter and methods for fixing these errors.
• Finally, you will learn how to handle exceptions in your code using
• the try catch block statements. This course is one of a collection
• of courses that prepares learners for Oracle’s 1Z0-811: Java
• Certified Foundations Associate certification.

• In Java, sometimes you have to iterate through and process a

• list of data. In this course, you will learn how Arrays and
• Arraylist are designed to handle looping through lists of data.
• First, you will learn about Arrays and the ArrayList class. Next
• you will learn about the Iterator class and how it can be used to
• processes list of data. Finally, you will learn about special
• classes used to store and retrieve lists of data such as the
• LinkedList class, the HashMap class, and the HashSet class. This
• course is one of a collection of courses that prepares learners for
• Oracle’s 1Z0-811: Java Certified Foundations Associate
• certification.

• Java is a powerful object-oriented programming language that

• encapsulates data and code in classes using properties and methods.
• Java uses objects that can interact with other objects. In this
• course, you'll learn about the components of a basic Java program
• such as classes, attributes, methods, and variables. First, you'll
• learn about the concepts of Java access modifiers and Java class
• members. Next, you'll examine the differences between a class,
• instance, and local variables and how they relate to Java. Next,
• you'll learn about the concept of overloading and how it applies to
• the constructor and methods. Finally, you'll explore how to create
• and instantiate a class with and without constructor parameters and
• modify the object fields. This course is one of a collection of
• courses that prepares learners for Oracle's 1Z0-811: Java Certified
• Foundations Associate certification.

• Java provides different data types that can be used to store and
• work with different types of data. In this course, you'll learn
• about these data types and how to perform actions on them. First,
• you'll learn about the various Java data types and their
• properties. Next, you'll examine how to declare and initialize
• variables in Java and purpose of the final keyword. You'll then
• move on to explore data type casting and the concepts of widening
• and narrowing casting. Finally, you'll learn about the Java String
• data type and how it relates to the Java StringBuilder class. This
• course is one of a collection of courses that prepares learners for
• Oracle's 1Z0-811: Java Certified Foundations Associate
• certification.

• Java is an object-oriented programming language that that uses

• classes to store data and provide methods to access and manipulate
• this data. In this course, you will learn how to create and use
• methods to manipulate the data inside a class. First, you will
• learn about Java methods, accessor methods, and mutator methods and
• how they are used in Java classes. Next, you will learn about
• describe overloading in Java and when to use it should be used.
• Next, you will learn about interfaces and how they are used to
• specify the behavior that a Class must implement. Finally, you will
• learn about the static keyword and how it can be applied to a
• method in a Class. This course is one of a collection of courses
• that prepares learners for Oracle’s 1Z0-811: Java Certified
• Foundations Associate certification.

Discover how to get up and running

Explore the use of variables and

Discover how to work with branching

Explore the essential elements of

Explore the concepts of

Explore working with strings in

Explore the JDK API documentation

Discover how to implement flow

Examine the methods of polymorphism in Java using inheritance, with subclasses and superclasses, and the use of abstract classes.

Explore the use of inheritance

Explore the use of try/catch blocks

Examine how to package Java

Explore the use of the JShell REPL

• Explore Java SE 11 and its language enhancements, the Shebang
• mechanism, and key features. Discover how to create and run simple
• executable Java programs, as well as how to create, import, and
• manipulate packages and strings. How to declare and initialize
• variables, work with local variable type inference, transform null
• or empty strings into an empty optional, and execute Single-File
• Source-Code programs is also covered.

• Explore the structure of Java classes, as well as how to work
• with Java control statements, Java operators, and loops. Discover
• how to declare, instantiate, initialize, and work with
• one-dimensional array, two-dimensional array, and Java objects.
• Finally, how to read and write to object fields and manipulate data
• with the StringBuilder class is also covered.

• Discover object-oriented programming (OOP) basics including how
• to create methods, overloaded methods, constructors with arguments,
• subclasses, and superclasses in Java. Examine how to extend
• abstract classes, apply the static keyword to methods and fields,
• apply access modifiers, apply encapsulation principles to classes,
• enable polymorphism, and use polymorphism to cast and call
• methods.

• Explore the differences between overloading, overriding, and
• hiding, as well as the differences between class inheritance and
• interface inheritance. Examine checked and unchecked exceptions and
• errors, along with the characteristics of Modular JDK in Java SE
• 11. In addition, discover how to create interfaces and try-catch
• blocks, create and invoke methods throwing exceptions, and work
• with list instances, ArrayList instances and Lambda
• expressions.

• Explore the concept of HotSpot, how to control JVM compilation
• with compiler directives, the changes introduced in JDK 11, and the
• performance enhancements in Oracle’s HotSpot Virtual Machine.
• Examine the role of class data sharing and the features of Native
• Memory Tracking. How to write directives to control compilation,
• transform null or empty strings into empty optional, and work with
• Java SE 11 nest-based access control is also covered.

1Z0-806 - Java SE 11 Programmer II: Core Java Libraries

1Z0-806 - Java SE 11 Programmer II: Class Concepts & Managing Exceptions

• Explore the concepts of Generics and Collections in Java,
• including different types of Generics, the Collections framework,
• implementations of Adapter and Map interfaces, features of
• concurrent implementations, and custom collection development.
• Discover how to create and use interfaces with default and private
• methods, simplify programs with Wrapper classes, and manage objects
• with boxing and unboxing. Working with diamond notation,
• NavigableSet, ConcurrentMap, ConcurrentNavigableMap, and marker
• interfaces is also covered.

• Explore implementations of comparable subinterfaces, the
• features of the Collator and RuleBasedCollator classes, the rules
• of functional interfaces and their role in functional programming,
• and the structure and syntax of building Lambda expressions.
• Discover how to work with the Comparator and Comparable interfaces,
• RuleBasedCollator, convenience factory methods and functional
• interfaces, as well as how to create and work with Lambda
• expressions and Lambda statements in Java SE 11.

• Explore streams and the Stream APIs, the differences between

• collections and streams, the structure of stream operations and
• pipelines, and methods of Stream interface in Java SE 11. Discover
• how to create basic streams and apply methods on them, apply
• reduction on parallel operations to manage concurrency, use the
• StreamSupport class to create low-level streams, and prevent
• interference when executing stream pipelines.

• Explore the java.util.function package interfaces, the roles of
• the Predicate, Consumer, Function, and Supplier interfaces,
• approaches for searching Stream data, and Optional class methods.
• Discover how to work with Lambda expressions, method references,
• and Function package interfaces, as well as how to extract, search,
• and match Stream data using the Stream API. How to implement
• calculations using the count, max, min, average and sum Stream
• operations is also covered.

• Explore the concept of NIO.2, implementing buffers, the
• attributes and methods of Path and File classes, and the channels
• supporting asynchronous I/O operations. Discover how to perform
• file I/O operations, manage metadata and walk a file tree using
• NIO.2, watch for changes in directories, use asynchronous datagram
• channels and multicasting, and implement completion handlers. Using
• the new java.nio.file.files class methods that were added in the in
• Java SE 11 is also covered.

• Explore cyclic dependency, the different types and components of
• services, service design and development, and service provider
• deployment as modules. Discover how to migrate from Java SE 9 to
• Java SE 11, run modularized applications, use JDeps, obtain service
• loaders, create worker threads, work with java.util.concurrent
• collections and classes, and write thread-safe code.

• Explore threading problems, the different states of threads, and
• concurrency management packages, synchronization classes, memory
• consistency properties. Examine the the Executor interface, classes
• that can be used to provision tuneable thread pools, and the
• exceptions that can be thrown while working with concurrency. How
• to use the CountDownLatch and CyclicBarrier classes, use the
• ForkJoinPool and ForkJoinTask methods, and work with the TimeUnit
• enum is also covered.

• Explore data integrity guidelines, how to enable accessibility
• and extensibility in Java applications, and how to handle input
• validation and mutability. Examine Java Cryptography Architecture,
• the Engine classes provided by JCA, and capabilities of the
• Provider class. Discover how to prevent Denial-of-Service and
• secure confidential information in Java applications, secure
• sensitive objects, and secure serialization and deserialization.
• How to generate key pairs, verify signatures with the generated key
• pairs, and secure socket code is also covered.

• Explore the contents of the java.sql package, how various SQL
• types are mapped to classes and interfaces, and enhancements in the
• features of the javax.sql package. Examine the Enum classes and
• their uses in JDBC and RowSet objects that can be used to hold
• tabular data in Java SE 11. In addition, discover how to connect to
• databases, perform CRUD operations with PreparedStatement, perform
• database operations using PreparedStatement and CallableStatement,
• work with DatabaseMetaData and ParameterMetaData interfaces, and
• use RowSet objects to manage data.

• Explore the concept of localization in Java SE 11, including
• locale management, using the Locale class, and resource bundles and
• their uses. Discover how to format messages, dates, and numbers, as
• well as how to work with commonly used annotations and the
• Annotation package Enums. In addition, how to create and use
• resource bundles, apply annotations to classes and methods, and
• build and declare custom annotations is also covered.