CoroutinesRoom.execute

Case 02 : LiveData<T>

@Query("SELECT * FROM user ORDER BY userId DESC")
fun getAllUsers(): LiveData<List<User>>

// generated Database_Impl.java
@Override
public LiveData<List<User>> getAllUsers() {
    //...
    return __db.getInvalidationTracker().createLiveData(...)
}

Problem

@Entity(tableName = "routines")
data class Routine (
    // other fields ...
        @ColumnInfo(name = "date")
        var date: LocalDate = LocalDate.now()
 )

...Why?

Referencing complex data using Room | Android Developer

Room provides functionality for converting between primitive and boxed types but doesn't allow for object references between entities.

Use type converters

Sometimes, you need your app to store a custom data type in a single database column. You support custom types by providing type converters, which are methods that tell Room how to convert custom types to and from known types that Room can persist. You identify type converters by using the @TypeConverter annotation.

Solution

Test

2. Add @RequiresApi(O) Annotation...?

Problem

...Why?

Use Java 8 language features and APIs | Android developer

If you're building your app using Android Gradle plugin 4.0.0 or higher, the plugin extends support for using a number of Java 8 language APIs without requiring a minimum API level for your app.

This additional support for older platform versions is possible because plugin 4.0.0 and higher extend the desugaring engine to also desugar Java language APIs. So, you can include standard language APIs that were available only in recent Android releases (such as java.util.streams) in apps that support older versions of Android.

Solution

Result

1. Navigating using menus, drawers and bottom navigation

NavigationUI and navigation-ui-ktx

The Navigation Components include a NavigationUI class and navigation-us-ktx kotlin extensions. NavigationUI has static methods that associate menu items with navigation destinations, and navigation-ui-ktx is a set of extenstion functions that do the same. If NavigationUI finds a menu item with the same ID as a destination on the current graph, it configures the menu item to navigate to that destination.

Using NavigationUI with an Options menu

One of the easiest ways to use NavigationUI is to have it simplify option menu setup. In particular, NavigationUI simplifies handling the onOptionsItemSelected callback.

1. Open MainActivity.kt Notice how you already have the code for inflating the menu overflow_menu in onCreateOptionsMenu

   MainActivity.kt

   

2. Open res/menu/overflow_menu.xml

3. Update your overflow menu to include the settings_dest

   overflow_menu.xml

   

   

4. Open MainActivity.kt

5. Have NavigationUI handle onOptionsItemSelected with the onNavDestinationSelected helper method. If the menu item is not meant to navigate, handle with super.onOptionsItemSelected

   MainActivity.kt

   

   

6. Run your app. You should have a functional ActionBar menu that navigates to the SettingsFragment.

Using NavigationUI to configure Bottom Navigation

The coded already contains the XML layout code for implementing bottom navigation, which is why you see the bottom navigation bar. But it doesn't navigate anywhere.

1. Open res/layout/navigation_activity.xml (h470dp) and click the Text tab Notice how the XML layout code for bottom navigation is there and refers to bottom_nav_menu.xml

   navigation_activity.xml (h470dp)

   

2. Open res/menu/bottom_nav_menu.xml Notice how there are two items for bottom navigation and that their ids match the destinations of navigation graph destinations:

   bottom_nav_menu.xml

   

   Let's make the bottom navigation actually do something using NavigationUI.

3. Open MainActivity.kt

4. Implement the setupBottomNavMenu method using setupWithNavController(bottomNavigationView: BottomNavigationView, navController: NavController)

   MainActivity.kt

   

   

Now your bottom navigation works!

Using NavigationUI to configure a Navigation Drawer

Finally, let's use NavigationUI to configure the side navigation and navigation drawer, including handling the ActionBar and proper up navigation. You'll see this if you've got a large enough screen or if the screen's too short for bottom navigation.

First observe how the proper layout XML code is already in the app.

1. Open both navigation_activity.xml and navigation_activity.xml (w960dp)

   Notice how both layouts contain a NavigationView connected to nav_drawer_menu. In the tablet version (w960dp) the NavigationView is always on screen. On smaller devices the NavigationView is nested within a DrawerLayout.

   navigation_activity.xml

   

   navigation_activity.xml (w960dp)

   

   Now to start implementing the NavigationView navigation.

2. Open MainActivity.kt

3. Implement the setupNavigationMenu method using setupWithNavController(navigationView: NavigationView, navController: NavController). Notice how this version of the method takes a NavigationView and not a BottomNavigationView.

   MainActivity.kt

   

   

   Now the navigation view menu will show on the screen, but it will not affect the ActionBar.

   Setting up the ActionBar requires creating an instance of AppBarConfiguration. The purpose of AppBarConfiguration is to specify the configuration options you want for your toolbars, collapsing toolbars, and action bars. Configuration options include whether the bar must handle a drawer layout and which destinations are considered top-level destinations.

   Top-level destinations are the root-level destinations of your app. These destinations do not display an "up" button in the app bar, and they display the drawer icon if the destination uses a drawer layout.

   

4. Create an AppBarConfiguration by passing in a set of top-level destination IDs and the drawer layout.

   MainActivity.kt

   

   

   How to determine top-level destinations

   Destinations reachable via global navigation UI, such as bottom nav or side nav, all appear to users as on the same top level of the hierarchy. Therefore, they are top level destinations. home_dest and deeplink_dest are in the bottom nav and we want the drawer icon to show on both of these destinations, so they are top-level destinations.

   Note that the start destination is always considered a top-level destination. If you don't specify a list of top-level destinations, then the only top-level destination is your start destination. You can learn more about AppBarConfiguration in the documentation.

   Now that you have an AppBarConfiguration, you can call NavigationUI.setupActionBarWithNavController. This will do the following:

   • Show a title in the ActionBar based off of the destination's label

   • Display the Up button whenever you're not on a top-level destination

   • Display a drawer icon (hamburger icon) when you're on a top-level destination

5. Implement setupActionBarWithNavController

   MainActivity.kt

   

   

   You should also have NavigationUI handle what happens when the Up button is pressed.

6. Override onSupportNavigateUp and call NavigationUI.navigateUp, using the same AppBarConfiguration.

   MainActivity.kt

   
   

7. Run your code. If you open the app in split screen, you should have a working navigation drawer. The up icon and the drawer icon should display at the appropriate times and work correctly.

   Notice

   The layout navigation_activity.xml (h470dp) will be used on phones in portrait mode. This layout does not include the navigation drawer and instead includes the bottom navigation, which is why you should open the app in split screen to see the navigation drawer. The reason there is not a layout with both a navigation drawer and bottom navigation is because Material Design guidelines cautions against this.

   

   Adding new destinations to a NavigationView is easy. Once you have the navigation drawer working with up and back navigation, you just need to add the new menu item.

8. Open menu/nav_drawer_menu.xml

9. Add a new menu item for setting_dest

   nav_drawer_menu.xml

   

   Now your navigation drawers shows the Settings screen as a destination.

   

2. Deep Linking to a destination

Deep Links and Navigation

Navigation components also include deep link support. Deep links are a way to jump into the middle of your app's navigation, whether that's from an actual URL link or a pending intent from a notification.

One benefit of using the navigation library to handle deep links is that it ensures users start on the right destination with the appropriate back stack from other entry points such as app widgets, notifications, or web links (covered in the next step).

Navigation provides a NavDeepLinkBuilder class to construct a PendingIntent that will take the user to a specific destination.

Add a Deep Link

We'll use the NavDeepLinkBuilder to hook up an app widget to a destination.

1. Open DeepLinkAppWidgetProvider.kt

2. Add a PendingIntent constructed with NavDeepLinkBuilder:

   DeepLinkAppWidgetProvider.kt

   

   

   

   

   Notice:

   • setGraph includes the navigation graph.
   • setDestination specifies where the link goes to.
   • setArguments includes any arguments you want to pass into your deep link.

   By default NavDeepLinkBuilder will start your launcher Activity. You can override this behavior by passing in an activity as the context or set an explicit activity class via setComponentName().

3. Add the Deep Link widget to your home screen.

4. Tap the widget, and verify that the Android destination opens with the correct argument. It should say "From Widget" at the top since that is the argument you passed in DeepLinkAppWidgetProvider.

5. Verify that hitting the back button takes you to the home_dest destination.

As a convenience, you can also call NavController's createDeepLink() method to use the Context and current navigation graph from the NavController.

DeepLink Backstack

The backstack for a deep link is determined using the navigation graph you pass in. If the explicit Activity you've chosen has a parent activity, those parent Activities are also included.

The backstack is generated using the destinations specified with app:startDestination. In this app we only have one activity and one level of navigation, so the backstack will take you to the home_dest destination.

More complicated navigation can include nested navigation graphs. The app:startDestination at each level of the nested graphs determines the backstack. For more information on deep links and nested graphs, check out the Principles of Navigation.

3. Associating a web link with a destination

The <deepLink> element

One of the most common uses of a deep link is to allow a web link to open an activity in your app. Traditionally you would use an intent-filter and associate a URL with the activity you want to open.

The navigation library makes this extremely simple and allows you to map URLs directly to destinations in your navigation graph.

<deepLink> is an element you can add to a destination in your graph. Each <deepLink> element has a single required attribute: app:uri.

In addition to a direct URI match, the following features are supported:

• URIs without a scheme are assumed to be http and https. For example, www.example.com will match http://www.example.com and https://www.example.com.

• You can use placeholders in the form of {placeholder_name} to match one or more characters. The String value of the placeholder is available in the arguments Bundle which has a key of the same name. For example, http://www.example.com/users/{id} will match http://www.example.com/users/4.

• You can use the .* wildcard to match zero or more characters.

• NavController will automatically handle ACTION_VIEW intents and look for matching deep links.

Add a URIbased Deep Link using <deepLink>

In this step, you'll add a deep link to www.example.com

1. Open mobile_navigation.xml

2. Add a <deepLink> element to the deeplink_dest destination.

   mobile_navigation.xml

   

3. Open AndroidManifest.xml

