Java annotations list with examples w3schools
Java annotations list with examples w3schools
Java Annotations are used to provide supplemental information about a program element, such as a class, method, or variable. They can also affect the behavior of the code.
Here is a list of Java annotations with examples from W3Schools:
@Override: This annotation indicates that a method overrides another method in the superclass. It ensures that you are not accidentally overriding the wrong method.
<code class="public class Animal { public void sound() { System.out.println("The animal makes a sound"); } }">
public class Dog extends Animal {
@Override
public void sound() {
System.out.println("The dog barks");
}
}
@Deprecated: This annotation indicates that a method or a field is deprecated and should not be used. Example: @Deprecated public int add(int a, int b) {
return (a + b);
}
}
@SuppressWarnings: This annotation tells the compiler to suppress specific warnings for a specified duration within the annotated code. Example:
@SuppressWarnings("unchecked") public static void main(String[] args) {
List list = new ArrayList();
}
}
@Target: This annotation specifies the kind of program element that the annotation can be applied to, such as a method or field. Example:
Target(ElementType.METHOD); }
public class Test {
@MyAnnotation
public void myMethod() {
System.out.println("Hello");
}
}
@Retention: This annotation specifies the retention policy for an annotation type, which determines how it is stored and preserved. Example:
Target(ElementType.METHOD); Retention(RetentionPolicy.RUNTIME);
}
public class Test {
@MyAnnotation
public void myMethod() {
System.out.println("Hello");
}
}
@Inherited: This annotation indicates that an annotation type is inherited by subclasses. Example:
Inherited; Target(ElementType.TYPE);
}
public class Parent {
@MyAnnotation
public void myMethod() {
System.out.println("Hello");
}
}
public class Child extends Parent {
}
@Documented: This annotation indicates that an annotation type should be documented. Example:
Documented; Target(ElementType.TYPE);
}
public class Parent {
@MyAnnotation
public void myMethod() {
System.out.println("Hello");
}
}
@Repeatable: This annotation indicates that an annotation type can be repeated on the same element. Example:
Repeatable; Target(ElementType.TYPE);
}
public class Parent {
@MyAnnotation
public void myMethod() {
System.out.println("Hello");
}
}
public class Child implements Parent {
}
@Invisible: This annotation indicates that an annotation type should not be displayed. Example:
Invisible; Target(ElementType.TYPE);
}
public class Parent {
@MyAnnotation
public void myMethod() {
System.out.println("Hello");
}
}
@Native: This annotation indicates that an annotation type is native to the Java platform. Example:
Native; Target(ElementType.TYPE);
}
public class Parent {
@MyAnnotation
public void myMethod() {
System.out.println("Hello");
}
}
This list shows examples of some of the most common annotations used in Java. Annotations are a powerful tool that can help you write cleaner, more maintainable code, and are an essential part of any Java developer's toolbox.
References:
Oracle: Java Language Specification W3Schools: Java Annotations Java Tutorial by FreeCodeCampJava annotations list with examples spring boot
Here is the information you requested:
Java Annotations List with Examples Spring Boot
Spring Boot provides various annotations to simplify the configuration and development process of a web application. Here are some common Java annotations used in Spring Boot, along with their explanations and examples:
@SpringBootApplication: This annotation enables auto-configuration for your Spring-based application.Example: @SpringBootApplication public class MyApplication { ... }
Example: @EnableAutoConfiguration @SpringBootApplication public class MyWebApplication { ... }
Example: @RestController public class MyController { ... }
Example: @RestController @RequestMapping("/api") public class MyController { ... }
@RequestMapping annotation, specifying GET, POST, PUT, and DELETE HTTP methods respectively.
Examples:
@RestController @RequestMapping("/api") public class MyController { @GetMapping("/users") public List<User> getUsers() { ... } } @RestController @RequestMapping("/api") public class MyController { @PostMapping("/users") public User createUser(User user) { ... } } @RequestParam: This annotation injects a request parameter into a method.
Example: @RestController @RequestMapping("/api") public class MyController { @GetMapping("/users") public List<User> getUsers(@RequestParam("name") String name) { ... } }
Example: @RestController @RequestMapping("/api") public class MyController { @PostMapping("/users") public User createUser(@RequestBody User user) { ... } }
Example: @RestController @RequestMapping("/api") public class MyController { @GetMapping("/users") public List<User> getUsers() { List<User> users = ...; return users; } }
Example: @RestController @RequestMapping("/api") public class MyController { private UserRepository userRepository; @Autowired public MyController(UserRepository userRepository) { this.userRepository = userRepository; } }
Example: @RestController @Value("${my.config.value}") public class MyController { private String myConfigValue; @Autowired public MyController(String myConfigValue) { this.myConfigValue = myConfigValue; } }
These are just a few of the many annotations available in Spring Boot. Understanding these annotations can help you simplify your development process and improve the overall performance of your application.
Please note that I will not respond with emoji, as per our agreement.
