The reason for this is that we rely on the processor parameter instead, that references a class which will generate the annotation. In the example, the visit method is the only method which has to be overridden. It is meant to return a list of annotation nodes that will be added to the node annotated with the meta-annotation. In this example, we return a single one corresponding to CompileStatic TypeCheckingMode.

They can be seen as interfaces carrying both default implementations and state. A trait is defined using the trait keyword:. Traits allow a wide range of capabilities, from simple composition to testing, which are described thoroughly in this section. In addition, traits may declare abstract methods too, which therefore need to be implemented in the class implementing the trait:.

Traits may also define private methods. Those methods will not appear in the trait contract interface:. If we have a class implementing a trait, conceptually implementations from the trait methods are "inherited" into the class. But, in reality, there is no base class containing such implementations. Rather, they are woven directly into the class.

A final modifier on a method just indicates what the modifier will be for the woven method. Normal method selection applies and the modifier used will be determined from the resulting method. this represents the implementing instance. Think of a trait as a superclass. This means that when you write:. Traits may implement interfaces, in which case the interfaces are declared using the implements keyword:. Since traits allow the use of private methods, it can also be interesting to use private fields to store state.

Traits will let you do that:. Public fields work the same way as private fields, but in order to avoid the diamond problem , field names are remapped in the implementing class:. The name of the field depends on the fully qualified name of the trait. All dots. So if the type of the field is String , the name of the package is my. package , the name of the trait is Foo and the name of the field is bar , in the implementing class, the public field will appear as:.

Traits can be used to implement multiple inheritance in a controlled way. For example, we can have the following traits:. Traits encourage the reuse of capabilities among objects, and the creation of new classes by the composition of existing behavior. Traits provide default implementations for methods, but it is possible to override them in the implementing class. For example, we can slightly change the example above, by having a duck which quacks:.

Alternatively, a trait may extend multiple traits. In that case, all super traits must be declared in the implements clause:. Traits can call any dynamic code, like a normal Groovy class. This means that you can, in the body of a method, call methods which are supposed to exist in an implementing class, without having to explicitly declare them in an interface.

This means that traits are fully compatible with duck typing:. It is also possible for a trait to implement MOP methods like methodMissing or propertyMissing , in which case implementing classes will inherit the behavior from the trait, like in this example:. It is possible for a class to implement multiple traits. If some trait defines a method with the same signature as a method in another trait, we have a conflict:.

In this case, the default behavior is that the method from the last declared trait in the implements clause wins. Here, B is declared after A so the method from B will be picked up:. In case this behavior is not the one you want, you can explicitly choose which method to call using the Trait. foo syntax. In the example above, we can ensure the method from trait A is invoked by writing this:. Groovy also supports implementing traits dynamically at runtime.

It allows you to "decorate" an existing object using a trait. the call to extra would fail because Something is not implementing Extra. It is possible to do it at runtime with the following syntax:. Should you need to implement several traits at once, you can use the withTraits method instead of the as keyword:. Groovy supports the concept of stackable traits.

The idea is to delegate from one trait to the other if the current trait is not capable of handling a message. Then you can compose a message handler by applying small behaviors. Now what if you want to log all messages, in addition to the default handler? One option is to write this:. we have an explicit reference to DefaultHandler in the on method, meaning that if we happen to change the trait that our class implements, code will be broken.

As the priority rules imply that LoggerHandler wins because it is declared last, then a call to on will use the implementation from LoggingHandler. But the latter has a call to super , which means the next trait in the chain. Here, the next trait is DefaultHandler so both will be called:. The interest of this approach becomes more evident if we add a third handler, which is responsible for handling messages that start with say :.

the logging handler calls super which will delegate to the next handler, which is the SayHandler. This approach is very powerful because it allows you to write handlers that do not know each other and yet let you combine them in the order you want.

For example, if we execute the code, it will print:. The reason is that now, since the SayHandler consumes the message without calling super , the logging handler is not called anymore. If a class implements multiple traits and a call to an unqualified super is found, then:. In this example, when super. append is encountered, there is no other trait implemented by the target object, so the method which is called is the original append method, that is to say the one from StringBuilder.

The same trick is used for toString , so that the string representation of the proxy object which is generated delegates to the toString of the StringBuilder instance. If a trait defines a single abstract method, it is candidate for SAM Single Abstract Method type coercion. For example, imagine the following trait:. Since getName is the single abstract method in the Greeter trait, you can write:.

In Java 8, interfaces can have default implementations of methods. If a class implements an interface and does not provide an implementation for a default method, then the implementation from the interface is chosen. This feature can be used to compose behaviors in a very precise way, in case you want to override the behavior of an already implemented method.

In this example, we create a simple test case which uses two properties config and shell and uses those in multiple test methods. Now imagine that you want to test the same, but with another distinct compiler configuration. One option is to create a subclass of SomeTest :. It works, but what if you have actually multiple test classes, and that you want to test the new configuration for all those test classes?

Then you would have to create a distinct subclass for each test class:. Then what you see is that the setup method of both tests is the same.

The idea, then, is to create a trait:. It would allow us to dramatically reduce the boilerplate code, and reduces the risk of forgetting to change the setup code in case we decide to change it. Even if setup is already implemented in the super class, since the test class declares the trait in its interface list, the behavior will be borrowed from the trait implementation! It can be used to mock methods or force a particular implementation of a method in a subclass. It lets you refactor your code to keep the overridden logic in a single trait and inherit a new behavior just by implementing it.

The alternative, of course, is to override the method in every place you would have used the new code. There are several conceptual differences with mixins, as they are available in Groovy. Note that we are talking about runtime mixins, not the Mixin annotation which is deprecated in favour of traits. internally, the trait is represented as an interface without default or static methods and several helper classes.

Traits with static methods cannot be compiled statically or type checked. The trait is interpreted as a template for the implementing class, which means that each implementing class will get its own static methods, properties and fields. You should typically not mix static and instance methods of the same signature. The normal rules for applying traits apply including multiple inheritance conflict resolution.