4. Add the nav-graph tag. This will ensure the appropriate intent filter is generated

   AndroidManifest.xml

   

   

5. Launch your app using a deep link. There are two ways to do this:

   • Use adb :

   • Navigate via the Google app. You should be able to put www.example.com/urlTest in the search bar and the disambiguation window will appear. Select Navigation codelab

     Either way, you should see the message "urlTest" on screen. This was passed through to the fragment, from the URL.

     

Learn more | Google Codelabs

Reference Android Navigation | Android developers Jetpack Navigation | Google Codelabs

1. Overview of Navigation

The Navigation Component consists of three key parts, working together. They are:

1. Navigation Graph (New XML resource) - This is a resource that contains all navigation-related information in one centralized location. This includes all the places in your app, known as destinations, and possible paths a user could take through your app.

2. NavHostFragment (Layout XML view) - This is a special widget you add to your layout. It displays different destinations from your Navigation Graph.

3. NavController (Kotlin/Java object) - Ths is an object that keeps track of the current position within the navigation graph. It orchestrates swapping destination content in the NavHostFragment as you move through a navigation graph.

When you navigate, you'll use the NavController object, telling it where you want to go or what path you want to take in your Navigation Graph. The NavController will then show the appropriate destination in the NavHostFragment.

2. Introducing the Navigation Graph

Destinations

The Navigation Component introduces the concept of a destination. A destination is any place you can navigate to in your app, usually a fragment or an activity. These are supported out of the box, but you can also make your own custom destination types if needed.

Navigation Graph

A navigation graph is a new resource type that defines all the possible paths a user can take through an app. It shows visually all the destinations that can be reached from a given destination. Android Studio displays the graph in its Navigation Editor. Here's part of the starting navigation graph you'll create for your app:

Exploring the Navigation Editor

1. Open res/navigation/mobile_navigation.xml

2. Click Design to go into Design mode The navigation graph shows the available destinations. The arrows between the destinations are called actions. You'll learn more about actions later.

3. Click on a destination to see its attributes.

4. Click on any action, represented by an arrow, to see its attributes.

Anatomy of a navigation XML file

All of the changes you make in the graphical Navigation Editor change the underlying XML file, similar to the way the Layout Editor modifies the layout XML.

Click the Text tab and you'll see some XML like this:

Notice:

• <navigation> is the root node of every navigation graph.

• <navigation> contains one or more destinations, represented by <activity> or <fragment> elements.

• app:startDestination is an attribute that specifies the destination that is launched by default when the user first opens the app.

Let's take a look at fragment destination:

Notice:

• android:id defines an ID for the fragment that you can use to reference the destination elsewhere in this XML and your code.

• android:name declares the fully qualified class name of the fragment to instantiate when you navigate to that destination.

• tools:layout specifies what layout should be shown in the graphical editor.

Some <fragment> tags also contain <action>, <argument> and <deepLink>, all of which we'll cover later.

3. Add a Destination to the Navigation Graph

You must add a destination to the navigation graph before you can navigate to it.

1. Open res/navigation/mobile_navigation.xml, and click the Design tab.

2. Click the New Destination icon, and select settings_fragment

The result is a new destination, which renders a preview of the fragment's layout in the design view.

Note : You can also edit the XML file directly to add destinations: To follow our naming convention, change the id to settings_dest from the default settingsFragment.

4. Using the Navigation Graph to Navigate

Activities and Navigation

The Navigation component follows the guidance outlined in the Principles of Navigation. The Principles of Navigation recommend you use activities as entry points for your app. Activities will also contain global navigation, such as the bottom nav,

In comparison, fragments will be the actual destination-specific layouts.

To get this all to work, you need to modify your activity layouts to contain a special widget called a NavHostFragment. A NavHostFragment swaps different fragment destinations in and out as you navigate through the navigation graph.

A simple layout supporting navigation similar to the picture above looks like this. An example of this code can be found in res/layout-470dp/navigation_activity.xml:

Notice:

• This is a layout for an activity. It contains the global navigation, including a bottom nav and a toolbar.

• android:name="androidx.navigation.fragment.NavHostFragmnet" and app:defaultNavHost="true" connect the system back button to the NavHostFragment

• app:navGraph="@navigation/mobile_navigation" associates the NavHostFragment with a navigation graph. This navigation graph specifies all the destinations the user can navigate to, in this NavHostFragment.

NavController

Finally, when a user does something like clicking a button, you need to trigger a navigate command. A special class called the NavController is what triggers the fragment swaps in the NavHostFragment.

Note that you pass in either a destination or action ID to navigate. These are the IDs defined in the navigation graph XML. This is an example of passing in a destination ID.

NavController is powerful because when you call methods like navigate() or popBackStack(), it translates these commands into the appropriate framework operations based on the type of destination you are navigating to or from. For example, when you call navigate() with an activity destination, the NavController calls startActivity() on your behalf.

There are a few ways to get a NavController object associated with your NavHostFragment. In Kotlin, it's recommended you use one of the following extension functions, depending on whether you're calling the navigation command from within a fragment, activity or view:

• Fragment.findNavController()

• View.findNavController()

• Activity.findNavController()

Your NavController is associated with a NavHostFragment. Thus whichever method you use, you must be sure that the fragment, view, or view ID is either a NavHostFragment itself, or has a NavHostFragment as a parent. Otherwise you will get an IllegalStateException.

Navigate to a Destination with NavController

