Learning Objectives: In this module, you will learn about Java architecture, advantages of Java, develop the code with various data types, conditions, and loops.
Topics:
  • Introduction to Java
  • Bytecode
  • Class Files
  • Compilation Process
  • Data types, and Operations
  • if conditions
  • Loops – for
  • while and do while
Learning Objectives: In this module, you will learn how to code with arrays, functions, and strings.
Topics:
  • Arrays – Single Dimensional and Multidimensional arrays
  • Functions
  • Function with Arguments
  • Function Overloading
  • The concept of Static Polymorphism
  • String Handling – String
  • StringBuffer Classes
Learning Objectives: In this module, you will learn object-oriented programming through Java using Classes, Objects and various Java concepts like Abstract, Final etc.
Topics:
  • OOPS in Java: Concept of Object Orientation
  • Attributes, and Methods
  • Classes and Objects
  • Methods and Constructors – Default Constructors and Constructors with Arguments
  • Inheritance
  • Abstract
  • Final
  • Static
Learning Objectives: In this module, you will learn about packages in Java and scope specifiers of Java. You will also learn exception handling and how multi-threading works in Java.
Topics:
  • Packages and Interfaces
  • Access Specifiers: Public, Private, Protected and Package
  • Exception Handling: Try, Catch, Finally, Throw and Throws
  • Multi-Threading: Runnable Interface, Extending a Thread Class, Synchronization in Threads
Learning Objectives: In this module, you will learn how to write code with Wrapper Classes, Inner Classes, and Applet Programs. How to use io.lang and util packages of Java and the very important topic of Java which is Collections.
Topics:
  • Wrapper Classes and Inner Classes: Integer, Character, Boolean, Float etc
  • Applet Programs: How to write UI programs with Applet, Java.lang, Java.io, Java.util
  • Collections: ArrayList, Vector, HashSet, TreeSet, HashMap, HashTable
Learning Objectives: In this module, you will learn how to write XML files and how to parse XML files using DOM and SAX in Java.
Topics:
  • Introduction to XML
  • Writing XML files
  • DOM Parser – Writing into an XML file and Parsing an XML file
  • SAX Parser, XSL
Learning Objectives: In this module, you will learn SQL, Architecture of JDBC, Different drivers of JDBC and to write code in JDBC to communicate with Database.
Topics:
  • Introduction to SQL: Connect, Insert, Update, Delete, Select
  • Introduction to JDBC and Architecture of JDBC
  • Types of Drivers: Type 1/2/3/4 drivers
  • Insert/Update/Delete/Select Operations using JDBC
  • Batch Processing Transaction
  • Management: Commit and Rollback

AngularJS is based on MVC framework, where MVC stands for Model-View-Controller. MVCperforms the following operations:

  • A model is the lowest level of the pattern responsible for maintaining data.
  • A controller is responsible for a view that contains the logic to manipulate that data. It is basically a software code which is used for taking control of the interactions between the Model and View.
  • A view is the HTML which is responsible for displaying the data.

Expressions in AngularJS are the code snippets that resolve to a value. AngularJS expressions are placed inside {{expression}}. Expressions are included in the HTML elements.

AngularJS expressions can also contain various valid expressions similar to JavaScript expressions. We can also use the operators between numbers, including strings, literals, objects, and arrays inside the expression {{ }}.

For example:

  1. {{1+1}}
  2. {{Name + ” ” + email}} (string)
  3. {{ Country.Name }} (object)
  4. {{ fact[4] }} (array)

The key differences between the Angular expressions and JavaScript expressions are given below:

Angular Expressions JavaScript Expressions
Angular expressions do not support conditional statements, loops, and exceptions. JavaScript expressions support conditional statements, loops, and exceptions.
Angular expressions support filters. JavaScript expressions do not support filters.
Angular expressions can be written inside HTML. JavaScript expressions cannot be written inside HTML.

A filter is used to format the value of the expression to display the formatted output. AngularJS allows us to write our own filter. Filters can be added to expressions by using the pipe character |, followed by a filter. For example:

  1. <div ng-app=“myApp” ng-controller=“personCtrl”>
  2. <p>The name is {{ firstName | uppercase }}</p>
  3. </div>
  4. <script>
  5. angular.module(‘myApp’, []).controller(‘personCtrl’, function($scope) {
  6.     $scope.firstName = “Sonoo”,
  7.     $scope.lastName = “Jaiswal”
  8. });
  9. </script>

