When styles defined in a component affect other components, it's likely that the component is using the "Emulated" (ViewEncapsulation.Emulated) mode. In this mode, Angular emulates the shadow DOM, and styles are scoped to the component, but they can leak out and affect other components. The other options (None, Shadow DOM, Native) have different encapsulation behaviors.

To ensure a single instance of a service is available throughout the app, you should set the providedIn property to 'root'. This means that the service is provided at the application level, and there will be only one instance of the service for the entire app, making it a singleton service that can be injected into multiple components.

To have a child component notify its parent in Angular, you typically use the @Input and @Output decorators. The child component can send data or events to the parent component using @Output, creating a custom event emitter. EventEmitter can be used, but it's often associated with custom events. Subjects are used for more complex scenarios. The ngModelChange event is used for form input changes, not parent-child communication.

To prevent memory leaks in Angular applications when an Observable is no longer needed, it should be unsubscribed. Failing to unsubscribe from Observables can lead to resource leaks, as they may continue to emit values and hold references to objects even after the component or service that used them is destroyed. Properly unsubscribing from Observables ensures that they are cleaned up and do not cause memory issues.

Custom attribute directives in Angular can alter the appearance or behavior of an element without changing its HTML structure. They can manipulate the element's behavior or appearance by binding to its properties or attributes, but they typically do not modify the fundamental structure of the HTML element. This allows for greater flexibility and reusability in Angular applications.

An Observable can emit multiple values over time, whereas a Promise can resolve only once. This fundamental difference makes Observables suitable for handling asynchronous streams of data, while Promises are used for handling single asynchronous operations.

To inject a service into an Angular component, you use the @Injectable() decorator. This decorator is applied to the service class, allowing Angular's dependency injection system to recognize and provide the service when requested by a component. The other options (@Component(), @Service(), @InjectService()) are not used for this purpose.

When using the OnPush change detection strategy in Angular, a component will be checked if a new object reference is passed to one of its inputs. This means that the component will only re-render if there's a change in the input values. The OnPush strategy is an optimization to reduce unnecessary checks and re-renders.

Change detection in Angular can be optimized by ensuring data structures are immutable. Immutable data structures ensure that when changes are made to data, a new reference is created, which helps Angular's change detection mechanism identify changes efficiently. By contrast, mutable data structures may not trigger change detection as expected.

The primary benefit of using lazy loading in Angular applications is faster initial loading. Lazy loading allows you to load only the necessary modules and components when they are needed, reducing the initial bundle size and improving the application's loading speed.