Training: Ontwikkel je van Java Novice naar Javanista (incl. begeleiding)
Java
103 uur
Engels (US)

Training: Ontwikkel je van Java Novice naar Javanista (incl. begeleiding)

Incompany training aanvragen

Snel navigeren naar:

  • Informatie
  • Inhoud
  • Kenmerken
  • Meer informatie
  • Reviews
  • FAQ

Productinformatie

Wil jij jezelf ontwikkelen van Java Novice naar Javanista? Dan is dit ontwikkelpad voor jou!

Java is een van de meest gevraagde programmeertalen ter wereld en een van de twee officiële programmeertalen die gebruikt worden bij de ontwikkeling van Android. Hoewel Java een pure object-georiënteerde taal is, heeft het zich ontwikkeld tot een multi-paradigma taal waardoor het zeer geschikt is voor elke situatie. Ontwikkelaars die bekend zijn met Java kunnen een breed scala aan applicaties, games en tools bouwen.

Wanneer je kiest voor dit ontwikkelpad, krijg jij:

  • toegang tot trainingen, livelabs en examens. Daarnaast krijg je toegang tot nog veel meer trainingen, proefexamens, bootcamps, e-books enzovoort.
  • begeleiding van ons Learning & Development team, samen met jou stellen we doelen, maken we een planning en monitoren we je voortgang.

Java Novice

In het eerste deel van dit ontwikkelpad begin je met het verkennen van de wortels en de belangrijkste kenmerken van Java. Daarnaast creëert het eerste deel een solide basis met hands-on codevoorbeelden met behulp van JShell.

Java Apprentice

In het tweede deel neem je een diepe duik in de geavanceerde functies van Java - zoals exception handling, Generics, Lambdas en Reflection. Het tweede deel sluit af met een focus op het bouwen van jar-bestanden voor Java-bibliotheken.

Javanista

In het laatste deel leer je database connectiviteit met Java en hoe je web applicaties en web services bouwt in Java. Kortom, je leert Java-programma's vanaf nul te schrijven en wordt een zelfverzekerde Java-ontwikkelaar.

Inhoud van de training

Ontwikkel je van Java Novice naar Javanista (incl. begeleiding)

103 uur

Getting Started with Java: The Fundamentals of Java Programming

This course serves as a theoretical introduction to the Java programming language - a class-based, object-oriented, and platform-independent language. Use this course to discover what these qualities mean when using Java to develop programs. Explore some of the significant features of Java. Get a glimpse into the Java ecosystem and the phases involved in translating Java code to a machine-executed form. In doing this, you'll examine concepts such as compilers, Java bytecode, and the Java Virtual Machine. Delve into some of the other properties of the language, such as using the just-in-time compiler and the automatic garbage collector. Finally, learn about the vast array of fields in which Java programming can be applied. At the end of this course, you'll have a solid foundational comprehension of the characteristics and use cases of the Java programming language.

Getting Started with Java: Writing & Running Java Programs

The Java programming language is a class-based, object-oriented, and platform-independent language. Follow along with this course and get some hands-on experience with Java programming. Get an environment ready to write Java programs by setting up the IntelliJ IDE. Write what might be your first Java program, where you print out a line of text to the console. While doing so, you'll get familiar with the structure of a Java program as well as the steps involved in running it. Move on to examine the syntax of Java and some of the common sources of errors. Then, get a glimpse into the use of comments to explain your code. Upon completion of this course, you'll be able to create your own program in Java.

Getting Started with Java: Variables & Primitive Types

The Java programming language is multi-faceted. To use it, developers need to understand what's meant by Java variables and recognize the different data types in the language. This course focuses on Java variables, and more specifically, the various primitive data types this language has to offer. Follow along with this course and create variables in your program to comprehend the effects of static typing in Java. Then, explore the various primitive data types in Java - from numeric types, such as integers and doubles, to text representations in the form of strings. Finally, you'll investigate the use of an ordered collection of data, namely arrays. When you're done with this course, you'll be able to confidently employ variables and several primitive data types when programming in Java.

Getting Started with Java: Operators

When developing with Java, you can perform many different operation types on the data in your Java program. The goal of this course is to give you hands-on experience with these operations. Begin by working with the basic math operations that apply to numeric data, such as addition, division, and so on, recognizing how these apply to different numeric types. Use logical and comparison operators, which allow you to evaluate a condition and check the relationship between different variables. Lastly, implement string operations in Java and explore some of the methods used to transform data from one type to another. When you're finished with this course, you'll be able to perform a variety of operations on your Java program data.

