Suppose a class X is extended directly or indirectly by the bean class of a managed bean or session bean Y.

A scope type explicitly declared by X and inherited by Y from X takes precedence over default scopes of stereotypes declared or inherited by Y.

For annotations defined by the application or third-party extensions, it is recommended that:

All scope types, qualifier types, and interceptor binding types defined by this specification adhere to these recommendations.

The stereotypes defined by this specification are not declared @Inherited.

However, in special circumstances, these recommendations may be ignored.

Note that the @Named annotation is not declared @Inherited and bean EL names are not inherited unless specialization is used.

Suppose a class X is extended directly or indirectly by the bean class of a managed bean or session bean Y.

If X is a generic type, and an injection point, producer method, producer field, disposer method or observer method declared by X is inherited by Y, and the declared type of the injection point, producer method, producer field, disposed parameter or event parameter contains type variables declared by X, the type of the injection point, producer method, producer field, disposed parameter or event parameter inherited in Y is the declared type, after substitution of actual type arguments declared by Y or any intermediate class that is a subclass of X and a superclass of Y.

For example, the bean DaoClient has an injection point of type Dao<T>.

public class DaoClient<T> {
	
    @Inject Dao<T> dao;
    ...

}

This injection point is inherited by UserDaoClient, but the type of the inherited injection point is Dao<User>.

public class UserDaoClient 
        extends DaoClient<User> { ... }

If two beans both support a certain bean type, and share at least one qualifier, then they are both eligible for injection to any injection point with that declared type and qualifier.

Consider the following beans:

@Default @Asynchronous 
public class AsynchronousService implements Service { 
    ... 
}

@Alternative 
public class MockAsynchronousService extends AsynchronousService { 
    ... 
}

Suppose that the MockAsynchronousService alternative is declared in the beans.xml file of some bean archive, as defined in Section 5.1, “Modularity”:

<beans xmlns="http://java.sun.com/xml/ns/javaee"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/beans_1_0.xsd">
   <alternatives>
      <class>org.mycompany.mock.MockAsynchronousService</class>
   </alternatives>
</beans>

Then, according to the rules of Section 5.2.1, “Unsatisfied and ambiguous dependencies”, the following ambiguous dependency is resolvable, and so the attribute will receive an instance of MockAsynchronousService:

@Inject Service service;

However, the following attribute will receive an instance of AsynchronousService, even though MockAsynchronousService is a selected alternative, because MockAsynchronousService does not have the qualifier @Asynchronous:

@Inject @Asynchronous Service service;

This is a useful behavior in some circumstances, however, it is not always what is intended by the developer.

The only way one bean can completely override a second bean at all injection points is if it implements all the bean types and declares all the qualifiers of the second bean. However, if the second bean declares a producer method or observer method, then even this is not enough to ensure that the second bean is never called!

To help prevent developer error, the first bean may:

explicitly declare that it specializes the second bean.

@Alternative @Specializes
public class MockAsynchronousService extends AsynchronousService { 
    ... 
}

When an enabled bean, as defined in Section 5.1.2, “Enabled and disabled beans”, specializes a second bean, we can be certain that the second bean is never instantiated or called by the container. Even if the second bean defines a producer or observer method, the method will never be called.

@Mock @Specializes
public class MockAsynchronousService extends AsynchronousService { 
    ... 
}

@Default @Asynchronous @Named("asyncService")
public class AsynchronousService implements Service{ 
    ... 
}