It's your turn to navigate using NavController. You'll hook up the Navigate To Destination button to the flow_step_one_dest destination (which is a destination that is a FlowStepFragment:

1. Open HomeFragment.kt

2. Hook up the navigate_destination_button in onViewCreated()

3. Run the app and click the Navigate To Destination button. Note that the button navigates to the flow_step_one_dest destination.

You can also use the convenience method Navigation.createNavigateOnClickListener(@IdRes destId: Int, bundle: Bundle). This method will build an OnClickListener to navigate to the given destination with a bundle of arguments to be passed to the destination.

The click listener code would look like this:

5. Changing the Navigation Transition

Each navigate() call has a not very exciting default transition associated with it, as seen below:

The default transition, as well as other attributes associated with the call, can be overridden by including a set of NavOptions. NavOptions uses a Builder pattern which allows you to override and set only the options you need. There's also a ktx DSL for NavOptions, which is what you'll be using.

For animated transitions, you can define XML animation resources in the anim resource folder and then use those animations for transitions. Some examples are included in the app code:

Add a Custom Transition

Update the code so that pressing the Navigate To Destination button shows a custom transition animation.

1. Open HomeFragment.kt

2. Define a NavOptions and pass it into the navigate() call to navigate_destination_button

3. Remove the code added in step 5, if it's still there

4. Verify that tapping the Navigate To Destination button causes the fragment to slide onto the screen and back causes it to slide off the screen

6. Navigate using actions

Actions

The navigation system also allows you to navigate via actions. As previously mentioned, the lines shown in the navigation graph are visual representations of actions.

Navigation by actions has the following benefits over navigation by destination:

• You can visualize the navigation paths through your app

• Actions can contain additional associated attributes you can set, such as a transition animation, arguments values, and backstack behavior

• You can use the plugin safe args to navigate, which you'll see shortly

Here's the visual and XML for the action that connects flow_step_one_dest and flow_step_two_dest:

Notice:

• The actions are nested within the destination - this is the destination you will navigate from

• The action includes a destination argument referring to flow_step_two_dest; this is the ID of where you will navigate to

• The ID for the action is next_action

Here is another example of the action connecting flow_step_two_dest to home_dest

Notice:

• The same ID next_action is used for the action connecting flow_step_two_dest to home_dest. You can navigate using the next_action id from either flow_step_one_dest or flow_step_two_dest. This is an example of how actions can provide a level of abstraction and can navigate your somewhere different depending on context.

• The popUpTo attribute is used - this action will pop fragments off of the back-stack until you reach home_dest

Navigate with an Action

Time to hook up the Navigate with Action button so that it lives up to its name!

1. Open the mobile_navigation.xml file in Design mode

2. Drag an arrow from home_dest to flow_step_two_dedst:

3. With the action arrow selected change the properties of the action so that:

4. Click the Text tab Note the newly added next_action action under the home_dest destination.

5. Open HomeFragment.kt

6. Add a click listener to the navigate_action_button

   Actions allow you to attach NavOptions in the navigation XML file, rather than specifying them programmatically.

7. Verify that tapping the Navigate To Action now navigates to the next screen.

7. Using safe args for navigation

Safe Args

The navigation component has a Gradle plugin, called safe args, that generates simple object and builder classes for type-safe access to arguments specified for destinations and actions.

Safe args allows you to get rid of code like this when passing values between destinations:

And, instead, replace it with code that has generated setters and getters.

Because of its type safety, navigation using safe args generated classes is the preferred way to navigate by action and pass arguments during navigation.

Pass a value using safe args

1. Open the project build.gradle file and notice the safe args plugin:

   build.gradle

   

2. Open the app/build.gradle file and notice the applied plugin:

   app/build.gradle

   

3. Open mobile_navigation.xml and notice how arguments are defined in the flow_step_one_dest destination.

   mobile_navigation.xml

   

   Using the <argument> tag, safeargs generates a class called FlowStepFragmentArgs.

   

   Since the XML includes argument called flowStepNumber, specified by android:name="flowStepNumber", the generated class FlowStepFragmentArgs will include variable flowStepNumber with getters and setters.

   

4. Open FlowStepFragment.kt

5. Comment out the line of code shown below:

   FlowStepFragment.kt

   

   This old-style code is not type-safe. It's better to use safe args.

6. Update FlowStepFragment to use the code generated class FlowStepFragmentArgs. This will get the FlowStepFragment arguments in a type-safe manner:

   FlowStepFragment.kt

   

   

Safe Args Direction classes

You can also use safe args to navigate in a type safe way, with or without adding arguments. You do this using the generated Directions classes.

Directions classes are generated for every distinct destination with actions. The Directions class includes methods for every action a destination has.

For example, the navigate_action_button click listener in HomeFragment.kt could be changed to:

HomeFragment.kt

Note that in your navigation graph XML you can provide a defaultValue for each argument. If you do not then you must pass the argument into the action, as shown:

HomeFragmentDirections.nextAction(flowStepNumberArg)

Next | Jetpack Navigation 02

Implementation Example

Iterable vs Sequence

Iterable

• Multi-step processing of iterables is executed eagerly.

• Each processing step completes and retruns its result - an intermediate collection.

• The following step executes on this collection(an intermediate collection). > >
• The order of operations execution :
  • Iterable completes each step for the whole collection and then proceeds to the next step.

    Sequence

• Multi-step processing of sequences is executed lazily when possible.

• Actual computing happens only when the result of the whole processing chain is requested.

• The order of operations execution:
  • Sequence performs all the processing steps one-by-one for every single element.

So, the sequences let you avoid building results of intermediate steps, therefore improving the performance of the whole collection processing chain. However, the lazy nature of sequences adds some overhead which may be significant when processing smaller collections or doing simpler computations. Hence, you should consider both Sequence and Iterable and decide which one is better for your case.

Constructing

From elements

To create a sequence, call the sequenceOf() function listing the elements as its arguments:

From Iterable

If you already have an Iterable object (such as a List or a Set), you can create a sequence from it by calling asSequence():

From function

One more way to create a sequence is by building it with a function that calculates its elements. To build a sequence based on a function, call generateSequence() with this function as an argument. Optionally, you can specify the first element as an explicit value or a result of a function call. The sequence generation stops when the provided function returns null. So, the sequence in the example below is infinite:

To create a finite sequence with generateSequence(), provide a function that returns null after the last element you need:

Note : generateSequence() & GeneratorSequence class

From chunks

Finally, there is a function that lets you produce sequence elements one by one or by chunks of arbitrary sizes - the sequence() function. This function takes a lambda expression containing calls of yield() and yieldAll() functions. They return an element to the sequence consumer and suspend the execution of sequence() until the next element is requested by the consumer.

• yield() takes a single element as an argument

• yieldAll() can take

  • an Iterable object,

  • an Iterator,

  • or another Sequence (it can be infinite - such a call must be the last: all subsequent calls will never be executed).

Sequence operations

The sequence operations can be classified into the following groups regarding their state requirements:

• Stateless operations require no state and process each element independently, for example, map() or filter(). Stateless operations can also require a small constant amount of state to process an element, for example, take() or drop().

• Stateful operations require a significant amount of state, usually proportional to the number of elements in a sequence.

If a sequence operation returns another sequence, which is produced lazily, it's called intermediate. Otherwise, the operation is terminal. Examples of terminal operations are toList() or sum(). Sequence elements can be retrieved only with terminal operations.

Sequences can be iterated multiple times; however some sequence implementations might constrain themselves to be iterated only once. That is mentioned specifically in their documentation.

Sequence processing example

Let's take a look at the difference between Iterable and Sequence with an example.

Iterable

Assume that you have a list of words. The code below filters the words longer than three characters and prints the lengths of first four such words.

When you run this code, you'll see that the filter() and map() functions are executed in the same order as they appear in the code. First, you see filter: for all elements, then length: for the elements left after filtering, and then the output of the two last lines. This is how the list processing goes:

Sequence

Now let's write the same with sequences:

The output of this code shows that the filter() and map() functions are called only when building the result list. So, you first see the line of text “Lengths of..” and then the sequence processing starts. Note that for elements left after filtering, the map executes before filtering the next element. When the result size reaches 4, the processing stops because it's the largest possible size that take(4) can return.

The sequence processing goes like this: In this example, the sequence processing takes 18 steps instead of 23 steps for doing the same with lists.

The Kotlin Standard Library provides implementations for basic collection types: sets, lists, and maps. A pair of interfaces represent each collection type:

• A read-only interface that provides operations for accessing collection elements.
• A mutable interface that extends the corresponding read-only interface with write operations: adding, removing, and updating its elements.

Note that altering a mutable collection doesn't require it to be a var: write operations modify the same mutable collection object, so the reference doesn't change. Although, if you try to reassign a val collection, you'll get a compilation error.

The read-only collection types are covariant. This means that, if a Rectangle class inherits from Shape, you can use a List<Rectangle> anywhere the List<Shape>is required. In other words, the collection types have the same subtyping relationship as the element types. Maps are covariant on the value type, but not on the key type.

In turn, mutable collections aren't covariant; otherwise, this would lead to runtime failures. If MutableList<Rectangle>was a subtype of MutableList<Shape>, you could insert other Shape inheritors (for example, Circle) into it, thus violating its Rectangle type argument.

Get familiar with collections

Collection

List

As you see, in some aspects lists are very similar to arrays. However, there is one important difference: an array's size is defined upon initialization and is never changed; in turn, a list doesn't have a predefined size; a list's size can be changed as a result of write operations: adding, updating, or removing elements.

In Kotlin, the default implementation of List is ArrayList which you can think of as a resizable array.

Set

Set<T> stores unique elements; their order is generally undefined. null elements are unique as well: a Set can contain only one null. Two sets are equal if they have the same size, and for each element of a set there is an equal element in the other set.

MutableSet is a Set with write operations from MutableCollection.

The default implementation of Set – LinkedHashSet – preserves the order of elements insertion. Hence, the functions that rely on the order, such as first() or last(), return predictable results on such sets.

An alternative implementation – HashSet – says nothing about the elements order, so calling such functions on it returns unpredictable results. However, HashSet requires less memory to store the same number of elements.

Map

Map<K, V> is not an inheritor of the Collection interface; however, it's a Kotlin collection type as well. A Map stores key-value pairs (or entries); keys are unique, but different keys can be paired with equal values. The Map interface provides specific functions, such as access to value by key, searching keys and values, and so on.

MutableMap is a Map with map write operations, for example, you can add a new key-value pair or update the value associated with the given key.

The default implementation of Map – LinkedHashMap – preserves the order of elements insertion when iterating the map. In turn, an alternative implementation – HashMap – says nothing about the elements order.

Constructing Collections

Constructing from elements

The most common way to create a collection is with the standard library functions listOf<T>(), setOf<T>(), mutableListOf<T>(), mutableSetOf<T>(). If you provide a comma-separated list of collection elements as arguments, the compiler detects the element type automatically. When creating empty collections, specify the type explicitly.

The same is available for maps with the functionsmapOf() and mutableMapOf(). The map's keys and values are passed as Pair objects (usually created with to infix function).

Note that the to notation creates a short-living Pair object, so it's recommended that you use it only if performance isn't critical. To avoid excessive memory usage, use alternative ways. For example, you can create a mutable map and populate it using the write operations. The apply() function can help to keep the initialization fluent here.

Empty collections

Initializer functions for lists

For lists, there is a constructor that takes the list size and the initializer function that defines the element value based on its index.

Note: List() & listOf()

Concreate type constructors

To create a concrete type collection, such as an ArrayList or LinkedList, you can use the available constructors for these types. Similar constructors are available for implementations of Set and Map.

Copying

To create a collection with the same elements as an existing collection, you can use copying operations. Collection copying operations from the standard library create shallow copy collections with references to the same elements. Thus, a change made to a collection element reflects in all its copies.

Collection copying functions, such as toList(), toMutableList(), toSet() and others, create a snapshot of a collection at a specific moment. Their result is a new collection of the same elements. If you add or remove elements from the original collection, this won't affect the copies. Copies may be changed independently of the source as well. These functions can also be used for converting collections to other types, for example, build a set from a list or vice versa.

Collection initialization can be used for restricting mutability. For example, if you create a List reference to a MutableList, the compiler will produce errors if you try to modify the collection through this reference.

Invoking functions on other collections

Collections can be created in result of various operations on other collections. For example, filtering a list creates a new list of elements that match the filter:

Mapping produces a list of a transformation results:

Association produces maps:

Iterators

For traversing collection elements, the Kotlin standard library supports the commonly used mechanism of iterators – objects that provide access to the elements sequentially without exposing the underlying structure of the collection. Iterators are useful when you need to process all the elements of a collection one-by-one, for example, print values or make similar updates to them.

Iterators can be obtained for inheritors of the Iterable<T> interface, including Set and List, by calling the iterator() function. Once you obtain an iterator, it points to the first element of a collection; calling the next() function returns this element and moves the iterator position to the following element if it exists.

*Note : *Once the iterator passes through the last element, it can no longer be used for retrieving elements; neither can it be reset to any previous position. To iterate through the collection again, create a new iterator.

Another way to go through an Iterable collection is the well-known for loop. When using for on a collection, you obtain the iterator implicitly. So, the following code is equivalent to the example above:

Finally, there is a useful forEach() function that lets you automatically iterate a collection and execute the given code for each element. So, the same example would look like this:

List iterators

For lists, there is a special iterator implementation: ListIterator. It supports iterating lists in both directions: forwards and backwards. Backward iteration is implemented by the functions hasPrevious() and previous(). Additionally, the ListIterator provides information about the element indices with the functions nextIndex() and previousIndex().

Having the ability to iterate in both directions, means the ListIterator can still be used after it reaches the last element.

Mutable iterators

For iterating mutable collections, there is MutableIterator that extends Iterator with the element removal function remove(). So, you can remove elements from a collection while iterating it.

In addition to removing elements, the MutableIterator can also insert and replace elements while iterating the list.

Ranges and Progressions

Kotlin lets you easily create ranges of values using the rangeTo() function from the kotlin.ranges package and its operator form ... Usually, rangeTo() is complemented by in or !in functions:

Integral type ranges (IntRange, LongRange, CharRange) have an extra feature: they can be iterated over. These ranges are also progressions of the corresponding integral types. Such ranges are generally used for iteration in the for loops:

To iterate numbers in reverse order, use the downTo function instead of ..:

It is also possible to iterate over numbers with an arbitrary step (not necessarily 1). This is done via the step function:

To iterate a number range which does not include its end element, use the until function:

Range

A range defines a closed interval in the mathematical sense: it is defined by its two endpoint values which are both included in the range. Ranges are defined for comparable types: having an order, you can define whether an arbitrary instance is in the range between two given instances. The main operation on ranges is contains, which is usually used in the form of in and !in operators.

To create a range for your class, call the rangeTo() function on the range start value and provide the end value as an argument. rangeTo() is often called in its operator form ...

Progression

As shown in the examples above, the ranges of integral types, such as Int, Long, and Char, can be treated as arithmetic progressions of them. In Kotlin, these progressions are defined by special types: IntProgression, LongProgression, and CharProgression.

Progressions have three essential properties: the first element, the last element, and a non-zero step. The first element is first, subsequent elements are the previous element plus a step. Iteration over a progression with a positive step is equivalent to an indexed for loop in Java/JavaScript.

for (int i = first; i <= last; i += step) {
    // ...
}

When you create a progression implicitly by iterating a range, this progression's first and last elements are the range's endpoints, and the step is 1.

for (i in 1..10) print(i)

To define a custom progression step, use the step function on a range.

for (i in 1..8 step 2) print(i)

The last element of the progressions is calculated this way:

• For a positive step: the maximum value not greater than the end value such that: (last - first) % step == 0.

• For a negative step: the minimum value not less than the end value such that: (last - first) % step == 0.

Thus, the last element is not always the same as the specified end value.

for (i in 1..9 step 3) print(i) // the last element is 7

To create a progression for iterating in reverse order, use downTo instead of .. when defining the range for it.

for (i in 4 downTo 1) print(i)

Progressions implement Iterable<N>, where N is Int, Long, or Char respectively, so you can use them in various collection functions like map, filter, and other.

println( (1..10).filter { it % 2 == 0 } )

Inside abstract class, private var instance: AppDatabase? with @Volatile keyword.

Pattern 2

Outside abstract class, private lateinit var INSTANCE: TitleDatabase.

Note: getDatabase() checks whether INSTANCE has been initialized during runtime using property reflection(::INSTANCE.isInitialized).

Upper Bounded Wildcards link

You can use an upper bounded wildcard to relax the restrictions on a variable. For example, say you want to write a method that works on List<Integer>, List<Double>, and List<Number>; you can achieve this by using an upper bounded wildcard.

To declare an upper-bounded wildcard, use the wildcard character('?'), followed by the extends keyword, followed by its upper bound. Note that, in this context, extends is used in a general sense to mean either "extends" (as in classes) or "implements" (as in interfaces).

To write the method that works on lists of Number and the subtypes of Number, you would specify List<? extends Number>. The term List<Number>is more restrictive than List<? extends Number> because the former matches a list of type Number only, whereas the latter matches a list of type Number or any of its subclasses.

Consider the following process method:

public static void process(List<? extends Foo> list) { /* ... */ }

The upper bounded wildcard , <? extends Foo>, where Foo is any type, matches Foo and any subtype of Foo. The process method can access the listt elements as type Foo:

public static void process(List<? extends Foo> list) {
    for (Foo elem: list) {
        // ...    
    }
}

In the foreach clause, the elem variable iterates over each element in the list. Any method defined in the Foo class can now be used on elem.

The sumOfList method returns the sum of the numbers in a list:

public static void double sumOfList(List<? extends Number> list) {
    double s = 0.0;
    for (Number n : list)
        s += n.doubleValue();
    return s;
}

The following code, using a list of Integer objects, prints sum = 6.0:

List<Integer> li = Arrays.asList(1,2,3);
System.out.println("sum = " + sumofList(li));

A list of Double values can use the same sumOfList method. The following code prints sum = 7.0:

List<Double> ld = Arrays.asList(1.2, 2.3, 3.5);
System.out.println("sum = " + sumOfList(ld));

Unbounded Wildcards link

The unbounded wildcard type is specified using the wildcard character (?), for example, List<?>. This is called a list of unknown type. There are two scenarios where an unbounded wildcard is a useful approach:

• If you are writing a method that can be implemented using functionality provided in the Object class.

• When the code is using methods in the generic class that don't depend on the type parameter. For example, List.size or List.clear. In fact, Class<?> is so often used because most of the methods in Class<T> do not depend on T.

Consider the following method, printList:

public static void printList(List<Object> list) {
    for (Object elem: list)
            System.out.println(elem + " " ;
    System.out.println();
}

The goal of printList is to print a list of any type, but it fails to achieve that goal - it prints only a list of Object instances; it cannot print List<Integer>, List<String>, List<Double>, and so on, because they are not subtypes of List<Object>. To write a generic printList method, use List<?>:

public static void printList(List<?> list) {
    for (Object elem: list)
            System.out.println(elem + " " ;
    System.out.println();
}

Because for any concrete typeA, List<A> is a subtype of List<?>, you can use printList to print a list of any type:

List<Integer> li = Arrays.asList(1, 2, 3);
List<String>  ls = Arrays.asList("one", "two", "three");
printList(li);
printList(ls);

Note : The Arrays.asList method is used in examples throughout this lesson. This static factory method converts the specified array and returns a fixed-size list.

It's important to note that List<Object> and List<?> are not the same. You can insert an Object, or any subtype of Object, into a List<Object>. But you can only insert null into a List<?>. The Guidelines for Wildcard Use section has more information on how to determine what kind of wildcard, if any, should be used in a given situation.

Lower Bounded Wildcards link

A lower bounded wildcard restricts the unknown type to be a specific type or a super type of that type.

A lower bounded wildcard is expressed using the wildcard character (?), following by the super keyword, followed by its lower bound: <? super A>.

Note: You can specify an upper bound for a wildcard, or you can specify a lower bound, but you cannot specify both.

Say you want to write a method that puts Integer objects into a list. To maximize flexibility, you would like the method to work on List<Integer>, List<Number>, and List<Object> - anything that can hold Integer values.

To write the method that works on lists of Integer and the supertypes of Integer, such as Integer, Number, and Object, you would specify List<? super Integer>. The term List<Integer> is more restrictive than List<? super Integer> because the former matches a list of type Integer only, whereas the latter matches a list of any type that is a supertype of Integer.

The following code adds the numbers 1 throught 10 to the end of a list:

public static void addNumbers(List<? super Integer> list) {
    for (int i = 1; i <= 10 ; i++) {
            list.add(i);
       }
}

The Guidelines for Wildcard Use section provides guidance on when to use upper bounded wildcards and when to use lower bounded wildcards.

Wildcards and Subtyping link

As described in Generics, Inheritance, and Subtypes, generic classes or interfaces are not related merely because there is a relationship between their types. However, you can use wildcards to create a relationship between generic classes or interfaces.

Given the following two regular (non-generic) classes:

class A { /* ... */ }
class B extends A { /* ... */ }

It would be reasonalbe to write the following code:

B b = new B();
A a = b;

This example shows that inheritance of regular classes follows this rule of subtyping: class B is a subtype of class A if B extends A. This rule does not apply to generic types:

List<B> lb = new ArrayList<>();
List<A> la = lb; // compile-time error

Given that Integer is a subtype of Number, what is the relationship between List<Integer> and List<Number> ? Although Integer is a subtype of Number, List<Integer> is not a subtype of List<Number> and, in fact, these two types are not related. The common parent of List<number> and List<Integer> is List<?>.

In order to create a relationship between these classes so that the code can access Number's methods through List<inger>'s elements, use an upper bounded whildcard:

List<? extends Integer> intList = new ArrayList<>();
List<? extends Number> numList = intList; // OK. List<? extends Integer> is a subtype of List<? extends Number>

Because Intger is a subtype of Number, and numList is a list of Number objects, a relationship now exists between intList (a list of Integer objects) and numList. The following diagram shows the relationships between several List classes declared with bouth upper and lower bounded wildcards. The Guidelines for Wildcard Use section has more information about the ramifications of using upper and lower bounded wildcards.

Wildcard Capture and Helper Methods

In some cases, the compiler infers the type of a wildcard. For example, a list may be defined as List<?> but, when evaluating an expression, the compiler infers a particular type from the code. This scenario is known as wildcard capture.

For the most part, you don't need to worry about wildcard capture, except when you see an error message that contains the phrase "capture of".

For more information, check this link.

Guidelines for Wildcard Use link

One of the more confusing aspects when learning to program with generics is determining when to use an upper bounded wildcard and when to use a lower bounded wildcard. This page provides some guidelines to follow when designing your code.

For purposes of this discussion, it is helpful to think of variables as providing one of two functions:

An "In" Variable

• An "in" variable serves up data to the code. Imagine a copy method with two arguments: copy(src, dest). The src argument provides the data to be copied, so it is the "in" parameter.

An "Out" Variable

• An "out" variable holds data for use elsewhere. In the copy example, copy(src, dest), the dest argument accepts data, so it is the "out" parameter.

You can use the "in" and "out" principle when deciding whether to use a wildcard and what type of wildcard is appropriate. The following list provides the guidelines to follow:

Wildcard Guidelines:

• An "in" variable is defined with an upper bounded wildcard, using the extends keyword.
• An "out" variable is defined with a lower bounded wildcard, using the super keyword.
• In the case where the "in" variable can be accessed using methods defined in the Object class, use an unbounded wildcard.
• In the case where the code needs to access the variable as both an "in" and an "out" variable, do not use a wildcard.

These guidelines do not apply to a method's return type. Using a wildcard as a return type should be avoided because it forces programmers using the code to deal with wildcards.

A list defined by List<? extends ...> can be informally thought of as read-only, but that is not a strict guarantee. Suppose you have the following two classes:

class NaturalNumber {

    private int i;

    public NaturalNumber(int i) { this.i = i; }
    // ...
}

class EvenNumber extends NaturalNumber {

    public EvenNumber(int i) { super(i); }
    // ...
}

Consider the following code:

List<EvenNumber> le = new ArrayList<>();
List<? extends NaturalNumber> ln = le;
ln.add(new NaturalNumber(35)); // compile-time error

Because List<EvenNumber> is a subtype of List<? extends NaturalNumber>, you can assign le to ln. But you cannot use ln to add a natural number to a list of even numbers. The following operations on the list are possible:

• You can add null.
• you can invoke clear,
• You can get the iterator and invoke remove.
• You can capture the wildcard and write elements that you've read from the list.

you can see that the list defined by List<? extends NaturalNumber> is not read-only in the strictest sense of the word, but you might think of it that way because you cannot store a new element or change an existing element in the list.

See More

Type Erasure link Restrictions on Generics link

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).

public class Box<T> {

    private T t;          

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }

    public <U extends Number> void inspect(U u){
        System.out.println("T: " + t.getClass().getName());
        System.out.println("U: " + u.getClass().getName());
    }

    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<Integer>();
        integerBox.set(new Integer(10));
        integerBox.inspect("10"); // error: this is still String!
    }
}

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