If the method chosen is static but some implemented trait has an instance variant, a compilation error will occur. If the method chosen is the instance variant, the static variant will be ignored the behavior is similar to static methods in Java interfaces for this case.

As usual, it is not recommended to use public fields. Anyway, should you want this, you must understand that the following code would fail:. because there is no static field CALLED defined on the trait itself.

Likewise, if you have two distinct implementing classes, each one gets a distinct static field:. We have seen that traits are stateful. So consider the following example:. The trait defines two properties, x and y , as well as a sum method. The result of calling f is 3 , because f delegates to sum in the trait, which has state.

But what if we write this instead? The reason is that the sum method accesses the fields of the trait. So it is using the x and y values defined in the trait. If you want to use the values from the implementing class, then you need to dereference fields by using getters and setters, like in this last example:. Sometimes you will want to write a trait that can only be applied to some type. For example, you may want to apply a trait on a class that extends another class which is beyond your control, and still be able to call those methods.

It is clear, here, that the Communicating trait can only apply to Device. However, the code compiles and runs perfectly fine, because id in the trait method will be resolved dynamically. The problem is that there is nothing that prevents the trait from being applied to any class which is not a Device. Any class which has an id would work, while any class that does not have an id property would cause a runtime error. The problem is even more complex if you want to enable type checking or apply CompileStatic on the trait: because the trait knows nothing about itself being a Device , the type checker will complain saying that it does not find the id property.

One possibility is to explicitly add a getId method in the trait, but it would not solve all issues. What if a method requires this as a parameter, and actually requires it to be a Device? If you want to be able to call this in the trait, then you will explicitly need to cast this into a Device. This can quickly become unreadable with explicit casts to this everywhere. In order to make this contract explicit, and to make the type checker aware of the type of itself , Groovy provides a SelfType annotation that will:.

So in our previous example, we can fix the trait using the groovy. SelfType annotation:. Now if you try to implement this trait on a class that is not a device, a compile-time error will occur:. In conclusion, self types are a powerful way of declaring constraints on traits without having to declare the contract directly in the trait or having to use casts everywhere, maintaining separation of concerns as tight as it should be.

Both Sealed and SelfType restrict classes which use a trait but in orthogonal ways. Consider the following example:. Within traits, prefix and postfix operations are not allowed if they update a field of the trait:.

Record classes, or records for short, are a special kind of class useful for modelling plain data aggregates. They provide a compact syntax with less ceremony than normal classes. Groovy already has AST transforms such as Immutable and Canonical which already dramatically reduce ceremony but records have been introduced in Java and record classes in Groovy are designed to align with Java record classes.

For example, suppose we want to create a Message record representing an email message. We can define such a record as follows:. The reduced ceremony saves us from defining explicit fields, getters and toString , equals and hashCode methods.

Note the special naming convention for record getters. They are the same name as the field rather than the often common JavaBean convention of capitalized with a "get" prefix. So our Message record has from , to , and body components. You can also use generics with records in the normal way. For example, consider the following Coord record definition:. Records have an implicit constructor. This can be overridden in the normal way by providing your own constructor - you need to make sure you set all the fields if you do this.

However, for succinctness, a compact constructor syntax can be used where the parameter declaration part of a normal constructor is elided. For this special case, the normal implicit constructor is still provided but is augmented by the supplied statements in the compact constructor definition:.

Groovy native records follow the special conventions for serializability which apply to Java records. Groovy record-like classes discussed below follow normal Java class serializability conventions. Groovy supports default values for constructor arguments. This capability is also available for records as shown in the following record definition which has default values for y and color :. Arguments when left off dropping one or more arguments from the right are replaced with their defaults values as shown in the following example:.

This processing follows normal Groovy conventions for default arguments for constructors, essentially automatically providing the constructors with the following signatures:.

This will produce a single constructor as per the default with Java. It will be an error if you drop off arguments in this scenario. Groovy in fact steps through an intermediate stage where the record keyword is replaced by the class keyword and an accompanying RecordType annotation:. Then RecordType itself is processed as a meta-annotation annotation collector and expanded into its constituent sub-annotations such as TupleConstructor , POJO , RecordBase , and others.

This is in some sense an implementation detail which can often be ignored. However, if you wish to customise or configure the record implementation, you may wish to drop back to the RecordType style or augment your record class with one of the constituent sub-annotations.

As an example, you can a three-dimensional point record as follows:. We are also ignoring null values the default value for z in our definition. We can see here that without the package name it would have the same toString as our previous example. It can be useful to make a copy of a record with some components changed. This can be done using an optional copyWith method which takes named arguments. Record components are set from the supplied arguments.

For components not mentioned, a shallow copy of the original record component is used. Here is how you might use copyWith for the Fruit record:.

The copyWith functionality can be disabled by setting the RecordOptions copyWith annotation attribute to false. As with Java, records by default offer shallow immutability. Records can make use of this defensive copying to gain deep immutability as follows:. Groovy has a limited number of TupleN classes. If you have a large number of components in your record, you might not be able to use this feature. Groovy supports creating record-like classes as well as native records. The RecordOptions annotation part of RecordType supports a mode annotation attribute which can take one of three values with AUTO being the default :.

Produces a class similar to what Java would do. Produces an error when compiling on JDKs earlier than JDK Whether you use the record keyword or the RecordType annotation is independent of the mode.

Prior to sealed classes, class hierarchy designers had two main options:. Sealed classes are also more flexible than other tricks previously used to try to achieve a middle-ground.

For example, for class hierarchies, access modifiers like protected and package-private give some ability to restrict inheritance hierarchies but often at the expense of flexible use of those hierarchies. Sealed hierarchies provide full inheritance within a known hierarchy of classes, interfaces and traits but disable or only provide controlled inheritance outside the hierarchy.

As an example, suppose we want to create a shape hierarchy containing only circles and squares. We also want a shape interface to be able to refer to instances in our hierarchy. We can create the hierarchy as follows:. Groovy also supports an alternative annotation syntax.

