Here’s a list of common Angular and AngularJS along with detailed examples to help you prepare.
Angular: Angular is a platform and framework for building single-page client applications using HTML, CSS, and JavaScript/TypeScript. It is a complete rewrite of AngularJS, developed by Google. Angular uses TypeScript, which is a superset of JavaScript, offering strong typing, interfaces, and decorators. 

• Key features of Angular:
• Two-way data binding
• Directives for extending HTML capabilities
• Dependency injection
• Routing and navigation
• Components-based architecture

Difference between AngularJS and Angular:
AngularJS  is the original version of Angular, and Angular (2 and above) is a complete rewrite.
Key differences:
Architecture: Angular uses a component-based architecture, whereas AngularJS uses a directive-based architecture.
Language: Angular uses TypeScript, while AngularJS uses JavaScript.
Performance: Angular has better performance because of the use of a new change detection mechanism (in Angular 2+).
Dependency Injection (DI): Angular's DI is more powerful and more flexible than AngularJS.
Angular Components:
In Angular, a component is a building block of the application. It controls a portion of the user interface (UI), with each component consisting of:

• HTML template (view)
• CSS styles (view styles)
• TypeScript class (logic and data)

Example:
import { Component } from '@angular/core'; @Component({ selector: 'app-hello', template: '<h1>{{ message }}</h1>', styleUrls: ['./hello.component.css'] }) export class HelloComponent { message = 'Hello, Angular!'; }
In this example, HelloComponent is an Angular component with a template displaying a message.
Data binding in Angular? Explain the types of data binding. Data binding in Angular is the mechanism to synchronize the data between the component and the view. Angular supports several types of data binding:
Interpolation: Binding data from the component to the view.

Property Binding: Bind an element property to a component property.

Event Binding: Bind an event (e.g., click) to a method in the component.

Two-Way Data Binding: Combines property and event binding.

Dependency Injection (DI) in Angular?
Dependency Injection (DI) is a design pattern used in Angular to achieve Inversion of Control (IoC). It allows services or objects to be injected into components or other services rather than being created manually inside the component.
Example:
import { Injectable } from '@angular/core'; @Injectable({ providedIn: 'root', }) export class DataService { getData() { return 'Some data'; } } @Component({ selector: 'app-data', template: '<p>{{ data }}</p>', }) export class DataComponent { data: string; constructor(private dataService: DataService) { this.data = this.dataService.getData(); } }
In this example, the DataService is injected into DataComponent via DI, and its method getData() is used in the component.
Angular Routing:
Angular Routing allows you to define routes and navigate between different views or pages in a single-page application (SPA). The routing module helps handle navigation and deep linking.
Example: Define routes in app-routing.module.ts: import { NgModule } from '@angular/core'; import { RouterModule, Routes } from '@angular/router'; import { HomeComponent } from './home/home.component'; import { AboutComponent } from './about/about.component'; const routes: Routes = [ { path: '', component: HomeComponent }, { path: 'about', component: AboutComponent }, ]; @NgModule({ imports: [RouterModule.forRoot(routes)], exports: [RouterModule] }) export class AppRoutingModule {}
Use the router-outlet in app.component.html:
Navigating using the routerLink directive:
Service in Angular:
A service is a class in Angular used to handle logic that can be shared across multiple components. Services are commonly used for business logic, data fetching, and state management. Services are injected into components or other services using Angular’s Dependency Injection system.
Example:
import { Injectable } from '@angular/core'; @Injectable({ providedIn: 'root', }) export class UserService { getUser() { return { name: 'John', age: 30 }; } }
In the component, the service is injected:
import { Component } from '@angular/core'; import { UserService } from './user.service'; @Component({ selector: 'app-user', template: '<p>{{ user.name }}</p>', }) export class UserComponent { user: any; constructor(private userService: UserService) { this.user = this.userService.getUser(); } }
Directives in Angular:
Directives are special markers in the DOM that allow Angular to modify the DOM structure. There are three types of directives in Angular:
Component Directives: These are the most common type of directives and include templates and logic (e.g., @Component).
Structural Directives: These modify the structure of the DOM (e.g., *ngIf, *ngFor).
Attribute Directives: These change the appearance or behavior of an element (e.g., ngClass, ngStyle).
Example: *ngIf: Conditionally display an element.
Observables in Angular:
Observables are a core part of Angular’s reactive programming. They represent a stream of asynchronous events. Angular uses RxJS (Reactive Extensions for JavaScript) for handling asynchronous operations like HTTP requests, user input, or timer events.
Example:
import { Component, OnInit } from '@angular/core'; import { HttpClient } from '@angular/common/http'; import { Observable } from 'rxjs'; @Component({ selector: 'app-data', template: `<div>{{ data | json }}</div>`, }) export class DataComponent implements OnInit { data: any; constructor(private http: HttpClient) {} ngOnInit() { this.http.get('https://api.example.com/data').subscribe((response) => { this.data = response; }); } }
In this example, the HttpClient service returns an Observable, and subscribe() is used to handle the response asynchronously.
Pipes in Angular:
Pipes are used to transform data in the template before it is displayed. Angular provides several built-in pipes like DatePipe, UpperCasePipe, LowerCasePipe, and CurrencyPipe. You can also create custom pipes.
Example:

