AMC Sem 5 Krishna

AMC

A Short Questions:

1. What is the difference between the variable declaration with var and
val?
ANS: -
Difference between var and val in Kotlin:
var is used to declare mutable variables. Mutable variables can be reassigned after their initial
assignment.
val is used to declare immutable variables. Immutable variables cannot be reassigned after their
initial assignment.
Example:

var x = 5 // Mutable

x = 10 // Valid reassignment

val y = 3 // Immutable

y=7 // Compilation error: Val cannot be reassigned

2. What is the difference between the variable declaration with val and
const?
ANS: -
Difference between val and const in Kotlin:
val is used to declare runtime constants. They are evaluated at runtime and can have different
values in different runtime environments.
const is used to declare compile-time constants. They are evaluated at compile-time and must
have a primitive data type or a String.
Example:
AMC Sem 5 Krishna

val pi = 3.14 // Runtime constant

const val appVersion = "1.0" // Compile-time constant

3. Do we have a ternary operator in Kotlin just like java?

ANS: -
Ternary Operator in Kotlin: Kotlin does not have a ternary operator like Java's ? :. Instead,
Kotlin encourages the use of the if expression for similar conditional assignments.
Example:

val result = if (condition) value1 else value2

4. Can we use primitive types such as int, double, float in Kotlin?

ANS: -
Use of Primitive Types in Kotlin: In Kotlin, you can use types like Int, Double, Float, etc., which
are conceptually equivalent to Java's primitive types. However, they are represented as objects
to support null safety and other features. Kotlin's compiler may optimize them when possible.

5. Is there any difference between == operator and === operator?

ANS: -
Difference between == and === Operators in Kotlin:
== is used for structural equality, comparing the content of objects.
=== is used for referential equality, comparing whether two references point to the same object in
memory.
Example:

val a = "hello"

val b = "hello"

val c = a

println(a == b) // true (content is the same)

println(a === b) // true (referential equality)

println(a === c) // true (referential equality)

 AMC Sem 5 Krishna

6. What is the forEach in Kotlin?

ANS: -
forEach in Kotlin: forEach is a higher-order function in Kotlin used for iterating over collections like
lists. It applies a lambda expression to each element in the collection.
Example:

val numbers = listOf(1, 2, 3, 4, 5)

numbers.forEach { println(it) } // Prints each number on a new line

7. What is the difference between List and Array types in Kotlin?

ANS: -
Difference between List and Array in Kotlin:

• Lists (List) are immutable collections with a fixed size. Elements cannot be added or
removed once initialized.

• Arrays (Array) are mutable collections with a fixed size. Elements can be modified, added, or
removed after initialization.

8. What is Kotlin’s Null Safety?

ANS: -
Kotlin's Null Safety: Kotlin has a strong null safety system, which means you must explicitly declare
when a variable can hold a null value using the ? modifier. This prevents null pointer exceptions and
makes code more robust.
Example:

val name: String? = null // Nullable String

val length = name?.length // Safe call operator

9. Give difference between Array and List.

ANS: -
This has been answered in question 7.
AMC Sem 5 Krishna

10. List out Conditional Statements.

ANS: -
Conditional Statements: Conditional statements in Kotlin include if, else if, else, when, and loops
like for and while. They are used to make decisions and control the flow of code.

11. Define Open Class in kotlin.

ANS: -
Open Class in Kotlin: An open class in Kotlin is a class that can be subclassed. By default, classes in
Kotlin are final, meaning they cannot be extended. Adding the open modifier allows other classes to
inherit from it.

12. What is OOP?

ANS: -
OOP (Object-Oriented Programming): OOP is a programming paradigm that uses objects and
classes for organizing code. It promotes concepts like encapsulation, inheritance, and
polymorphism for building modular and maintainable software.

13. What do you mean by properties in Kotlin?

ANS: -
Properties in Kotlin: Properties in Kotlin are special member functions that are used to define the
behavior of accessing or modifying class attributes (fields). They are declared using the val or var
keyword and can have custom getter and setter methods.

14. What is the difference between Default and Named Parameters in Kotlin?

ANS: -
Difference between Default and Named Parameters in Kotlin: Default parameters allow you to
provide default values for function parameters. Named parameters allow you to specify the
argument names when calling a function, making it more readable and avoiding parameter order
issues.

15. What is the difference between JSON and XML in Kotlin?

ANS: -
Difference between JSON and XML in Kotlin: JSON (JavaScript Object Notation) and XML
(eXtensible Markup Language) are both data interchange formats. JSON is more concise, human-
readable, and commonly used for web APIs. XML is more verbose and structured, often used in
configuration files and data exchange
AMC Sem 5 Krishna

16. What are the different visibility modifier in kotlin?

ANS: -
Visibility Modifiers in Kotlin: Kotlin provides four visibility modifiers: public, internal, protected,
and private. They control the visibility of classes, functions, and properties within modules and
packages.

17. Discuss Break and Continue?

ANS: -
Break and Continue: break is used to exit a loop prematurely, and continue is used to skip the rest
of the current iteration and continue with the next iteration of a loop.

18. What is Getter?

ANS: -
Getter: A getter is a special function in Kotlin that is used to retrieve the value of a property. It is
invoked when you access the property.

19. Why call back method is needed?