We can have a reference of type ShapeI which, thanks to the permits clause, can point to either a Circle or Square and, since our classes are final , we know no additional classes will be added to our hierarchy in the future. At least not without changing the permits clause and recompiling. In general, we might want to have some parts of our class hierarchy immediately locked down like we have here, where we marked the subclasses as final but other times we might want to allow further controlled inheritance.

In this example, our permitted subclasses for Shape are Circle , Polygon , and Rectangle. Circle is final and hence that part of the hierarchy cannot be extended. Polygon is implicitly non-sealed and RegularPolygon is explicitly marked as non-sealed. Rectangle is itself sealed which means that part of the hierarchy can be extended but only in a controlled way only Square is permitted.

Sealed classes are useful for creating enum-like related classes which need to contain instance specific data. For instance, we might have the following enum:. but we now wish to also add weather specific instance data to weather forecasts. We can alter our abstraction as follows:.

Sealed hierarchies are also useful when specifying Algebraic or Abstract Data Types ADTs as shown in the following example:. Java provides no default modifier for subclasses of sealed classes and requires that one of final , sealed or non-sealed be specified.

We anticipate the style checking tool CodeNarc will eventually have a rule that looks for the presence of non-sealed so developers wanting that stricter style will be able to use CodeNarc and that rule if they want.

This may change in a future version of Groovy. The SealedOptions annotation supports a mode annotation attribute which can take one of three values with AUTO being the default :. Indicates the class is sealed using the Sealed annotation. Whether you use the sealed keyword or the Sealed annotation is independent of the mode. This chapter covers Groovy Closures. A closure in Groovy is an open, anonymous, block of code that can take arguments, return a value and be assigned to a variable. A closure may reference variables declared in its surrounding scope.

In opposition to the formal definition of a closure, Closure in the Groovy language can also contain free variables which are defined outside of its surrounding scope.

While breaking the formal concept of a closure, it offers a variety of advantages which are described in this chapter. The parameters look similar to a method parameter list, and these parameters may be typed or untyped. The statements portion consists of 0, 1, or many Groovy statements. A closure is an instance of the groovy. Closure class, making it assignable to a variable or a field as any other variable, despite being a block of code:.

A closure, as an anonymous block of code, can be called like any other method. If you define a closure which takes no argument like this:. Then the code inside the closure will only be executed when you call the closure, which can be done by using the variable as if it was a regular method:. Unlike a method, a closure always returns a value when called. The next section discusses how to declare closure arguments, when to use them and what is the implicit "it" parameter.

This means that this code:. If you want to declare a closure which accepts no argument and must be restricted to calls without arguments, then you must declare it with an explicit empty argument list:.

It is possible for a closure to declare variable arguments like any other method. Vargs methods are methods that can accept a variable number of arguments if the last parameter is of variable length or an array like in the next examples:. Groovy defines closures as instances of the Closure class. It makes it very different from lambda expressions in Java 8. Delegation is a key concept in Groovy closures which has no equivalent in lambdas. The ability to change the delegate or change the delegation strategy of closures make it possible to design beautiful domain specific languages DSLs in Groovy.

To understand the concept of delegate, we must first explain the meaning of this inside a closure. A closure actually defines 3 distinct things:. owner corresponds to the enclosing object where the closure is defined, which may be either a class or a closure.

delegate corresponds to a third party object where methods calls or properties are resolved whenever the receiver of the message is not defined. In a closure, calling getThisObject will return the enclosing class where the closure is defined. It is equivalent to using an explicit this :.

The owner of a closure is very similar to the definition of this in a closure with a subtle difference: it will return the direct enclosing object, be it a closure or a class:.

The delegate of a closure can be accessed by using the delegate property or calling the getDelegate method.

It is a powerful concept for building domain specific languages in Groovy. While this and owner refer to the lexical scope of a closure, the delegate is a user defined object that a closure will use. By default, the delegate is set to owner :. The delegate of a closure can be changed to any object. At this point, the behavior is not different from having a target variable defined in the lexical scope of the closure:. the delegate can be used transparently, that is to say without prefixing method calls with delegate.

as explained in the next paragraph. Whenever, in a closure, a property is accessed without explicitly setting a receiver object, then a delegation strategy is involved:.

The reason this code works is that the name property will be resolved transparently on the delegate object! This is a very powerful way to resolve properties or method calls inside closures. receiver: the call will be made because the default delegation strategy of the closure makes it so. A closure actually defines multiple resolution strategies that you can choose:. If not, then the delegate is used.

It makes only sense to use this if you implement your own subclass of Closure. By changing the resolveStrategy , we are modifying the way Groovy will resolve the "implicit this" references: in this case, name will first be looked in the delegate, then if not found, on the owner. Since name is defined in the delegate, an instance of Thing , then this value is used. The difference between "delegate first" and "delegate only" or "owner first" and "owner only" can be illustrated if one of the delegate resp.

owner does not have such a method or property:. In this example, we define two classes which both have a name property but only the Person class declares an age.

The Person class also declares a closure which references age. We can change the default resolution strategy from "owner first" to "delegate only". Since the owner of the closure is the Person class, then we can check that if the delegate is an instance of Person , calling the closure is successful, but if we call it with a delegate being an instance of Thing , it fails with a groovy.

Despite the closure being defined inside the Person class, the owner is not used. And a similar story for "delegate first" but in reverse. Instead of using the word " existed ", it would have been more accurate to use the wording " handled ". In this example, even though our instance of the Thing class our delegate for the last use of cl has no age property, the fact that it handles the missing property via its propertyMissing hook, means that age will be In our example, the GString is created with an expression referencing x.

When the GString is created, the value of x is 1, so the GString is created with a value of 1. When the assert is triggered, the GString is evaluated and 1 is converted to a String using toString.

When we change x to 2, we did change the value of x , but it is a different object, and the GString still references the old one. Closures can be converted into interfaces or single-abstract method types. Please refer to this section of the manual for a complete description. Closures, like lambda expressions in Java 8 are at the core of the functional programming paradigm in Groovy.

