International Certification Program Software Programmer Fundamentals + Java SE 17 OCP y OCE Developing Applications for the Java EE 7 Platform Ed 1

1.1. Concepts of Algorithm and Their Importance

• Definition of algorithms.
• Structure of an algorithm: Input, Process, and Output.
• Types of algorithms: iterative, recursive, and algorithmic.
• Examples of algorithms in real life.

1.2. Computational Thinking and Problem Solving

• Decomposing problems into smaller steps.
• Pattern recognition and abstraction.
• Structure of the solution: Development and optimization.
• Designing efficient algorithms.

1.3. Practice: Solving Simple Problems with Pseudocode

• Modeling real problems with pseudocode.
• Conversions between pseudocode and flowcharts.
• Practical exercise: Developing pseudocode to solve a mathematical problem.

2.1. Use Case Diagrams

• Identification of actors.
• Diagrams of main and alternative scenarios.
• Extended and general use cases.

2.2. Sequence Diagrams

• Representation of interaction between objects and events.
• Modeling of data flow and message sequence.

2.3. Activity Diagrams

• Representation of activities, decisions, and alternative flows.
• Activity diagrams with partitions (swimlanes).

3.1. Data Types and Operators

• Primitive data types: integers, floats, booleans, strings.
• Arithmetic, logical, comparison, assignment, and bitwise operators.
• Data type conversion (casting).

3.2. Conditional Control Structures and Loops

• Conditional statements: if, else, elif, switch.
• Counter-controlled loops: for and while.
• Condition-controlled loops: do-while.
• Concepts of recursion vs iteration.

3.3. Declaration and Use of Functions

• Return and non-return functions.
• Parameters by value and by reference.
• Nested and recursive functions.
• Use of lambda functions.

3.4. Practice: Problem Solving with Functions

• Exercises on functional decomposition to solve problems.
• Code modularization to enhance reusability.

4.1. Lists, Tuples, Dictionaries, and Sets

• Basic operations on data structures: creation, updating, deletion.
• Advanced methods and operations: append, pop, sort, reverse.
• Dictionaries and handling key-value pairs.

4.2. Sorting Algorithms (Bubble, Selection)

• Step-by-step implementation of sorting algorithms.
• Time and space complexity: O(n^2), O(n log n).
• Comparison between sorting algorithms: efficiency and appropriate use.

4.3. Search Algorithms (Binary, Linear)

• Implementation of sequential search and binary search.
• Necessary conditions for using binary search.
• Comparison of complexities.

4.4. Practice: Implementation of Algorithms in Python

• Exercises on searching and sorting with lists and dictionaries.
• Optimization of search code for large volumes of data.

5.1. Basic Concepts of Objects and Classes

• Definition of objects, classes, attributes, and methods.
• Encapsulation, abstraction, and modularity.

5.2. Creation of Objects and Methods

• Creation and use of objects in Python.
• Public, private, and protected methods.

5.3. Inheritance and Polymorphism

• Concept of inheritance and class reusability.
• Overridden methods and polymorphism.

5.4. Practice: Modeling Objects and Their Interaction

• Practical exercise to model entities using OOP.

6.1. Types of Databases (Relational and Non-Relational)

• Key differences between relational and non-relational databases.
• Examples of relational databases (MySQL, PostgreSQL) and non-relational databases (MongoDB).
• When to use a relational database vs a non-relational one.

6.2. Database Components: Tables, Rows, Columns

• Definition and creation of tables.
• Relationships between tables: one-to-one, one-to-many, and many-to-many.
• Data types in SQL: VARCHAR, INT, DATE, etc.

7.1. Entity-Relationship Diagrams

• Definition of entities, attributes, and relationships.
• Creation of ER diagrams to represent data models.

7.2. Primary and Foreign Keys

• Definition of primary keys and how they ensure record uniqueness.
• Foreign keys and their importance in linking tables.

7.3. Database Normalization

• Concept of normalization and its levels (1NF, 2NF, 3NF).
• Practical exercises to avoid redundancy in databases.

8.1. Creation of tables and relationships

• Basic SQL syntax: CREATE TABLE, ALTER TABLE.
• Definition of constraints (PRIMARY KEY, UNIQUE, NOT NULL).

8.2. SQL Queries: SELECT, INSERT, UPDATE, DELETE

• Read queries: SELECT with filters, operators, and sorting.
• Queries for inserting, modifying, and deleting data: INSERT INTO, UPDATE, DELETE.

8.3. Aggregate functions: COUNT, SUM, AVG

• Use of functions to calculate aggregates over data sets.
• Data grouping with GROUP BY and filtering with HAVING

• Key features of the Java language
• Java technology and development environment
• Running and testing a Java program

• Java classes
• The Main method
• Adding a Main method

• Introducing variables
• Working with strings
• Working with numbers
• Manipulating numeric data