Filters can be applied in view templates, controllers, services and directives. It is important to know that filters are case-sensitive. There are some built-in filters provided by AngularJS such as Currency, Date, Filter, JSON, Limit, Lowercase, Number, Orderby, and Uppercase.

Uppercase filters are used to convert a text to upper case text. For example:

  1. Type first name:<input type = “text” ng-model = “student.firstName”>
  2. Type last name: <input type = “text” ng-model = “student.lastName”>
  3. Name in Upper Case: {{student.fullName() | uppercase}}

In above example, uppercase filter is added to an expression using pipe character. It will print student name in capital letters.

On the other side, lowercase filters are used to convert a text to lower case text. For example:

  1. Type first name:<input type = “text” ng-model = “student.firstName”>
  2. Type last name: <input type = “text” ng-model = “student.lastName”>
  3. Name in Upper Case: {{student.fullName() | lowercase}}

It will print student name in lowercase letters.

We can create our own filters in AngularJS. It can be performed by associating the filter to our module. These types of filters are known as custom filters.

An example given below can be used to count the number of elements in the string by using the filter:

  1. angular.module(‘myCountFilterApp’, [])
  2.    .filter(‘count’,function()
  3. {
  4.     return(function(input)
  5.     {
  6.         var out=[];
  7.         out=input.split(‘,’);
  8.         return out.length;
  9.     })
  10. });

As per above example, if the string is “21, 34, 45” then output after applying filter will be 3.

The currency filter contains the “$” Dollar symbol as default. We can apply the following code as the html template format of Currency Filter.

  1. {{ currency_expression | currency : symbol : fractionSize}}