Some functional programming operations on functions are available directly on the Closure class, like illustrated in this section. In Groovy, currying refers to the concept of partial application. It does not correspond to the real concept of currying in functional programming because of the different scoping rules that Groovy applies on closures. Currying in Groovy will let you set the value of one parameter of a closure, and it will return a new closure accepting one less argument.

In case a closure accepts more than 2 parameters, it is possible to set an arbitrary parameter using ncurry :. Memoization allows the result of the call of a closure to be cached.

It is interesting if the computation done by a function closure is slow, but you know that this function is going to be called often with the same arguments. A typical example is the Fibonacci suite.

A naive implementation may look like this:. It is a naive implementation because 'fib' is often called recursively with the same arguments, leading to an exponential algorithm:. computing fib 15 requires the result of fib 14 and fib computing fib 14 requires the result of fib 13 and fib Since calls are recursive, you can already see that we will compute the same values again and again, although they could be cached. This naive implementation can be "fixed" by caching the result of calls using memoize :.

memoizeAtMost will generate a new closure which caches at most n values. memoizeAtLeast will generate a new closure which caches at least n values.

memoizeBetween will generate a new closure which caches at least n values and at most n values. Closure composition corresponds to the concept of function composition, that is to say creating a new function by composing two or more functions chaining calls , as illustrated in this example:. Recursive algorithms are often restricted by a physical limit: the maximum stack height. For example, if you call a method that recursively calls itself too deep, you will eventually receive a StackOverflowException.

An approach that helps in those situations is by using Closure and its trampoline capability. Closures are wrapped in a TrampolineClosure. Upon calling, a trampolined Closure will call the original Closure waiting for its result. If the outcome of the call is another instance of a TrampolineClosure , created perhaps as a result to a call to the trampoline method, the Closure will again be invoked.

This repetitive invocation of returned trampolined Closures instances will continue until a value other than a trampolined Closure is returned. That value will become the final result of the trampoline. That way, calls are made serially, rather than filling the stack. It is often practical to be able to use a regular method as a closure. For example, you might want to use the currying abilities of a closure, but those are not available to normal methods.

In Groovy, you can obtain a closure from any method with the method pointer operator. Variables can be defined using either their type like String or by using the keyword def or var followed by a variable name:.

def and var act as a type placeholder, i. a replacement for the type name, when you do not want to give an explicit type. It is mandatory for variable definitions to have a type or placeholder. If left out, the type name will be deemed to refer to an existing variable presumably declared earlier. For scripts, undeclared variables are assumed to come from the Script binding.

In other cases, you will get a missing property dynamic Groovy or compile time error static Groovy. If you think of def and var as an alias of Object , you will understand in an instant. Groovy supports multiple assignment, i. where multiple variables can be assigned at once, e. With this technique, we can combine multiple assignments and the subscript operator methods to implement object destructuring. Consider the following immutable Coordinates class, containing a pair of longitude and latitude doubles, and notice our implementation of the getAt method:.

The switch statement in Groovy is backwards compatible with Java code; so you can fall through cases sharing the same code for multiple matches. One difference though is that the Groovy switch statement can handle any kind of switch value and different kinds of matching can be performed.

Regular expression case values match if the toString representation of the switch value matches the regex. Collection case values match if the switch value is contained in the collection. This also includes ranges since they are Lists. Closure case values match if the calling the closure returns a result which is true according to the Groovy truth.

If none of the above are used then the case value matches if the case value equals the switch value. You can specify a complete try-catch-finally , a try-catch , or a try-finally set of blocks. We can put code within a 'finally' clause following a matching 'try' clause, so that regardless of whether the code in the 'try' clause throws an exception, the code in the finally clause will always execute:.

With the multi catch block since Groovy 2. That syntax is now supported for Java programmers migrating to Groovy and still wanting to use the old style:. Unlike Java with which Groovy shares the assert keyword, the latter in Groovy behaves very differently. First of all, an assertion in Groovy is always executed, independently of the -ea flag of the JVM.

It makes this a first class choice for unit tests. The notion of "power asserts" is directly related to how the Groovy assert behaves.

The result of the assertion is very different from what you would get in Java. If the assertion is true, then nothing happens. If the assertion is false, then it provides a visual representation of the value of each sub-expressions of the expression being asserted. Power asserts become very interesting when the expressions are more complex, like in the next example:. Any statement can be associated with a label.

Labels do not impact the semantics of the code and can be used to make the code easier to read like in the following example:. Despite not changing the semantics of the labelled statement, it is possible to use labels in the break instruction as a target for jump, as in the next example. However, even if this is allowed, this coding style is in general considered a bad practice:.

It is important to understand that by default labels have no impact on the semantics of the code, however they belong to the abstract syntax tree AST so it is possible for an AST transformation to use that information to perform transformations over the code, hence leading to different semantics.

This is in particular what the Spock Framework does to make testing easier. Expressions are the building blocks of Groovy programs that are used to reference existing values and execute code to create new ones. Groovy also expands on the normal dot-notation used in Java for member access.

Groovy provides special support for accessing hierarchical data structures by specifying the path in the hierarchy of some data of interest. These Groovy path expressions are known as GPath expressions. GPath is a path expression language integrated into Groovy which allows parts of nested structured data to be identified. In this sense, it has similar aims and scope as XPath does for XML. GPath is often used in the context of processing XML, but it really applies to any object graph.

It uses just a single thread for garbage collection. The way it works by freezing all the application threads while doing garbage collection may not be suitable for a server environment. It is best suited for simple command-line programs. Parallel garbage collector is also called as throughput collector. It is the default garbage collector of the JVM. Unlike serial garbage collector, this uses multiple threads for garbage collection.

Similar to serial garbage collector this also freezes all the application threads while performing garbage collection. In Soft reference, even if the object is free for garbage collection then also its not garbage collected, until JVM is in need of memory badly.

The objects gets cleared from the memory when JVM runs out of memory. To create such references java. SoftReference class is used. Garbage collection works on Mark and Sweep algorithm. In Mark phase it detects all the unreachable objects and Sweep phase it reclaim the heap space used by the garbage objects and make the space available again to the program.