Control Structures in Java: Implementing Java Control Structures

Before you build any significant Java application, it is important to get familiar with controlling the flow of code using control structures - a fundamental concept in any programming language. And this is precisely the focus of this course. With the help of this course, you'll learn how to work with basic if statements, where code is executed if a certain condition is met and if-else and switch statements, which allow you to check for multiple conditions and run chunks of code accordingly. You'll then delve into for and while loops, which allow you to define a block of code that needs to be executed repeatedly under specific conditions and recognize the use of continue and break statements that influence their behavior. After finishing this course, you'll have the knowledge and skills to control the flow of code execution in your program based on the value of variables or the outcome of operations.

Modeling Entities in Java: Getting Started with Classes & Objects

Classes are a core concept in Java's object-oriented programming model. The class is an abstract type and an object is an instance of that type. Object oriented Java programming allows classes to be instantiated and inherit features from the Java.lang.object. You will learn about member variables, fields, functions, and methods. Learn to instantiate objects of built-in Java classes and invoke methods on them.

Modeling Entities in Java: Defining Custom Classes & Objects

Modeling entities in the real world require you to create custom classes to add to the various built-in classes already provided by Java. Creating such custom classes is key to harnessing the power of object-oriented programming (OOP) in Java. This course focuses on defining such custom classes and then creating objects. Make the most of this course by exploring custom classes, the use of constructors, and modifiers such as private and public. You will also learn the idiomatic Java method of working with getter and setter methods as well as conventions in naming, input parameters, and return types from such methods. After completing this course, you'll not only be able to define custom classes to serve as types in your programs but also instantiate and use objects of these custom classes.

Modeling Entities in Java: Methods, Method Overloading, & Constructors

Modeling complex entities involves defining and invoking methods and constructors. Furthermore, defining robust and reusable code requires learning important mechanisms for code re-uses, such as constructor chaining and method overloading. Use this course to delve into these important techniques that are required to write clean and maintainable Java code. Learn how to define methods with the same name but different signatures (i.e., different order and type of input arguments), invoke overloaded methods, and add constructors to a class. This course will also enable you to use the 'this' keyword to invoke multiple constructors, also known as constructor chaining. By the time you are done with this course, you will have the skills to use important code re-use mechanisms such as method overloading and constructor chaining in java.

Modeling Entities in Java: Static Members, Arguments, & Method Overriding

The best way to avoid mysterious bugs while running your Java code is to be adept at working with static members, argument passing, and object base class methods. Use this course to master these subtleties: the difference between static and instance variables and methods, the hashCode contract, and how pass-by-value and pass-by-reference semantics play out with argument passing in Java. By the end of this course, you'll be able to model state in classes using both static and instance variables, write methods to avoid unexpected changes in input arguments, and adhere to the hashCode contract so that objects function as expected when placed in common Java containers.

Mapping Relationships in Java: Modeling Is-a Relationships Using Inheritance

Java is an object-oriented programming language, meaning Java programs and frameworks are built on the pillars of inheritance and runtime polymorphism. Inheritance is used to model is-a relationships between classes; such relationships could include either behavior and state or just behavior alone. Use this course to appreciate how classes can be used to model an entity's state and behavior and inheritance to model is-a relationships between two classes. Create various objects of the universal base class Java.lang.Object and of other built-in and custom classes. Use the instanceof operator and the getClass method. Create an inheritance hierarchy out of custom classes. Then, practice using up-casting and down-casting on your objects to explore the relationship between variable types, object types, and inheritance. By the time you're finished, you'll clearly understand how inheritance is a powerful mechanism for code re-use and modeling is-a relationships in Java.

Mapping Relationships in Java: Constructors & Polymorphism

Runtime polymorphism involves variables of a base class containing objects of a derived class. Java uses dynamic binding to ensure that such variables are a powerful mechanism for writing clean, extensible, and correct code. This course takes you through the use of these advanced Java processes and mechanisms. Examine how constructors work with inheritance, including the order of constructor invocation, the role of base and derived class constructors, and the super keyword. Learn about runtime polymorphism and how this process of determining which implementation of a method to invoke at runtime is known as dynamic method dispatch. As you advance, use compile-time polymorphism in Java through method overloading. By the end of this course, you'll have a solid grasp of constructor invocation and both runtime and compile-time polymorphism in Java.

Mapping Relationships in Java: Overriding Methods and Using Access Modifiers