ANS: -
Callback Methods: Callback methods are functions that are passed as arguments to other functions
and are executed later when certain conditions are met. They are often used for handling
asynchronous tasks.

20. Discuss Logcat.

ANS: -
Logcat: Logcat is a debugging tool in Android used to view log messages generated by an Android
app. Developers use it for debugging and analysing application behaviour.

21. Give the advantages is JSON.

ANS: -
Advantages of JSON: JSON is lightweight, easy to read, and widely supported. It's the preferred
format for data interchange in web APIs due to its simplicity and human-readability.

22. How to transfer data from one activity to another activity?

ANS: -
Transfer Data Between Activities: Data can be transferred between activities in Android using
intents, bundles, or other data storage mechanisms like SharedPreferences or databases.
AMC Sem 5 Krishna

23. What is SQLiteOpenHelper?

ANS: -
SQLiteOpenHelper: SQLiteOpenHelper is a helper class in Android used to manage database
creation and version management. It simplifies database operations.

24. Which class is used for Google map services?

ANS: -
Google Maps Service Class: The GoogleMap class is used for accessing and displaying Google Maps
in Android applications. It provides various features for mapping and location services.

25. How to write Comment in JSON?

ANS: -
Writing Comments in JSON: JSON does not support comments. It is a data format and not designed
for adding comments within the data structure. Comments are typically added in documentation or
descriptions separate from JSON data.

B Long Questions:

1. Give difference between Array and List.

ANS: -

Property Array List

Mutable (mutableListOf()) and Immutable

Nature Mutable
(listOf())

Using arrayOf() function or Array Using listOf() function for immutable lists
Declaration
constructor and mutableListOf() for mutable lists

Elements are initialized during

Elements are initialized during declaration
Initialization declaration using the
using listOf() or mutableListOf()
constructor or arrayOf()

Accessing Elements accessed using get() Elements accessed using get() function or
Elements function or index [ ] operator index [ ] operator

Elements can be modified using Mutable lists can be modified using set()
Modifying
set() function or index [ ] function or index [ ] operator; Immutable
Elements
operator lists cannot be modified
AMC Sem 5 Krishna

Fixed size upon creation, cannot Can be fixed-size (immutable) or variable-size

Size
be changed (mutable)

Provides functions like Offers various functions like contains(),

Additional
intArrayOf(), charArrayOf(), etc., containsAll(), indexOf(), lastIndexOf(),
Functions
for specific types isEmpty(), etc., for list operations

Used for ordered collections; Immutable lists

Suitable for fixed-size collections
Use Case for read-only data, mutable lists for dynamic
that require modification
data

In summary, Arrays in Kotlin are best suited for situations where you need a fixed-size collection of
elements that can be modified. On the other hand, Lists offer more flexibility with both mutable
and immutable options and provide additional built-in functions for working with elements. The
choice between Arrays and Lists depends on the specific requirements of your program.

2. Explain conditional statements and also give the difference between if

and when.
ANS: -
Conditional statements in Kotlin are used for making decisions in code execution. They determine
which code to run based on whether a given condition is true or false. Kotlin provides several
conditional statements, including the if, if-else, if-else as an expression, and when statements.
Let's explore these conditional statements and highlight the differences between the if and when
statements:
➢ if statement: The if statement checks a condition, and if the condition is true, the code following
the if block is executed. In Kotlin, the if statement can also be used as an expression, meaning it
can return a value based on the condition.
Example:

var max = a

if (b > a)

max = b

➢ if-else statement: The if-else statement allows you to execute one block of code if the condition
is true and another block if the condition is false. It is used when you need to handle both cases.
Example:

if (a > b)
AMC Sem 5 Krishna

max = a

else

max = b

➢ if-else as an expression: In Kotlin, the if-else statement can also be used as an expression,
similar to a ternary operator in other languages. If the condition is true, it returns the first value;
otherwise, it returns the second value.
Example:

var max = if (a > b) a else b

➢ when statement: The when statement in Kotlin replaces the traditional switch statement in
languages like Java. It allows you to execute code blocks based on multiple conditions. It
compares the argument provided to each branch and executes the code block for the first
matching branch. Unlike switch in Java, you don't need break statements at the end of each
branch.

• Using when as a statement with else: You can use when as a statement with an else
branch. If none of the branches match, the code in the else block is executed.
Example:

when (lb) {

"Sun" -> println("Sun is a Star")

"Moon" -> println("Moon is a Satellite")

"Earth" -> println("Earth is a planet")

else -> println("I don't know anything about it")

• Using when as a statement without else: You can use when as a statement without an else
branch. In this case, if none of the branches matches, the code block simply exits without
printing anything to the output.
Example:

when (lb) {

"Sun" -> println("Sun is a Star")

"Moon" -> println("Moon is a Satellite")

"Earth" -> println("Earth is a planet")

AMC Sem 5 Krishna

• Using when as an expression: when can also be used as an expression, where the value of
the branch that matches the condition becomes the value of the entire expression.
Example:

var month = when (monthOfYear) {

1 -> "January"

2 -> "February"

// ...

12 -> "December"

else -> {

println("Not a month of the year")

"Invalid"

Aspect if Statement when Statement

Usage Used for single conditional checks. Used for handling multiple conditions.

Number of Conditions Typically handles one condition. Designed for handling multiple cases
simultaneously.

Syntax Uses if (condition) { ... } Uses when (value) { ... }

Example (Single kotlin if (x == 5) { ... } N/A (Not typically used for single
Condition) conditions)

Example (Multiple N/A (Not typically used for multiple kotlin when (x) { case1 -> ... case2 -> ...
Conditions) conditions) else -> ... }

In summary, conditional statements in Kotlin are essential for decision-making in code execution.
The if statement handles simple conditionals, while the when statement is more versatile and can
replace both simple and complex conditionals, providing a cleaner and more readable way to make
decisions in your Kotlin code.
AMC Sem 5 Krishna

3. Explain looping statements in detail with example.

ANS: -
➢ Loops (Iterative Statements)
In programming, loops are used to execute a specific block of code repeatedly until a certain
condition is met. This helps in automating repetitive tasks and reducing code duplication. Kotlin
provides several loop constructs, including for, while, and do-while, to facilitate iteration.
➢ for Loop
The for loop in Kotlin is used to iterate over a range, an array, a string, or any iterable collection. It
iterates through each element of the specified collection and executes a block of code for each
element.
Syntax of for loop in Kotlin:

for (item in collection) {

// Body of the loop

Example: Iterate through a range using for loop:

fun main(args: Array<String>) {

print("for (i in 1..5) print(i) = ")

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

Example: Iterate through an array using for loop:

fun main(args: Array<String>) {

val numbers = arrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

for (num in numbers) {

if (num % 2 == 0) {

print("$num ")

Example: Iterate through a string using for loop:

fun main(args: Array<String>) {

AMC Sem 5 Krishna

val name = "Geeks"

val name2 = "forGeeks"

// Traversing string without using index property

for (alphabet in name) print("$alphabet ")

// Traversing string with using index property

for (i in name2.indices) print(name2[i] + " ")

println(" ")

// Traversing string using withIndex() library function

for ((index, value) in name.withIndex()) {

println("Element at $index th index is $value")

Example: Iterate through a collection using for loop:

fun main(args: Array<String>) {

// Read-only, fix-size collection

val collection = listOf(1, 2, 3, "listOf", "mapOf", "setOf")

for (element in collection) {

println(element)

➢ while Loop
The while loop is used to iterate a specific block of code repeatedly until a certain condition is met.
It checks the condition before each iteration.
Syntax of while loop in Kotlin:
AMC Sem 5 Krishna

while (condition) {

// Body of the loop

Example: Using a while loop to print numbers from 1 to 5:

fun main(args: Array<String>) {

var i = 1

while (i <= 5) {

println(i)

i++

Example: Using a while loop to print elements of an array:

fun main(args: Array<String>) {

val names = arrayOf("Praveen", "Gaurav", "Akash", "Sidhant", "Abhi", "Mayank")

var index = 0

while (index < names.size) {

println(names[index])

index++

4. Discuss break, continue and return with example.

ANS: -
Break, Continue, and Return
In Kotlin, break, continue, and return are control flow statements used to modify the behavior of
loops and functions.
➢ Break:
The break statement is used to terminate the nearest enclosing loop immediately, without checking
the loop's condition. It is often used to exit a loop prematurely based on some condition.
Example: Using break to exit a loop early:
AMC Sem 5 Krishna

for (i in 1..10) {

if (i == 5) {

break

// Code here will execute for i from 1 to 4

➢ Continue:
The continue statement is used to skip the current iteration of a loop and proceed to the next
iteration. It is often used when you want to bypass certain iterations based on specific conditions.
Example: Using continue to skip iterations:

for (i in 1..5) {

if (i == 3) {

continue

// Code here will execute for all iterations except i = 3

➢ Return:
The return statement is used to exit a function immediately and, optionally, return a value from the
function. It allows you to return control to the caller of the function.
Example: Using return to exit a function and return a value:

fun add(a: Int, b: Int): Int {

val result = a + b

return result

In this example, the add function returns the sum of two numbers, and the control is returned to
the caller of the function.
These control flow statements are essential for managing the flow of your programs and making
decisions within loops and functions. They provide flexibility and control over how your code
behaves under different conditions.
AMC Sem 5 Krishna

5. What is Constructor? How to create constructor in kotlin?

ANS: -
In Kotlin, a constructor is a special member function that is responsible for initializing the properties
or fields of a class when an object of that class is created. Constructors are used to set up the initial
state of an object. Kotlin provides two types of constructors:
➢ Primary Constructor: The primary constructor is defined in the class header itself. It allows you
to declare and initialize properties directly within the constructor parameters. There can be only
one primary constructor in a class.
➢ Secondary Constructor: Secondary constructors are additional constructors that you can define
within the class. They are created using the constructor keyword. A class can have one or more
secondary constructors.
Let's discuss each type of constructor in detail:
Primary Constructor:
The primary constructor is declared in the class header and is used to initialize the class properties.
Here's an example:

class MyClass(val name: String, var id: Int) {

// Class body

}In this example, name is a read-only property (initialized using val), and id is a read-write property
(initialized using var). When an object of MyClass is created, you can pass values for name and id
directly in the constructor:

val myClass = MyClass("Ashu", 101)

Primary Constructor with Initializer Block:

You can use an initializer block (init) within the primary constructor to perform additional
initialization logic. For example:

class MyClass(name: String, id: Int) {

val e_name: String

var e_id: Int

init {

e_name = name.capitalize()

e_id = id

println("Name = $e_name")
AMC Sem 5 Krishna

println("Id = $e_id")

In this case, the init block is executed when an object of MyClass is created, and it initializes
e_name and e_id properties.
Secondary Constructor:
Secondary constructors are defined using the constructor keyword. They allow you to create
additional ways of initializing objects. Here's an example:

class MyClass {

constructor(id: Int) {

// Initialization logic

constructor(name: String, id: Int) {

// Initialization logic

You can have multiple secondary constructors in a class, each with a different set of parameters.
Calling One Constructor from Another (Primary to Secondary):
You can also call one constructor from another constructor within the same class using the this
keyword. For example:

class MyClass(password: String) {

constructor(name: String, id: Int, password: String) : this(password) {

// Additional initialization logic

In this example, the secondary constructor calls the primary constructor using this(password)
before performing its own initialization.
Constructors play a crucial role in initializing the state of objects in Kotlin classes, making it easier to
work with objects in a consistent and predictable manner. Depending on your use case, you can
choose between primary and secondary constructors to suit your needs.
AMC Sem 5 Krishna

6. Discuss Inheritance in detail.

ANS: -
Inheritance is a fundamental concept in object-oriented programming (OOP) that allows one class
to inherit the properties and behaviors (attributes and methods) of another class. It is a mechanism
that promotes code reuse and establishes relationships between classes, making it a crucial part of
building complex software systems. Kotlin, as an object-oriented programming language, supports
inheritance.
Here, we will discuss inheritance in detail, based on the provided data and examples:
Basics of Inheritance:
Superclass (Base Class or Parent Class): The main class that contains properties and methods is
called the superclass or base class. It serves as the blueprint for creating new classes.
Subclass (Derived Class or Child Class): The class that inherits properties and methods from the
superclass is called the subclass or derived class. It adds its own properties and methods while also
inheriting those from the superclass.
Key Concepts:
1. Extending a Class:
Inheritance is used to create a new class (subclass) that extends or inherits the characteristics of an
existing class (superclass). In Kotlin, this is done by using the : operator in the class header.

class DerivedClass : BaseClass() {

// Additional properties and methods of the derived class

2. Inheriting Properties and Methods:

When a subclass inherits from a superclass, it automatically gains access to all the properties and
methods of the superclass. This allows the subclass to reuse existing code.
3. Constructors in Inheritance:
If the superclass has a primary constructor, the subclass must initialize it by calling it in its own
primary constructor using the super keyword. Secondary constructors in the subclass can also call
secondary constructors in the superclass using super.

class SubClass : SuperClass() {

constructor(param: Type) : super(param) {

// Additional initialization logic for the subclass

}
AMC Sem 5 Krishna

4. Overriding Methods:
Subclasses can override (provide a new implementation for) methods that are inherited from the
superclass. To override a method, you use the override keyword in the subclass.

open class SuperClass {

open fun someMethod() {

// Original implementation in the superclass

class SubClass : SuperClass() {

override fun someMethod() {

// New implementation in the subclass

5. Access Modifiers:
In Kotlin, the access modifiers (public, protected, internal, and private) play a crucial role in
inheritance. By default, properties and methods in Kotlin classes are public. To control access, you
can use the appropriate modifier.
Example:
Here's an example that demonstrates inheritance and its concepts:

open class Employee(name: String, age: Int) {

init {

println("Employee: $name, $age years old")

open fun work() {

println("Employee is working")

}
AMC Sem 5 Krishna

class Manager(name: String, age: Int, department: String) : Employee(name, age) {

init {

println("Manager: $name, $age years old, Department: $department")

override fun work() {

println("Manager is managing the team")

fun main(args: Array<String>) {

val employee = Employee("Alice", 30)

val manager = Manager("Bob", 40, "HR")

employee.work()

manager.work()

In this example, Manager is a subclass of Employee. The Manager class inherits the properties and
methods of the Employee class and provides its own implementation of the work method.
In summary, inheritance is a fundamental concept in Kotlin that enables code reuse, the creation of
specialized classes, and the establishment of relationships between classes in an object-oriented
program. It plays a crucial role in building complex software systems by promoting modularity and
maintainability.

7. Write a short note on constraint Layout.

ANS: -
Constraint Layout is a powerful and flexible layout manager available in Android that allows you to
create complex and responsive UIs for your Android apps. It was introduced to improve the
performance and reduce the complexity of UI layouts compared to other layout managers like
RelativeLayout and LinearLayout. Here's a short note on Constraint Layout:
AMC Sem 5 Krishna

Introduction:

• Constraint Layout is a ViewGroup that helps you create complex layouts with a flat view
hierarchy.

• It allows you to position and size widgets (UI elements) in a highly flexible way.

• Constraint Layout was introduced at Google I/O 2016 and has since become widely used for
Android app development.
Advantages of Constraint Layout:

• Reduced Nesting: Constraint Layout reduces the need for deeply nested view hierarchies,
which can improve the performance of your app.

• Flexibility: It offers a high degree of flexibility in positioning and sizing views.

• Animation: You can easily apply animations to views within a Constraint Layout with
minimal code.

• Visual Design: Android Studio's Layout Editor provides a drag-and-drop interface to build
layouts visually.

• Performance: It generally performs better than some other layout managers, especially for
complex UIs.
Using Constraint Layout:

• To use Constraint Layout in your Android project, add the ConstraintLayout library to your
app's dependencies in the build.gradle file.

• Android Studio provides a visual design editor for Constraint Layout, making it easier to
design your UI.
Constraints:

• In Constraint Layout, you define constraints to specify the position and relationships
between views.

• Constraints can be both horizontal and vertical, allowing precise control over view
placement.

• You can set constraints programmatically or use the visual editor to drag and drop them.
Handles and Anchor Points:

• Handles or anchor points in Constraint Layout are points on views that you can connect to
other views to establish constraints.

• They help you define relationships between views to control their positioning.
Chains:
AMC Sem 5 Krishna

• Chains in Constraint Layout allow you to group multiple views in a horizontal or vertical
alignment.

• Chains provide options like spread, spread_inside, and packed to control the spacing
between views.
Guidelines:

• Guidelines are used to create invisible lines that you can use as reference points for
positioning views.

• They are helpful for precise layout design.

Percentage Dimensions:

• Constraint Layout supports percentage-based sizing, which allows views to take a

percentage of the available space.
Barriers:

• Barriers are used to prevent views from overlapping by automatically adjusting their
positions when needed.
Groups:

• Groups in Constraint Layout allow you to perform actions on a set of views, such as changing
their visibility, as a group.
Design and Blueprint Mode:

• Android Studio provides design and blueprint modes for Constraint Layout, allowing you to
switch between visual design and a wireframe representation for fine-tuning layouts.
In summary, Constraint Layout is a powerful and flexible layout manager for Android app
development. It simplifies the creation of complex UIs, improves app performance, and provides
tools for visual design and fine-tuning. Developers can use Constraint Layout to create responsive
and visually appealing user interfaces.

8. Explain Abstract Class in detail.

ANS: -
An abstract class in Kotlin is a class that is declared with the abstract keyword. It serves as a
blueprint for other classes and cannot be instantiated on its own. Abstract classes allow you to
define methods and properties that must be implemented by any concrete (non-abstract)
subclasses. Here are the key points about abstract classes:
AMC Sem 5 Krishna

Cannot be Instantiated: Abstract classes cannot be directly instantiated, meaning you cannot
create objects of an abstract class. You can only create objects of concrete subclasses that extend
the abstract class.
May Contain Abstract and Non-Abstract Members: An abstract class can contain both abstract and
non-abstract (concrete) methods and properties. Non-abstract members have default
implementations in the abstract class, while abstract members do not provide an implementation
and must be overridden by concrete subclasses.
Abstract Methods: Abstract methods are declared without an implementation in the abstract class.
They are marked with the abstract keyword and do not include a method body. Subclasses must
provide a concrete implementation of these abstract methods.
Open by Default: Abstract classes and their abstract methods are considered "open" by default,
which means they can be overridden by subclasses. You don't need to explicitly use the open
keyword when declaring abstract classes or their abstract methods.
Subclasses Must Implement Abstract Members: Any class that extends an abstract class with
abstract members must implement those members; otherwise, the subclass itself becomes
abstract.
Concrete Members: Abstract classes can also have concrete (non-abstract) members with
implementations. These concrete members can be used as-is or overridden in subclasses.
Use Cases: Abstract classes are often used to define a common interface or behavior that multiple
related classes should share. They provide a level of abstraction and ensure that certain methods or
properties are present in all subclasses.
Here's an example of an abstract class and its usage:

abstract class Shape {

abstract fun area(): Double // Abstract method

fun description() {

println("This is a shape.")

class Circle(val radius: Double) : Shape() {

override fun area(): Double {

return Math.PI * radius * radius

}
AMC Sem 5 Krishna

class Rectangle(val width: Double, val height: Double) : Shape() {

override fun area(): Double {

return width * height

fun main() {

val circle = Circle(5.0)

val rectangle = Rectangle(4.0, 6.0)

println("Circle Area: ${circle.area()}")

println("Rectangle Area: ${rectangle.area()}")

circle.description()

rectangle.description()

In this example, Shape is an abstract class with an abstract method area(), and concrete method
description(). Both Circle and Rectangle are subclasses of Shape and provide concrete
implementations of the area() method. When an instance of Shape is created, it cannot call area()
because it is abstract, but it can call description() directly.

9. Discuss JSON Object in detail.

ANS: -
A JSON object (JavaScript Object Notation object) is a fundamental data structure used in JSON
(JavaScript Object Notation) to represent structured data. JSON is a lightweight data interchange
format that is easy for humans to read and write and easy for machines to parse and generate.
JSON objects are often used for data exchange between a server and a web application, or between
different parts of a program.
Here are the key characteristics and details about JSON objects:
AMC Sem 5 Krishna

JSON Syntax: JSON objects are defined using a key-value pair syntax, which makes them similar to
dictionaries or associative arrays in other programming languages. In JSON, keys are always strings,
and values can be strings, numbers, booleans, null, arrays, or nested JSON objects.
Key-Value Pairs: A JSON object consists of zero or more key-value pairs enclosed in curly braces {}.
Each key is followed by a colon : and the corresponding value. Key-value pairs are separated by
commas.

"name": "John",

"age": 30,

"isStudent": false,

"grades": [95, 88, 73],

"address": {

"street": "123 Main St",

"city": "New York"

Keys as Strings: JSON keys are always enclosed in double quotation marks, making them strings. For
example, "name" and "age" are keys in the JSON object above.
Values: JSON values can be of various data types:

• Strings: Enclosed in double quotation marks (e.g., "John").

• Numbers: Can be integers or floating-point numbers (e.g., 30).

• Booleans: true or false.

• null: Represents the absence of a value.

• Arrays: Ordered lists of values enclosed in square brackets (e.g., [95, 88, 73]).

• Nested JSON Objects: JSON objects can be nested within other JSON objects (e.g.,
"address").
Structure: JSON objects are hierarchical and can have nested objects or arrays as values. This allows
for the representation of complex data structures.
Uniqueness of Keys: Keys within a JSON object must be unique. If you define two identical keys, the
JSON would be considered invalid.
Order of Elements: JSON does not require a specific order for key-value pairs within an object.
However, many JSON parsers preserve the order of elements as they appear in the source text.
AMC Sem 5 Krishna

Use Cases: JSON objects are commonly used for representing structured data in various scenarios,
including:

• Data exchange between a client and a server in web applications (e.g., API responses).

• Configuration files for applications.

• Storing and exchanging data between different parts of a program.

• Serialization and deserialization of data.

JSON Libraries: Nearly all modern programming languages provide libraries or built-in functions for
working with JSON. These libraries can parse JSON strings into native data structures and serialize
native data structures into JSON.
JSON is widely used because of its simplicity and readability, making it a popular choice for data
interchange in web services and applications. It is language-agnostic, meaning it can be used with a
variety of programming languages, making it an excellent choice for cross-platform data exchange.

10. Explain Kotlin String. Also discuss Nullable variable.

ANS: -
In Kotlin, a String is a fundamental data type that represents a sequence of characters. It is used to
store and manipulate textual data. Strings in Kotlin are immutable, which means once a string is
created, its value cannot be changed. You can create strings using double-quoted string literals or
by using the String constructor.
Here's how you can declare and use strings in Kotlin:

// Using double-quoted string literals

val str1: String = "Hello, World!"

val str2 = "Kotlin is awesome!"

// Using the String constructor

val str3: String = String(charArrayOf('H', 'e', 'l', 'l', 'o'))

You can concatenate strings using the + operator:

val firstName = "John"

val lastName = "Doe"

val fullName = firstName + " " + lastName // "John Doe"

You can access individual characters in a string using indexing:

AMC Sem 5 Krishna

val text = "Kotlin"

val firstChar = text[0] // 'K'

Kotlin provides many string manipulation functions as part of the standard library, such as length,
substring, startsWith, endsWith, contains, toUpperCase, toLowerCase, and many more.
Now, let's discuss nullable variables in Kotlin.
In Kotlin, variables can be declared as nullable by adding a ? symbol after the type declaration. A
nullable variable is one that can hold either a non-null value or a special value called null, which
indicates the absence of a value.
Here's how you can declare nullable and non-nullable variables:

// Non-nullable variable

var nonNullableStr: String = "This cannot be null"

// nonNullableStr = null // This would result in a compilation error

// Nullable variable

var nullableStr: String? = "This can be null"

nullableStr = null // OK

The nonNullableStr variable is declared as a non-nullable String, which means it can only hold string
values, and attempting to assign null to it will result in a compilation error.
On the other hand, the nullableStr variable is declared as a nullable String?, which means it can
hold either a string value or null. Assigning null to a nullable variable is allowed.
However, when working with nullable variables, you need to be cautious to avoid null pointer
exceptions (NPEs). You can safely access properties or call methods on a nullable variable by using
the safe call operator ?.:

val length = nullableStr?.length // If nullableStr is null, length will be null

Alternatively, you can use the non-null assertion operator !!. if you are certain that the variable
won't be null; however, if it is null, it will result in an NPE:

val length = nullableStr!!.length // This may cause an NPE if nullableStr is null

Using nullable types and handling null values effectively is a key aspect of writing safe and robust
Kotlin code.

11. What is array in Kotlin? How to Create, modify and access array?

ANS: -
AMC Sem 5 Krishna

In Kotlin, an array is a collection of similar data types, such as Int, String, etc. Arrays in Kotlin are
mutable, which means they can be modified (changeable) in nature but have a fixed size. This
allows you to perform both read and write operations on elements within the array.
Here's how to create, modify, and access arrays in Kotlin:
Creating Arrays

• Using the arrayOf() Function

You can use the arrayOf() function to create an array by passing the values of the elements to the
function. There are two ways to declare arrays using arrayOf():

val NewArray1 = arrayOf(6, 11, 5, 20, 7) // Implicit type declaration

val NewArray2 = arrayOf<Int>(20, 2, 72) // Explicit type declaration

val NewArray3 = arrayOf<String>("Hiren", "Rakesh", "Pankaj") // Explicit type

declaration

You can also create arrays with specific data types using functions like intArrayOf(), charArrayOf(),
booleanArrayOf(), and so on:

var NewArray5: IntArray = intArrayOf(6, 11, 5, 20, 7)

• Using the Array Constructor

Since Array is a class in Kotlin, you can also use the Array constructor to create an array. The
constructor takes two parameters: the size of the array and a function that initializes the elements.

val num = Array(3) { i -> i * 1 }

In this example, we create an array of size 3 and initialize its elements using a lambda expression.
Modifying and Accessing Array Elements
➢ Modifying Array Elements
You can modify elements in an array using the set() function or the index operator []:

NewArray1.set(1, 3) // Set the value of the second element to 3

NewArray1[2] = 9 // Change the value of the third element to 9

➢ Accessing Array Elements

You can access elements in an array using the get() function or the index operator []:

val x = NewArray1.get(0) // Get the value of the first element

val y = NewArray1[1] // Get the value of the second element

Here's a complete example that demonstrates modifying and accessing array elements:
AMC Sem 5 Krishna

fun main(args: Array<String>) {

val arr1 = arrayOf(6, 7, 8, 9)

val arr2 = arrayOf<Long>(15, 20, 25, 30)

arr1.set(0, 5)

arr1[2] = 3

arr2.set(2, 28)

arr2[3] = 18

for (element in arr1) {

println(element)

println()

for (element in arr2) {

println(element)

This code demonstrates creating arrays, modifying their elements, and accessing them in Kotlin.

12. How to set different screen sizes and Layouts on different devices?
ANS: -
To support different screen sizes and layouts on different devices in Android development, you can
follow the guidelines mentioned in the provided information. Here's how you can achieve this with
appropriate examples, drawings, and diagrams:
1 . Responsive and Adaptive Layouts:
Responsive Layouts: Responsive layouts adjust their design based on the available screen size to
provide an optimized user experience. These layouts adapt to various screen sizes and orientations.
AMC Sem 5 Krishna

Adaptive Layouts: Adaptive layouts provide alternative designs optimized for specific display
dimensions. These layouts may include different UI components or arrangements for different
screen sizes.
2. Window Size Classes:
Android uses window size classes to categorize the display area available to your app as compact,
medium, or expanded, both in terms of width and height.
Window size classes are not determined by the physical device size but by the available window
space for your app.
Example diagram illustrating different window size classes based on width and height:

3. Resource Qualifiers:
Use resource qualifiers in your Android project to create alternative layouts for different screen
sizes and orientations.
Smallest Width Qualifier: Create different layouts for screens with different minimum widths
measured in density-independent pixels (dp).
Available Width/Height Qualifier: Modify layouts based on the current available width or height,
allowing for responsive changes.
Orientation Qualifiers: Adjust layouts for both portrait and landscape orientations.
Example layout directory structure for alternative layouts:

res/

├── layout/

│ └── main_activity.xml (for phones)

├── layout-sw600dp/

│ └── main_activity.xml (for 7” tablets)

├── layout-land/

│ └── main_activity.xml (for phones in landscape)

AMC Sem 5 Krishna

├── layout-sw600dp-land/

│ └── main_activity.xml (for 7” tablets in landscape)

4. ConstraintLayout for Responsiveness:

Use ConstraintLayout as the base layout for your UI. ConstraintLayout allows you to define view
positions and sizes based on spatial relationships with other views.
ConstraintLayout makes it easier to create responsive designs that adapt to various screen sizes.

5. Modularized UI Components with Fragments:

Extract UI logic into separate fragments to avoid duplicating UI behavior across activities.
Combine fragments to create multi-pane layouts on large screens or place fragments in separate
activities on small screens.
6. Activity Embedding:
Use activity embedding to display multiple activities or instances of the same activity
simultaneously on larger screens.
Activities can be displayed side by side on large screens and stacked on top of each other on smaller
screens.
Create an XML configuration file or use Jetpack WindowManager API calls to determine how your

app displays activities based on screen size.

7. Testing for Different Aspect Ratios:
Test your app on devices with various screen sizes and aspect ratios to ensure proper scaling and
layout.
Android 10 and higher support a wide range of aspect ratios, including foldable form factors.
Diagram illustrating different screen aspect ratios and their compatibility:
AMC Sem 5 Krishna

Use maxAspectRatio and minAspectRatio in your AndroidManifest.xml to specify the acceptable

aspect ratios for your app.
8. Android Emulator for Testing:
If you don't have access to physical devices with different screen sizes, use the Android Emulator to
emulate a wide range of screen sizes and configurations for testing.
The emulator allows you to test your app on various virtual devices with different screen sizes,
resolutions, and orientations.

By following these guidelines and using appropriate resource qualifiers, layouts, and modularization
techniques, you can create Android apps that provide an optimal user experience on a wide range
of devices and screen sizes.

13. Write a note on Activity Lifecycle

ANS: -
The Android Activity Lifecycle is a crucial concept for Android app developers to understand. It
represents the various states an activity goes through during its lifetime, from its creation to its
destruction. These states are managed by the Android system, and each state transition triggers
specific callback methods that developers can override to perform tasks or manage the behavior of
their app. Here's a note on the Android Activity Lifecycle based on the provided data:
Activity Lifecycle Callbacks
➢ onCreate():

• This is the first callback and is called when the activity is first created.

• It is where you typically perform one-time initialization, such as setting up the user interface
and other resources.
AMC Sem 5 Krishna

• After onCreate, the activity transitions to the onStart state.

➢ onStart():

• This callback is called when the activity becomes visible to the user.

• You can perform tasks like starting animations or refreshing the user interface.

• After onStart, the activity transitions to the onResume state.

➢ onResume():

• This is called when the user starts interacting with the application.

• You should start or resume any operations that were paused or stopped in onPause.

• This is where the activity is actively running and in the foreground.

• After onResume, the activity is running and ready to receive user input.
➢ onPause():

• The paused activity does not receive user input and cannot execute any code.

• This callback is called when the current activity is being paused and the previous activity is
being resumed.

• It's a good place to save changes and stop animations or other ongoing tasks.

• After onPause, the activity can either go to onStop or onResume based on user interaction.
➢ onStop():

• This callback is called when the activity is no longer visible.

• It's a good place to release resources and stop background services.

• The activity can be brought back to the foreground with onRestart or destroyed with
onDestroy.
➢ onDestroy():

• This callback is called before the activity is destroyed by the system.

• It's the final opportunity to release any resources, unregister receivers, or perform cleanup.

• After onDestroy, the activity is removed from memory and cannot be resumed.
➢ onRestart():

• This callback is called when the activity restarts after stopping it.

• It's an opportunity to reinitialize components that were released in onStop.

Activity Lifecycle Flow
AMC Sem 5 Krishna

• An activity typically starts with onCreate and goes through the sequence of onStart,
onResume, onPause, onStop, and onDestroy during its lifetime.

• User interaction can lead to transitions between onPause, onStop, and onResume.

• The activity can also be explicitly restarted using onRestart.

Understanding the Android Activity Lifecycle is crucial for managing resources, saving and restoring
state, and providing a smooth user experience in Android apps. It helps developers handle various
scenarios, such as responding to incoming calls or handling screen rotations, gracefully.

14. Differentiate between JSON and XML

ANS: -

Aspect JSON XML

Full Form JavaScript Object Notation Extensible Markup Language

Data JSON is a lightweight data XML is a markup language used for encoding
Structure interchange format. documents in a format that is both human-
readable and machine-readable.

Syntax Uses key-value pairs, making it Uses tags and attributes, which can be verbose
easy to read and write. and complex.

Readability JSON is more concise and XML can be verbose and less readable due to
easier for humans to read and its tag-based structure.
write.

Complexity Simpler structure with minimal Supports complex data structures and
markup. hierarchies.

Extensibility Limited extensibility with Highly extensible and allows custom data
predefined data types. structures via Document Type Definitions (DTD)
or XML Schema Definitions (XSD).

Parsing Faster parsing due to its Slower parsing due to the need to interpret
lightweight structure. tags and attributes.

Usage Commonly used for APIs, Commonly used for documents, web services,
configuration files, and data and structured data storage.
interchange.

Support for Supports arrays as collections Arrays are typically represented using XML
Arrays of values. elements.

Namespaces Does not natively support Supports namespaces for disambiguating

namespaces. element names in complex documents.
AMC Sem 5 Krishna

Error Limited error handling Provides comprehensive error-handling

Handling capabilities. features.

Tools and Abundant JSON parsers and Numerous XML parsers and libraries available
Libraries libraries available for various for most programming languages.
programming languages.

Example json { "name": "John", "age": xml <person> <name>John</name>

30, "city": "New York" } <age>30</age> <city>New York</city>
</person>

Both JSON and XML have their strengths and weaknesses, and the choice between them often
depends on the specific use case and compatibility requirements. JSON is preferred for simplicity
and efficiency, while XML is more suitable for complex document structures and data interchange
with strong schema definitions.

15. What do you mean by Intents? Explain Different types of intents

ANS: -
In Android, an Intent is a fundamental component used for communication between different parts
of an application or between different applications. Intents serve as a messaging system to request
an action from another component, such as starting an activity, service, or broadcasting a message.
There are two main types of Intents in Kotlin:
➢ Explicit Intents:

• Explicit Intents are used to launch a specific component within your own application, such
as starting a particular activity, service, or BroadcastReceiver.

• You specify the target component's class name or the action to be performed explicitly.

• Typically used for navigating within your app.

val explicitIntent = Intent(this, TargetActivity::class.java)

startActivity(explicitIntent)

➢ Implicit Intents:

• Implicit Intents are used to request an action from other components outside of your app.
You don't specify a specific component, but you specify an action, data, or type, and the
Android system decides which component can fulfill the request.

• Implicit Intents are often used to interact with system components or other third-party
apps.
AMC Sem 5 Krishna

val implicitIntent = Intent(Intent.ACTION_VIEW)

implicitIntent.data = Uri.parse("https://www.example.com")

startActivity(implicitIntent)

Types of Intents based on their usage:

• Activity Intents: Used to navigate between different activities within your app or to launch a
specific activity from another app.

• Service Intents: Used to start or communicate with background services. Services run in the
background and perform tasks without requiring a user interface.

• Broadcast Intents: Used to send system-wide broadcasts or custom broadcasts within your
app. Other components can listen to these broadcasts and respond accordingly.

• Content Provider Intents: Used to interact with content providers to access or modify data
stored in a structured way.

• Notification Intents: Used to launch specific activities or perform actions when a notification
is clicked.
Intents are a crucial part of Android app development, enabling communication and interaction
between different parts of an app and between apps themselves. They provide a flexible and
extensible way to perform various tasks within the Android ecosystem.