Box.java:21: <U>inspect(U) in Box<java.lang.Integer> cannot
  be applied to (java.lang.String)
                        integerBox.inspect("10");
                                  ^
1 error

*Result : *

public class Box<T> {
  ...
  public <U extends Number> void inspect(U u){
          System.out.println("T: " + t.getClass().getName());
          System.out.println("U: " + u.getClass().getName());
  }
  public static void main(String[] args) {
      ...
        Box<Integer> integerBox = new Box<>();
       >    integerBox.set(10);
     integerBox.inspect(0.1); 
        // T: java.lang.Integer
      // U: java.lang.Double
        ...
}

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:

public class NaturalNumber<T extends Integer> {

    private T n;

    public NaturalNumber(T n)  { this.n = n; }

    public boolean isEven() {
        return n.intValue() % 2 == 0;
    }

    // ...
}

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 :

<T extends B1 & B2 & B3>

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:

Class A { /* ... */ }
interface B { /* ... */ }
interface C { /* ... */ }

class D <T extends A & B & C> { /* ... */ }

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

class D <T extends B & A & C> { /* ... */ }  // compile-time error

Generic Methods and Bounded Type Parameters link

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.

public static <T> int countGreaterThan(T[] anArray, T elem) {
    int count = 0;
    for (T e : anArray)
        if (e > elem)  // compiler error
            ++count;
    return count;
}

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:

public interface Comparable<T> {
    public int compareTo(T o);
}

The resulting code will be:

public static <T extends Comparable<T>> int countGreaterThan(T[] anArray, T elem) {
    int count = 0;
    for (T e : anArray)
        if (e.compareTo(elem) > 0)
            ++count;
    return count;
}

Generics, Inheritance, and Subtypes link

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:

Box<Number> box = new Box<Number>();
box.add(new Integer(10));   // OK
box.add(new Double(10.1));  // OK

Now consider the following method:

public void boxTest(Box<Number> n) { /* ... */ }

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.

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 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:

interface PayloadList<E,P> extends List<E> {
  void setPayload(int index, P val);
  ...
}

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

• PayloadList<String, String>

• PayloadList<String, Integer>

• PayloadList<String, Exception>