Method overriding is a way in which a derived class can redefine - and override - the implementation of a method already defined in a base class. By overriding only those methods you absolutely need to and relying on the base class implementations for all others, you get a lot done with relatively little new code. Use this course to learn how to carry out this technique. Explore the somewhat surprising behavior of static methods and the phenomenon known as hiding. Use the final keyword to mark member variables, member functions, and even entire classes. Use the abstract keyword to indicate a given method is not implemented. Study the semantics of the access modifiers public, private, protected, and package-private. When you're done, you'll recognize how overriding differs from hiding, the semantics of access modifiers, and how abstract classes are used.

Mapping Relationships in Java: Working with Interfaces & Class Loaders

An interface is effectively a class in which all methods are public and abstract by default. Interfaces are ubiquitous in Java libraries and frameworks because they're such a great way of defining APIs. Use this course to learn how to get the most out of these abstract classes. Explore how a class can implement an interface and how Java supports multiple inheritance of interfaces, even though multiple inheritance of other base classes is disallowed. Move on to examine a case study that brings together the different aspects of inheritance used in this course and through which you'll implement your own class loader to load a Java .class file. By the end of this course, you'll be able to use interfaces to define and implement APIs as well as inheritance for advanced Java tasks, such as implementing your own custom class loader.

Interactive Java & JShell: Writing Java Programs with the Interactive JShell

Most Java developers use a full-fledged IDE to build complex Java applications. However, there will be many occasions where you need to test snippets of Java code quickly or build a small script without the overhead of having to develop, compile, and execute programs. This is where JShell comes in. In this course, practice using JShell to run snippets of Java code and get immediate results. Use various features of JShell, from the declaration of functions, available feedback modes, and the auto-complete feature. Define a class in various iterations until you're satisfied with its behavior. Then, compile several snippets of previously run Java code to build a JShell script that reads data from one file, transforms it, and writes it into another file. When you're done with this course, you'll be able to use JShell to write your Java programs.

Final Exam: Java Novice

Final Exam: Java Novice will test your knowledge and application of the topics presented throughout the Java Novice track of the Skillsoft Aspire Java Novice to Javanista Journey.

Handling Errors: An Introduction to Exceptions

Developers need to be aware of the concept of exceptions in the context of Java and how they are implemented in the language so that they can handle it efficiently. Use this course to familiarize yourself with Java exceptions from both a theoretical and practical standpoint. Delve into the two major categories of Java exceptions - checked exceptions that can be identified at the compile stage and unchecked exceptions which occur while the program is running. Next, you'll be able to try your hand at some hands-on programming and discover how to work with compile-time errors and distinguish them from exceptions. After finishing this course, you'll be in a position to recognize the purpose and categories of Java exceptions and how to tackle them.

Handling Errors: Handling Exceptions in Java

It is important to handle exceptions proactively in Java to ensure that the flow of a program doesn't break on the occurrence of an exception. Take this course to explore the fundamentals of handling exceptions and different constructs available in Java that allow you to do so. Delve into working with try-catch, finally, and try-with-resource blocks to handle various exceptions within your code. These blocks can be used to catch single, multiple, or categories of exceptions, clean up after your code has run, and handle exceptions related to specific Java objects, respectively. Upon completion of this course, you'll be able to implement exception handling within Java effectively.

Handling Errors: Advanced Topics in Exceptions

While handling exceptions is enough for most programmers, if you are building an app that other developers consume, you should know how to throw exceptions proactively and the various options available in Java in this regard. This is precisely the focus of this course. Learn about throwing an exception based on your conditions in a Java program and how nested function calls influence exception throwing and handling. You'll get a chance to explicitly throw an exception using the throw keyword, add complexity to your code by throwing different exceptions based on different conditions, and build a customized Exception class to define an exception that is not covered by Java's library. Having finished this course, you'll have the knowledge to throw exceptions and run your program without breaking its flow.

Collections in Java: Arrays & Non-parameterized ArrayLists

The Java collections framework is a set of classes and interfaces that implement commonly reusable collection data structures. Though not part of the Java collection framework, arrays allow you to store multiple elements. They are incredibly useful, albeit with significant drawbacks, when used as collection containers. Use this course to practice working with arrays and collections. Start by storing data in an ordered form using arrays. Through this, explore the drawbacks of arrays. Next, examine multi-dimensional arrays and jagged arrays. Finally, create and use the non-parameterized array list to store elements. When you're finished with this course, you'll have a good understanding of how arrays work, their drawbacks, and how the use of collections can overcome many of the limitations of working with arrays.

Collections in Java: Lists & List Operations

