java unchecked assignment generics

• Watch & Listen
• Oracle University

Next in the Series: Type Inference

Introducing Generics

Why use generics.

In a nutshell, generics enable types (classes and interfaces) to be parameters when defining classes, interfaces and methods. Much like the more familiar formal parameters used in method declarations, type parameters provide a way for you to re-use the same code with different inputs. The difference is that the inputs to formal parameters are values, while the inputs to type parameters are types.

Code that uses generics has many benefits over non-generic code:

Stronger type checks at compile time. A Java compiler applies strong type checking to generic code and issues errors if the code violates type safety. Fixing compile-time errors is easier than fixing runtime errors, which can be difficult to find.

Elimination of casts. The following code snippet without generics requires casting:

When re-written to use generics, the code does not require casting:

• Enabling programmers to implement generic algorithms. By using generics, programmers can implement generic algorithms that work on collections of different types, can be customized, and are type safe and easier to read.

Generic Types

A simple box class.

A generic type is a generic class or interface that is parameterized over types. The following Box class will be modified to demonstrate the concept.

Since its methods accept or return an Object , you are free to pass in whatever you want, provided that it is not one of the primitive types. There is no way to verify, at compile time, how the class is used. One part of the code may place an Integer in the box and expect to get objects of type Integer out of it, while another part of the code may mistakenly pass in a String , resulting in a runtime error.

A Generic Version of the Box Class

A generic class is defined with the following format:

The type parameter section, delimited by angle brackets ( <> ), follows the class name. It specifies the type parameters (also called type variables) T1 , T2 , ..., and Tn .

To update the Box class to use generics, you create a generic type declaration by changing the code " public class Box " to " public class Box<T> ". This introduces the type variable, T , that can be used anywhere inside the class.

With this change, the Box class becomes:

As you can see, all occurrences of Object are replaced by T . A type variable can be any non-primitive type you specify: any class type, any interface type, any array type, or even another type variable.

This same technique can be applied to create generic interfaces.

Type Parameter Naming Conventions

By convention, type parameter names are single, uppercase letters. This stands in sharp contrast to the variable naming conventions that you already know about, and with good reason: without this convention, it would be difficult to tell the difference between a type variable and an ordinary class or interface name.

The most commonly used type parameter names are:

E - Element (used extensively by the Java Collections Framework)

S, U, V etc. - 2nd, 3rd, 4th types

You will see these names used throughout the Java SE API and the rest of this section.

Invoking and Instantiating a Generic Type

To reference the generic Box class from within your code, you must perform a generic type invocation, which replaces T with some concrete value, such as Integer :

You can think of a generic type invocation as being similar to an ordinary method invocation, but instead of passing an argument to a method, you are passing a type argument — Integer in this case — to the Box class itself.

Type Parameter and Type Argument Terminology : Many developers use the terms "type parameter" and "type argument" interchangeably, but these terms are not the same. When coding, one provides type arguments in order to create a parameterized type. Therefore, the T in Foo<T> is a type parameter and the String in Foo<String> f is a type argument. This section observes this definition when using these terms.

Like any other variable declaration, this code does not actually create a new Box object. It simply declares that integerBox will hold a reference to a "Box of Integer", which is how Box<Integer> is read.

An invocation of a generic type is generally known as a parameterized type.

To instantiate this class, use the new keyword, as usual, but place <Integer> between the class name and the parenthesis:

The Diamond

In Java SE 7 and later, you can replace the type arguments required to invoke the constructor of a generic class with an empty set of type arguments ( <> ) as long as the compiler can determine, or infer, the type arguments from the context. This pair of angle brackets, <> , is informally called the diamond. For example, you can create an instance of Box<Integer> with the following statement:

For more information on diamond notation and type inference, see the Type Inference section of this tutorial.

Multiple Type Parameters

As mentioned previously, a generic class can have multiple type parameters. For example, the generic OrderedPair class, which implements the generic Pair interface:

The following statements create two instantiations of the OrderedPair class:

The code, new OrderedPair<String, Integer>() , instantiates K as a String and V as an Integer . Therefore, the parameter types of OrderedPair 's constructor are String and Integer , respectively. Due to autoboxing, it is valid to pass a String and an int to the class.

As mentioned in The Diamond section, because a Java compiler can infer the K and V types from the declaration OrderedPair<String, Integer> , these statements can be shortened using diamond notation:

To create a generic interface, follow the same conventions as for creating a generic class.

Parameterized Types

You can also substitute a type parameter (that is, K or V ) with a parameterized type, that is, List<String> . For example, using the OrderedPair<K, V> example:

A raw type is the name of a generic class or interface without any type arguments. For example, given the generic Box class:

To create a parameterized type of Box<T> , you supply an actual type argument for the formal type parameter T :

If the actual type argument is omitted, you create a raw type of Box<T> :

Therefore, Box is the raw type of the generic type Box<T> . However, a non-generic class or interface type is not a raw type.

Raw types show up in legacy code because lots of API classes (such as the Collections classes) were not generic prior to JDK 5.0. When using raw types, you essentially get pre-generics behavior — a Box gives you Objects. For backward compatibility, assigning a parameterized type to its raw type is allowed:

But if you assign a raw type to a parameterized type, you get a warning:

You also get a warning if you use a raw type to invoke generic methods defined in the corresponding generic type:

The warning shows that raw types bypass generic type checks, deferring the catch of unsafe code to runtime. Therefore, you should avoid using raw types.

The Type Erasure section has more information on how the Java compiler uses raw types.

Unchecked Error Messages

As mentioned previously, when mixing legacy code with generic code, you may encounter warning messages similar to the following:

This can happen when using an older API that operates on raw types, as shown in the following example:

The term "unchecked" means that the compiler does not have enough type information to perform all type checks necessary to ensure type safety. The "unchecked" warning is disabled, by default, though the compiler gives a hint. To see all "unchecked" warnings, recompile with -Xlint:unchecked .

Recompiling the previous example with -Xlint:unchecked reveals the following additional information:

To completely disable unchecked warnings, use the -Xlint:-unchecked flag. The @SuppressWarnings("unchecked") annotation suppresses unchecked warnings. If you are unfamiliar with the @SuppressWarnings syntax, see the section Annotations.

Generic Methods

Generic methods are methods that introduce their own type parameters. This is similar to declaring a generic type, but the type parameter's scope is limited to the method where it is declared. Static and non-static generic methods are allowed, as well as generic class constructors.