There are methods like System. gc and Runtime. gc which is used to send request of Garbage collection to JVM but it's not guaranteed that garbage collection will happen. If there is no memory space for creating a new object in Heap Java Virtual Machine throws OutOfMemoryError or java. OutOfMemoryError heap space. The singly linked list is a linear data structure in which each element of the list contains a pointer which points to the next element in the list.

Each element in the singly linked list is called a node. Each node has two components: data and a pointer next which points to the next node in the list.

A weakly referenced object is cleared by the Garbage Collector when it's weakly reachable. Weak reachability means that an object has neither strong nor soft references pointing to it. The object can be reached only by traversing a weak reference. WeakReference class is used. JDBC Driver is a software component that enables java application to interact with the database. There are 4 types of JDBC drivers:. LocalDateTime combines together LocaleDate and LocalTime contains the date and time in the calendar system ISO without reference to the time zone.

Time is stored accurate to the nanosecond. It contains many convenient methods such as plusMinutes, plusHours, isAfter, toSecondOfDay, etc. ZonedDateTime - an analogue java. Calendar , a class with the most complete amount of information about the temporary context in the calendar system ISO It includes a time zone, therefore, this class carries out all operations with time shifts taking into account it.

To define a repeatable annotation, you must create a container annotation for the list of repeatable annotations and designate a repeatable meta annotation Repeatable :. Base64 - a thread-safe class that implements a data encoder and decoder using a base64 encoding scheme according to RFC and RFC Skip to content.

Star 1. Java Basics Java-8 learning-zone. This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository. Branches Tags. Could not load branches. Could not load tags.

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior.

Are you sure you want to create this branch? Local Codespaces. HTTPS GitHub CLI. Sign In Required Please sign in to use Codespaces. Launching GitHub Desktop If nothing happens, download GitHub Desktop and try again. Launching Xcode If nothing happens, download Xcode and try again. Launching Visual Studio Code Your codespace will open once ready. Latest commit. ea Dec 5, Git stats 1, commits.

Failed to load latest commit information. View code. Java Basics Related Topics Table of Contents 1. What are the important features of Java 8 release? What is Nashorn? What is jjs? In Java, How many ways you can take input from the console? What is the purpose of using javap? Explain the expression System.

Tell us about parallel processing in Java 8? What is JVM and is it platform independent? What is JIT compiler in Java? What is Classloader in Java? Java Compiler is stored in JDK, JRE or JVM? What is difference between Heap and Stack Memory in java? How many types of memory areas are allocated by JVM? JAVA DATA TYPES Q. What are autoboxing and unboxing? What is the difference between transient and volatile variable in Java? What are assertions in Java?

What is the final variable, final class, and final blank variable? What is a compile time constant in Java? What are the different access specifiers available in java? JAVA METHODS Q. Can you have virtual functions in Java? What is a native method? What are the restrictions that are applied to the Java static methods?

What is a lambda? What variables do lambda expressions have access to? What is a method reference? What types of method references do you know? JAVA CLASSES Q. What is difference between the Inner Class and Sub Class? Distinguish between static loading and dynamic class loading? What is the purpose of the Runtime class and System class? What are the ways to instantiate the Class class? What is immutable object? How can we create an immutable class in Java?

How bootstrap class loader works in java? How can we create a object of a class without using new operator? What are methods of Object Class? What is Optional 8. How many types of constructors are used in Java? How can constructor chaining be done using this keyword? What is a private constructor? JAVA ARRAY Q. What is copyonwritearraylist in java? JAVA STRINGS Q. What is the difference between creating String as new and literal?

What is difference between String, StringBuffer and StringBuilder? Why string is immutable in java? What is Java String Pool? What is difference between String, StringBuilder and StringBuffer?

What is StringJoiner? What is Java Reflection API? JAVA STREAMS Q. What is Stream? What are the ways to create a stream? What is the difference between Collection and Stream? What is the method collect for streams for? Why do streams use forEach and forEachOrdered methods? What are map , mapToInt , mapToDouble and mapToLong methods in Stream?

What is the purpose of filter method in streams? What is the use of limit method in streams? What is the use of sorted method in streams? What streamers designed methods flatMap , flatMapToInt , flatMapToDouble , flatMapToLong? What are the final methods of working with streams you know? What intermediate methods of working with streams do you know? Explain Difference between Collection API and Stream API?

Name some classes present in java. regex package? JAVA FILE HANDLING Q. What is the purpose of using BufferedInputStream and BufferedOutputStream classes? How to set the Permissions to a file in Java? Give the hierarchy of InputStream and OutputStream classes? How serialization works in java? What are the types of Exceptions?

Explain hierarchy of Java Exception classes? What is difference between Error and Exception? Explain about Exception Propagation? What are different scenarios causing "Exception in thread main"? What are the differences between throw and throws?

While overriding a method can you throw another exception or broader exception? What is checked, unchecked exception and errors? What is difference between ClassNotFoundException and NoClassDefFoundError? What is the difference between aggregation and composition?

The difference between Inheritance and Composition? Can you declare the main method as final? What is covariant return type? Can you explain Liskov Substitution principle? What is the difference between compile-time polymorphism and runtime polymorphism? What do you mean Run time Polymorphism? What is runtime polymorphism in java? What is the difference between abstract class and interface? What are Wrapper classes?

What is the difference between abstraction and encapsulation? Can we use private or protected member variables in an interface? When can an object reference be cast to a Java interface reference? How can you avoid serialization in child class if the base class is implementing the Serializable interface?

What is the difference between Serializable and Externalizable interface? How to create marker interface? Can you declare an interface method static? What is a Functional Interface? What are default interface methods? How to call default interface method in a class that implements this interface? What is static interface method? How to call static interface method? What is Spliterator in Java SE 8? What is Type Inference in Java 8? What is difference between External Iteration and Internal Iteration?

How Encapsulation concept implemented in JAVA? JAVA GENERICS Q. Do you know Generics? How did you used in your coding? How will you invoke any external process in Java? What is the static import? What is the difference between factory and abstract factory pattern? What are the methods used to implement for key Object in HashMap?