If you're writing Java code and need a container to store elements, a list is likely what you'll use. The Java collections framework provides several different list implementations. Use this course to practice using parameterized lists. Start by working with parameterized collections with type parameters to indicate the type of data you want to store within that collection. Compare parameterized and non-parameterized lists. Then, explore first-hand the advantages of working with parameterized lists. Next, investigate all the methods you can use to operate on lists in Java, examining the inheritance hierarchy of interfaces in the Java collections framework and the use case for each kind of interface. When you're finished with this course, you'll be able to use parameterized lists to store your data and perform the correct operation based on your use case.

Collections in Java: Sets & Maps

The Java collections framework has several different, specialized collections, such as sets and maps. These allow you to store values and data in different ways. In this course, you'll explore these and other valuable collections from the Java collections framework. Create and work with sets, performing several different operations, including union, intersection, difference, and subset operations. Next, explore the different set implementations that Java offers beyond the basic HashSet. Discover how the LinkedHashSet and TreeSet differ in how elements of the set are accessed. Finally, work with another important and commonly used Java collection, the map. Investigate several different map implementations and use maps to build a Least Recently Used cache and a priority queue. When you're finished, you'll have a solid foundational, working knowledge in using special collections in the Java collections framework.

Generics in Java: Creating Classes and Methods Using Generics

Generics is a handy tool in Java that greatly increases the maintainability of your code by allowing you to reuse code, using the same class or method with different types of data. Furthermore, generics also convert runtime checks to compile-time checks, making your code less error-prone. In this course, learn how to use generics in Java to write reusable and maintainable code, exploring why generic code has several advantages over non-generic code. Get hands-on practice with creating and defining classes with generic type parameters. Investigate how these generic types can be used as types for member variables, input arguments to methods, and return values from methods. Moving along, implement generic methods where the generic type parameter is associated with the method rather than the class itself. When you're finished, you'll have a solid foundation in defining and working with generic classes and methods in Java.

Generics in Java: Bounded Type Parameters & Wildcards

In Java, bounded type parameters and wildcards offer certain flexibility and disadvantages. Recognizing these will help you decide when and how to use these tools to your advantage when writing code. Use this course to get to grips with what's meant by unbounded and bounded type parameters, explore the use of wildcards in Java, and recognize the applications of unbounded, upper-bounded, and lower-bounded wildcards. As you advance, investigate what's meant by 'wildcard capture' and 'type erasure.' When you're finished, you'll be able to correctly identify scenarios for using bounded type parameters and wildcards and implement them correctly.

Classes in Java: Working with Static Nested, Inner, & Local Classes

Static nested and inner classes in Java are used when classes have a logical relationship with or are intimately associated with the outer class within which they are defined. Local classes are classes defined within a scope and can only be accessed and used within that scope. They're the perfect tools to use when you want to limit the visibility of your classes. Through this course, learn to create and use static nested classes defined within an outer class. Explore how a closer relationship with an outer class can be expressed using inner classes and why access modifiers do not apply to local classes. And define and use local classes created with a code block. When you're finished with this course, you'll be able to pick the right kind of class for your use case and correctly implement nested classes, inner classes, and local classes.

Classes in Java: Creating & Using Anonymous Classes

Anonymous classes in Java allow you to define code that use-and-throw. These are classes where you define and instantiate a class simultaneously and which are anonymous, i.e., do not have a name. These are perfect in scenarios where you want a class that implements a certain interface but will not be reused beyond where it is defined and accessed. Through this course, learn to create and use anonymous classes, recognizing how they are nested, inner, and unnamed classes that either implement an interface or derive from a base class. As you advance, explore some common use cases for anonymous classes. When you're finished with this course, you'll be able to create and use anonymous classes in Java correctly, with the correct syntax, and for the proper use case.

Classes in Java: Implementing Functional Interfaces Using Lambdas

Lambda expressions allow you to define classes that implement single-method interfaces in a very concise and compact manner. This makes code that uses lambda functions easier to read and understand and much more maintainable. Lambda expressions can be made even more compact and readable by the use of method references. In this course, you will learn to create and use lambda expressions to implement functional interfaces. You will see that lambda expressions are essentially blocks of code that accept input arguments, perform operations, and return values. Lambda expressions can be used in any place where we use anonymous classes or a named class that implements an interface with just a single abstract method. You will see that lambdas can only be used to implement functional interfaces i.e. interfaces that have exactly one abstract method. Such interfaces are usually annotated using the @FunctionalInterface annotation which allows the compiler to detect if the single abstract method contract has been violated for such interfaces. You will understand and implement the four types or categories of functional interfaces, the Predicate, Function, Consumer, and Supplier interfaces. Finally, you will round this course off by exploring and implement method references which are essentially even more compact representations of lambda expressions. When you are finished with this course you will have the skills and knowledge to construct lambda expressions in the right way and use Predicates, Functions, Suppliers, and Consumers to process and store your objects.