The syntax for a generic method includes a list of type parameters, inside angle brackets, which appears before the method's return type. For static generic methods, the type parameter section must appear before the method's return type.

The Util class includes a generic method, compare, which compares two Pair objects:

The complete syntax for invoking this method would be:

The type has been explicitly provided, as shown in bold. Generally, this can be left out and the compiler will infer the type that is needed:

This feature, known as type inference, allows you to invoke a generic method as an ordinary method, without specifying a type between angle brackets. This topic is further discussed in the following section, Type Inference.

Bounded Type Parameters

There may be times when you want to restrict the types that can be used as type arguments in a parameterized type. For example, a method that operates on numbers might only want to accept instances of Number or its subclasses. This is what bounded type parameters are for.

To declare a bounded type parameter, list the type parameter's name, followed by the extends keyword, followed by its upper bound, which in this example is Number . Note that, in this context, extends is used in a general sense to mean either " extends " (as in classes) or " implements " (as in interfaces).

By modifying our generic method to include this bounded type parameter, compilation will now fail, since our invocation of inspect still includes a String :

In addition to limiting the types you can use to instantiate a generic type, bounded type parameters allow you to invoke methods defined in the bounds:

The isEven() method invokes the intValue() method defined in the Integer class through n .

Multiple Bounds

The preceding example illustrates the use of a type parameter with a single bound, but a type parameter can have multiple bounds:

A type variable with multiple bounds is a subtype of all the types listed in the bound. If one of the bounds is a class, it must be specified first. For example:

If bound A is not specified first, you get a compile-time error:

Generic Methods and Bounded Type Parameters

Bounded type parameters are key to the implementation of generic algorithms. Consider the following method that counts the number of elements in an array T[] that are greater than a specified element elem .

The implementation of the method is straightforward, but it does not compile because the greater than operator ( > ) applies only to primitive types such as short , int , double , long , float , byte , and char . You cannot use the > operator to compare objects. To fix the problem, use a type parameter bounded by the Comparable<T> interface:

The resulting code will be:

Generics, Inheritance, and Subtypes

As you already know, it is possible to assign an object of one type to an object of another type provided that the types are compatible. For example, you can assign an Integer to an Object , since Object is one of Integer 's supertypes:

In object-oriented terminology, this is called an "is a" relationship. Since an Integer is a kind of Object, the assignment is allowed. But Integer is also a kind of Number , so the following code is valid as well:

The same is also true with generics. You can perform a generic type invocation, passing Number as its type argument, and any subsequent invocation of add will be allowed if the argument is compatible with Number :

Now consider the following method:

What type of argument does it accept? By looking at its signature, you can see that it accepts a single argument whose type is Box<Number> . But what does that mean? Are you allowed to pass in Box<Integer> or Box<Double> , as you might expect? The answer is "no", because Box<Integer> and Box<Double> are not subtypes of Box<Number> .

This is a common misunderstanding when it comes to programming with generics, but it is an important concept to learn. Box<Integer> is not a subtype of Box<Number> even though Integer is a subtype of Number .

Note: Given two concrete types A and B , for example, Number and Integer , MyClass<A> has no relationship to MyClass<B> , regardless of whether or not A and B are related. The common parent of MyClass<A> and MyClass<B> is Object .

For information on how to create a subtype-like relationship between two generic classes when the type parameters are related, see the section Wildcards and Subtyping .

Generic Classes and Subtyping

You can subtype a generic class or interface by extending or implementing it. The relationship between the type parameters of one class or interface and the type parameters of another are determined by the extends and implements clauses.

Using the Collections classes as an example, ArrayList<E> implements List<E> , and List<E> extends Collection<E> . So ArrayList<String> is a subtype of List<String> , which is a subtype of Collection<String> . So long as you do not vary the type argument, the subtyping relationship is preserved between the types.

Now imagine we want to define our own list interface, PayloadList , that associates an optional value of generic type P with each element. Its declaration might look like:

The following parameterizations of PayloadList are subtypes of List<String> :

• PayloadList<String,String>
• PayloadList<String,Integer>
• PayloadList<String,Exception>

In this tutorial

Last update: September 14, 2021

DEV Community

Posted on Jun 1, 2023

How to Avoid Unchecked Casts in Java Programs

Unchecked cast refers to the process of converting a variable of one data type to another data type without checks by the Java compiler.

This operation is unchecked because the compiler does not verify if the operation is valid or safe. Unchecked casts can lead to runtime errors, such as ClassCastException, when the program tries to assign an object to a variable of an incompatible type.

Hence, it is important to avoid unchecked casts in Java programs to prevent potential errors and ensure the program's reliability.

Consequences of Unchecked Casts

In Java programs, unchecked casts can lead to several issues. The most common problem is a ClassCastException at runtime, which occurs when we try to cast an object to a wrong type. This can cause the program to crash or behave unexpectedly.

Unchecked casts also violate the type safety of the Java language, which can lead to bugs that are difficult to detect and debug. Additionally, unchecked casts can make the code less readable and maintainable, as they hide the true type of objects and dependencies between components.

Therefore, it is important to avoid unchecked casts and use other mechanisms, such as generics or polymorphism, to ensure type safety and code quality in Java programs.

How Unchecked Casts Occur

Unchecked casts in Java programs occur when an object of one type is assigned to a reference of another type without proper type checking. This can happen when a programmer assumes that a reference to a superclass is actually a reference to its subclass and tries to cast it into that subclass. If the assumption is incorrect, the cast will result in a ClassCastException at runtime.

Unchecked casts can also occur when dealing with raw types, which are generic types without any type parameters specified. In such cases, the compiler cannot perform type checking and the programmer must ensure that the proper type conversions are made. Failing to do so can result in unchecked casts and potential runtime errors.

Why unchecked casts are problematic

In Java, unchecked casts allow a programmer to cast any object reference to any other reference type without providing any type information at compile-time. While this flexibility may seem useful, it can lead to serious run-time errors. If the object being casted is not actually of the type specified, a ClassCastException will occur at run-time.

Unchecked casts can cause difficult-to-debug errors in large and complex codebases, as it may not be immediately clear where the error originated. Additionally, unchecked casts can undermine Java's type system, creating code that is harder to read, maintain, and reason about. As a result, avoiding unchecked casts should be a priority when writing Java programs.

Examples of Unchecked Casts in Java