• Working with conditions
• Using IF statements
• Working with a list of items
• Processing a list of items

• Working with objects and classes
• Defining fields and methods
• Declaring, instantiating, and initializing objects
• Working with object references
• Doing more with arrays

• Using the String class
• Using the Java API docs
• Using the StringBuilder class
• More about primitive data types
• More numeric operators
• Promoting and casting variables

• Using methods
• Method arguments and return values
• Static methods and variables
• How arguments are passed to a method
• Overloading a method

• Access control
• Encapsulation
• Overloading constructors

• Relational and conditional operators
• More ways to use IF/ELSE constructs
• Using switch statements
• Using the Netbeans debugger

• Working with dates
• Parsing the args array
• Two-dimensional arrays
• Alternate looping constructs
• Nesting loops
• The ArrayList class

• Overview
• Working with subclasses and superclasses
• Overriding methods in the superclass
• Creating and extending abstract classes

• Polymorphism
• Polymorphism in the JDK foundation classes
• Using interfaces  
• Local variable type inference  
• Using the List interface  
• Introducing Lambda expressions
   

• Overview  
• Propagation of exceptions  
• Catching and throwing exceptions  
• Handling multiple exceptions and errors

• Packages, JARs, architecture
• Application modification and requirements

• The Module system
• JARs
• Module declarations
• Modular JDK

• Testing code
• JShell basics
• JShell in an IDE

• Functional Interfaces and Lambda Expressions
• Collections Streams, and Filters
• Built-in Functional Interfaces

• Introduction to Modular Programming in Java  
• Services in a Modular Application  
• Migration to a Modular Application

• Concurrency  
• Parallel Streams  
• Terminal Operations: Collectors  
• Creating Custom Streams

• I/O (Fundamentals and NIO2)  
• Secure Coding  
• Database Applications with JDBC  
• Localization

• What is the Collections Framework?  
• Iterators  
• Type Wrapper Classes  
• What are Generics?

• Exceptions  
• Error handling  
• Assertion

• Standards, containers, APIs, and services
• Interconnect Application Components with CDI Annotations and JNDI
• Web container technologies, Business logic implementation technologies, and web service technologies
• Application component functionalities mapped to tiers and containers
• Packaging and deployment
• Linking components together with annotations, injections, and JNDI
• Understanding lifecycle and memory scopes
• Enterprise JavaBeans, managed beans, and CDI beans

• Describe persistence management and locking mechanisms
• Create and execute JPQL statements
• Create JPA entities with Object-Relational Mappings (ORM)
• Use Entity Manager to perform database operations with JPA entities
• Handle entity data with conversions, validations, and key generation

• Describe persistence management and locking mechanisms  
• Create and execute JPQL statements  
• Create JPA entities with Object-Relational Mappings (ORM)  
• Use Entity Manager to perform database operations with JPA entities  
• Handle entity data with conversions, validations, and key generation

• Use durable and shared topic consumer subscriptions  
• Describe Java Message Service (JMS) API messaging models  
• Use transactions with JMS  
• Create message-driven beans  
• Implement Java SE and Java EE message producers and consumers

• Create SOAP Web Services using JAX-WS API  
• Create SOAP Web Service clients  
• Describe a SOAP Web Service structure

• Create Java servlet classes and map them to URLs  
• Implement asynchronous servlets and use NIO API  
• Manage servlet life cycle with container callback methods  
• Use servlets to handle different content types  
• Use Interceptors and Filters  
• Handle HTTP headers, parameters, cookies  
• Describe HTTP basics  
• Use CDI Managed Beans

• Describe JSP life cycle  
• Handle errors  
• Describe JSP syntax  
• Use Tag Libraries  
• Use Expression Language (EL)  
• Use CDI Beans

• Create REST services using JAX-RS API  
• Understand REST service conventions  
• Consume REST service within the client tier

• Manage WebSocket Endpoint lifecycle  
• Encode and Decode JSON messages  
• Understand WebSockets communication style  
• Produce and consume WebSocket messages  
• Handle Errors  
• Provide WebSocket Client Endpoint handler using JavaScript  
• Create WebSocket Endpoint Handlers using JSR 356 API

• Add AJAX support  
• Use UI templates  
• Describe JSF lifecycle and architecture, and understand JSF syntax  
• Use Expression Language (EL), and CDI Beans  
• Produce messages  
• Apply Validators and Converters to UIComponents  
• Use JSF Tag Libraries  
• Define navigation, and handle localisation

• Define Application Roles and Security Constraints  
• Configure Authentication using Login Modules  
• WebServices security standards  
• Use programmatic security  
• Understand Java EE security architecture

• JAXB API  
• CDI Beans  
• Pre-CDI Servlet Examples  
• BeanValidation and JPA API  
• Batch and Concurrency APIs  
• Java Logging