Java: Getting Started with Reflection

Reflection is a popular programming technique that accesses and modifies class and object information at runtime. Reflection is available in many programming languages, but Java has an especially powerful set of reflection APIs that reflect - no pun intended - the emphasis that Java lays on type safety. Learn how to access a Java class object. Use reflection APIs to view class fields, constructors, and methods. Create objects for various built-in classes and use reflection to view the class of an object. Investigate the significance of the fully qualified name of a class and how you can use the .forName() method from the built-in class java.lang.Class. Use this method to obtain variables of primitive types and arrays of differing dimensionality. Then use reflection to access modifiers applied to member fields. Upon completion, you'll be able to use reflection in your Java operations with confidence.

Java: Accessing Constructors, Methods, & Fields Using Reflection

Reflective access allows a whole range of operations on objects that may not be permitted when you construct and use objects in the regular manner. This is extremely useful while building frameworks that may need access to the internals of your object. Use this course to extract information and metadata about the constructors in a class and use them, accessed via reflection, to instantiate objects. Access and modify fields or the member variables in an object. Access and invoke the methods defined on a class. Invoke static methods on the class itself and instance methods on specific objects of a class. When you're done, you'll have the ability to use reflection to access and work with all class members, whether they are fields, constructors, or methods.

Java: Working with Annotations, Generics, & Arrays Using Reflection

Annotations on Java code allow you to associate additional metadata with classes, member variables, constructors, and methods. These annotations can be used to perform additional checks or add functionality to your Java code. Use this course to practice using annotations with reflection. Work with both built-in and custom annotations and see how you can access the annotations applied on classes, fields, and methods. Learn why not all annotations can be accessed via reflection. Create your own custom annotation and experiment with various retention policies. Next, examine accessing generics and arrays with reflection. When you're finished, you'll be able to harness the power of reflection to add new functionality to your code and work with generics and arrays.

Java: Leveraging Reflection to Build Dynamic Proxies & Unit Tests

Reflection in Java is commonly used to create and use dynamic proxies, which allow you to create objects that implement one or more interfaces at runtime. Reflection is also used to build harnesses for unit testing frameworks to invoke set up and tear down methods and run tests. Use this course to get to grips with these use cases. Work with and learn why dynamic proxies are incredibly powerful. Investigate what happens to methods you invoke on an instance of a dynamic proxy class. Then create a unit-testing framework harness similar to the JUnit framework in Java. Use annotations to identify methods and mark tests to run before using reflection to identify them and run them in the correct sequence. When you're finished, you'll have the ability to use reflection to create dynamic proxies and build harnesses for unit test frameworks.

Java Archive (JAR): Building Java Archives

Java Archives (JARs) wrap a Java application into a single archive file for deployment, distribution, and execution. Use this course to acquaint yourself with building Java archives or JAR files using the JAR utility, run from the command line. Over the length of the course, you'll outline how a simple Java project packaged into a JAR file can be executed directly, different attributes of a JAR manifest can affect the use of a JAR file, and a project with external dependencies can be packaged into an executable JAR. Upon completion of this course, you'll be able to build different Java archives: JAR with multiple main classes, JAR containing several packages, and JAR that is not directly executable by itself but usable as a dependency in other projects.

Java Archive (JAR): Packaging Java Apps Using Maven

Based on the concept of a project object model (POM), Apache Maven is a project management software as well as build automation and comprehension tool. Explore the flexibility offered by Maven in the creation of Java archives or JAR files using this course. Try your hand at using Apache Maven to build a Java application and package it into an executable JAR file, create a JAR file for an app with external dependencies and ways to execute it, and package your Java app along with all of its external dependencies into a single package known as a fat or uber JAR. Having finished this course, you'll have the skills and knowledge to build lean as well as uber JAR files using Apache Maven.

Final Exam: Java Apprentice

Final Exam: Java Apprentice will test your knowledge and application of the topics presented throughout the Java Apprentice track of the Skillsoft Aspire Java Novice to Javanista Journey.

Serialization in Java: Getting Started with Object Serialization