Unchecked casts are a common source of Java program errors. Here are some examples of unchecked casts:

This cast statement above can result in a class cast exception if the object referred to by obj is not a List.

In this case, the cast could fail at runtime if the array contains objects of a type other than String.

Finally, this cast could fail if the object referred to by obj is not a Map.

Using Generics to Avoid Unchecked Casts in Java

In Java, Generics is a powerful feature that allows you to write classes and methods that are parameterized by one or more types. Generics are a way of making your code more type-safe and reusable. With generics, you can define classes and methods that work on a variety of types, without having to write separate code for each type.

Using generics in Java programs has several advantages. It enables type safety at compile-time, which can prevent ClassCastException errors at runtime. With generics, the compiler can detect type mismatches and prevent them from happening, which leads to more robust and reliable code. It also allows for code reuse without sacrificing type safety and improve performance by avoiding unnecessary casting and allowing for more efficient code generation.

Generics allow Java developers to create classes and methods that can work with different data types. For example, a List can be defined to hold any type of object using generics. Here's an example:

In this example, we create a List that holds String objects. We can add String objects to the list and iterate over them using a for-each loop. The use of generics allows us to ensure type safety and avoid unchecked casts. Another example is the Map interface, which can be used to map keys to values of any data type using generics.

Using the instanceof operator to Avoid Unchecked Casts in Java

The instanceof operator is a built-in operator in Java that is used to check whether an object is an instance of a particular class or interface. The operator returns a boolean value - true if the object is an instance of the specified class or interface, and false otherwise.

The instanceof operator is defined as follows:

where object is the object that is being checked, and class/interface is the class or interface that is being tested against.

The instanceof operator can be useful in situations where we need to perform different operations based on the type of an object. It provides a way to check the type of an object at runtime, which can help prevent errors that can occur when performing unchecked casts.

Here are some examples of using the instanceof operator:

In this example, we use the instanceof operator to check whether the object obj is an instance of the String class. If it is, we perform an explicit cast to convert the object to a String and call the toUpperCase() method on it.

In this example, we use the instanceof operator to check whether the List object passed as a parameter is an instance of the ArrayList or LinkedList classes. If it is, we perform an explicit cast to convert the List to the appropriate class and perform different operations on it depending on its type.

Overall, using the instanceof operator can help us write more robust and flexible code. However, it should be used judiciously as it can also make code harder to read and understand.

Using Polymorphism to Avoid Unchecked Casts in Java

Polymorphism is a fundamental concept in object-oriented programming. It refers to the ability of an object or method to take on multiple forms. It allows us to write code that can work with objects of different classes as long as they inherit from a common superclass or implement a common interface. This helps to reduce code duplication and makes our programs more modular and extensible.

Some of the advantages of using polymorphism are:

• Code reusability: We can write code that can work with multiple objects without having to rewrite it for each specific class.
• Flexibility: Polymorphism allows us to write code that can adapt to different types of objects at runtime.
• Ease of maintenance: By using polymorphism, changes made to a superclass or interface are automatically propagated to all its subclasses.

Here are a few examples of how you can use polymorphism to avoid unchecked casts in Java:

Example 1: Shape Hierarchy

In this example, the abstract class Shape defines the common behavior draw(), which is implemented by the concrete classes Circle and Rectangle. By using the Shape reference type, we can invoke the draw() method on different objects without the need for unchecked casts.

Example 2: Polymorphic Method Parameter

In this example, the makeAnimalSound() method accepts an Animal parameter. We can pass different Animal objects, such as Dog or Cat, without the need for unchecked casts. The appropriate implementation of the makeSound() method will be invoked based on the dynamic type of the object.

By utilizing polymorphism in these examples, we achieve type safety and avoid unchecked casts, allowing for cleaner and more flexible code.

Tips to Avoid Unchecked Casts in Java Programs

Unchecked casts in Java programs can introduce runtime errors and compromise type safety. Fortunately, there are several techniques and best practices you can employ to avoid unchecked casts and ensure a more robust codebase. Here are some effective tips to help you write Java programs that are type-safe and free from unchecked cast exceptions.

• Use generic classes, interfaces, and methods to ensure that your code handles compatible types without relying on casting.
• Embrace polymorphism by utilizing abstract classes and interfaces, define common behavior and interact with objects through their common type.
• Check the type of an object using the instanceof operator. This allows you to verify that an object is of the expected type before proceeding with the cast.
• Favor composition over inheritance, where classes contain references to other classes as instance variables.
• Familiarize yourself with design patterns that promote type safety and avoid unchecked casts. Patterns such as Factory Method, Builder, and Strategy provide alternative approaches to object creation and behavior, often eliminating the need for explicit casting.
• Clearly define the contracts and preconditions for your methods. A well-defined contract helps ensure that the method is called with appropriate types, improving overall code safety.
• Refactor your code and improve its overall design. Look for opportunities to apply the aforementioned tips, such as utilizing generics, polymorphism, or design patterns.

Unchecked casts in Java programs can introduce runtime errors and undermine type safety. By adopting practices like using generics, leveraging polymorphism, checking types with instanceof, favoring composition over inheritance, reviewing design patterns, employing design by contract, and improving code design, you can avoid unchecked casts and enhance the robustness of your Java programs. Prioritizing type safety will result in more reliable code and a smoother development process.

Lightly IDE as a Programming Learning Platform

So, you want to learn a new programming language? Don't worry, it's not like climbing Mount Everest. With Lightly IDE, you'll feel like a coding pro in no time. With Lightly IDE , you don't need to be a coding wizard to start programming.

One of its standout features is its intuitive design, which makes it easy to use even if you're a technologically challenged unicorn. With just a few clicks, you can become a programming wizard in Lightly IDE. It's like magic, but with less wands and more code.

If you're looking to dip your toes into the world of programming or just want to pretend like you know what you're doing, Lightly IDE's online Java compiler is the perfect place to start. It's like a playground for programming geniuses in the making! Even if you're a total newbie, this platform will make you feel like a coding superstar in no time.

Read more: How to Avoid Unchecked Casts in Java Programs

Top comments (0)

Templates let you quickly answer FAQs or store snippets for re-use.

Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink .

Hide child comments as well

For further actions, you may consider blocking this person and/or reporting abuse

Rust Advance Cheatsheet

Syed Muhammad Ali Raza - May 12

Executing C Code with JavaScript