  A sample PayloadList hierarchy

Why Use generics? link

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:

  List list = new ArrayList(); list.add("hello"); String s = (String) list.get(0);

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

  List<String> list = new ArrayList<String>(); list.add("hello"); String s = list.get(0) // no cast

• 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 link

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.

A Simple Box Class

Begin by examining a non-generic Box class that operates on objects of any type. It needs only to provide two methods: set, which adds an object to the box, and get, which retrieves it:

public class Box {
    private Object object;

    public void set(Object object) { this.object = object; }
    public Object get() { return object; }
}

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 Integers 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:

class ClassName<T1, T2, .., Tn> { /* ... */ }

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:

This same technique can be applied to create generic interfaces.

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:

Box<Integer> integerBox = new Box<Integer>();

// 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.
Box<String> stringBox = new Box<>(); 

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.

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

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:

public interface Pair<K, V> {
    public K getKey();
    public V getValue();
}

public class OrderedPair<K, V> implements Pair<K, V> {

    private K key;
    private V value;

    public OrderedPair(K key, V value) {
    this.key = key;
    this.value = value;
    }

    public K getKey()    { return key; }
    public V getValue() { return value; }
}

The following statements create two instantiations of the OrderedPair class:

Pair<String, Integer> p1 = new OrderedPair<String, Integer>("Even", 8);
Pair<String, String>  p2 = new OrderedPair<String, String>("hello", "world");

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, 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:

OrderedPair<String, Integer> p1 = new OrderedPair<>("Even", 8);
OrderedPair<String, String>  p2 = new OrderedPair<>("hello", "world");

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

Parameterized Types

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

OrderedPair<String, Box<Integer>> p = new OrderedPair<>("primes", new Box<Integer>(...));

Raw Types link

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

public class Box<T> {
    public void set(T t) { /* ... */ }
    // ...
}

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

Box<Integer> intBox = new Box<>();

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

Box rawBox = new Box();

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.

More informations are available in here.

Generic Methods link

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:

public class Util {
    public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {
        return p1.getKey().equals(p2.getKey()) &&
               p1.getValue().equals(p2.getValue());
    }
}

public class Pair<K, V> {