Serialization in Java allows the conversion of the internal state of an object to a byte stream. On the other hand, deserialization enables the recreation of the original object from the byte stream, thus facilitating data transfer. Learn how to define Java classes that are serializable using this course. Explore the use of the Serializable marker interface and the serialVersionUID, and the Externalizable interface. You'll also learn more about backward compatible and backward-incompatible changes, the use of the transient modifier to mark states that should not be serialized, and the conditions under which Java will serialize objects with nested references. When you are finished with this course, you will have the skills and ability to use serialization and deserialization to work with byte streams, stored to files or transferred over a network.

Serialization in Java: Using JSON Simple for Serialization & Parsing

When building applications, there is often the need to represent objects using a wire protocol that is both structured and human-readable. The JavaScript Object Notation (JSON) format is a popular and widely used data format for this very purpose. Use this course to get familiar with how JSON format is used to represent data. Examine how simple primitives, entities, and arrays are represented in JSON and the use of JSON Simple library to create JSON objects. You'll also learn more about the SAX-based interface, the JSON Simple library, and the JSONAware and JSONStreamAware interfaces. After completing this course, you will have the knowledge to work with JSON data, serialize structures to the JSON format, and parse JSON data to get Java objects.

Serialization in Java: Using JSON in Java for Serialization & Parsing

The JavaScript Object Notation (JSON) format is a widely used data format for serializing the internal state of objects to a structured and human-readable format. Take this course to explore the org.json library, which offers powerful features and constructs for the serialization of Java objects to the JSON format and parsing JSON files and structures. Investigate how JSON in the Java library offers more powerful functionality to work with JSON as compared to the JSON Simple library. You'll also explore the use of different methods to create JSON arrays, discover the nuances of working with each of these methods and how they differ from each other. You will have the skills and the ability to use the powerful features of JSON in the Java library to perform JSON serialization and parsing after finishing this course.

HTTP Requests in Java: Sending Simple HTTP Requests

The HttpURLConnection is the oldest implementation of an HTTP client in Java and is still widely used today due to its simplicity and the fact that it is very lightweight. Use this course to familiarize yourself with different forms of HTTP requests. Try your hand at constructing a basic GET request to retrieve data, submitting it to a remote server, and processing the response that is returned. You'll also examine the use of a POST request to submit data to create a resource at a server, a PUT request to update a resource, and a DELETE request to remove it. You'll also look into setting a timeout for requests that take too long to process. After finishing this course, you'll be able to identify various HTTP requests and how these can be formulated and communicated in a Java app using the HttpURLConnection class.

HTTP Requests in Java: HTTP Requests with Java's HttpClient

Examine basic and advanced operations possible when building HTTP requests with Java's HttpClient through this course. Explore how to send a basic GET request and process the response that is returned, configure your request with timeouts, and implement POST, PUT, and DELETE requests. Delve into the features of the HttpClient, such as the use of BodyHandlers to write a response body to a file, detecting and getting information about any URL redirects involved in processing your request, and sending requests asynchronously. Upon completing this course, you'll be able to work with various HTTP requests using Java's HttpClient.

Java Database Connectivity (JDBC): An Introduction to JDBC

Java Database Connectivity (JDBC) is the Java application programming interface (API) that manages the connection and execution of queries with a database. The focus of this course is to provide you hands-on experience with a variety of JDBC objects that are required to set up a connection to a relational database and run queries against it. Learn how to set up a MySQL database and use DataSource and Data Manager instances to connect to it from your Java application. Delve into objects such as Statements and PreparedStatements that enable you to execute a variety of queries against the database and familiarize yourself with the ResultSet that allows you to parse the results of the execution of a select query. You'll have the foundational knowledge to connect to and query against databases using JDBC objects after completing this course.

Java Database Connectivity (JDBC): Interacting with Databases using RowSets

RowSet is a Java Database Connectivity (JDBC) object that holds tabular data in a form that makes it more adaptable and easier to use. Explore how to enable database operations from within your Java application using RowSet type in JDBC with the help of this course. Explore RowSets within JDBC and how they don't just represent the results of query execution, but include methods to connect to and run queries against a database as well. The course will also help you examine JdbcRowSets in detail and distinguish it from CachedRowSets. After finishing the course, you'll have an understanding of RowSets in JDBC and how connected and disconnected RowSets differ from each other.

Java Database Connectivity (JDBC): Joining & Filtering Data with RowSets

