In Android development, you can handle changes in device orientation by using the following approaches or techniques:

1. Handling Configuration Changes with Lifecycle Events:
Android provides a mechanism to handle configuration changes, including orientation changes, by preserving the activity’s state and recreating it with the new configuration. By default, when a configuration change occurs, the activity is destroyed and recreated. You can override specific lifecycle methods to save and restore the state of your activity, such as `onSaveInstanceState()` and `onRestoreInstanceState()`. These methods allow you to save and retrieve data that is essential to your activity’s state, such as user input, scroll positions, or other variables.

2. Handling Configuration Changes with Manifest Configuration:
In the AndroidManifest.xml file, you can specify `android:configChanges` attribute for your activity to indicate that you want to handle specific configuration changes manually. By specifying this attribute, the activity will not be restarted when the specified configuration changes occur. Instead, the `onConfigurationChanged()` method will be called, and you can handle the configuration changes yourself. You can override this method and update your UI or perform any necessary adjustments based on the new configuration.

3. Using Fragments:
Fragments provide a flexible way to handle configuration changes. When using fragments, you can retain the state of the fragments across configuration changes by calling `setRetainInstance(true)` in the fragment’s `onCreate()` method. This allows the fragment to be detached and reattached to the new activity instance without being destroyed and recreated. The fragment’s UI can be updated accordingly in the `onActivityCreated()` method.

4. Using ViewModel:
ViewModel is part of the Android Architecture Components and is designed to hold and manage UI-related data across configuration changes. ViewModels are not tied to the lifecycle of an activity or fragment and can survive configuration changes. By storing the UI-related data in a ViewModel, you can easily access and update it in the new activity or fragment instance after an orientation change.

5. Saving and Restoring UI State:
You can save the state of UI components manually and restore them after an orientation change. For example, you can save the scroll position of a RecyclerView or ListView and restore it after the activity or fragment is recreated. By saving and restoring the necessary UI state, you can provide a seamless user experience without losing important information.

6. Providing Different Layouts:
In some cases, you may want to provide different layouts for different orientations. By creating separate layout files for portrait and landscape orientations, you can customize the UI layout based on the device’s orientation. Android will automatically load the appropriate layout file based on the current configuration.

These are some of the common approaches used in Android development to handle orientation changes. The choice of approach depends on the specific requirements of your app and the complexity of the UI components involved.