Scribd
Upload
6 views

2- Nested class and Inner class

2- Nested class and Inner class

Uploaded by

specsdeveloper13
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
6 views

2- Nested class and Inner class

2- Nested class and Inner class

Uploaded by

specsdeveloper13
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 6

Trending Now Data Structures Algorithms Topic-wise Practice Python Machine Learning Data Science J

Kotlin Nested class and Inner class


Read Discuss Courses Practice

Nested Class
In Kotlin, you can define a class inside another class, which is known as a
nested class. Nested classes have access to the members (fields and methods)
of the outer class.

Here is an example of a nested class in Kotlin:

Kotlin

class Car {
var make: String
var model: String
var year: Int

inner class Engine {


var horsepower: Int = 0
var cylinders: Int = 0

fun getEngineInfo(): String {


return "$horsepower horsepower, $cylinders cylinders, in a $make $mode
}
}

fun getInfo(): String {


return "$make $model, year $year"
}
}

fun main() {
val myCar = Car()
myCar.make = "Toyota"
myCar.model = "Camry"
myCar.year = 2020

val engine = myCar.Engine()


engine.horsepower = 250
engine.cylinders = 6

println(engine.getEngineInfo())
}

Output:

250 horsepower, 6 cylinders, in a Toyota Camry

A class is declared within another class then it is called a nested class. By


default nested class is static so we can access the nested class property or
variables using dot(.) notation without creating an object of the class.
Syntax of declaration:

class outerClass {
............
// outer class properties or member function

class nestedClass {
..........
// inner class properties or member function
}
}
Note: Nested class can’t access the members of the outer class, but we
can access the property of nested class from the outer class without
creating an object for nested class.

Kotlin program of accessing nested class properties:

Kotlin

// outer class declaration


class outerClass {
var str = "Outer class"
// nested class declaration
class nestedClass {
val firstName = "Praveen"
val lastName = "Ruhil"
}
}
fun main(args: Array<String>) {
// accessing member of Nested class
print(outerClass.nestedClass().firstName)
print(" ")
println(outerClass.nestedClass().lastName)
}

Output:

Praveen Ruhil

In Kotlin, to access the member function of nested class, we need to create the
object for nested class and call the member function using it.

Kotlin program of accessing nested class member function:

Kotlin

// outer class declaration


class outerClass {
var str = "Outer class"
// nested class declaration
class nestedClass {
var s1 = "Nested class"
// nested class member function
fun nestfunc(str2: String): String {
var s2 = s1.plus(str2)
return s2
}
}
}
fun main(args: Array<String>) {
// creating object of Nested class
val nested = outerClass.nestedClass()
// invoking the nested member function by passing string
var result = nested.nestfunc(" member function call successful")
println(result)
}

Output:

Nested class member function call successful

Comparison with Java

Kotlin classes are much similar to Java classes when we think about the
capabilities and use cases, but not identical. Nested in Kotlin is similar to a
static nested class in Java and the Inner class is similar to a non-static nested
class in Java.
Kotlin Inner Class
When we can declare a class inside another class using the keyword inner
then it is called inner class. With the help of the inner class, we can access the
outer class property inside the inner class.

class outerClass {
............
// outer class properties or member function

inner class innerClass {


..........
// inner class properties or member function
}
}

In the below program we are trying to access str from the inner class member
function. But it does not work and gives a compile-time error.
Kotlin program of inner class:

Kotlin

// outer class declaration


class outerClass {
var str = "Outer class"
// innerClass declaration without using inner keyword
class innerClass {
var s1 = "Inner class"
fun nestfunc(): String {
// can not access the outer class property str
var s2 = str
return s2
}
}
}
// main function
fun main(args: Array<String>) {
// creating object for inner class
val inner= outerClass().innerClass()
// inner function call using object
println(inner.nestfunc())
}
Output:

Error:(9, 22) Kotlin: Unresolved reference: str

First, use the inner keyword in front of the inner class. Then, create an instance
of the outer class else we can’t use inner classes.

Kotlin

// outer class declaration


class outerClass {
var str = "Outer class"
// innerClass declaration with using inner keyword
inner class innerClass {
var s1 = "Inner class"
fun nestfunc(): String {
// can access the outer class property str
var s2 = str
return s2
}
}
}
// main function
fun main(args: Array<String>) {
// creating object for inner class
val inner= outerClass().innerClass()
// inner function call using object
println(inner.nestfunc()+" property accessed successfully from inner class ")
}

Output:

Outer class property accessed successfully from inner class

Advantages or Disadvantages:

Advantages of using nested and inner classes in Kotlin:

1. Encapsulation: Nested and inner classes allow you to group related


functionality together and keep it separate from the rest of the code,

You might also like