A CachedRowSet is a Java Database Connectivity (JDBC) RowSet where the rows are cached, and the RowSet is disconnected (i.e., doesn't maintain an active connection to the database). CachedRowSets allow you to work on data without keeping your database connection open all the time. This course will help you get acquainted with specialized implementations of the CachedRowSet - the JoinRowSet and FilteredRowSet - which enable offline joins and data filtering. Discover how to implement join operations using a JoinRowSet and examine the use of a FilteredRowSet in implementing the equivalent of the WHERE clause in a SQL query. You will also explore the use of predicate class in order to achieve this. Upon completion of this course, you'll be able to carry out join and filter operations within a Java program using JDBC JoinRowSets and FilteredRowSets.

Java Database Connectivity (JDBC): Batch Executions & Transactions with JDBC

In scenarios where an application has to issue several updates, performing them in batches greatly benefits performance. A set of updates can then be wrapped in an interaction that either succeeds or fails altogether with the help of transactions in relational databases. Use this course to explore the implementation of advanced database operations using Java Database Connectivity (JDBC), specifically batch executions and transactions. Discover how executions of multiple similar queries can be optimized by aggregating them together in a batch and then executing them together and learn to set up queries to execute as transactions. You will also examine concepts, such as rollbacks, commits, and savepoints, and how these can be implemented using JDBC. You will be able to implement batch executions and transactions in a Java program using JDBC.

Building Web Applications with JSP: An Introduction to JSP

JavaServer Pages (JSP) is a technology for developing web pages that support scripting and element-based dynamic content. This helps developers insert java code in HTML pages by making use of special JSP tags. Use this course to familiarize yourself with the different aspects of building a website using JSP. With the help of this course, explore how to set up Apache Maven and Apache Tomcat web server, build JSP applications, and apply scriptlets as well as specific tags for declarations and expressions. You'll also dive into other features of JSP applications, including the separation of Java code into different files and accessing the request object, and learn more about the contents of a WAR file. After finishing this course, you'll have a foundational understanding of building and deploying JSP applications.

Building Web Applications with JSP: Handling Errors

It is important to provide your end-users the best experience when browsing on your JSP website. Investigate how to achieve this by seamlessly handling errors using this course. You'll discover default and manual error handling in a JSP app, the creation of a custom error page, and the referencing of resources such as images in a JSP page. This course will also help you explore the use of web.xml deployment descriptor files in setting configurations and techniques when it comes to handling exceptions in JSP. Upon completion of this course, you'll have the foundational knowledge to handle errors in a JSP app.

Building Web Applications with JSP: Customizing Responses with Servlets

Java servlets are server-side programs that manage clients' requests and return a customized response for each of them. Use this course to gain some hands-on experience in customizing responses in your web application with HttpServlets. Discover how to build simple web pages that accept user input in a form, develop a servlet that can process the inputs, and add complexity to your app by introducing multiple pages. This course will also help you examine the use of a RequestDispatcher and the ServletConfig and ServletContext classes and recognize how attributes are stored at different scopes in a JSP app. Having completed this course, you'll be able to use servlets to process requests and produce customized responses in a JSP application.

Building Web Applications with JSP: Integrating a JSP App with a Database

Discover how to connect a JSP website to a database and allow end-users to perform database operations from the web UI using this course. Learn how to set up a MySQL database, use JDBC to connect to and run queries against this database, and utilize the JSTL library in order to iterate over the data that is returned and render them on your web page. You'll also explore write operations, JSP action tags like useBean and setProperty, and implementing update and delete operations on the database. After finishing this course, you'll have the skills and knowledge to allow users of a JSP website to interact with a database.

Java Web Services: Getting Started with SOAP-based Web Services

If you work on a team offering data or services to clients, you'll likely need to build web services. The most widely adopted technologies for Java-based web services are SOAP and REST, as they allow standardized, scalable, and language-independent external application communication. Use this course shows to learn how to build a web service that adopts the SOAP protocol. Use Maven to create a web service project and the JAX-WS library to build a web service class and a method that remote client applications can invoke. Then, deploy this service to a URL endpoint where clients can access it. Next, explore the automatically generated JAX-WS artifacts, including the WSDL file. Then, use the WSDL file to build a client application and interact with the server-side web service. Bu the end of this course, you'll be able to build SOAP-based web services using JAX-WS and Maven.

Java Web Services: Integrating Web Services with a Database

SOAP-based web services for Java applications offer a standardized and scalable means to communicate with external applications. In this course, you'll build a SOAP-based web service app for a fictitious book store that will enable client apps to view, add, update, and delete books whose details are stored in a database. Begin by defining a Book class whose instances can be transmitted between applications using the SOAP protocol. Then, integrate a MySQL database with the web services app and load it with data that will be made accessible to client applications using CRUD techniques. Lastly, host your web service application in a production environment by deploying it to an Apache Tomcat web server. When you're done, you'll know how to use the SOAP protocol to enable client apps to interact with a remote database.

Java Web Services: Building REST APIs

Web services for Java applications based on the REST architectural style allow you to communicate with external apps in a standardized and scalable manner independent of the programming language. This course demonstrates using the Jersey framework to build REST APIs in Java. Begin by implementing a simple method that returns data in response to a GET request. While doing so, explore the use of Jersey annotations to construct a URL to a particular web method and set it to respond to GET requests. As you advance, construct a response to incoming requests that includes HTTP status codes. Furthermore, examine the transmission of Java objects in the form of JSON structures as a response to an HTTP request. When you're done, you'll be able to use Java to build RESTful applications that can respond to HTTP GET requests.

Java Web Services: Enabling CRUD Operations with REST APIs

Web services for Java applications based on the REST technology provide a normalized and scalable means to set up client communication with external applications. This course demonstrates how to integrate RESTful applications with a relational database so that clients can interact with it and perform create, read, update, and delete (CRUD) operations on it. Learn how to link a MySQL database with a RESTful app. Set it up to respond to a GET request by looking up a table in your database. Advancing from read operations, establish add, update, and delete operations, defining methods that can respond to POST, PUT, and DELETE requests. By the end of the course, you'll be able to facilitate your clients to use your web service app to interact with a database.

Final Exam: Javanista

Final Exam: Javanista will test your knowledge and application of the topics presented throughout the Javanista track of the Skillsoft Aspire Java Novice to Javanista Journey.

Kenmerken

Docent inbegrepen
Bereidt voor op officieel examen
Engels (US)
103 uur
Java
365 dagen online toegang
HBO

Meer informatie

Doelgroep Softwareontwikkelaar, Webontwikkelaar
Voorkennis

Je bent bekend met de basisprincipes van software ontwikkeling, Object Orientend Programming en database concept.

Resultaat

Na het volgen van dit ontwikkelpad ben je een echte Javanista. Je hebt je Java kennis en vaardigheden aangescherpt.





Positieve reacties van cursisten

Training: Leidinggeven aan de AI transformatie

Nuttige training. Het bestelproces verliep vlot, ik kon direct beginnen.

- Mike van Manen

Onbeperkt Leren Abonnement

Onbeperkt Leren aangeschaft omdat je veel waar voor je geld krijgt. Ik gebruik het nog maar kort, maar eerste indruk is goed.

- Floor van Dijk

Training: Leidinggeven aan de AI transformatie

Al jaren is icttrainingen.nl onze trouwe partner op het gebied van kennisontwikkeling voor onze IT-ers. Wij zijn blij dat wij door het platform van icttrainingen.nl maatwerk en een groot aanbod aan opleidingen kunnen bieden aan ons personeel.

- Loranne, Teamlead bij Inwork

Hoe gaat het te werk?

1

Training bestellen

Nadat je de training hebt besteld krijg je bevestiging per e-mail.

2

Toegang leerplatform

In de e-mail staat een link waarmee je toegang krijgt tot ons leerplatform.

3

Direct beginnen

Je kunt direct van start. Studeer vanaf nu waar en wanneer jij wilt.

4

Training afronden

Rond de training succesvol af en ontvang van ons een certificaat!

Veelgestelde vragen

Veelgestelde vragen

Op welke manieren kan ik betalen?

Je kunt bij ons betalen met iDEAL, PayPal, Creditcard, Bancontact en op factuur. Betaal je op factuur, dan kun je met de training starten zodra de betaling binnen is.

Hoe lang heb ik toegang tot de training?

Dit verschilt per training, maar meestal 180 dagen. Je kunt dit vinden onder het kopje ‘Kenmerken’.

Waar kan ik terecht als ik vragen heb?

Je kunt onze Learning & Development collega’s tijdens kantoortijden altijd bereiken via support@icttrainingen.nl of telefonisch via 026-8402941.

Background Frame
Background Frame

Onbeperkt leren

Met ons Unlimited concept kun je onbeperkt gebruikmaken van de trainingen op de website voor een vast bedrag per maand.

Bekijk de voordelen

Heb je nog twijfels?

Of gewoon een vraag over de training? Blijf er vooral niet mee zitten. We helpen je graag verder. Daar zijn we voor!

Contactopties