    private K key;
    private V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public void setKey(K key) { this.key = key; }
    public void setValue(V value) { this.value = value; }
    public K getKey()   { return key; }
    public V getValue() { return value; }
}

The complete syntax for invoking this method would be:

Pair<Integer, String> p1 = new Pair<>(1, "apple");
Pair<Integer, String> p2 = new Pair<>(2, "pear");
boolean same = Util.<Integer, String>compare(p1, p2);

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

Pair<Integer, String> p1 = new Pair<>(1, "apple");
Pair<Integer, String> p2 = new Pair<>(2, "pear");
boolean same = Util.compare(p1, p2);

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.

Class references

The most basic reflection feature is getting the runtime reference to a Kotlin class. To obtain the reference to a statically known Kotlin class, you can use the class literal syntax:

The reference is value of type KClass.

Note that a Kotlin class reference is not the same as a Java class reference. To obtain a Java class reference, use the .java property on a KClass instance.

JvmClassMapping.kt

Bound Class references (since 1.1)

You can get the reference to a class of a specific object with the same ::class syntax by using the object as a receiver:

※ In Java | Retrieving Class Objects

SomeClass.class; // The .class Syntax someInstance.getClass(); // Object.getClass()

Callable references

References to functions, properties, and constructors, apart from introspecting the program structure, can also be called or used as instances of function types.

The common sypertype for all callabel references is KCallable<out R>, where R is

• the return value type,
• which is property type for properties,
• and the constructed type for constructors.

Function references

When we have a named function declared like this:

We can easily call it directly (isOdd(5)), but we can also use it as a function type value, e.g. pass it to another function. To do this, we use the :: operator :

Here ::isOdd is a value of function type (Int) -> Boolean.

Function references belong to one of the KFunction<out R> subtypes, depending on the parameter count, e.g. KFunction3<T1, T2, T3, R>.

:: can be used with overloaded functions when the expected type is known from the context. For example :

Alternatively, you can provide the necessary context by storing the method reference in a variable with an explicitly specified type:

If we need to use a member of a class, or an extension function, it needs to be qualified, e.g. String::toCharArray.

Note that even if you initialize a variable with a reference to an extension function, the inferred function type will have no receiver (it will have an additional parameter accepting a receiver object). To have a function type with receiver instead, specify the type explicitly:

Receivers

The signature of a member function or an extension function begins with a receiver : the type upon which the function can be invoked. For example, the signature of toString() is Any.() -> String - it can be called on any non-null object(the receiver), it taks no parameters, and it returns a String. it is possible to write a lambda function with such a signature - this is called a function literal with receiver, and is extremely useful for building DSLs.

A function literal with receiver is perhaps easiest to think of as an extension function in the form of a lambda expression. The declaration looks like an ordinary lambda expression; what makes it take a receiver is the context - it must be passed to a function that takes a function with receiver as a parameter, or assigned to a variable/property whose type is a function type with receiver. The only way to use a function with receiver is to invoke it on an instance of the receiver class, as if it were a member function or extension function. For example:

class Car(val horsepowers: Int)
>
>val boast: Car.() -> String = { I'm a car with $horsepowers HP!" }
>val car = Car(120)
>println(car.boast())

Inside a lambda expression with receiver, you can use this to refer to the receiver object (in this case, car). As usual, you can omit this if there are no naming conflicts, which is why we can simply say $horsepowers instead of ${this.horsepowers}. So beware that in Kotlin, this can have different meanings depending on the context: if used inside (possibly nested) lambda expressions with receivers, it refers to the receiver object of the innermost enclosing lambda expression with receiver. If you need to "break out" of the function literal and get the "original" this (the instance the member function you're inside is executing on), mention the containing class name after this@ - so if you're inside a function literal with receiver inside a member function or Car, use this@Car.

As with other function literals, if the function takes one parameter (other than receiver object that it is invoked on), the single parameter is implicitly called it, unless you declare another name. If it takes more than one parameter, you must declare their names.

Here's a small DSL example for constructing tree structures:The block after tree("weightlifting") is the first function literal with receiver, which will be passed to tree() as the initialize parameter. According to the parameter list of tree(), the receiver is of type TreeNode, and therefor, tree() can call initialize() on root. root then becomes this insided the scope of that lambda expression, so when we call node("upper-body"), it implicitly says this.node("upper-body"), where this refers to the same TreeNode as root. The next block is passed to TreeNode.node(), and is invoked on the first child of the root node, namely upper-body, and inside it, this will refer to upper-body.

other example available in here

Example: function composition

Consider the following function:

It reterns a composition of two functions passed to it: compose(f,g) = f(g(*)). Now, you can apply it to callable references:

Property references

To access properties as first-class objects in Kotlin, we can also use the :: operator:

The expression ::x evaluates to a property object of type KProperty<Int>, which allows us to read its value using get() or retrieve the property name using the name property. For more information, please refer to the docs on the KProperty class.

For a mutable property, e.g. var y = 1, ::y returns a value of type KMutableProperty<Int>, which has a set() method:

var y = 1

fun main() {
    ::y.set(2)
    println(y)
}

A property reference can be used where a function with a single generic parameter is expected:

To access a property that is a member of a class, we qualify it:

class A(val p: Int)
val prop = A::p
println(prop.get(A(1)))

For an extension property:

val String.lastChar: Char
    get() = this[length - 1]

fun main() {
    println(String::lastChar.get("abc"))
}

Interoperability with Java reflection

On the JVM platform, standard library contains extensions for reflection classes that provide a mapping to and from Java reflection objects (see package kotlin.reflect.jvm). For example, to find a backing field or a Java method that serves as a getter for a Kotlin property, you can say something like this:

import kotlin.reflect.jvm.*

class A(val p: Int)

fun main() {
    println(A::p.javaGetter) // prints "public final int A.getP()"
    println(A::p.javaField)  // prints "private final int A.p"
}

To get the Kotlin class corresponding to a Java class, use the .kotlin extension property:

fun getKClass(o: Any): KClass<Any> = o.javaClass.kotlin

Constructor references

Constructors can be referenced just like methods and properties. They can be used wherever an object of function type is expected that takes the same parameters as the constructor and returns an object of the appropriate type. Constructors are referenced by using the :: operator and adding the class name. Consider the following function that expects a function parameter with no parameters and return type Foo:

class Foo

fun function(factory: () -> Foo) {
    val x: Foo = factory()
}

Using ::Foo, the zero-argument constructor of the class Foo, we can simply call it like this:

function(::Foo)

Callable references to constructors are typed as one of the KFunction<out R> subtypes, denpedning on the parameter count.

Bound function and property references (since 1.1)

You can refer to an instance method of a particular object:

Instead of calling the method matches directly we are storing a reference to it. Such reference is bound to its receiver. it can be called directly (like in the example above) or used whenever an expression of function type is expected:

Compare the types of bound and the corresponding unbound references. Bound callable reference has its receiver "attached" to it, so the type of the receiver is no longer a parameter:

Property referece can be bound as well:

Bound constructor references

A bound callable reference to a constructor of an inner class can be obtained by providing an instance of the outer class:

주변을 자세히 살펴 보자. 이름만 알고 있다면, 그 물체의 모든 정보를 알 수 있는 것들이 많이 존재한다. 내 오른손에 있는 마우스 “MOUSE(MOARUO)”의 경우, 구글과 같은 검색서비스를 이용하면 “Optical, Wheel, Mouse, USB” 라는 정보를 찾아낼 수 있다. 뿐만 아니라, 옥션과 같은 주문서비스를 통해 새로운 “MOUSE(MOARUO)” 마우스를 구매할 수도 있다.

프로그래밍의 세계에서도, 현실의 검색서비스 그리고 주문서비스의 기능을 제공하는데, 이를 “Self Introspection” 또는 “Reflection”이라고 부른다. 클래스(Class)의 이름만으로 클래스의 정보(필드, 메서드)를 찾거나 새로운 객체(Object)를 생성할 수 있다는 얘기다.

Java는 “java.lang.reflect” 패키지를 통해 Reflection 기능을 제공한다. “Java Reflection” 기능은 간접적으로는 알게 모르게 사용하고 있으며, 또한 필요할 경우 직접적으로 사용할 때도 있다. Reflection을 직접적으로 사용할 경우, 항상 성능을 염두해야 하지만, 성능만이 고려대상의 전부는 아니다. 수 차례의 SI 프로젝트를 겪으며 터득한 “Java Reflection”에 대한 진실과 오해에 대해 알아보자.

Java Reflection이란?

오늘은 금요일. 마우스를 제어하는 컨트롤러 프로그램을 개발하기 위해 당신은 두 달여 간을 쉬지 않고 일했다. 오늘은 마우스를 호출하는 작업을 완료하면, 두 달 동안 팽개친 애인에게 점수를 딸 수 있는 유일한 기회이다!

여기 2개의 마우스 클래스가 있다. 하나는 유선 마우스로 MouseMoaruo이고, 다른 하나는 MouseMx610으로 무선 마우스다.

그림 1. 마우스 클래스 Diagram

컨트롤러 프로그램으로부터 받은 마우스 이름을 매개변수로 사용해서, 컨트롤러에 연결할 마우스 클래스의 객체를 생성하는 Factory 클래스를 개발하려고 한다. 매개변수가 “moaruo”일 경우에는 MouseMoaruo 클래스의 객체를 생성하고, “mx610″일 경우에는 MouseMx610 클래스의 객체를 생성해야 한자. 제일 먼저 생각나는 가장 쉬운 접근법은 “if/else”문을 이용하는 것이다

개발이 완료될 즈음, 고객이 표준 마우스 모델이 하나 더 추가 되어야 한다고 수정을 요구했다(여러분이라면 이런 상황은 쉽게 상상할 수 있을 것이다). 늘 그렇듯, 고객의 요구를 받아들여 소스코드를 수정하여 if문을 하나 더 추가하여 요구사항을 해결했다. 이제 퇴근하려는 찰나, 고객은 여러분을 실망시키지 않고 또 다른 마우스를 들고 와서는, 하는 김에 이것도 추가해 달라고 얘기한다. 고객과 애인, 어느 것을 선택할 것 인가!

Factory 클래스의 가장 큰 문제는 if/else문의 사용이다. 객체 지향 프로그램의 대부분에서 if/else문은 필요치 않다. 프로그램에 if/else문(특히, 대량의 if/else문)을 사용했다면, 객체지향 철학을 어긴 것은 아닌지 의심해 보아야 한다.

애초부터 고객과 애인 중 하나를 선택해야 하는 햄릿의 고민은 할 필요가 없었다. 고객과 애인 모두를 만족시킬 수 있는 방법이 있기 때문이다. Reflection을 사용한 방법이 그것이다.

“그림 3″에서 보는 바와 같이, Constructor 객체를 이용하여 마우스 객체를 생성한다. 이 경우, 컨트롤러에서 클래스의 이름을 넘겨주어야 하지만, 새로운 마우스가 생기더라도 Factory 클래스의 수정 없이 유연하게 확장 가능한 코드가 된 것이다.

우리가 일하는 엔터프라이즈 프로젝트 현장에서는 이와 같은 Reflection이 셀 수 없을 만큼 다양하게 활용하고 있다.

사용처

현장에서 자바 개발자들이 Reflection을 직접 사용하는 것은 극히 드문 일이다. 그것은 Reflection이 적용될 수 있고 또한 적용되어야 할 곳은 라이브러리 클래스, 공통 컴포넌트 클래스, 그리고 프레임워크와 같이 Reflection을 통해 얻는 이득(재사용성, 확장성, 생산성, 유연성 등)이 극대화될 수 있는 곳이어야 하기 때문이다.

1. Java Serialization

객체를 직렬화(Serialization) 해야 할 경우 Serializable 인터페이스를 구현한다. 그리고, 직렬화된 객체를 읽기 위해서는 java.io.ObjectInputStream 클래스의 readObject() 메서드를 이용한다. 필요에 따라 Serializable 인터페이스를 구현한 클래스가 readObject() 메서드를 구현할 수도 있다. 이때, java.io.ObjectInputStream 클래스의 readObject() 메서드는 내부적으로 Reflection을 이용하여 직렬화된 객체의 readObject() 메서드를 호출한다.

2. Apache Commons BeanUtils library

Struts 프레임워크를 적용한 프로젝트에서 개발한 경험이 있다면, Apache Commons 프로젝트의 BeanUtils 라이브러리 사용을 고민해 본 경험 또한 있을 것이다. Struts 프레임워크는 HttpRequest 객체의 파라미터를 이용하여 ActionForm 클래스의 객체를 생성한다. 이 ActionForm 클래스의 객체를 생성하는 곳에서도 Reflection이 적용되었다.

Struts를 이용할 경우, 가장 성가신 부분은 ActionForm 클래스의 객체를 대응하는 VO 클래스의 객체로 변환하는 작업이다. 이 작업은 서비스 레이어를 Struts에 종속되지 않게 하기 위해 또는, 레이어 분리를 위해 반드시 수행되어야 한다. 만일 지금까지 ActionForm 객체를 서비스 레이어로 바로 넘겼다면 다시 한번 생각해 보라. VO 클래스 사용에 따른 레이어의 분리와, VO를 사용하지 않음으로써 얻는 개발 생산성 증가, 둘 중 어느 한가지를 택한 것인지.

이때, 사용할 수 있는 것이 Commons BeanUtils 라이브러리이다. Beanutils.copyProperties(Object dest, Object orig)를 이용하여 간단히 ActionForm 객체를 VO 객체로 변환할 수 있다. 규칙은 ActionForm 클래스의 인스턴스 변수명과 VO 클래스의 인스턴수 변수명이 같아야 한다는 것이다. 이 규칙을 따른다면, Reflection의 마술이 여러분을 위한 모든 작업을 수행해 줄 것이다.

이슈

1. Reflection을 사용한 코드는 느리다

개발자들 사이에 공공연히 진실로 받아들여지는 이 말은 사실이 아니다. 적절히 사용한 Reflection은 오히려 성능을 향상시킬 수 있으며, 또한 많은 이득을 제공한다. 뿐만 아니라, 성능만을 고려한 구현이 객체 지향의 설계 원칙들을 역행한다면, 오히려 이는 더욱 나쁜 결과를 낳게 된다.

2. Reflection을 이용하여 개발한 프로그램은 에러가 발생하기 쉽고 디버깅이 어렵다

Reflection은 컴파일 시 타입 체킹을 할 수 없다. 따라서, 런타임시 잘못된 파라미터로 인해 런타임 에러가 발생하기 쉽다. 이는 사실이다. 하지만, 적절히 사용된 런타임 에러 메시지를 이용해 충분히 디버깅이 쉬운 환경으로 만들 수 있다.

3. Reflection을 사용한 코드는 복잡하다

Reflection을 사용한 코드는 일반적인 객체 생성, 메서드 호출 코드에 비교하면 복잡한 것이 사실이다. 하지만 클래스의 타입을 비교하여 객체를 생성하는 코드의 경우, 대량의 if/else문을 사용하는 것보다 Reflection을 이용하여 재사용 가능한 컴포넌트로 만든다면, 오히려 코드를 단순화한다.

4. 성능(Performance) vs. 유연성(Flexibility)

앞서 말한 바와 같이 “Reflection을 사용한 코드는 느리다”는 사실은 사실이 아니다. 이 말은 Reflection을 사용할 경우 성능이 떨어지지 않는다라는 얘기가 아니다. 오히려, 성능이 떨어진다는 결과가 다수 존재한다. 아래는 Dennis Sosnoski(5. Java Programming dynamics, Part 2: Introducing reflection)가 측정한 Reflection에 관한 성능 결과이다. 그림에서 알 수 있듯이, Reflection을 사용할 경우, 직접(Direct) 또는 참조(Reference)의 경우에 비해 2 ~ 4배 정도 느리다.

이 결과를 통해 알 수 있는 사실은 “Reflection에 따른 성능 저하”가 아니라 “성능 측정 결과, Reflection을 사용한 지금 이 경우에는 성능이 저하되는 것을 검증했다”라는 것이다. 최적화 또는 성능 개선(Optimization)시 유의해야 할 점은 반드시 최적화 이전과 이후의 성능을 측정하여, 성능개선이 가시적으로 보일 때에만 적용해야 한다는 것이다. 만일 최적화가 필요하다고 느낀다면, 아래 규칙을 따르라.

Reflection과 관련된 성능에 관한 논쟁은 오해에서 비롯된 것이다. 이것은 JDK 초기 버전(1.3.0 이전 버전)의 경우 Reflection의 성능이 현저히 떨어졌다. 하지만 이후의 JDK 버전에서는, Reflection의 중요성을 인식한 Sun의 지속적인 노력으로 성능이 개선되고 있으며, 앞으로도 개선의 여지가 남아 있다. 뿐만 아니라 잘 적용한 Reflection은 많은 이득을 제공한다.

Reflection을 통해 얻을 수 있는 가장 큰 이득은 시스템 유연성(Flexibility)이다. “그림 3″에서 보는 바와 같이 Mouse 컨트롤러는 미래의 어떤 마우스와도 동작할 수 있다. 이처럼 성능보다 유연성이 더 중요한 상황이 많다

물론 Reflection 적용에 따른 가시적인 성능 저하를 확신한다면, 다른 대안을 생각해 볼 수 있다. 대안에는, Reflection 대신 interface를 통한 메서드 호출, 코드 자동 생성(Code Generation), 또는 최악의 경우 하드 코딩이 있다.

5. Compile vs. Run-time Type Checking

자바의 경우 컴파일 단계에 강력한 Type Checking을 지원한다. 아래와 같이 두 개의 클래스가 틀릴 경우, 컴파일이 에러가 발생한다.

그림 8. 컴파일 에러 예

Reflection은 실제 클래스 없이 클래스의 이름 또는 메서드의 이름만을 이용한다. 따라서, 아래와 같이, 개발 단계 또는 컴파일 단계에는 Type Checking을 하지 않는다.

대신, 실행시 발생할 수 있는 Exception을 처리하기 위한 try/catch문을 추가해야 한다.

자바가 제공하는 Exception의 종류에는 Checked Exception, Run-time Exception 그리고 error가 있다. 이중 Checked Exception의 경우, 위와 같이 컴파일 단계에 catch하거나 throw해야만 컴파일 오류가 발생하지 않는다. 이는 Checked Exception은 예외 상황에서 프로그램적으로 복구할 수 있는 방법이 존재하는 경우를 위한 Exception이기 때문이다.

하지만 Reflection 사용에 따른 Exception으로부터 복구할 수 있는 상황이란 거의 없다. 예를 들어, 위의 Class Not Found Exception이 발생한다면, 이는 클라이언트가 잘못된 클래스 명을 넘겨주었거나 또는 해당 클래스가 없을 2가지 경우다. 이는 모두 프로그램 에러 상황으로 오히려 Run-time Exception에 가깝다.

결국, Reflection을 사용함으로써, 개발단계에서 조기에 발견될 수도 있었을 프로그램 에러들이 런타임시에 발생하게 되는 것이다. 이처럼 에러 상황이 늦게 발견하면 디버깅이 어려워지게 된다. 이와 같은 경우를 위해서, 런타임시 디버깅을 위해 상세한 에러 메시징 기능을 포함하는 것이 좋다.

Drug heals the pain, Overdose kills the gain

Reflection의 사용에 관한 사실들은 사실 사실이 아니다. 성능, 디버깅, 그리고 복잡성과 관련된 내용들은 잘못 사용된 예에서 파생한 오해들이다.

Reflection은 염려할 만큼의 성능저하를 가져오지 않는다. 대량의 if/else문이나 switch문 대신, 잘 설계된 Reflection은 객체지향 철학을 어기지 않으면서도 더 좋은 성능을 발휘할 수도 있다.

또한 디버깅이 어려운 것은 컴파일 단계에 처리할 수 있는 오류들이 실행 단계에 발생하기 때문이 아니다. 더 근본적인 이유는 Reflection을 사용할 경우에 발생할 런타임 에러 메시지를 최대한 상세하게 그리고 친절하게 표시하도록 Exception 전략을 설계하지 못했기 때문이다. 잘 설계된 Exception 처리 전략은 Reflection 뿐만 아니라 시스템의 전체적인 디버깅을 쉽게 만든다.

Reflection의 복잡성은 사실 개발자 개개인의 초점에 맞추었을 때의 얘기다. 하지만, Reflection의 사용은 개발자의 관점이 아닌 아키텍트 중심으로 설계되어야 한다. Reflection이 가장 유용한 곳이 바로 시스템의 아키텍처를 이루는 컴포넌트들이기 때문이다. 오히려 잘 설계된 Reflection이 제공하는 서비스는 개발을 더욱 단순화 한다.

하지만 지나친 사용은 화를 부를 수 있다. Reflection을 적절히 사용했고 많은 이득이 따른다 하더라도, 더 간단한 해결책이 존재한다면, Reflection을 사용하지 말 것을 권한다. 단순한 해결책은 언제 어느 경우에나 최상의 선택이다.

Reflection의 사용은 양날의 검과 같다. 잘 사용한다면, 이름을 불러주었을 때, 여러분의 꽃이 되어 줄 것이다.

References :

본문 | 자바 리플렉션에 대한 오해와 진실 Java Programming dynamics, Part1: Java classes and class loading Java Programming dynamics, Part2: Introducing reflection

리플렉션(Reflection)은 :

• 객체를 통해 클래스의 정보를 분석해내는 프로그램 기법이다.

• 클래스 파일의 위치나 이름만 있으면 해당 클래스의 정보를 얻어내고, 객체를 생성하는 것 또한 가능하게 해주는 유연한 프로그래밍을 위한 기법이다. 동적으로 객체를 생성하는 것 또한 가능하다.

• Class 클래스

  • Java 에서 사용되는 클래스들에 대한 구조에 관한 정보를 가지고 있는 클래스.
  • 
  • User 클래스는 4개의 필드, 2개의 생성자, 9개의 메소드(getter/setter 포함)라는 속성을 가지고 있는 클래스로 정의 된다.
  • 클래스라는 것 자체도 필드, 생성자, 메소드 등과 같은 속성을 가지고 있다고 생각 할 수 있다.
  • 즉, Class 클래스는 이러한 클래스의 구조 자체를 하나의 클래스로 표현해놓은 클래스 이다.

Example

Class Reflection

package kr.klokov.Reflection;

import java.util.ArrayList;
import java.util.HashSet;

public class ClassReflection {

    private static void getClassHelper(Object o) {
        System.out.println(o.getClass());
    }

    private static void dotClassHelper(Class c) {
        System.out.println(c);
    }

    public static void main(String[] args) {

        // getClass()
        getClassHelper("string"); // class java.lang.String
        getClassHelper(new HashSet()); // class java.util.HashSet
        getClassHelper(new byte[1024]); // class [B
        getClassHelper(new ArrayList<String>()); // class java.util.ArrayList

        // .class
        dotClassHelper(boolean.class); // boolean
        dotClassHelper(java.io.File.class); // class java.io.File
    }
}

Field Reflection

package kr.klokov.Reflection;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class FieldReflection {

    public static final int a = 10;
    private double b;
    protected static final String s = "hello!";

    public static void main(String[] args) {
        try {
            Class c = Class.forName("kr.klokov.Reflection.FieldReflection");
            Field[] fields = c.getDeclaredFields();

            for(int i = 0; i < fields.length ; i++) {

                System.out.println("---------------------------");

                Field field = fields[i];

                System.out.println("name : " + field.getName());
                System.out.println("declare Class : " + field.getDeclaringClass());
                System.out.println("type : " + field.getType());
                System.out.println("modifier : " + Modifier.toString(field.getModifiers()));

            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Method Reflection

package kr.klokov.Reflection;

import java.lang.reflect.Method;

public class MethodReflection {
    public int sum(int a, int b) throws NoSuchFieldException {
        return a+b;
    }

    public static void main(String[] args) {
        try {
            Class c = Class.forName("kr.klokov.Reflection.MethodReflection");

            Method[] m = c.getDeclaredMethods();

            for (int i = 0 ; i < m.length ; i++) {
                System.out.println("--------------------------------");
                Method method = m[i];
                System.out.println("name : " + method.getName());
                System.out.println("declare Class : " + method.getDeclaringClass());

                Class[] parameterTypes = method.getParameterTypes();
                for (int j = 0; j < parameterTypes.length ; j++) {
                    System.out.println("Param : " + parameterTypes[j]);
                }

                Class[] exceptionTypes = method.getExceptionTypes();
                for (int j = 0; j < exceptionTypes.length ; j++) {
                    System.out.println("Exception : " + exceptionTypes[j]);
                }

                System.out.println("Return Type : " + method.getReturnType());

            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
 }

Constructor Reflection

package kr.klokov.Reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;

public class ConstructorReflection {

    public ConstructorReflection() {}

    protected ConstructorReflection(String s, int b) {}

    private ConstructorReflection(String s, int b, int c) {}

    ConstructorReflection(String a, int b, char c) {}

    public static void main(String[] args) {
        try {
            Class c = Class.forName("kr.klokov.Reflection.ConstructorReflection");

            Constructor[] constructors = c.getDeclaredConstructors();

            for (int i = 0 ; i < constructors.length ; i++) {
                System.out.println("---------------------------------");
                Constructor constructor = constructors[i];
                System.out.println("name : " + constructor.getName());
                System.out.println("declare Class : " + constructor.getDeclaringClass());
                System.out.println("modifier : " + Modifier.toString(constructor.getModifiers()));

                Class[] parameterTypes = constructor.getParameterTypes();

                for (int j = 0 ; j < parameterTypes.length ; j++) {
                    System.out.println("Params : " + parameterTypes[j]);
                }
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

More (Other post available in HERE)

1. The Reflection API | Java Doc

2. 자바 Reflection 이란?

3. Java Reflection 개념 및 사용법

4. Reflection, Class 클래스

5. String in Java | JournalDev

Compare

public class HousePark  {
    String lastname = "Park";
>
    public static void main(String[] args) {
        HousePark pey = new HousePark();
        HousePark pes = new HousePark();
    }
}

public class HousePark  {
    static String lastname = "Park";

public static void main(String[] args) {
    HousePark pey = new HousePark();
    HousePark pes = new HousePark();
}

위와 같이 `lastname` 변수에 <span style="color:#ff00ff">static</span> 키워드를 붙이면 자바는 메모리 할당을 딱 한번만 하게 되어 메모리 사용에 이점을 볼 수 있게된다.

<span style="color:#808080">
※ 만약 HousePark 클래스의 lastname값이 변경되지 않기를 바란다면 static 키워드 앞에 final이라는 키워드를 붙이면 된다. final 키워드는 한번 설정되면 그 값을 변경하지 못하게 하는 기능이 있다. 변경하려고 하면 예외가 발생한다.
</span>


> ### Compare
>#### Example 1 : Code
```java
public class Counter  {
    int count = 0;
    Counter() {
        this.count++;
        System.out.println(this.count);
    }
>
    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
    }
}

Example 1 : Result

1
1

Example 2 : Code

public class Counter  {
    static int count = 0;
    Counter() {
        this.count++;
        System.out.println(this.count);
    }

public static void main(String[] args) {
    Counter c1 = new Counter();
    Counter c2 = new Counter();
}

}

>#### Example 2 : Result
>```java
1
2

Example 1 c1, c2 객체 생성시 count 값을 1씩 증가하더라도 c1과 c2의 count는 서로 다른 메모리를 가리키고 있기 때문에 원하던 결과(카운트가 증가된)가 나오지 않는 것이다. 객체변수는 항상 독립적인 값을 갖기 때문에 당연한 결과이다.

Example 2 int count = 0 앞에 static 키워드를 붙였더니 count 값이 공유되어 다음과 같이 방문자수가 증가된 결과값이 나오게 되었다.

Static Method

Example

 public class Counter  {
    static int count = 0;
    Counter() {
        this.count++;
    }
>
    public static int getCount() {
        return count;
    }
>
    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
>
        System.out.println(Counter.getCount());
    }
}

getCount() 라는 static 메소드가 추가되었다. main 에서 getCount()는 Counter.getCount() 와 같이 클래스를 통해 호출할 수 있게 된다.

자바에는 다음과 같은 접근 제어자가 있다.

1. private
2. default
3. protected
4. public

private → default → protected → public 순으로 보다 많은 접근을 허용한다.

private

private이 붙은 변수, 메소드는

• 해당 클래스에서만 접근이 가능하다.

Example

public class AccessModifier {
    private String secret;
    private String getSecret() {
        return this.secret;
    }
}

위 예제의 secret 변수와 getSecret() 메소드는 오직 AccessModifier 클래스에서만 접근이 가능하다.

default

접근 제어자를 별도로 설정하지 않는다면, 접근 제어자가 없는 변수, 메소드는

• default 접근제어자가 되어 해당 패키지 내에서만 접근이 가능하다.

Example

package jump2java.house;
>
public class HouseKim {
    String lastname = "kim";
}

package jump2java.house;

public class HousePark { String lastname = "park";

public static void main(String[] args) {
    HouseKim kim = new HouseKim();
    System.out.println(kim.lastname);
}

}

`HouseKim`과 `HousePark`의 패키지는 **jump2java.house** 로 동일하다. `HouseKim` 클래스의 `lastname` 변수는 접근제어자가 default 이므로 `HousePark` 클래스에서 `main` 메소드에서 사용한 것과 같이 `kim.lastname` 으로 `HouseKim` 의 `lastname` 변수에 접근이 가능하다.


## protected
---
접근 제어자가 protected로 설정되었다면, protected가 붙은 변수, 메소드는
- 동일 패키지내의 클래스 또는
- 해당 클래스를 상속받은 외부 패키지의 클래스

에서 접근이 가능하다.

> ### Example
```java
package jump2java.house;
>
public class HousePark {
    protected String lastname = "park";
}

package jump2java.house.person;

import house.HousePark;

public class EungYongPark extends HousePark {
public static void main(String[] args) { EungYongPark eyp = new EungYongPark(); System.out.println(eyp.lastname);
}
}

`HousePark` 클래스를 상속받은 `EungYongPark`이라는 클래스의 패키지는 **jump2java.house.person**으로 `HousePark`의 패키지인 **jump2java.house**와 다르지만 `HousePark`의 `lastname` 변수가 `protected`로 설정되었기 때문에 `eyp.lastname`과 같은 접근이 가능하다.
>
만약 `lastname`의 접근제어자가 protected 가 아닌 default 접근제어자였다면 `eyp.lastname` 문장은 컴파일 에러를 유발 할 것이다.


## public
---
접근 제어자가 public으로 설정되었다면 public 접근 제어자가 붙은 변수, 메소드는
- **어떤 클래스에서라도 접근이 가능하다.**

> ### Example
```java
package jump2java.house;
>
public class HousePark {
    protected String lastname = "park";
    public String info = "this is public message.";
}

위 예제의 HousePark의 info 변수는 public 접근제어자가 붙어 있으므로 어떤 클래스에서던지 접근이 가능하다.

Data abstraction is the process of hiding certain details and showing only essential information to the user. Abstraction can be achieved with either abstract classes or interfaces

The abstract keyword is non-access modifier, used for classes and methods:

• *Abstract class: * is a restricted class that cannot be used to create objects (to access it, it must be inherited from another class).

• Abstract method: can only be used in an abstract class, and it does not have a body. The body is provided by the subclass (inherited from).

An abstract class can have both abstract and regular methods:

abstract class Animal {
  public abstract void animalSound();
  public void sleep() {
    System.out.println("Zzz");
  }
}

From the example above, it is not possible to create an object of the Animal class:
>```java
Animal myObj = new Animal(); // will generate an error

To access the abstract class, it must be inherited from another class.

Example

// Abstract class
abstract class Animal {
  // Abstract method (does not have a body)
  public abstract void animalSound();
  // Regular method
  public void sleep() {
    System.out.println("Zzz");
  }
}
>
// Subclass (inherit from Animal)
class Pig extends Animal {
  public void animalSound() {
    // The body of animalSound() is provided here
    System.out.println("The pig says: wee wee");
  }
}
>
class Main {
  public static void main(String[] args) {
    Pig myPig = new Pig(); // Create a Pig object
    myPig.animalSound();
    myPig.sleep();
  }
}

See More

Java Abstract Class Java Abstraction

What is Polymorphism?

tiger, lion 객체는 각각 :

• Tiger, Lion 클래스의 객체이면서,

• Animal 클래스의 객체이기도 하고,

• Barakble, Predator 인터페이스의 객체이기도 하다.

이러한 이유로 barkAnimal메소드의 입력 자료형을 Animal에서 Barkable로 바꾸어 사용할 수 있는 것이다.

이렇게 하나의 객체가 여러개의 자료형 타입을 가질 수 있는 것을 다형성, 폴리모피즘(Polymorphism)이라고 부른다.

See More

Tiger 클래스의 객체는 다음과 같이 여러가지 자료형으로 표현할 수 있다.

Tiger tiger = new Tiger();
Animal animal = new Tiger();
Predator predator = new Tiger();
Barkable barkable = new Tiger();

여기서 알아두어야 할 사항은 Predator로 선언된 predator 객체와 Barkable로 선언된 barkable 객체는 사용할 수 있는 메소드가 서로 다르다는 점이다. predator 객체는 getFood() 메소드가 선언된 Predator 인터페이스의 객체이므로 getFood() 메소드만 호출이 가능하다. 이와 마찬가지로 Barkable 로 선언된 barkable 객체는 bark() 메소드만 호출이 가능하다.

만약 tiger 객체에서 getFood, bark 둘 다 사용하고 싶다면 어떻게 해야 할까?

• Predator, Barkable 인터페이스를 구현한 Tiger로 선언된 tiger 객체를 사용하거나,

• 다음과 같이 getFood, bark 메소드를 모두 포함하는 새로운 인터페이스를 새로 만들어 사용하면 된다.

Notes on Interfaces :

• Like abstract classes, interfaces cannot be used to create objects

• Interface methods do not have a body - the body is provided by the "implement" class

• On implementation of an interface, you must override all of its methods

• Interface methods are by default abstract and public

• Interface attributes are by default public, static and final

• An interface cannot contain a constructor (as it cannot be used to create objects)

Why And When To Use Interfaces?

1. To achieve security - hide certain details and only show the important details of an object (interface).

2. Java does not support multiple inheritance (a class can only inherit from one superclass). Howerver, it can be achieved with interfaces, because the class can implement multiple interfaces.

   *Note : *To implement multiple interfaces, separate them with a comma.

   
   

See More : Java Interface