anchor.diff:  		public SimpleMovieLister(MovieFinder movieFinder) {
   			this.movieFinder = movieFinder;
   		}
  -
   	}
   ----
   
  
positive.code: 		public void afterPropertiesSet() {
  			// do some initialization work
  		}
  
  	}
  ----
  
  
negative.code: ----
  transferService -> com.acme.TransferServiceImpl
  ----
  
  You may also declare your `@Bean` method with an interface (or base class)
  return type:
  
  [source,java,indent=0]
  [subs="verbatim,quotes"]
  ----
  	@Configuration
  	public class AppConfig {
  
  		@Bean
  		public TransferService transferService() {
  			return new TransferServiceImpl();
  		}
  	}
  ----
  
  However, this limits the visibility for advance type prediction to the specified
  interface type (`TransferService`) then, with the full type (`TransferServiceImpl`)
  only known to the container once the affected singleton bean has been instantiated.
  Non-lazy singleton beans get instantiated according to their declaration order,
  so you may see different type matching results depending on when another component
  tries to match by a non-declared type (such as `@Autowired TransferServiceImpl`
  which will only resolve once the "transferService" bean has been instantiated).
  
  [TIP]
  ====
  If you consistently refer to your types by a declared service interface, your
  `@Bean` return types may safely join that design decision. However, for components
  implementing several interfaces or for components potentially referred to by their
  implementation type, it is safer to declare the most specific return type possible
  (at least as specific as required by the injection points referring to your bean).
  ====
  
  
  [[beans-java-dependencies]]
  