In this example, birthday will be transformed into a formatted date using the DatePipe.
You can also create custom pipes:
import { Pipe, PipeTransform } from '@angular/core'; @Pipe({ name: 'reverse' }) export class ReversePipe implements PipeTransform { transform(value: string): string { return value.split('').reverse().join(''); } }
In the template:

These are some of the key Angular and AngularJS, along with practical examples. Practicing these concepts and writing code will help you to be more prepared for your Development!

In Java 8,
The Predicate is a functional interface that represents a single argument function that returns a boolean value. It is widely used in functional programming, especially when working with streams, as it allows you to define conditions that can be tested.
The Predicate Interface: Let’s look at an example of how to use the @FunctionalInterface annotation in a Spring Boot application:
@FunctionalInterface public interface Predicate<T> { boolean test(T t); // Other default methods default Predicate<T> and(Predicate<? super T> other) { return (t) -> test(t) && other.test(t); } default Predicate<T> or(Predicate<? super T> other) { return (t) -> test(t) || other.test(t); } default Predicate<T> negate() { return (t) -> !test(t); } static <T> Predicate<T> isEqual(Object targetRef) { return (null == targetRef) ? Objects::isNull : targetRef::equals; } }
The Predicate interface contains a method called test(T t) that evaluates a condition and returns a boolean. It also contains some useful default methods like:

• and(Predicate other): Combines two predicates with a logical AND. 
• or(Predicate other): Combines two predicates with a logical OR. 
• negate(): Negates the result of the predicate.

Example 1: Simple Predicate In the following example, a Predicate is used to test whether a number is greater than 10
import java.util.function.Predicate; public class PredicateExample { public static void main(String[] args) { // Define a Predicate to check if a number is greater than 10 Predicate<Integer> isGreaterThanTen = (n) -> n > 10; // Test the Predicate with different values System.out.println(isGreaterThanTen.test(5)); // output false System.out.println(isGreaterThanTen.test(15)); // output true } }
Example 2: Combining Predicates with and(), or(), and negate() You can combine multiple predicates to create more complex conditions using and(), or(), and negate().
import java.util.function.Predicate; public class CombinedPredicateExample { public static void main(String[] args) { // Predicate to check if a number is greater than 10 Predicate<Integer> isGreaterThanTen = (n) -> n > 10; // Predicate to check if a number is Mehuln Predicate<Integer> isMehuln = (n) -> n % 2 == 0; // Combining predicates using 'and()' (number > 10 and Mehuln) Predicate<Integer> isGreaterThanTenAndMehuln = isGreaterThanTen.and(isMehuln); // Combining predicates using 'or()' (number > 10 or Mehuln) Predicate<Integer> isGreaterThanTenOrMehuln = isGreaterThanTen.or(isMehuln); // Negating the 'isGreaterThanTen' predicate Predicate<Integer> isNotGreaterThanTen = isGreaterThanTen.negate(); // Test the combined predicates System.out.println(isGreaterThanTenAndMehuln.test(12)); // output true (12 > 10 and 12 is Mehuln) System.out.println(isGreaterThanTenOrMehuln.test(8)); //output true (8 is Mehuln) System.out.println(isNotGreaterThanTen.test(8)); //output true (8 is not greater than 10) } }
Example 3: Using Predicate with Collections and Streams The Predicate interface is often used with the Streams API to filter collections based on certain conditions.
import java.util.Arrays; import java.util.List; import java.util.function.Predicate; import java.util.stream.Collectors; public class PredicateWithStreamExample { public static void main(String[] args) { List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); // Predicate to check if a number is Mehuln Predicate<Integer> isMehuln = (n) -> n % 2 == 0; // Using the 'filter' method in Stream with Predicate List<Integer> MehulnNumbers = numbers.stream() .filter(isMehuln) // Applying the Predicate .collect(Collectors.toList()); System.out.println(MehulnNumbers); // Output Prints: [2, 4, 6, 8, 10] } }
Example 4: Predicate with isEqual Static Method Java 8 introduces a static method isEqual in the Predicate interface, which is used to create a predicate that checks if two objects are equal.
import java.util.function.Predicate; public class PredicateIsEqualExample { public static void main(String[] args) { Predicate<String> isHello = Predicate.isEqual("Hello"); System.out.println(isHello.test("Hello")); // Output true System.out.println(isHello.test("World")); // Output false } }
Example 5: Using Predicate with a List of Objects You can use predicates to filter lists of custom objects. Hare's an example where we filter a list of Person objects based on age.
import java.util.Arrays; import java.util.List; import java.util.function.Predicate; import java.util.stream.Collectors; class Person { String name; int age; Person(String name, int age) { this.name = name; this.age = age; } @Override public String toString() { return name + " (" + age + ")"; } } public class PersonPredicateExample { public static void main(String[] args) { List<Person> people = Arrays.asList( new Person("John", 25), new Person("Manoj", 32), new Person("Bob", 17), new Person("Mehul", 6) ); // Predicate to check if a person is over 18 years old Predicate<Person> isAdult = person -> person.age > 18; // Using the predicate with streams to filter the list List<Person> adults = people.stream() .filter(isAdult) // Applying the Predicate .collect(Collectors.toList()); System.out.println(adults); // output Prints: [John (25), Manoj (32), Mehul (6)] } }
Summary of Predicate Methods: 

test(T t): Evaluates the predicate on the given argument and returns true or false. 

and(Predicate other): Combines this predicate with another one using logical AND. 

or(Predicate other): Combines this predicate with another one using logical OR. 

negate(): Reverses the result of the predicate (logical NOT). 

isEqual(Object targetRef): Creates a predicate that checks if an object is equal to the given target.

 
* Common Use Cases: 

 Filtering collections with Stream.filter(). Validating input, such as checking if a string matches a pattern or if a number falls within a range. Using complex conditional logic in combination with other predicates.
Predicates are a powerful tool in functional programming and are heavily used in Java 8's Streams API to make code more readable and expressive.

In Spring Framework, the `@ExceptionHandler` annotation is used to handle exceptions that occur during the execution of a controller method. This allows you to handle specific exceptions in a centralized manner without cluttering your code with `try-catch` blocks. You can define exception handler methods in your controller or in a global exception handler class.

 
Example of using @ExceptionHandler:

Let’s look at an example of how to use the `@ExceptionHandler` annotation in a Spring Boot application:
Create a custom exception class First, let's define a custom exception that we will handle in the controller.

 
public class ResourceNotFoundException extends RuntimeException { public ResourceNotFoundException(String message) { super(message); } }

Create a Controller that throws the exception In this step, we’ll create a simple controller that throws a `ResourceNotFoundException` when an endpoint is accessed.

 
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class MyController { @GetMapping("/resource/{id}") public String getResourceById(int id) { if (id <= 0) { throw new ResourceNotFoundException("Resource with ID " + id + " not found!"); } return "Resource found with ID " + id; } }

Handle the exception using `@ExceptionHandler`  Now, let’s handle the `ResourceNotFoundException` using the `@ExceptionHandler` annotation in the same controller.

 
import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.ExceptionHandler; import org.springframework.web.bind.annotation.RestControllerAdvice; @RestControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(ResourceNotFoundException.class) public ResponseEntity<String> handleResourceNotFoundException(ResourceNotFoundException ex) { return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND); } }

 
Running the Application When you run this Spring Boot application and access the /resource/{id} endpoint with an invalid ID (e.g., `/resource/0` or `/resource/-1`), it will return a response like:
HTTP Status: 404 Not Found Body: Resource with ID 0 not found!
Example Output:

• - When accessing `/resource/1`, it will return "Resource found with ID 1". 
• - When accessing `/resource/0`, it will return a 404 response with the message "Resource with ID 0 not found!".

Advantages of using @ExceptionHandler:
 Centralized exception handling. - Cleaner code with no need for `try-catch` blocks in each controller method. 

 Ability to return custom error responses with HTTP status codes. You can handle multiple exceptions in a similar way by adding more `@ExceptionHandler` methods in the same class, or even define exception handling globally for all controllers using `@ControllerAdvice` instead of `@RestControllerAdvice`.