We can use Currency Filter by using the following methods:

  • Default
    If we do not provide any currency symbol, then Dollar sign will be used by default as shown below:
    <!– by default –>
    Default Currency{{amount | currency}}
  • User-Defined
    To use different types of currency symbols, we have to define our own symbol by applying the Hexa-Decimal code or Unicode of that Currency.
    E.g., To define Indian Currency Symbol, then we have to use Unicode-value or Hexa-Decimal value.
    Indian Currency{{amount | currency:”&# 8377″}}

Dependency Injection (also called DI) is one of the best features of AngularJS. It is a software design pattern where objects are passed as dependencies rather than hard coding them within the component. It is useful for removing hard-coded dependencies and making dependencies configurable. To retrieve the required elements of the application that need to be configured when the module is loaded, the “config” operation uses Dependency Injection. It allows separating the concerns of different components in an application and provides a way to inject the dependent component into the client component. By using Dependency Injection, we can make components maintainable, reusable, and testable.

A simple case of dependency injection in AngularJS is shown below:

  1. myApp.controller(‘myController’, function ($scope, $http, $location)
  2.     {
  3.         //logic
  4.     });

Here, a controller is declared with its dependencies.

AngularJS provides the following core components which can be injected into each other as dependencies:

  • Value
  • Factory
  • Service
  • Provider
  • Constant

AngularJS enriches form filling and validation. AngularJS provides client-side form validation. It checks the state of the form and input fields (input, text-area, select), and notify the user about the current state. It also holds the information about whether the input fields have been touched, or modified, or not.

There are following directives that can be used to track error:

  • $dirty
    It states that the value has been changed.
  • $invalid
    It states that the value which is entered is invalid.
  • $error
    It states the exact error.

Moreover, we can use novalidate with a form declaration to disable the browser’s native form validation.

Link is used for combining the directives with a scope and producing a live view. The link function is used for registering DOM listeners as well as updating the DOM. The linking function is executed as soon as the template is cloned.

There are two types of linking function:

  • Pre linking function
    Pre-linking functions are executed before the child elements are linked. This method is not considered as a safe way for DOM transformation.
  • Post linking function
    Post-linking functions are executed after the child elements are linked. This method is a safe way for DOM transformation.

An injector is referred to as a service locator. It is used to receive object instances as defined by the providers, invoke methods, instantiate types, and load modules. Each Angular application consists of a single injector which helps to look upon an instance by its name.

Factory method is used for creating a directive. Whenever the compiler matches the directive for the first time, the factory method is invoked. Factory method is invoked using $injector.invoke.

Syntax

  1. module.factory(‘factoryName’, function);

Each Angular application contains one root scope, but there can be several child scopes. The application may have multiple scopes because child controllers and some directives create new child scopes. When the new scope is formed or created, it is added as a child of the parent scope. As similar to DOM, scopes also create a hierarchical structure.

Logs can be maintained using $log service. The main purpose of $log service is to help in debugging and troubleshooting. It is done with the help of the following methods.

  • log()- It writes a log message in the console.
  • info()- It writes an information message.
  • warn()- It writes a warning message.
  • error()- It writes an error message.
  • debug()- It writes a debug message.
  1. $log.error(‘this will displayed as an error in console’)

Find index is used to return the position of an element. It returns the value (-1) if the requested element is not found.

  1. var index = $scope.items.findIndex(record => record.date ==’2018-12-12′);

In the given code, index of the object is returned where item.date=2018-12-12.

Learning Objectives: In this module, you will learn Web Technologies and developing applications using Servlet.
Topics:
  • Introduction to Web Technologies
  • Type of Servlets: Generic and Http Servlet
  • Request Dispatchers: Forward and Include
  • 4 types of Session Tracking and Filters
Learning Objectives: In this module, you will learn how to develop code with JSP.
Topics:
  • Introduction to JSP
  • Architecture of JSP
  • tags (Scripts, declarative, expression)
  • Implicit objects
  • JSP Directives
  • JSP and JDBC
Learning Objectives: In this module, you will learn about hibernate framework and how to interact with the database using hibernate. You will also learn to perform various operations on database like Insert, Update, Delete and Select Operations.
Topics:
  • Introduction to Hibernate
  • Architecture of Hibernate
  • Database Operations: Insert/Update/Delete/Select
  • Inheritance
  • Collections
  • HQL and Restrictions
  • Caching in Hibernate
Learning Objectives: In this module, you will learn Introduction to spring framework and writing code with spring framework components like Dependency Injection and Auto Wiring.
Topics:
  • Introduction to Spring Framework
  • Architecture
  • Display a Sample Message
  • IoC Containers
  • Bean Definition
  • Bean Scopes
  • Bean Post Processors
  • Dependency Injection Auto-Wiring
Learning Objectives: In this module, you will learn advanced concepts of Spring Framework like AOP, Transaction Management Operations Commit and Rollback operations on a database. Interacting with a server using Ajax framework and Java EE design patterns.
Topics:
  • Aspect Oriented Programming (AOP)
  • Integrating Spring framework with Hibernate
  • Transaction Management
  • Ajax Framework and Design Patterns: DAO, DTO, MVC
  • Intercepting filters
  • Front Controller
  • Business Delegate
Learning Objectives: In this module, you will learn SOA and SOA Architecture. You will also learn how SOA is useful for organizations to perform the required task easily and how it can be implemented in web services.
Topics:
  • Introduction to SOA
  • SOA Architecture
  • Business layer of SOA
  • Advantages of SOA
  • What is Contract
  • Address, and Binding in SOA
  • Composition of Service
  • Relation between SOA and Web Services
Learning Objectives: In this module, you will learn SOA and implementation of web services. We will also discuss how to develop a project using Spring and Hibernate. This is a banking project with web services.
Topics:
  • Introduction to Web Services
  • WSDL file
  • WSDL and UDDI
  • SOAP, RESTfulWeb Service
  • JAX-WS Implementation

AngularJS is an open-source JavaScript framework used to build rich and extensible web applications. It is developed by Google and follows the MVC (Model View Controller) pattern. It supports HTML as the template language and enables the developers to create extended HTML tags which will help to represent the application’s content more clearly. It is easy to update and receive information from an HTML document. It also helps in writing a proper maintainable architecture which can be tested at a client-side.

Some of the main advantages of AngularJS are given below:

  • Allows us to create a single page application.
  • Follows MVC design pattern.
  • Predefined form validations.
  • Supports animations.
  • Open-source.
  • Cross-browser compliant.
  • Supports two-way data binding.
  • Its code is unit testable.

There are some drawbacks of AngularJS which are given below:

  • JavaScript Dependent
    If end-user disables JavaScript, AngularJS will not work.
  • Not Secured
    It is a JavaScript-based framework, so it is not safe to authenticate the user through AngularJS only.
  • Time Consumption in Old Devices
    The browsers on old computers and mobiles are not capable or take a little more time to render pages of application and websites designed using the framework. It happens because the browser performs some supplementary tasks like DOM (Document Object Model) manipulation.
  • Difficult to Learn
    If you are new in AngularJS, then it will not be easy for you to deal with complex entities such as Quite layered, hierarchically and scopes. Debugging the scope is believed a tough task for many programmers.

A $scope is an object that represents the application model for an Angular application.

Each AngularJS application can have only one root scope but can have multiple child scopes. For example:

  1. var app = angular.module(‘myApp’, []);
  2. app.controller(‘myCtrl’, function($scope) {
  3.     $scope.carname = “Volvo”;
  4. });

Some of the key characteristics of the $scope object are given below:

  • It provides observers to check for all the model changes.
  • It provides the ability to propagate model changes through the application as well as outside the system to other associated components.
  • Scopes can be nested in a way that they can isolate functionality and model properties.
  • It provides an execution environment in which expressions are evaluated.

AngularJS is a JavaScript framework with key features like models, two-way binding, directives, routing, dependency injections, unit tests, etc. On the other hand, JQuery is a JavaScript library used for DOM manipulation with no two-way binding features.

A term IDE stands for Integrated Development Environment. There are some IDE’s given below which are used for the development of AngularJS:

  • Eclipse
    It is one of the most popular IDE. It supports AngularJS plugins.
  • Visual Studio
    It is an IDE from Microsoft that provides a platform to develop web apps easily and instantly.
  • WebStorm
    It is one of the most powerful IDE for modern JavaScript development. It provides an easier way to add dependencies with angular CLI.
  • Aptana
    It is a customized version of Eclipse. It is free to use.
  • Sublime Text
    It is one of the most recommendable editors for HTML, CSS, and JavaScript. It is very much compatible with AngularJS code.

Some important features of AngularJS are given below:

  • MVC- In AngularJS, you just have to split your application code into MVC components, i.e., Model, View, and the Controller.
  • Validation- It performs client-side form validation.
  • Module- It defines an application.
  • Directive- It specifies behavior on the DOM element.
  • Template- It renders the dynamic view.
  • Scope- It joins the controller with the views.
  • Expression- It binds application data to HTML.
  • Data Binding- It creates a two-way data-binding between the selected element and the $ctrl.orderProp model.
  • Filter- It provides the filter to format data.
  • Service- It stores and shares data across the application.
  • Routing- It is used to build a single page application.
  • Dependency Injection- It specifies a design pattern in which components are given their dependencies instead of hard-coding them within the component.
  • Testing- It is easy to test any of the AngularJS components through unit testing and end-to-end testing.

Directives are the markers on DOM element which are used to specify behavior on that DOM element. All AngularJS directives start with the word “ng“. There are many in-built directives in AngularJS such as “ng-app“, “ng-init“, “ng-model“, “ng-bind“, “ng-repeat” etc.

  • ng-app
    The ng-app directive is the most important directive for Angular applications. It is used to locate the beginning of an Angular application for AngularJS HTML compiler. It marks the HTML elements that Angular intends to make the root element of the application. The custom attributes use spinal-cases, whereas the corresponding directives follow the camelCase. If we do not use this directive and try to process other directives, it gives an error.
  • ng-init
    The ng-init directive is useful for initializing the data variable’s inline statement of an AngularJS application. Therefore, those statements can be used in the specified blocks where we can declare them. A directive ng-init is like a local member of the ng-app directive, and it may be a single value or a group of the values. It directly supports JSON data.
  • ng-model
    The ng-model directive binds the values of HTML elements such as input, select, textarea to the application data. It provides two-way binding behavior with the model value. Sometimes, it is also used for databinding.
  • ng-bind
    The ng-bind directive is used to bind the model/variable’s value to HTML controls of an AngularJS application. It can also be used with HTML tags attributes like: <p/>, <span/> and more but it does not support two-way binding. We can only check the output of the model values.
  • ng-repeat
    The ng-repeat directive is used to repeat HTML statements. It works the same as for each loop in C#, Java or PHP on a specific collection item like an array.

Let’s see a simple example of AngularJS directive:

  1. <div ng-app = “” ng-init = “countries = [{locale:’en-IND’,name:’India’}, {locale:’en-PAK’,name:’Pakistan’}, {locale:’en-AUS’,name:’Australia’}]”>
  2. <p>Enter your Name: <input type = “text” ng-model = “name”></p>
  3. <p>Hello <span ng-bind = “name”></span>!</p>
  4. <p>List of Countries with locale:</p>
  5. <ol>
  6. <li ng-repeat = “country in countries”>
  7.                {{ ‘Country: ‘ + country.name + ‘, Locale: ‘ + country.locale }}
  8. </li>
  9. </ol>
  10. </div>

Controllers are JavaScript functions which are used to provide data and logic to HTML UI. It acts as an interface between Server and HTML UI. Each controller accepts $scope as a parameter which refers to the application/module that controller is going to control. For example:

  1. <script>
  2. var app = angular.module(‘myApp’, []);
  3. app.controller(‘myCtrl’, function($scope) {
  4.     $scope.firstName = “Aryan”;
  5.     $scope.lastName = “Khanna”;
  6. });
  7. </script>

AngularJS controllers are used for:

  • Setting the initial state of the $scope object
  • Adding behavior to the $scope object

Data Binding is the automatic synchronization of data between model and view. In AngularJS, it performs the automatic synchronization process between the model and view.

If the model is changed, the view reflects it automatically and vice-versa. There are two ways of data binding that AngularJS supports:

  • One Way Data Binding
    In one-way data binding, view (UI part) does not get updated automatically when the data model is changed. We need to write custom codes to make it updated every time. A directive ng-bind has one-way data binding. Here, value is taken from the data model and inserted into an HTML element.
  • Two Way Data Binding
    In two-way data binding, scope variable changes its value whenever the data model is allotted to a different value. It treats the model as the single-source-of-truth in the application. The view is a projection of the model at all time s. If the model is changed, the view reflects the change and vice versa.

Services are objects that can be used to store and share data across the application. AngularJS offers many built-in services, and each of them is responsible for a specific task. They are always used with the prefix $ symbol.

Some of the important services used in any AngularJS application are as follows:

  • $http- It is used to make an Ajax call to get the server data.
  • $window- It provides a reference to a DOM object.
  • $Location- It provides a reference to the browser location.
  • $timeout- It provides a reference to the window.set timeout function.
  • $Log- It is used for logging.
  • $sanitize- It is used to avoid script injections and display raw HTML in the page.
  • $Rootscope- It is used for scope hierarchy manipulation.
  • $Route- It is used to display browser-based path in browser’s URL.
  • $Filter- It is used for providing filter access.
  • $resource- It is used to work with Restful API.
  • $document- It is used to access the window.Document object.
  • $exceptionHandler- It is used for handling exceptions.
  • $q- It provides a promise object.
  • $cookies- It is used for reading, writing, and deleting the browser’s cookies.
  • $parse- It is used to convert an AngularJS expression into a function.
  • $cacheFactory- It is used to evaluate the specified expression when the user changes the input.

A module is a container for the different parts of the application like a controller, services, filters, directives, etc. It is treated as a main() method. All the dependencies of applications are generally defined in modules only. A module is created using an angular object’s module() method. For example:

  1. var app = angular.module(‘myApp’, []);

Routing is one of the main features of the AngularJS framework, which is useful for creating a single page application (also referred to as SPA) with multiple views. It routes the application to different pages without reloading the application. In Angular, the ngRoute module is used to implement Routing. The ngView, $routeProvider, $route, and $routeParams are the different components of the ngRoute module, which help for configuring and mapping URL to views.

A template consists of HTML, CSS, and AngularJS directives, which are used to render the dynamic view. It is more like a static version of a web page with some additional properties to inject and render that data at runtime. The templates are combined with information coming from model and controller.