Siddhant Khare - May 12

Topic Modeling: Machine Learning Technique 301

Aftab Ahmed (Abro) - May 12

Automatic Image Cropping

Michael Smith - May 12

We're a place where coders share, stay up-to-date and grow their careers.

Generics unchecked assignment

SCJP 1.4 - SCJP 6 - SCWCD 5 - OCEEJBD 6 - OCEJPAD 6 How To Ask Questions How To Answer Questions

The Java Tutorials have been written for JDK 8. Examples and practices described in this page don't take advantage of improvements introduced in later releases and might use technology no longer available. See Java Language Changes for a summary of updated language features in Java SE 9 and subsequent releases. See JDK Release Notes for information about new features, enhancements, and removed or deprecated options for all JDK releases.

Lesson: Generics (Updated)

In any nontrivial software project, bugs are simply a fact of life. Careful planning, programming, and testing can help reduce their pervasiveness, but somehow, somewhere, they'll always find a way to creep into your code. This becomes especially apparent as new features are introduced and your code base grows in size and complexity.

Fortunately, some bugs are easier to detect than others. Compile-time bugs, for example, can be detected early on; you can use the compiler's error messages to figure out what the problem is and fix it, right then and there. Runtime bugs, however, can be much more problematic; they don't always surface immediately, and when they do, it may be at a point in the program that is far removed from the actual cause of the problem.

Generics add stability to your code by making more of your bugs detectable at compile time. After completing this lesson, you may want to follow up with the Generics tutorial by Gilad Bracha.

About Oracle | Contact Us | Legal Notices | Terms of Use | Your Privacy Rights

Copyright © 1995, 2022 Oracle and/or its affiliates. All rights reserved.

JEP draft: Universal Generics (Preview)

Unify the treatment of reference and primitive types in generic code by allowing Java type variables to range over both kinds of types. Produce new warnings to maintain the safety guarantees of generic code. This is a preview language feature .

The core primitive class types feature is introduced by JEP 401 (Primitive Classes) . This JEP is only concerned with supporting primitive class types as type arguments.

In the future (see Dependencies ), we expect the JVM to optimize the performance of primitive type parameterizations, with help from the Java compiler. But for now, generics continue to be implemented via erasure.

Significant adjustments to generic standard library code are expected in response to new warnings, but those adjustments will be pursued in a separate JEP. Future work may also refactor implementations of hand-specialized primitive code.

A common programming task is to take code that solves a problem for values of a particular type and extend that code to work on values of other types. Java developers can use three different strategies to perform this task:

Hand-specialized code: Rewrite the same code multiple times (perhaps with copy and paste), using different types each time.

Subtype polymorphism: Change the types in the solution to be a common supertype of all anticipated operand types.

Parametric polymorphism: Replace the types in the solution with type variables , instantiated by callers with whatever types they need to operate on.

The java.util.Arrays.binarySearch methods are a good illustration of all three strategies:

The first variant uses subtype polymorphism. It works for all arrays of reference types, which share the common supertype Object[] . The search key can, similarly, be any object. The behavior of the method depends on dynamic properties of the arguments—at run time, do the array components and key support comparison to each other?

The second variant uses parametric polymorphism. It also works for all arrays of reference types, but asks the caller to provide a comparison function. The parameterized method signature ensures at compile time, for each call site, that the array components and key are of types supported by the provided comparison function.

Additional variants use hand specialization. These work on arrays of basic primitive types, which do not have a useful common supertype. Unfortunately, this means there are seven different copies of a nearly-identical method, adding a lot of complexity to the API and violating the DRY principle .

Primitive class types , introduced in JEP 401 , are a new kind of type, allowing developers to operate directly on custom-defined primitives. Primitive values have lightweight conversions to reference types, and thus can participate in subtyping relationships. Arrays of primitive values also support these conversions (e.g., an array of values can be treated as an Object[] ). Thus, primitive value types work out-of-the-box with APIs that rely on subtype polymorphism, such as the Object[ ] variant of binarySearch .

With JEP 402 (Classes for the Basic Primitives) , we will update the language to treat the basic primitive types ( int , double , etc.) as primitive class types, and primitive arrays such as int[ ] as subtypes of Object[] . This will eliminate the need for overloads like those of binarySearch that were hand-specialized across basic primitive types. (Existing APIs may have binary compatibility obligations, of course, and subtype polymorphism may not be acceptable for performance-critical code.)

The third option, parametric polymorphism, was unfortunately designed for reference types only. Under current rules, no primitive type can be a type argument. Instead, for a primitive class type Point , sorting an array of Point s with a comparison function requires choosing a reference type as the instantiation of T , and then providing a comparison function that works on all values of that reference type.

Primitive classes do come with a sharp companion reference type—in this case, Point.ref —but using such a type as a type argument is a poor solution. For one thing, everything that interacts with the type, such as the comparison function, would also have to work with Point.ref , producing a lot of extra noise in the source code. For another, in the future, we would like to optimize calls to the comparison function by passing inlined Point values directly. But the reference type Point.ref cannot be inlined as efficiently.

A much better solution is for generic APIs to support primitive class types directly, in addition to reference types. Ideally, this should be the default behavior of Java's generics, so that primitive class types can participate fully in the Java ecosystem.

The language can achieve this by relaxing the requirement that type arguments must be reference types, and then adjusting the treatment of type variables, bounds, and inference accordingly.

A significant implication that developers will need to account for is that a universal type variable might now represent a type that does not permit null . Java compilers can produce warnings, much like the unchecked warnings introduced in Java 5, to alert developers to this possibility. Then developers can make use of some new language features to address the warnings.

Description

The features described below are preview features, enabled with the --enable-preview compile-time and runtime flags.

Type variables and bounds

Previously, Java's type variable bounds were interpreted according to the language's subtyping relation. We now say that a type S is bounded by a type T if any of the following is true:

S is a subtype of T (where every type is a subtype of itself, and reference types are subtypes of many other types, per their class declarations and other subtyping rules); or

S is a primitive class type whose corresponding reference type is bounded by T ; or

S is a type variable with an upper bound that is bounded by T , or T is a type variable with a lower bound and S is bounded by the lower bound of T .

As usual, type variables are declared with upper bounds, and those declared without bounds ( <T> ) implicitly have upper bound Object ( <T extends Object> ). Any type may act as an upper bound.