What is a Memory Leak? The difference between Serial and Parallel Garbage Collector? What is difference between WeakReference and SoftReference in Java? How Garbage collector algorithm works? Java Program to Implement Singly Linked List? What do we mean by weak reference? What are the different types of JDBC Driver?

What additional methods for working with associative arrays maps appeared in Java 8? What is LocalDateTime? What is ZonedDateTime? How to determine repeatable annotation?

How to create a Base64 encoder and decoder? Give me an example of design pattern which is based upon open closed principle? How do you test static method? How to do you test a method for an exception using JUnit? Which unit testing libraries you have used for testing Java programs? What is the difference between Before and BeforeClass annotation? Related Topics Multithreading Basics Collections Basics JDBC Basics Java Programs Java String Methods JSP Basics Servlets Basics Java Multiple Choice Questions Spring Basics Hibernate Basics Java Design Pattern Table of Contents Introduction Java Architecture Java Data Types Java Methods Java Functional programming Java Lambda expressions Java Classes Java Constructors Java Array Java Strings Java Reflection Java Streams Java Regular Expressions Java File Handling Java Exceptions Java Inheritance Java Method Overriding Java Polymorphism Java Abstraction Java Interfaces Java Encapsulation Java Generics Miscellaneous 1.

Interface methods by default; Lambda expressions; Functional interfaces; References to methods and constructors; Repeatable annotations Annotations on data types; Reflection for method parameters; Stream API for working with collections; Parallel sorting of arrays; New API for working with dates and times; New JavaScript Nashorn Engine ; Added several new classes for thread safe operation; Added a new API for Calendar and Locale ; Added support for Unicode 6.

getBytes ; A new implementation AccessController. class files. BufferedReader ; import java. IOException ; import java. println name ; } }. nextLine ; System. nextInt ; System. nextFloat ; System. readLine ; System. println "Hello World" ; } }. Compiled from ". java" class Simple { Simple ; public static void main java. String [] ; }. collect Collectors.

toList ;. println a ; } }. myMethod ; } }. Error : Unresolved compilation problem : The final field Demo. myMethod Details. java : 6 at beginnersbook. main Details. java : println "XYZ Class Method" ; } } class ABC extends XYZ { void demo { System. demo ; } }. public class Main { public native int intMethod int i ; public static void main String [] args { System.

loadLibrary "Main" ; System. println new Main. intMethod 2 ; } }. javac Main. java javah - jni Main gcc - shared - fpic - o libMain. c java - Djava. display ; } }. calculate 10 , 20 ; System. println s ; printer. println a. length "abc" ; }. println "In a nested class method" ; } } } class Main { public static void main String [] args { Outer. new Inner ; in. show ; } }. forName String className ;. println " Exit" ; } } public static void main String [] args { try { Runtime.

addShutdownHook new Message ; System. println " Program Started println " Wait for 5 seconds sleep ; System. println " Program Ended printStackTrace ; } } }. forName "subin. newInstance ;. clone ;. readObject ;. getTime ; } }. Level ; import java. forName "Explicitly load class" , true , ClassLoaderTest. getParent ; } catch ClassNotFoundException ex { Logger. getLogger ClassLoaderTest. log Level. newInstance ; System.

println obj ; System. println obj1 ; } catch ClassNotFoundException e { e. printStackTrace ; } catch InstantiationException e { e. printStackTrace ; } catch IllegalAccessException e { e.

class CreateObjectWithClone implements Cloneable { Override protected Object clone throws CloneNotSupportedException { return super. clone ; System. println obj2 ; } catch CloneNotSupportedException e { e. loadClass "CreateObjectWithClassLoader". printStackTrace ; } catch ClassNotFoundException e { e. printStackTrace ; } System. println obj ; } }. of " hello " ; optional. println s. orElse " ops Default Constructor of Car class called. Calling parameterized constructor of base Calling parameterized constructor of derived.

public class MyClass { static { System. println "outer static block.. println "outer instance block.. println "outer private constructor.. println "outer data member function.. println "inner instance block.. println "inner constructor.. println "static main method.. import java. hasNext System. println it. hasNext { System. next ; it. iterator ; list. One instance of where this is handy is for returning a 'sensible default' value if an expression resolves to false -ish as in Groovy truth.

A simple example might look like this:. Usage of the Elvis operator reduces the verbosity of your code and reduces the risks of errors in case of refactorings, by removing the need to duplicate the expression which is tested in both the condition and the positive return value.

The Safe Navigation operator is used to avoid a NullPointerException. Typically when you have a reference to an object you might need to verify that it is not null before accessing methods or properties of the object. To avoid this, the safe navigation operator will simply return null instead of throwing an exception, like so:. The user. name call triggers a call to the property of the same name, that is to say, here, to the getter for name. If you want to retrieve the field instead of calling the getter, you can use the direct field access operator:.

The method pointer operator. There are multiple advantages in using method pointers. First of all, the type of such a method pointer is a groovy.

Closure , so it can be used in any place a closure would be used. In particular, it is suitable to convert an existing method for the needs of the strategy pattern:.

Method pointers are bound by the receiver and a method name. Arguments are resolved at runtime, meaning that if you have multiple methods with the same name, the syntax is not different, only resolution of the appropriate method to be called will be done at runtime:.

To align with Java 8 method reference expectations, in Groovy 3 and above, you can use new as the method name to obtain a method pointer to the constructor:. Also in Groovy 3 and above, you can obtain a method pointer to an instance method of a class. This method pointer takes an additional parameter being the receiver instance to invoke the method on:. For backwards compatibility, any static methods that happen to have the correct parameters for the call will be given precedence over instance methods for this case.

The method reference operator :: can be used to reference a method or constructor in contexts expecting a functional interface. Indeed, for dynamic Groovy, the method reference operator is just an alias for the method pointer operator. For static Groovy, the operator results in bytecode similar to the bytecode that Java would produce for the same context.

Some examples highlighting various supported method reference cases are shown in the following script:. Some examples highlighting various supported constructor reference cases are shown in the following script:.

The pattern operator ~ provides a simple way to create a java. Pattern instance:. while in general, you find the pattern operator with an expression in a slashy-string, it can be used with any kind of String in Groovy:. Matcher instance:. When the intent is to iterate over matches of the specified pattern in while , etc. call find directly on the matcher or use the iterator DGM.

Typically, the match operator is used when the pattern involves a single exact match, otherwise the find operator might be more useful. It is equivalent to calling the action on each item and collecting the result into a list:. make is equivalent to cars. collect{ it. make }. In the previously mentioned case, the expression cars. make can be used, though retaining the explicit spread-dot operator is often recommended.

The spread operator is null-safe, meaning that if an element of the collection is null, it will return null instead of throwing a NullPointerException :.

The spread operator can be used on any class which implements the Iterable interface:. name when working with aggregates of data structures which themselves contain aggregates:. Consider using the collectNested DGM method instead of the spread-dot operator for collections of collections:. There may be situations when the arguments of a method call can be found in a list that you need to adapt to the method arguments.

In such situations, you can use the spread operator to call the method. For example, imagine you have the following method signature:. When used inside a list literal, the spread operator acts as if the spread element contents were inlined into the list:.

The spread map operator works in a similar manner as the spread list operator, but for maps. It allows you to inline the contents of a map into another map literal, like in the following example:. Groovy supports the concept of ranges and provides a notation.. to create ranges of objects:. Ranges implementation is lightweight, meaning that only the lower and upper bounds are stored.

For example, you can create a range of characters this way:. The subscript operator is a short hand notation for getAt or putAt , depending on whether you find it on the left hand side or the right hand side of an assignment:.

Groovy 3. For example:. The membership operator in is equivalent to calling the isCase method. In the context of a List , it is equivalent to calling contains , like in the following example:. In Groovy, it is calling equals. If you want to compare reference equality, you should use is like in the following example:.

The coercion operator as is a variant of casting. Coercion converts object from one type to another without them being compatible for assignment. When an object is coerced into another, unless the target type is the same as the source type, coercion will return a new object. The rules of coercion differ depending on the source and target types, and coercion may fail if no conversion rules are found. Custom conversion rules may be implemented thanks to the asType method:.

It is used to indicate that generic types should be inferred from the declaration:. In dynamic Groovy, this is totally unused. In statically type checked Groovy, it is also optional since the Groovy type checker performs type inference whether this operator is present or not.

The call operator is used to call a method named call implicitly. For any object which defines a call method, you can omit the. call part and use the call operator instead:. in instanceof! instanceof as. Groovy allows you to overload the various operators so that they can be used with your own classes.

Consider this simple class:. All non-comparator Groovy operators have a corresponding method that you can implement in your own classes. The only requirements are that your method is public, has the correct name, and has the correct number of arguments. The argument types depend on what types you want to support on the right hand side of the operator.

For example, you could support the statement. Socialize Discuss on the mailing-list Groovy newsletter Groovy on Twitter Events and conferences Source code on GitHub Report issues in Jira Stack Overflow questions Slack Community Apache Groovy.

August 10, 17 min read Generics are a way to reduce the need to write repetitive code and instead delegate this task to the compiler while also making the code more flexible. Many languages support some way to do this, even though they might call it something different. Using generics, we can write code that can be used with multiple data types without having to rewrite the same code for each data type, making life easier and coding less error-prone. In this article, we will see what generics are, how they are used in Rust, and how you can use them in your own code.

Particularly, we will see:. As a note, you will need to be comfortable reading and writing basic Rust code. This includes variable declarations, if…else blocks, loops, and struct declaration. A bit of knowledge of traits is also helpful. If you have used Rust before, chances are you have already used generics without even noticing. Before we get into the definition of generics and how they work in Rust, let us first see why we might need to use them.

Consider a case where we want to write a function that takes a slice of numbers and sorts them. It seems pretty straightforward, so we go ahead and start writing the function:. After spending several minutes on trying to remember how to use quicksort in Rust, and then looking it up on web, we realize something: this method is not particularly flexible.

Yes, we can pass arrays of usize to sort, but because Rust does not implicitly typecast values, any other types of numerical values — u8 , u16 and others — will not be accepted by this function. To sort these other integer types, we would need to create another array, fill it with the original values typecasted to usize , and pass it as the input.

We would also need to typecast the sorted array back to the original type. Furthermore, this solution will still not work at all for signed types such as i8 , i16 , and so on. Another problem with this is that even typecasting can only sort numerical values alone. Consider an example where we have a list of users, each with a numerical id field. We cannot pass them to this function! That is also a lot of work, especially considering the core of what we are doing — sorting — is the same.

Of course, we can write one function dedicated to each type we need: one for usize , one for i16 , one that provides access to structs , and so on. But that is a lot of code to write and maintain. Imagine if we used this method, but we made one mistake in the first function. If we then copied and pasted the function for various other types, we would then have to manually correct each one. If we forgot to fix any, we would get strange sorting errors that only showed up for one type.

Now consider if we want to write a Wrapper type. It would basically wrap the data inside it and provide more functionalities such as logging, debug trace, and more. We can define a struct, and keep a field in it to store that data, but we would then need to write a separate and dedicated struct for each data type that we want to wrap and reimplement the same functionality manually for each type.

Another issue is if we decided to publish this as library, the users would not be able to use this wrapper for their custom data types unless they wrote another struct and manually implemented everything for it, making the library redundant.

Informally, generic programming involves focusing on what you care about, and ignoring or abstracting everything else. In other words, when we write code, we write it with placeholder types instead of actual types. The actual types are inserted later. Think of how, in functions, we write the code in terms of its parameters. For example, an addition function takes two parameters, a and b , and adds them.

Instead, whenever we call that addition function, we pass those values as parameters to get the result. So, going back to apply generics to our previous example, we would write the sort function using a placeholder type; let us call it Sortable.

Then, when we call the function with a slice of usize , the compiler will replace this placeholder with usize to create a new function and use that function for the call to sort. If we called our sort function from another place and gave it an i16 slice, the compiler would generate yet another function — this time replacing the placeholder type with i16 — and use this function for the call.

As for the wrapper, we can simply put a type placeholder in the definition of our structure and make the data field be of this placeholder type. Then, whenever we use this wrapper, the compiler will generate a structure definition specifically tailored for that type. That way, we can use the wrapper for any of our types, and even the users of our library will be able to wrap their own types in this wrapper. Now we will see how generics are used in Rust.

As mentioned in the start, if you have used Rust for some time, you probably have already used generics in Rust. Think about the example Wrapper type we wanted to implement. We use these types to wrap some value when we want to indicate an optional value or a result, respectively. They have almost no restrictions and can take almost any type of value. Thus, we can use them to wrap any arbitrary data type we want to, which is because they are defined as generic types.

The Option type is an enum roughly defined as:. In the above, T is the type parameter we mentioned in the last section. Whenever we use it with a type, compiler generates the enum definition tailored to that particular type; for example, if we use Option for a String , the compiler will essentially generate a definition similar to the below:. Here, we can define any type to take place of T and E , and the compiler will generate and use a unique definition for each combination.

As another example, consider the various collections Rust offers : Vec , HashMap , HashSet , etc. All of these are generic structs, and thus can be used with any data types to store almost any values, with some restrictions in the cases of HashMap and HashSet , which we will see later. One thing to note at this stage is that once we declare the concrete type for the generic struct or enum, it essentially generates and uses a unique struct or enum with a fixed type.

If you want to store values of different types in the same structure, generics cannot be used alone, but will need to be used with Rust traits , which are not covered in this article. After that, we can use those declared parameters as types wherever we want to use the generic typing in the function, struct, or enum. However, it is pretty similar to others, where we first declare the generic parameters, but then we use it immediately.

Note that in this example, the T is part of the struct type whose implementation we are giving, and not declaration of generic parameter. Similar to the Option and Result examples in the last section, whenever we will use this struct or the function, the compiler will generate a dedicated struct or function, replacing the type parameters with the actual concrete type.

We will first tackle the Wrapper type. Here, we declared a generic type parameter called DataType , then declared the field data to be of this generic type.

Now we can declare a DataStore with u8 as the data, and another with a string as the data:. The compiler usually automatically detects the type to be filled in for the generic type, but in this case, 5 can be u8 , u16 , usize or quite a few other types. Thus, sometimes we might need to explicitly declare the type, like so:. Recalling the note we mentioned before: once declared, the type is fixed and behaves as a unique type.

A vector can only store elements of the same type. Remember, we get the following type error when we try to call collect on some iterator without specifying the type of variable:.

Hence, we need to explicitly state the collection type. Then, the compiler can figure out the data type that is to be stored in the collection:. To summarize, in the case of compiler not being able to figure out collection type needed to store the collected data, we need to specify the type.

Here, the solution is not as simple as declaring a generic type and using it as the datatype of the input array. This is because when simply declared as T , the type has no restrictions on it whatsoever.

Thus, when we try to compare two values, we get an error as shown below:. Hence, we must explicitly tell the compiler to only allow types to be substituted here if they can be compared to each other. And for that, in Rust, we have to use trait bounds. They contain the method signatures which must be implemented by all the types which implement the trait. For our sort function, we need to restrict — or bound — the type parameter T by a trait that has a compare function.

This function must give the relationship greater than, less than, or equal to between two elements of the same type that are given to it. Or we can use traits that are built into Rust to make things easier, which we will now do. Eq and Ord are two traits in the standard Rust library that provide the functionality we require.

The Eq trait provides a function to check if two values are equal or not, and Ord provides a way to compare and check which one between two is less that or greater than the other. These are by default implemented by the numerical types except f32 and f64 , which do not implement Eq , as NaN is neither equal nor not equal to NaN , so we only have to implement these traits for our own types, such as the user struct.

This will instruct the compiler that Type can only be substituted by those types, which implement trait1 and trait2 and so on. We can specify a single trait or multiple traits to restrict the type. Here, we declared a generic type with name Sortable and restricted it with traits Ord and Eq.

Now, types that are substituted for it must implement both the Eq and Ord traits. This will allow us to use this same function for u8 , u16 , usize , i32 , and so on. Also, if we implement these traits for our user struct, it can be sorted using this same function instead of us needing to write a separate one. Here, instead of writing the traits along with the type parameter declaration, we wrote them after the function parameters. To think about this in another way: trait bounds provide us guarantees about the types that are substituted in the type parameters.

In other words, it needs a guarantee that a hashing function can be called on the type substituted for the type of key, and it will give some value that can be regarded as the hash of that key. Similarly, HashSet requires that the elements stored in it can be hashed, and it restricts their types to those that implement the Hash trait.

Thus, we can think of trait bounds on type parameters as ways to restrict which types can be substituted, as well as having a guarantee that the substituted type will have certain properties or function associated with it.

This is harder to notice since lifetimes in Rust are mostly compile-time entities and not directly visible in code or compiled binary.

Usually if a type has a static lifetime, this means that the value should live until the end of the program. Note that this is not exactly what it means, but for now, we can think of it like that. Even then, lifetime generics are still a bit different than type generics: their final value is calculated by the compiler instead of us specifying the type in the code and compiler simply substituting it.

delegate corresponds to a third party object where methods calls or properties are resolved whenever the receiver of the message is not defined. The default methods of the implemented functional interface are not allowed to be accessed inside the lambda expression. All classes of the collection framework ArrayList, LinkedList, Vector, HashSet, LinkedHashSet, TreeSet, PriorityQueue, ArrayDeque, etc. Rn pn We have seen that a method named m is invoked to correspond to a message m sent to the object. or T is an array and A is a collection or stream and the component type of A is assignable to the component type of T. Let's see with this snippet.

Categories:

• Forex Bitcoin
• Forex Brokers
• Forex
• Binary Options
• Binary Options online