At a use site, any type may be provided as a type argument instantiating a type variable, as long as the type argument is bounded by the type variable's upper bounds. For example, if Point is a primitive class type, the type List<Point> is valid because Point is bounded by Object .

Type variables can thus range over any type, and are no longer assumed to represent a reference type.

Wildcards also have bounds, which again may be any type. Similar bounds checks are performed when testing that one parameterized type is a subtype of another. For example, if the primitive class Point implements Shape , the type List<Point> is a subtype of List<? extends Shape> , and the type List<Shape> is a subtype of List<? super Point> , because Point is bounded by Shape .

Type argument inference is enhanced to support inferring primitive class types. When an inference variable has a primitive type as its lower bound, that type may become the inference result. For example, the invocation List.of(new Point(3.0, -1.0)) typically has inferred type List<Point> . If it occurs in an assignment context, with target type Collection<Point.ref> , it has inferred type List<Point.ref> . (To do: since these inference variables can range over both primitive and reference types, "strict" applicability testing can no longer be sure that an inferred parameterization won't end up requiring a conversion. Unexpected errors or incorrect overload resolution results may occur.)

These changes to type variables, bounds checking, and inference are applied automatically to existing code. Many existing generic APIs will smoothly handle primitive class types without any modification.

Interaction with JEP 402: Wherever the phrase "any type" is used above, it describes the state of things after JEP 402 has been completed. Until that point, universal type variables will be not-quite-universal since they will be instantiable by reference types and primitive class types but not by the basic primitive types. While JEP 402 is not a prerequisite to this JEP (see Dependencies ), it is expected to be completed in a similar timeframe.

With JEP 402, there is some source compatibility risk due to type inference preferring int over Integer in existing code. This requires further exploration.

Null pollution and null warnings

References can be null , but primitive class types are not reference types, so JEP 401 prohibits assigning null to them.

By allowing type variables to range over a wider set of types, we must ask developers to make fewer assumptions about their instantiations. Specifically, it is usually improper to assign null to a variable with a type-variable type, because the type variable may be instantiated by a primitive class type.

In this example, the type of the field x is erased to Object , so at run time a C<Point> will happily store a null , even though this violates the expectations of the compile-time type. This scenario is an example of null pollution , a new kind of heap pollution. Like other forms of heap pollution, the problem is detected at run time when the program attempts to assign a value to a variable whose erased type does not support it—in this case, the assignment to p .

As for other forms of heap pollution, the compiler produces null warnings to discourage null pollution:

A warning is issued when a null literal is assigned to a universal type-variable type.

A warning is issued when a non- final field with a universal type-variable type is left uninitialized by a constructor.

(There are also null warnings for certain conversions, discussed in a later section.)

As with unchecked warnings, null warnings alert programmers to the risk of heap pollution, which can lead to unexpected runtime exceptions in downstream assignments. Code that compiles without warnings will not throw these exceptions, and can safely be instantiated with primitive class types.

A significant amount of existing generic code produces null warnings, having been written with the assumption that type variables are reference types. We encourage developers, as they are able, to update their code to eliminate sources of null pollution.

In a future release (see Dependencies ), the physical layout of generic code may be specialized for each primitive class type. At that point null pollution will be detected earlier, and code that has failed to address the warnings may become unusable. Code that has addressed the warnings is specialization-ready , meaning that future JVM enhancements will not disrupt its functionality.

Reference type-variable types

When generic code needs to work with null , the language offers a few special features to ensure that a type-variable type is a ( null -friendly) reference type.

A type variable that is bounded by IdentityObject (either directly or via an identity class bound) is always a reference type.

A type variable whose declaration is modified by the contextual keyword ref prohibits primitive type arguments, and thus is always a reference type.

A type variable use may be modified by the syntax .ref , which represents a mapping from the instantiating type to its tightest bounding reference type (e.g., Point maps to Point.ref , while FileReader maps to FileReader ).

(The new syntax above is subject to change.)

In the last case, the types T and T.ref are two distinct type-variable types. Assignments between the two types are allowed, as a form of value object conversion or primitive value conversion.

A type variable that is bounded by IdentityObject or declared with the ref modifier is a reference type variable . All other type variables are called universal type variables .

Similarly, a type that names a reference type variable or has the form T.ref is called a reference type-variable type , while a type that names a universal type variable without .ref is called a universal type-variable type .

Warnings on value conversion

Primitive value conversions allow a value object to be converted to a primitive value of the same class. Per JEP 401 , if the reference is null, the conversion fails at run time.

When primitive value conversion is applied to a type-variable type there is no runtime check, but the conversion may be a source of null pollution.

To help prevent both NullPointerException s and null pollution, primitive value conversions produce null warnings unless the compiler can prove that the reference being converted is non- null .

If a parameter, local variable, or final field has a reference type-variable type then the compiler may be able to prove, at certain usages, that the variable's value is non- null . In that case, primitive value conversion may occur without a null warning. The details and limitations of this analysis require further exploration, but might be similar to the control-flow analysis that determines whether a variable has been initialized before use.

Similar to assignment, overrides that involve adding or removing .ref to a type-variable type are allowed, but prompt a null warning.

Parameterized type conversions

Unchecked conversions traditionally allow a raw type to be converted to a parameterization of the same class. These conversions are unsound, and are thus accompanied by unchecked warnings.

As developers make changes such as applying .ref to certain type variable uses, they may end up with parameterized types (e.g., List<T.ref> ) in API signatures that are out of sync with other code. To ease migration, the allowed set of unchecked conversions is expanded to include the following parameterized-to-parameterized conversions:

Changing a type argument of a parameterized type from a universal type-variable type ( T ) to its reference type ( T.ref ), or vice versa:

Changing a type argument of a parameterized type from a primitive class type ( Point ) to its reference type ( Point.ref ), or vice versa:

Changing a wildcard bound in a parameterized type from a universal type-variable type ( T ) or a primitive class type ( Point ) to its reference type ( T.ref , Point.ref ), or vice versa (where the conversion is not already allowed by subtyping):

Recursively applying an unchecked conversion to any type argument or wildcard bound of a parameterized type:

These unchecked conversions may seem easily avoidable in small code snippets, but the flexibility they offer will significantly ease migration as different program components or libraries adopt universal generics at different times.

In addition to unchecked assignments, these conversions can be used by unchecked casts and method overrides:

Compiling to class files

Generic classes and methods will continue to be implemented via erasure, replacing type variables with their erased bounds in generated bytecode. Within generic APIs, primitive objects will therefore generally be operated on as references.

The usual rules for detecting heap pollution apply: Casts are inserted at certain program points to assert that a value has the expected runtime type. In the case of primitive class types, this includes checking that the value is non-null.

We extend the Signature attribute to encode additional forms of compile-time type information:

• Type variables declared as ref T ,
• Type variable uses of the form T.ref , and
• Primitive class types appearing as type arguments and type variable/wildcard bounds.

Alternatives

We could ask developers to always use primitive reference types when making use of generic APIs. This is not a very good solution, as argued in the Motivation section.

We could also ask API authors to opt-in to universal type variables, rather than making type variables universal by default. But the goal is for universal generics to be the norm, and in practice there is no reason most type variables cannot be universal. An opt-in would introduce too much friction and lead to a fragmented Java ecosystem.

As noted, the erasure-based compilation strategy does not allow for the performance we might hope for from generic APIs operating on primitive values. In the future (see Dependencies ) we expect to enhance the JVM to allow for compilation that produces heterogeneous classes specialized to different type arguments. With the language changes in this JEP developers can write more expressive code now and make their generic APIs specialization-ready, in anticipation of performance improvements in the future.

We could avoid introducing new warnings and accept null pollution as a routine fact of programming with primitive class types. This would make for a cleaner compilation experience, but the unpredictability of generic APIs at run time would not be pleasant. Ultimately, we want developers who use null in generic APIs to notice and think carefully about how their usage interacts with primitive types.

In the other extreme, we could treat some or all of the warnings as errors. But we do not want to introduce source and migration incompatibilities. Legacy code and uses of legacy APIs should still successfully compile, even if there are new warnings.

Risks and Assumptions

The success of these features depends on Java developers learning about and adopting an updated model for the interaction of type variables with null . The new warnings will be highly visible, and they will need to be understood and appreciated—not ignored—for them to have their desired effect.

Making these features available before specialized generics presents some challenges. Some developers may be dissatisfied with the performance (e.g., comparing ArrayList<Point> to Point[] ) and develop incorrect long-term intuitions about the costs of using generics for primitive class types. Other developers may make suboptimal choices when applying .ref , not noticing any ill effects until running on a specialization-supporting VM, long after the code has been changed.

Dependencies

JEP 401 (Primitive Classes) is a prerequisite.

We expect JEP 402 (Classes for the Basic Primitives) to proceed concurrently with this JEP; together, they provide support for basic primitive types as type arguments and bounds.

A followup JEP will update the standard libraries, addressing null warnings and making the libraries specialization-ready.

Another followup JEP will introduce runtime specialization of generic APIs in the JVM.

• Java Arrays
• Java Strings
• Java Collection
• Java 8 Tutorial
• Java Multithreading
• Java Exception Handling
• Java Programs
• Java Project
• Java Collections Interview
• Java Interview Questions
• Spring Boot

Non-generic Vs Generic Collection in Java

• Garbage Collection in Java
• Need of Concurrent Collections in java
• Iterator vs Collection in Java
• Java Collection Exercise
• Collections.nCopies() in Java
• Collections enumeration() method in Java with Examples
• Collection vs Collections in Java with Example
• Why We Need Collection Framework in Java?
• Generic For Loop in Java
• Java.util.Collections.frequency() in Java
• Java Convenience Factory Methods for Collections
• Collections.sort() in Java with Examples
• How to Compare two Collections in Java?
• C++ STL vs Java Collections Framework
• Collection contains() method in Java with Examples
• Convert an Iterable to Collection in Java
• Templates in C++ vs Generics in Java
• Collection Interface in Java with Examples
• Collections in Java

We will be discussing differences later prior let us understand what is generic Collection and non-generic Collection, and most importantly dealing with the implementation part as during implementation one can only really get the real understanding of the concept, henceforth the differences between them.

Generics are basically the errors appearing are compile-time than at run-time. there are certain advantages of generics over non-generic are as follows: 

• Code Reuse: With help of Generics, one needs to write a method/class/interface only once and use it for any type whereas, in non-generics, the code needs to be written again and again whenever needed.
• Type Safety: Generics make errors to appear compile time than at run time (It’s always better to know problems in your code at compile time rather than making your code fail at run time).

Example: To create an ArrayList that store name of students and if by mistake programmer adds an integer object instead of string, the compiler allows it. But, when this data is retrieved from ArrayList, it causes problems at runtime for Non-generic ArrayList

Implementation:

Output:  

How generics solve this problem?

If this list was made Generic, then it would take only String objects and threw Compile Time Error in any other case.

Now moving forward, Individual Type Casting is not needed.

If Generics is not needed, then, in the above example every time the data is to be retrieved from ArrayList, it needs to be typecasted. Typecasting at every retrieval operation is a big headache. This can be avoided if somehow it is already known that the list only holds string data.

Geek , now you should be wondering how generics solve this problem?

If this list was made Generic, then it would take only String objects and would return only String objects while retrieval. And hence individual typecasting won’t be required. The above statement is justified 

Note: With the help of generics, while one can implement algorithms Implementing generic algorithms, one can have t hat work on different types of objects and at the same they are type-safe too.

Do remember that there are some points, which will describe the difference between Generics and Non-Generic which are tabulated below in order to get a crisp understanding between them.  

Please Login to comment...

Similar reads.

• Java-Collections
• Technical Scripter 2018
• Difference Between
• Technical Scripter

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Piramal Pharma aims to grow innovation business faster than generics

Nandini piramal, chairperson of company expects an early teens growth in both revenue and earnings before interest, tax, depreciation, and amortisation (ebitda) this financial year..

Share Market Live

• Updated Terms of Use
• New Privacy Policy
• Your Privacy Choices
• Closed Captioning Policy

Quotes displayed in real-time or delayed by at least 15 minutes. Market data provided by  Factset . Powered and implemented by  FactSet Digital Solutions .  Legal Statement .

This material may not be published, broadcast, rewritten, or redistributed. ©2024 FOX News Network, LLC. All rights reserved. FAQ - New Privacy Policy

With Flovent inhaler off the market, some parents face challenges in getting generics for kids with asthma

Asthma and allergy specialists explain why some families are paying more for medications.

Drug, pharmaceutical supply chain 'is a mess': Dr. Marc Siegel

Fox News medical contributor Dr. Marc Siegel discusses a new bill around insured mammograms and an ongoing national drug shortage.

After Flovent, one of the most popular inhalers for treating childhood asthma, was discontinued this past January, some parents are reporting challenges in obtaining the generic versions of the medication.

Both versions are identical medications and manufactured by the same pharmaceutical company, GSK, which is based in London.

"Effective Jan. 1, 2024, and subsequent to the availability of these authorized generics, GSK will discontinue manufacturing branded Flovent HFA (all strengths) and branded Flovent Diskus (all strengths) for the U.S. market," GSK said in a statement in the fall of 2023.

WITH POPULAR ASTHMA INHALER NOW DISCONTINUED, WHAT OTHER OPTIONS DO PATIENTS HAVE?

"It’s important to understand that the transition from branded to authorized generics will not have an impact on our ability to supply the market, and we expect minimal disruption for patients," the company added.

Most insurance plans likely will replace Flovent with a generic version, but some customers may experience delays if their insurance doesn’t cover the generic, the Asthma and Allergy Foundation of America (AAFA) says on its website.

GSK discontinued manufacturing the Flovent inhaler in the U.S. as of Jan. 1, 2024. (Getty Images / Getty Images)

"The U.S. has a complicated drug pricing ecosystem," said Kenneth Mendez, president and CEO of AAFA, in a statement the foundation shared with FOX Business. 

"The U.S. has a complicated drug pricing ecosystem."

"Drug manufacturers, pharmacy benefit managers, insurance companies, employers and federal policies can create situations that reduce access to critical medications for patients," he added.

Here’s what to know about the transition from the brand name to the generic version of Flovent.

Generic versions vs. Flovent

Asthma is a chronic lung condition characterized by narrowing and inflammation of the airways, according to the National Institutes of Health (NIH).

Bronchodilators, such as albuterol, help dilate the airways, while inhaled steroids like Flovent help control lung inflammation.

Some patients with asthma need to take inhaled steroids daily to prevent worsening of respiratory symptoms.

Asthma is a chronic lung condition characterized by narrowing of the airways and inflammation surrounding the airways, according to the National Institutes of Health. (iStock / iStock)

GSK noted that the authorized generic versions of Flovent contain the same medicine – in the same device and with the same instructions – as the name-brand version.

"We have seen the price of Flovent increase. The price of Flovent HFA, fluticasone propionate HFA and Flovent Diskus has risen 47% since 2014," Tori Marsh, director of research at GoodRx, who is based in Colorado, told Fox News Digital.

"Usually when we see brand drugs discontinued in favor of generics, it’s to create lower prices for consumers."

PFIZER SCRAPS TWICE-DAILY WEIGHT LOSS PILL DANUGLIPRON AFTER STUDY SHOWS ‘HIGH RATES’ OF ADVERSE SIDE EFFECTS

When medications become generics, multiple manufacturers can produce them, which creates more competition, she said.

Yet consumers don’t always see these savings because insurance coverage plays a big role in determining what they will actually pay at the pharmacy, Marsh added.

If the insurance plan doesn’t cover the generic fluticasone, AAFA recommends requesting a "formulary exception" to determine whether the provider will opt to cover the inhaler. 

GSK noted that the authorized generic versions of Flovent contain the same medicine, in the same device and with the same instructions as the name-brand version. (Getty Images / Getty Images)

If the insurance plan still will not cover the generic, providers will look for alternative brands of inhalers, like ArmonAir Digihaler and Arnuity Ellipta, according to AAFA.

When insurance only covers a different generic inhaler, but not generic Flovent, this is when customers typically see large price discrepancies, Marsh said.

Reactions to the switch

Some users are discussing on social media how the switch is affecting their children .

One reported that a pharmacy had difficulty maintaining a consistent supply of the drug.

"And as a bonus, my insurance still charges me the same copay as a brand-name medication," a frustrated user wrote on Reddit.

NARCAN NASAL SPRAY IS AVAILABLE FOR OVER-THE-COUNTER PURCHASE IN US: ‘LIFESAVING DRUG’

Other parents have not noticed any difficulties with the switch.

One user said they're using the generic version, while another "just noticed that my son has actually been on the generic [version] for a while … He has not noticed a difference."

Another parent expects her child’s doctor to switch the child to Arnuity, "which is basically the same thing."

"I expect this to have minimal effect on her."

Differences between inhaler types

"The type of device and type of medicine can impact effectiveness on individual patients," Mendez told Fox News Digital.

Two common types of inhalers are meter dose inhalers (MDIs) or dry powder inhalers (DPIs) — but they are not used the same way, AAFA cautioned.

If children are switched to a different brand of inhaler, they may be forced to use a different type, an expert noted. (iStock / iStock)

An MDI sprays a pre-set amount of medicine through the mouth into the airway, according to Cleveland Clinic’s website.

When the canister is pressed down, a propellant helps the medicine get into the lungs .

Some children have difficulty with this step because they must take a deep breath right as they press down on the canister, so the medicine may stay at the back of the throat instead of entering the lungs, Cleveland Clinic stated.

DELTA AIR LINES BACKS FLIGHT ATTENDANT WHO DENIED PASSENGER’S ALLERGY ACCOMMODATION

Children often have an easier time using an MDI attached to a small cylinder-shaped tube known as spacer, according to the American Lung Association.

After the inhaler is attached to the end of the spacer, the child seals the lips tightly around the rubber ring on the other end.

Instead of having to synchronize a deep breath while pressing down on the inhaler, the child can take more normal breaths after the inhaler is pressed.

GSK, the pharmaceutical company that made Flovent, is based in London. (iStock / iStock)

The spacer whistles to warn the child when they are breathing too fast to get the medicine to their lungs.

If a child is switched to a different brand of inhaler, he or she may be forced to use a DPI inhaler instead of an MDI, Mendez noted.

"A DPI is breath-actuated, meaning that a patient needs to be able to adequately breathe in the medicine and properly use the diskus device," he said.

CLICK HERE TO SIGN UP FOR OUR HEALTH NEWSLETTER

Pulmicort, an inhaler in the same class of inhaled corticosteroids but with a different active ingredient than Flovent, only comes as a DPI.

The medicine is stored as a powder, but the inhaler does not contain a propellant to push the medicine into the lungs, so the patient must take a deep breath to use the inhaler properly, according to Cleveland Clinic.

GET FOX BUSINESS ON THE GO BY CLICKING HERE

"DPIs can be challenging to use for children, seniors who may lack dexterity , or those with severe asthma who cannot breathe deeply enough to get the medicine into their lungs," Mendez said. 

Fox News Digital reached out to GSK, maker of Flovent, requesting comment.

For more Health articles, visit www.foxnews/health .

Dr. Reddy's (RDY) Q4 Earnings Top, North America Sales Grow

Dr. Reddy's Laboratories Limited RDY reported fourth-quarter fiscal 2024 earnings of 94 cents per American Depositary Share (ADS), which beat the Zacks Consensus Estimate of 86 cents per ADS. In the year-ago quarter, the company reported earnings of 69 cents per ADS.

Revenues grew 12% year over year to $850 million, surpassing the Zacks Consensus Estimate of $825 million. The year-over-year improvement was primarily driven by growth in global generics revenues in North America as well as Emerging Markets.

Shares of the company have gained 2.5% year to date compared with the industry’s 5% growth.

Image Source: Zacks Investment Research

Quarter in Detail

Dr. Reddy’s reports revenues under three segments: Global Generics, Pharmaceutical Services & Active Ingredients (PSAI) and Others.

Global Generics revenues were INR 61.2 billion, up 13% year over year, in the fiscal fourth quarter. The increase was primarily driven by new product launches and increased volumes of the company’s existing core products, partially offset by price erosion in certain markets.

During the reported quarter, Dr. Reddy’s launched five new products in the North America region, of which four were unveiled in the United States.

As of Mar 31, 2024, cumulatively, 86 generic filings were pending approval from the FDA (81 abbreviated new drug applications and five new drug applications). Of these 86 pending filings, 50 are Para IVs.

PSAI revenues were INR 8.2 billion, up 6% from the year-ago quarter. The improvement was fueled by revenues from new products and favorable forex rates, partly offset by price decline.

Revenues in the Others segment came in at INR 1.4 billion, up 54% year over year.

Gross margin improved to 58.6% from 57.2% in the year-ago quarter due to a rise in product mix and productivity cost savings.

Research and development expenses jumped 28% year over year to $83 million, driven by increased spending in ongoing clinical studies on differentiated assets and other developmental efforts.

Selling, general and administrative expenses were $246 million, up 14% year over year, primarily owing to investments in business growth and other initiatives.

Fiscal 2024 Results

Revenues in fiscal 2024 came in at $3.3 billion, up 14% from fiscal 2023. Earnings per share totaled $4.01 compared with $3.25 in fiscal 2023.

Dr. Reddy's Laboratories Ltd Price, Consensus and EPS Surprise

Dr. Reddy's Laboratories Ltd price-consensus-eps-surprise-chart | Dr. Reddy's Laboratories Ltd Quote

Pipeline Updates

RDY received a Complete Response Letter from the FDA for its biologics license application for a proposed biosimilar of rituximab.

During the fourth quarter, the company entered into an exclusive partnership with Sanofi to promote and distribute its vaccine brands in India. RDY also partnered with Bayer to distribute the second brand of heart failure management drug, vericiguat, in India.

Dr. Reddy’s fourth-quarter results were better than expected. The generic of blockbuster oncology drug Revlimid boosted the results.

However, investors were not impressed, and shares were down 4.73% post the earnings announcement. The lack of near-term catalysts remains a woe.

Zacks Rank and Stocks to Consider

Dr. Reddy’s currently carries a Zacks Rank #4 (Sell).

Some better-ranked stocks from the healthcare industry are Ligand Pharmaceuticals LGND, ANI Pharmaceuticals ANIP and BridgeBio Pharma BBIO. While LGND sports a Zacks Rank #1 (Strong Buy), ANIP & BBIO carry a Zacks Rank #2 (Buy) each at present. You can see the complete list of today’s Zacks #1 Rank stocks here .

In the past 30 days, the Zacks Consensus Estimate for Ligand’s 2024 and 2025 earnings per share (EPS) has remained constant at $4.56 and $5.27, respectively. Shares of LGND are up 2.5% year to date.

In the past 60 days, estimates for ANI Pharmaceuticals’ 2024 EPS have improved from $4.40 to $4.44. Shares of ANIP have jumped 21% year to date. ANIP’s earnings beat estimates in each of the trailing four quarters, delivering an average surprise of 109.06%.

In the past 30 days, the Zacks Consensus Estimate for BBIO’s 2024 loss per share has narrowed from $3.61 to $3.12. BBIO beat estimates in one of the trailing four quarters and missed the mark on the other three occasions, delivering an average surprise of 11.73%.

To read this article on Zacks.com click here.

Robinsons Retail to ramp up supermarket, drugstore expansion in provinces

Robinsons Retail Holdings Inc. (RRHI), a member of the Gokongwei Group, is seeking to accelerate its expansion outside of Metro Manila—mainly through its supermarket and drugstore businesses.

During the firm’s annual stockholders’ meeting, RRHI President and CEO Robina Gokongwei-Pe said that, “With 30 percent of our stores located in Metro Manila, we want to accelerate our expansion outside the capital. In terms of formats, were looking to open more of our core supermarket and drugstore banners."

RRHI’s supermarket business consists of Robinsons Supermarket, The Marketplace (acquired from Rustans), and Robinsons Easymart. It also owns Southstar Drug, TGP (The Generics Pharmacy), and Rose Pharmacy.

Amid stiff competition in the supermarket business, particularly from the emerging hard discount stores, Gokongwei-Pe said RRHI intends to maintain market share by continuing to differentiate by “offering a wide range of relevant products and providing an exceptional shopping experience either offline or online.”

She also noted that, “Our margins should remain intact as we continuously enhance our product mix and gain more scale.”

Meanwhile, Gokongwei-Pe said “We have entered the hard discount category through a stake in O! Save which is aggressively expanding.”

But she pointed out, “That hard discounters’ focus on small pack sizes and sachets, versus our core supermarket formats that offer regular and large pack sizes, suggests that there is limited pricing pressure for some products.”

For its drugstore business, Gokongwei-Pe said that its aspiration for the segment is to simply "become more accessible to our customers" to boost its market share and brand value. 

“We believe there is opportunity to increase market coverage for all our banners, as there are a lot of municipalities and barangays in the Philippines that still lack drugstores. In terms of major acquisitions. We are always on the lookout for value accretive M&As should there be an opportunity, we will be ready to capitalize,” she added.