DEV Community: Daniel Brian

Mastering Nullability and Collections in Kotlin: Unleash the Full Power of Your Code.

Daniel Brian — Mon, 24 Apr 2023 20:17:50 +0000

In this article, we're going to look at two important concepts in Kotlin OOP;
1. Nullability
2. Collections

1. Nullability

NullPointer Exceptions are thrown by the program at runtime and sometimes cause application failure or system crashes.
NullPointer exceptions are caused by:

Explicit call to throw NullPointer()
Use of the null assertion operator !!
Data inconsistency with regard to initialization
Java interoperations eg attempts to access a member on a null reference.
Kotlin is designed to avoid errors due to null values. The code below demonstrates this design choice;

fun main() {
   var message : String = "Hello world"
    message = null
    println(message)
}

When you try to run the above code you will realize that it is not possible to assign a null value to the message variable and the compiler will display an error.
To allow a variable to hold null, we can declare a variable as nullable string, written as String?

fun main() {
   var message : String? = "Hello world"
    message = null
    println(message)
}

If you try to access the length property of the message variable while the message variable is null, the exception will be thrown.

fun main() {
   var message : String? = "Hello world"
   message = null
   var length = message.length
    println(length)

}

To avoid these errors, you will need to check for a null value before accessing the property. Here's the update for the above code in using the length method.

fun main() {
   var message : String? = "Hello world"
   message = null
    if (message != null){
        var length = message.length
        println(length)
    }else {
        println(null)
    }    
}

We can deal with nulls in the following ways:

Smart casting - It is used if you add a condition and it allows for treating a variable as not null after you check that it is not null.
Safe call - It means calling the right side, if the left side is not null.
Elvis Operator - It is used to provide a default value when a value could be null.
Not null insertion - The "Not null assertion" is an unsafe option, as it throws an exception when a value is null.

1. Smart - Casting

Kotlin compiler tracks conditions inside the if expression. If the compiler founds a variable is not null or type nullable then the compiler will allow to access the variable.

fun main() {
   var message : String? = "Hello world"
    //Smart cast
    if (message != null){
        var length = message.length
        println(length)
    }else {
        println(null)
    }    
}

While using is and !is for checking the variable the compiler tracks this information and internally cat the variable to the target type.

fun main() {
   var message : Any? = "Hello world"
    //Smart cast using is
    if (message is String){
        var length = message.length
        println("The string length is $length")
    }    
}

This is done inside the scope if is or !is returns true.
In addition we can use !is for smart cast.

fun main() {
   var message : Any? = 67
    //Smart cast using is
    if (message !is String){
      println("Object is not String")
    } else {
         var length = message.length
        println("The string length is $length") 
    }   
}

2. Not null insertion : !! Operator

The not null assertion (!!) operator converts any value to non-null type and throws an exception if the value is null.
If anyone want NullPointer Exception then he can ask explicitly using this operator.

fun main() {
   var message : String? = "Meercedes Benz"
    //using the not null assertion
    println(message!!.length)  
    // Using a null 
    // The length method we throw an error
    message = null
    println(message!!.length)
}

3. Elvis Operator

It returns a non- null value or a default value, when the original variable is null.
In other words, if left expression is not null then elvis operator returns it, otherwise it returns the right expression.

fun main() {
 val str: String? = null
val length = str?.length ?: -1
println("Length of the string is $length")
}

we can also throw and return expressions on the right side of the elvis operator and it is very useful infunctions. Hence, we can throw an exception instead of returning a default value in theright side of the elvis operator.

val name = firstname?: throwIllegalArgumentsExceptions("Enter valid name")

4. Safe call

A safe call is when ?. is used instead of. syntax between an object and its function or property.
A safe call calls the right side if the left side is not null. Otherwise, It does nothing and returns null.

fun main() {
 var str: String? = "Happy Birthday"
    println(str?.length)
    str = null
    println(str?.length)
}

The output of the first pritnln will be the length of our string ,14, the last println will be null.

We can use the safe call operator with let(), also() and run() if value is not null.

let() method

The lambda expression present inside the let is executed only if the variable firstName is not null.

val firstName: String? = null
firstName?.let { println(it.toUpperCase()) }

Here, the variable firstName is null, so the lambda expression is not executed to convert the string to Upper Case letters. Kotlin program of using let.

fun main(args: Array<String>) {
    // created a list contains names
    var stringlist: List<String?> = listOf("Geeks","for", null, "Geeks")
    // created new list
    var newlist = listOf<String?>()
    for (item in stringlist) {
        // executes only for non-nullable values
        item?.let { newlist = newlist.plus(it) }
    }
    // to print the elements stored in newlist
    for(items in newlist){
        println(items)
    }
}

also() method chain with let()

If we want to apply some additional operation like printing the non-nullable items of the list we can use an also() method and chain it with a let() or run():

fun main(args: Array<String>) {
    // created a list contains names
    var stringlist: List<String?> = listOf("Geeks","for", null, "Geeks")
    // created new list
    var newlist = listOf<String?>()
    for (item in stringlist) {
        // executes only for non-nullable values
        item?.let { newlist = newlist.plus(it) }
        item?.also{it -> println(it)}
    }
}

run() method

Kotlin has a run() method to execute some operation on a nullable reference.
It seems to be very similar to let() but inside of a function body, the run() method operates only when we use this reference instead of a function parameter:

fun main(args: Array<String>) {
    // created a list contains names
    var stringlist: List<String?> = listOf("Geeks","for", null, "Geeks")
    // created new list
    var newlist = listOf<String?>()
    for (item in stringlist) {
        // executes only for non-nullable values
        item?.run { newlist = newlist.plus(this) } // this reference
        item?.also{it -> println(it)}
    }
}

2. Collections in Kotlin

A collection usually contains a number of objects of the same type called elements or items.
In Kotlin collections can be either mutable or immutable.
Immutable collections supports read-only functionalities and cannot be modified whereas mutable collections supports both read and write functionalities.
We will look at several collections which include:

Lists
Sets
Map

Lists

It is an ordered collection in which we can access elements using indices.
In a list, we can have repeating elements.

fun main() {
 var groceries = listOf("carrots","onions","kales")
 println(groceries)
}

The result type is list<T> where T is the type of the elements in the list. In the code above our lists consists of string hence its type is list<String>
We add elements to alist using the plus sign (+). You can add a single element to a list or you can add two lists together.

fun main() {
 var groceries : List<String> = listOf("carrots","onions","kales")
 var numbers : List<Int> = listOf(12,45,78)
 println(groceries + numbers)
}

We can check the number of items in a list using the size property.

fun main() {
 var groceries : List<String> = listOf("carrots","onions","kales")
 var numbers : List<Int> = listOf(12,45,78)
 val shopping = groceries + numbers
 println(shopping.size)//6
}

We can use the isEmpathy method or compare the size of a list to zero to check if the list is empty.
You can get an element at a certain position using the index that is the box brackets.

fun main() {
 var groceries : List<String> = listOf("carrots","onions","kales")
 var numbers : List<Int> = listOf(12,45,78)
 // using the + adding sign
 val shopping = groceries + numbers
 //using the size property
 println(shopping.size)//6
 // Using the isEmpty() property
 println(shopping.isEmpty())//false
}

We use the contains method or in operator to check if a set contains a certain element. In the above code we can add the following code.

println("carrots" !in list)//true
println("apple" in list)// false

With mutable lists you can use methods like add or remove to add or remove a certain element.

fun main() {
    val mutableList = mutableListOf("apple", "banana", "cherry")

    // adding an element to the list
    mutableList.add("date")

    // removing an element from the list
    mutableList.remove("banana")

    // updating an element in the list
    mutableList[0] = "apricot"

    // printing the contents of the list
    println(mutableList)
}

Set

It is a collection of unordered elements which are unique. It does not support duplicate elements.

fun main() {
    val setList = setOf("apple", "banana", "cherry")
    for (items in setList){
        println(items)
    }
}

With mutable sets you can use methods like add or remove an element. Set preserve the order of the elements.

fun main() {
   // create a mutable set
val mutableSet = mutableSetOf<Int>()

// add elements to the mutable set
mutableSet.add(1)
mutableSet.add(2)
mutableSet.add(3)

// remove an element from the mutable set
mutableSet.remove(2)

// check if an element is in the mutable set
val containsOne = mutableSet.contains(1)

// iterate over the mutable set
for (element in mutableSet) {
    println(element)
  }
}

Map

Map keys are unique and hold only one value for each key. Each key maps to exactly one value.
Maps are used to store logical connections between two objects. The values in a map can be duplicate with unique keys.

fun main() {
    // create an immutable map
val immutableMap = mapOf(
    "apple" to 1,
    "banana" to 2,
    "orange" to 3,
    "pear" to 4,
    "grape" to 5
)

// access values in the map
val bananaValue = immutableMap["banana"]

// add a new element to the map
val newMap = immutableMap + ("kiwi" to 6)

// remove an element from the map
val removedMap = immutableMap - "pear"

// iterate over the map using restructuring
for ((key, value) in immutableMap) {
    println("$key -> $value")
 }
}

Maps do not allow duplicates so when you add a new association, it removes the old one.
You can remove certain elements from a map using the minus sign.
Kotlin supports the restructuring of a map in a for loop.

fun main() {
    // Create a mutable map
    val myMap = mutableMapOf<String, Int>()

    // Add items to the map
    myMap["apple"] = 3
    myMap["banana"] = 5
    myMap["orange"] = 2

    // Print the map
    println("My map: $myMap")

    // Update an item in the map
    myMap["banana"] = 6

    // Print the updated map
    println("My updated map: $myMap")

    // Remove an item from the map
    myMap.remove("orange")

    // Print the updated map
    println("My final map: $myMap")
}

You can add new associations to a map using the bracket and assignment. In addition, we can also remove an association by using the remove method.

Exploring Kotlin's Abstract Classes and Specialized Class Types: A Guide to Object-Oriented Programming Concepts.

Daniel Brian — Fri, 21 Apr 2023 21:53:35 +0000

In this article, we are going to look at two concepts that are crucial in Modern Android development.
By the end of this article, Our aim will be to dive into:
1. Abstract classes
2. Special kinds of classes in Kotlin

I. Abstract Classes

Abstract classes can be thought of as a hybrid of an open class and an interface.
An abstract class is declared using the abstract keyword in front of the class.

abstract class className {}

Abstract classes can contain both abstract and non-abstract member properties in an abstract class. These properties are marked with the abstract modifier and they do not have a body as shown below.

abstract class className(val x : String) //non-abstract property
 {
    abstract var y : Int //Abstract property
    abstract fun method () //Abstract property
    fun method () //non-abstract method property
                 {
    println("Non abstract function")
                  }
}

Abstract classes cannot be used to create objects. However, you can inherit subclasses from them but they need to be overridden.
The key advantage of abstract classes is that they can have non-open methods and non-abstract properties.

abstract class Employee (val name : String,val experience : Int){
    //abstract property
    abstract var salary : Double 
    abstract fun dateOfBirth(date : String)
    //non-abstract property
    fun employeeDetails() {
        println("Name of the employee : $name")
        println("Experience in years : $experience")
        println("Annual salary : $salary")
    }
}
//derived class
class Engineer (name: String, experience: Int): Employee(name, experience) {
    override var salary = 5000.00
    override fun dateOfBirth(date : String){
        println("Date of Birth is: $date")
    }
}
fun main () {
    val eng = Engineer("Praveen",2)
    eng.employeeDetails()
    eng.dateOfBirth("02 December 1994")
}

Abstract classes are mainly used when you want to specify a set of generic operations for multiple classes. An abstract member of the abstract class can be overridden in all the derived classes.
In the below class we override the cal function in three derived classes of the calculator.

abstract class Calculator {
    abstract fun cal (firstNum : Int, secondNum : Int): Int
}
//Addition of two numbers
class Add : Calculator () {
    override fun cal (firstNum : Int, secondNum : Int) : Int{
        return firstNum + secondNum
    }
}
//Division of two numbers
class Divide : Calculator () {
    override fun cal (firstNum : Int, secondNum : Int) : Int{
        return firstNum / secondNum
    }
}
//Multiplication of two numbers
class Multiply : Calculator () {
    override fun cal (firstNum : Int, secondNum : Int) : Int{
        return firstNum * secondNum
    }
}
//Subtraction of two numbers
class Subtract : Calculator () {
    override fun cal (firstNum : Int, secondNum : Int) : Int{
        return firstNum - secondNum
    }
}

fun main () {
    var add : Calculator = Add()
    var add1 = add.cal(4,3)
    println("Addition of two numbers $add1")

    var subtract : Calculator = Subtract()
    var add2 = subtract.cal(4,3)
    println("Subtraction of two numbers $add2")

    var multiply : Calculator = Multiply()
    var add3 = multiply.cal(4,3)
    println("Multiplication of two numbers $add3")

    var divide : Calculator = Divide()
    var add4 = divide.cal(24,3)
    println("Division of two numbers $add4")
}

In kotlin, we can override the non-abstract open member function of the open class using the override keyword followed by an abstract in the abstract class.

open class vertebrates {
     open fun Backbone () {
        println("All vertebrates have a backbone")
    }
}

abstract class Animal : vertebrates () {
    override abstract fun Backbone ()
}   

class Birds : Animal () {
    override fun Backbone () {
        println("Birds have a backbone")
    }
}

fun main () {
    val animals = vertebrates ()
    animals.Backbone()
    val birds = Birds()
    birds.Backbone()

}

II. Special Kind of Classes

There are different classes each with a dedicated purpose. These classes include:

Data classes
Enum classes
Exception classes
Sealed classes
Annotation classes

1. Data classes

Data classes are a special kind of class dedicated to serving as a holder of data. They help to compare, display, read, and modify this data more easily.

Basic values like strings can be compared using the double equality sign.

class superCars (val name : String,val year : Int)
fun main () {
    var car1 = superCars("volvo",2020)
    var car2 = superCars("BMW" ,2021)
    var car3 = superCars("volvo",2020)
    var car4 = superCars("Benz",2019)

    println(car1 == car2)//false
    println(car1 == car1)//true
    println(car3 == car4)//false
}

The result is true if the values are alike and false if the values vary.
When we use the dot syntax in our main function to call the properties of the class as shown below.

class superCars (val name : String,val Modelyear : Int)
fun main () {
    var car1 = superCars("volvo",2020)
    var car2 = superCars("BMW" ,2021)
    var car3 = superCars("volvo",2020)
    var car4 = superCars("Benz",2019)

    println(car1.name)
    println(car1.Modelyear)

    println(car4.name)
    println(car4.Modelyear) 

}

The output of the code will volvo 2020 and Benz 2019

When we call the instances of our class without specifying the keyword data, the output gives the memory location of where the instance is stored in the class.

class superCars (val name : String,val Modelyear : Int)
fun main () {
    var car1 = superCars("volvo",2020)
    var car2 = superCars("BMW" ,2021)
    var car3 = superCars("volvo",2020)
    var car4 = superCars("Benz",2019)

    println(car1)//superCars@37f8bb67
    println(car2)//superCars@439f5b3d
           }

The output of the code above is superCars@37f8bb67 for car1 and superCars@439f5b3d for car2 respectively.

When we specialize the keyword data before class the output of the code changes. This is because the behavior of equality has changed.

data class superCars (val name : String,val Modelyear : Int)
fun main () {
    var car1 = superCars("volvo",2020)
    var car2 = superCars("BMW" ,2021)
    var car3 = superCars("volvo",2020)
    var car4 = superCars("Benz",2019)
println(car1)
println(car2)
    }

Data classes have a copy method that creates a copy of an object. It allows you to specify what modifications you would like to introduce to an object.

data class Person(val firstName: String, val familyName:String) {
var age = 0
}
fun main() {

val person1 = Person("John", "Doe").apply { age = 25 }
val(firstName,familyName) = person1

println(person1.copy(familyName = "Maye"))
}

You use data modifiers for classes that are used to represent a bundle of data.

Pair and Triple

This is a data class with two constructor properties, you don't need to define it, as it is distributed with Kotlin.
Pair is used to keep two values on properties first, and second.
You can use first and second properties when working with pair and triple.

fun main () {

    val fruits = Pair ("orange","Banana")

    //Using the first property 
    println(fruits.first)

     //Using the second property 
    println(fruits.second)
}

We can use to function between two values using the pair property.

fun main () {

    val Pair = 10 to "A"

    //Using the first property 
    println(Pair.first)

     //Using the second property 
    println(Pair.second)
}

Triple is used to keep three values on properties first, second, and third.

fun main () {

    val pair = Triple("Daniel",45, 'M')

    //Using the first property 
    println(pair.first)

     //Using the second property 
    println(pair.second)

    //Using the third property 
    println(pair.third)  
           }

we can also get the same output using the below code

fun main () {

    val pair = Triple("Daniel",45,'M')
    val(name,age,gender) = pair

    //Getting the first property 
    println(name)

     //Getting the second property 
    println(age)

    //Getting the third property 
    println(gender)  
    }

2. Enum classes

An enum has its own specialized type, indicating that something has a number of possible values.

Enums are defined by using the enum keyword in front of a class.

enum class days {
sunday,
monday,
tuesday,
wednesday,
thursday,
friday,
saturday
}

Enum have a constructor. Their constants are instances of an enum class. The constants can be initialized by passing specific values to the primary constructor.
we can access the colour of the ripe banana using an instance that we create in our main function.

enum class bananas (val color : String) {
    ripe("yellow"),
    unripe("green")
}
fun main () {

   val colour = bananas.ripe.color
    println(colour)
}

Kotlin enum classes has some inbuilt properties and functions which can be used by a programmer.
In properties we have ordinal and name. The ordinal property stores the ordinal value of the constant, which is usually a zero-based index. The name property stores the name of the constant.
In methods we have values and valueOf. The values property returns a list of all constants defined within the enum class.
The valueOf property returns the enum constant defined in enum, matching the input string. If the constant, is not present in the enum, then an illegalArgumentException is thrown.

enum class HalfYear {
    January,
    February,
    March,
    April,
    May,
    June
}
fun main () {
    for(month in HalfYear.values()){
        println("${month.ordinal} = ${month.name}")
        }
    }

We can access the individual month from the class using the valueOf property in the main function.

println("${HalfYear.valueOf("April")}")

Enum classes can be combined with when expression. Since enum classes restrict the value a type can take, so when is used with the when expression and the definitions for all the constants provided, then the need for the else clause is completely eliminated.

enum class Planets {
    Mercury,
    Venus,
    Earth,
    Mars,
    Jupiter,
    Saturn,
    Uranus
}

fun main() {
    for (planet in Planets.values()) {
        when (planet) {
            Planets.Mercury -> println("The Swift Planet")
            Planets.Venus -> println("The Morning and evening star")
            Planets.Earth -> println("The Goldilocks Planet")
            Planets.Mars -> println("The Red Planet")
            Planets.Jupiter -> println("The Gas giant Planet")
            Planets.Saturn -> println("The Ringed Planet")
            Planets.Uranus -> println("The Ice giant Planet")
        }
    }
}

Enum constants also behave as anonymous classes by implementing their own functions along with overriding the abstract functions of the class.
The most important thing is that each enum constant must be overridden.

enum class seasons (var weather : String) {

    Summer ("hot") {
        override fun foo () {
            println("Hot days of the year")
        }
    },

     Winter ("cold") {
        override fun foo (){
            println("Cold days of the year")
        }
    },

     Rainny ("rain") {
        override fun foo (){
            println("Rainny days of the year")
        }
    };

 abstract fun foo ()
}

fun main () {
    seasons.Winter.foo()
}

In enum classes functions are usuallly defined within the companion object so that they do not depend on specific instances of the class.
However, they can be defined without companion objects also.

enum class DAYS(val isWeekend: Boolean = false){
    SUNDAY(true),
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY(true);

    companion object{
        fun today(obj: DAYS): Boolean {
            return obj.name.compareTo("SATURDAY") == 0 || obj.name.compareTo("SUNDAY") == 0
        }
    }
}

fun main(){
    for(day in DAYS.values()) {
        println("${day.ordinal} = ${day.name} and is weekend ${day.isWeekend}")
    }
    val today = DAYS.MONDAY;
    println("Is today a weekend ${DAYS.today(today)}")
}

3. Exception classes

Exceptions are the errors which comes at the runtime and disrupts your flow of execution of the program.
We have two types of execution;

i. Checked Exception - these are exceptions that occur at the compile time eg IOException.
ii. Unchecked Exception - these are exceptions that occur at runtime eg OutOfBoundException. In kotlin we use unchecked exceptions.

We have some keywords which help us to handle exceptions.

i. Try - It helps us to find the exceptions.
ii. Throw - If the exception is found it throws the exception.
iii. Catch - After throwing it will catch the exception and
execute the body.
iv. Finally - It will always execute either we get
exception or not.

If the program exit by exitProcess(int) or absort(), then the finally will not be executed.
The syntax :

try {
    // your code
    // may throw an exception
}
catch (ex : ExceptionName)
{
    // Exception handle code
}
finally
{
    //This will execute everytime
    //It will execute whether we find an exceptiion or not
}

We can use the above syntax to create an exception class to divide a number by zero.

fun main () {

 try {

 divide (10,0)

    }
catch (ex : Exception)
{
    println(ex.message)
  }
}

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

    if(b == 0)
    throw Exception("Divide by Zero")
    println("Division is :" +a /b)
}

We can add the finally block in our code above. In the below below finally is executed in both cases either exceptions occur or not.

 fun main()
   {
    try
    {
    divide(20, 10)
    }
    catch (ex : Exception)
    {
    println(ex.message)
    }
    finally
    {
    println("I'm executed")
    }

    // 2nd try block
    try
    {
    // throw an exception
    divide(10, 0)
    }
    catch (ex : Exception)
    {
    println(ex.message)
    }
    finally
    {
    println("I'm executed")
    }
}

fun divide(a : Int, b : Int)
{
    if (b == 0)
        throw Exception("Divide by zero")
    println("Division is :" + a / b)
}

4. Sealed classes

A sealed class defines a set of subclasses within it. Sealed classes ensure type safety by restricting the types to be matched at compile-time rather than at runtime.

The syntax declaration of sealed classes is as shown below : sealed class NameOfTheClass
Sealed classes constructors are protected by default. Sealed class is implicitly abstract and hence it cannot be instantiated.

sealed class DemoClass
    fun main () {
        var InstanceDemo = Demo ()
    }

The above code would not run because of compile error as sealed classes cannot be instantiated.
All subclasses of a sealed class must be defined within the same kotlin file.

sealed class School {
    class Public:School(){
        fun display(){
            println("They are funded by the government")
        }
    }
    class Private:School(){
        fun display(){
            println("They are funded by individuals")
        }
    }
}

fun main(){
    val obj = School.Public()
    obj.display()
    val obj1= School.Private()
    obj1.display()
}

You cannot define a subclass of a sealed class inside a subclass because the sealed class woukd not be visible.
Sealed classes mostly uses when and eliminates the else clause.

// A sealed class with a string property
sealed class Fruit(val x : String)
{
    // Two subclasses of sealed class defined within
    class Apple : Fruit("Apple")
    class Mango : Fruit("Mango")
}

// A subclass defined outside the sealed class
class Pomegranate: Fruit("Pomegranate")

// A function to take in an object of type Fruit
// And to display an appropriate message depending on the type of Fruit
fun display(fruit: Fruit)
{
    when(fruit)
    {
        is Fruit.Apple -> println("${fruit.x} is good for iron")
        is Fruit.Mango -> println("${fruit.x} is delicious")
        is Pomegranate -> println("${fruit.x} is good for vitamin d")
    }
}
fun main()
{
    // Objects of different subclasses created
    val obj = Fruit.Apple()
    val obj1 = Fruit.Mango()
    val obj2 = Pomegranate()

    // Function called with different objects
    display(obj)
    display(obj1)
    display(obj2)
}

5. Annotation classes

Annotations allows the programmer to embed supplemental information into the source file. The information does not change the actions of the program.

Annotations contains compile-time constants parameters which include;
1. primitive types(Int,Long etc)
2. strings
3. enumerations
4. class
5. other annotations
6. arrays of the above-mentioned types
We can apply annotation by putting its name prefixed with the @ symbol in front of a code element.

 `@Positive val i : Int`

A parameter can be passed in parenthesis to an annotation similar to function call.

 `@Allowedlanguage("Kotlin")`

When an annotation is passed as parameter in another annotation, then we should omit the @ symbol. Here we have passed Replacewith() annotation as parameter.

` @Deprecated("This function is deprecated, use === instead", ReplaceWith("this === other"))`

When an annotation parameter is a class object, we should add ::class to the class name as:

@Throws(IOException::class)

To declare an annotation, the class keyword is prefixed with the annotation keyword.
By their nature, declarations of annotation cannot contain any code.
While declaring our custom annotations, we should specify to which code elements they might apply and where they should be stored.
The simplest annotation contains no parameters

annotation class MyClass
An annotation that requires parameter is much similar to a class with a primary constructor

annotation class Suffix(val s: String)
We can also annotate the constructor of a class. It can be done by using the constructor keyword for constructor declaration and placing the annotation before it.

class MyClass@Inject constructor(dependency: MyDependency) {  
//. . .   
}

We can annotate the properties of class by adding an annotation to the properties.

class Lang (
    @Allowedlanguages(["Java","Kotlin"]) val name: String)
}

Kotlin also provides certain in-built annotations, that are used to provide more attributes to user-defined annotations.

@Target

This annotation specifies the places where the annotated annotation can be applied such as classes, functions, constructors, type parameters, etc.
When an annotation is applied to the primary constructor for a class, the constructor keyword is specified before the constructor.

@Target(AnnotationTarget.CONSTRUCTOR, AnnotationTarget.LOCAL_VARIABLE)
annotation class AnnotationDemo2

class ABC @AnnotationDemo2 constructor(val count:Int){
    fun display(){
        println("Constructor annotated")
        println("Count is $count")
    }
}
fun main(){
    val obj =  ABC(5)
    obj.display()
    @AnnotationDemo2 val message: String
    message = "Hello"
    println("Local parameter annotated")
    println(message)
}

@Retention

This annotation specifies the availability of the annotated annotation i.e whether the annotation remains in the source file, or it is available at runtime, etc.
Its required parameter must be an instance of the AnnotationRetention enumeration that has the following elements:
SOURCE
BINARY
RUNTIME Example to demonstrate @Retention annotation:

//Specifying an annotation with runtime policy
@Retention(AnnotationRetention.RUNTIME)
annotation class AnnotationDemo3

@AnnotationDemo3 fun main(){
    println("Main function annotated")
}

@Repeatable

This annotation allows an element to be annotated with the same annotation multiple times.
As per the current version of Kotlin 1.3, this annotation can only be used with the Retention Policy set to SOURCE.

@Repeatable
@Retention(AnnotationRetention.SOURCE)
annotation class AnnotationDemo4 (val value: Int)

@AnnotationDemo4(4)
@AnnotationDemo4(5)
fun main(){
    println("Repeatable Annotation applied on main")
}

💫💫Thank you for taking the time to read my article, I appreciate your interest and support. I hope you enjoyed😇😇🥳🥳

Mastering Kotlin's Object-Oriented Programming 101: Unleashing the Full Potential of Your Code.

Daniel Brian — Mon, 10 Apr 2023 14:44:22 +0000

Hellooooo🥳️🥳️🥳️I am glad🤗 that you have joined me again in this Android development journey🚀. I am glad that you have decide to join me again on this exciting journey as we explore the world of kotlin for Android development.

🚀Kotlin is a programming language that's gaining popularity due to its ability to combine object-oriented and functional programming paradigms.
🚀In this article, we'll explore Kotlin's object-oriented programming features and how they can be used to build efficient software applications. Whether you're a seasoned developer or just starting out, come with us on this journey to discover why Kotlin is worth learning.

In this article, we are going to deep dive into one of the most important concepts of Kotlin:

1. Functions
2. Classes and Objects
3. Interfaces and Inheritance
4. Class Inheritance

1. Functions

Functions help in writing the code once and re-using it in other parts of your code.

Functions are used to break the code into smaller, more understandable, and reusable parts.

Variable scope and local functions

Variables defined inside of a function are called local variables. They are visible only in their defined scope.
These variables can be used in the functions they are defined.

fun firstFunction () {
val name = "Google Office Zurich"
    println(name)
}
fun CarType () {
    val car = "Bently"
    firstFunction()
    println(car)
}
fun main () {
    CarType()
}

The output of the above code after calling the function CarType() in the main function is Google Zurich Office and Bently. firstFunction cannot be used to access the type of car becaude it is mentioned outside its scope.

Local functions are defined inside other functions. They can only be used in their scope of the definition.
Top-level functions do not have such limitations they can be used everywhere even in functions defined earlier in a file.
Below is an example of a top-level function

fun calculateCircleArea(radius: Double): Double {
    return Math.PI * radius * radius
}
fun main () {
val area = calculateCircleArea(2.0)
println("The area of the circle is $area")
}

The output of the above code is 12.566370614359172

Functions with Parameters and result

Parameters are named variables that is defined as part of a function. They are specified using parenthesis after the function name.
When you declare or write a function and you use as a parameter, when you want to call this function, you must supply the parameter with a value. The value supplied for this parameter is called Argument

fun calculateCircleArea(radius: Double): Double {
    return Math.PI * radius * radius
}
fun main () {
val area = calculateCircleArea(2.0)
println("The area of the circle is $area")
}

In the above code sample the name radius: Double is the parameter of the function calculateCircleArea. The Argument supplied for the calculateCircleArea function is 2.0

An absolete function is a function that returns an integer value without a sign so this doesn't change positive values, but it returns all negative values into positive.

fun absolete(value : Int) :Int {
    if(value >= 0){
        return value
    }else{
        return -value
    }
}
fun main () {
    println(absolete(123)) // output 123 
    println(absolete(-1)) // output 1
    println(absolete(9)) // output 9
}

Single expression functions

In Kotlin, there is a special syntax for single expressions functions. Instead of braces with the body, you can use the equality sign, which specifies what should be returned.

fun triangleArea(width : Double, height : Double) : Double = width * height/2
fun main () {
val area = triangleArea(12.0,56.0)
println(area)
}

The ouput of the above code is 336.0

Recursion

These are functions that call themselves.
A factorial function is an example of a recursive function. To implement such a function we might define a variable called accumulator with an initial value of 1, which will be used to accumulate all the numbers. Then, for each number from 1 to the number you calculate the factorial, you will modify the value by multiplying it by the next number.
After that, all you need to do is to return the accumulator variable.

fun factorial(number : Int) : Int {
    var accumulator = 1
    for(i in 1..number){
       accumulator = accumulator * i 
    }
   return accumulator 
}
fun main () {
    println(factorial(5))
}

Default and Named arguments

Default arguments that need not specify explicitly while calling a function. When a function is called without passing arguments the parameters become the default arguments.

fun student(name: String="Praveen", standard: String="IX" , roll_no: Int=11) {  
    println("Name of the student is: $name")
    println("Standard of the student is: $standard")
    println("Roll no of the student is: $roll_no")
}
fun main() {
    student()        
}

The output of the above code is Praveen IX 11 since we have not passed any arguments in our student function in the main function.

Named arguments allows to specify arguments while calling a function. With named arguments, you can pass arguments to a function in any order, as long as you specify the name of each argument.

fun student( name: String="Praveen", standard: String="IX" , roll_no: Int=11 ) {
    println("Name of the student is: $name")
    println("Standard of the student is: $standard")
    println("Roll no of the student is: $roll_no")
}

fun main(args: Array<String>) {
    val name_of_student = "Gaurav"
    val standard_of_student = "VIII"
    val roll_no_of_student = 25
student(name=name_of_student,roll_no=roll_no_of_student)
}

For this code to work we pass arguments with names as defined in function.

2. Classes and Objects

A class is like a template that defines what an object looks like and how it can be used.
It specifies how the objects should be created and which methods and properties it consists of.

An object is an instance of a class. A type represents a category of objects eg an integer represents all integers.
To define a class in kotlin you use the keyword class and specify the name of the class.

class Car {
    var brand = ""
    var model = ""
    var year = 0
}

You will realize that when we use curly braces to define a class we must initialize the objects, we cannot leave them open but when we use brackets we don't have to initialize the class we only specify the type.
When we use brackets to enclose the class we should use commas to separate different properties inside it.

class Car (
   var brand : String,
    var model : String,
    var year : Int
         )

Creating an object

We can create an object of the Car class above called objCar, and then we can access the properties of objCar by using the dot syntax (.)

class Car (
   var brand : String,
    var model : String,
    var year : Int
         )
 fun main () {
     var objCar = Car(
     "Bently",
     "Mustang",
     2013
     )
      println( objCar.brand)
     println( objCar.model)
     println( objCar.year)
 }

When we use the brackets to define the class we use the primary constructor property when specifying a value for a regular property.
When we use the curly braces we define the properties of the class not as parameters as shown below.

class Car {
    var brand : String = ""
    var model : String = ""
    var year : Int = 0
         }
 fun main () {
     var objCar = Car()

     objCar.brand = "Bently"
     objCar.model = "Mustang"
     objCar.year = 2013

     println( objCar.brand)
     println( objCar.model)
     println( objCar.year)
 }

We can also specify the property of a class inside a class body. First, we use curly brackets as shown below.

class Car (
    var brand : String,
    var model : String
          )
{
    var ObjCar : String = "$brand($model)"
}
 fun main () {
     var CarType = Car( brand = "Bently", model = "Mustang")
     println(CarType.ObjCar)
            }

The output of the above code will be Bently(Mustang)

Methods

A method is a function associated with a class, for example a defined class. They are defined inside the class body. In other words, they are defined inside the curly braces.
Methods have direct access to all the properties of a class as shown below

class Subject (val name : String)

{
    fun Teacher (course : String, grade : String) : Teaches {
        println("$name teaches $course well I got $grade grade")
        return Teaches(course,grade)
                             }
    fun TeachesWell (course : String, grade : String){
        println("Congratulations")
    //Methods can be used to call other methods    
        Teacher(course, grade)
               }
}

class Teaches (
    var course : String,
    var grade : String
              )

fun main () {
    val read = Subject ("Daniel")
    read.TeachesWell(course = "Physics", grade = "A")
}

The output of the above code is

Congratulations
Daniel teaches Physics well I got A grade

In order to call a method, you need to have an object. For instance, when you have a class Dog with a method feed, to call this method outside the class, you need to first have an object of type Dog.

class Dog (var name: String)
{
    var hunger : Int = 62

    fun feed (){
        println("Feeding $name")
        hunger = 0
    }

}

fun main () {
    var dog = Dog ("Rex")
    dog.feed()
}

The output of the above code is feeding Rex.

Inside the method, we use the nameand hunger properties from the object that was used during the call. In a way, It is similar to defining feed as a top-level function and parsing Dog as an argument.
In methods, you can access members implicitly. For instance in the below code use just name, not dog.name

class Dog (var name : String)
{
    var hunger : Int = 62
}

fun feed (dog : Dog){
     println("Feeding ${dog.name}")
     dog.hunger = 0
    }

fun main () {
    var dog = Dog ("Rex")
    feed(dog)
}

The output of the above code is feeding Rex.

When you call methods, the object of their class is passed to their class body. This is called a receiver.
A receiver can be accessed using this keyword also known as reciever reference. So if you want to reference an object used to call a method inside this method, use this keyword.

class Dog(var name : String){
    var hunger = 62

    fun feed (){
      //Receiver
      var currentDog : Dog = this
        println("Feeding ${currentDog.name}")
        currentDog.hunger = 0
    }
}

fun main (){
    var dog = Dog("Rex")
    dog.feed()
}

when you call methods or properties inside methods, such as when you call name, you are calling methods or properties in the receiver, so its like calling this.name

class Dog(var name : String){
    var hunger = 62

    fun feed (){
      //Receiver
      //var currentDog : Dog = this
        println("Feeding ${this.name}")
        this.hunger = 0
    }
}

fun main (){
    var dog = Dog("Rex")
    dog.feed()
}

this keyword can be used to call methods or properties and sometimes it can be used explicitly.
One example might be when you have a method parameter and class property with the same name. Like in the below class, there is a property name and a method changeName with a parameter name. So if you see name inside the class, you will have a value of the parameter. To access the property use this.name

class User (var name : String) {
    fun changeName (name : String){
        println("Change name from ${this.name} to $name")
        this.name = name
    }
}

fun main () {
    val user = User("Alpha")
    user.changeName("Beta")
    println(user.name)
}

3. Interfaces and Inheritance

An interface is a collection of abstract methods and properties that define a common contract for classes that implement the interface.

Interfaces cannot be instantiated directly.

Creating interfaces

Interface is defined by the keyword Interface followed by the name of the interface and curly braces.
Functions and properties of the interface reside inside the curly braces.

interface Fruit {
  fun  BitterFruit()
  fun SweetFruit()
}

Implementing Interfaces

Interfaces are implemented by classes or objects.
Classes or objects implementing the interface should be followed by a colon and the name of the interface which is to be implemented. eg

interface Fruit {

   fun BitterFruit()
   fun SweetFruit()

}

class TypeFruit: Fruit {

    override fun BitterFruit() {
        println("Lemon is a bitter fruit")
    }
    override fun SweetFruit() {
        println("Apple is sweet fruit ")
    }
}

fun main () {
    val fruit = TypeFruit ()

    fruit.BitterFruit()
    fruit.SweetFruit()
}

We are using the keyword override in our functions because they were specified in the interface.

Default values and Default methods

Methods can have default values as parameters which are used when no value is passed during the function call.

interface Sum {
    // 10 and 20 are default values
    fun add( firstNum : Int = 10,secondNum : Int = 20)
    fun output () {
        println("This is an example of an addition of numbers")
    }
}
class Addition (): Sum {
    override fun add (firstNum : Int, secondNum : Int){
        val SumOfNumbers = firstNum + secondNum
        println("The sum of $firstNum and $secondNum is $SumOfNumbers")
    }
    override fun output () {
        super.output()
        println("Sum of two numbers")
    } 
}
fun main () {
    val addition = Addition()
    //We are overriding the default values with new arguments
    addition.add(30,30)
    addition.output()
}

The output is 60 and not 30. In our main function, we have changed our default values to hold 30 in both firstNum and secondNum.

The super keyword is used to call the default implementation of print specified in the inheritance.

Inheritance properties in interface

Interfaces can contain properties that cannot be instantiated hence no backfield to hold their values. The fields in the interface are either left abstract or are provided an implementation.

-Interfaces can also inherit others interfaces adding its own properties and methods in both the interfaces.

An interface can inherit more than interface.
The value of length and breadth are the properties of the interface dimensions.

interface Dimensions {
    val length : Double
    val breadth : Double
}
interface CalculateParameters : Dimensions {
    fun area ()
    fun perimeter ()
}
class Calculations () : CalculateParameters {
    override val length : Double
    get() = 40.0
    override val breadth : Double
    get() = 60.0

    override fun area () {
        println("The area is ${length * breadth}")
    }
    override fun perimeter () {
        println("The perimeter is ${2*(length + breadth)}")
    }
}
fun main () {
    var obj = Calculations ()
    // The area is 2400.0
    obj.area()
    // The perimeter is 200.0
    obj.perimeter()
}

Kotlin has multiple interface implementations. A class can implement more than one interface provided that it has a definition for all the numbers of the interface.
A class can only inherit one class.

interface Dimensions {
    val length : Double
    val breadth : Double
}
interface CalculateParameters {
    fun area ()
    fun perimeter ()
}
class Calculations () : Dimensions, CalculateParameters {
    override val length : Double
    get() = 40.0
    override val breadth : Double
    get() = 60.0

    override fun area () {
        println("The area is ${length * breadth}")
    }
    override fun perimeter () {
        println("The perimeter is ${2*(length + breadth)}")
    }
}
fun main () {
    var obj = Calculations ()
    // The area is 2400.0
    obj.area()
    // The perimeter is 200.0
    obj.perimeter()
}

4. Class Inheritance

During class inheritance

1. One must define a class that extends from another class.
2. The class to be inherited must be open.
3. One must introduce the same modifications to the behavior.

When one class inherits from another, it takes all the previous class methods and properties. It becomes its subclass, which means that it can be used wherever its parent is expected.

open class Klass () {
    fun students () {
        println("There are 50 students in the class")
    }
    fun subject () {
        println("The class takes chemistry as a compulsory subject")
    }
   }
class Teacher () : Klass() {
    fun teaches () {
        println("The teacher teaches all the 50 students chemistry")
    }

}
fun main () {
    val teach = Teacher ()
    teach.students()
    teach.subject()
}

class Klass is the super or the primary class while class Teacher is the subclass or the secondary class.

Visibility Modifiers in Classes

To make encapsulation possible you need to hide some properties and methods so that they can be used inside of a class but not outside of it. To do that you use the private visibility modifier before a function or a property you want to hide.
Private means that a particular property or a function can only be used in that class.
Protected means that a property can be used inside classes that are open or abstract.
Internal means that an element will be visible throughout the same module.

💫💫Thank you for taking the time to read my article, I appreciate your interest and support.😇😇🥳🥳

MODULE ONE: INTRODUCTION TO KOTLIN PROGRAMMING 101.

Daniel Brian — Sun, 26 Mar 2023 19:54:56 +0000

Hellooooo🥳️🥳️🥳️I am glad🤗 that you have joined me again in this Android development journey🚀. I am glad that you have decide to join me again on this exciting journey as we explore the world of kotlin for Android development. Here is one of the three articles we will be interacting with🥳️🥳️.Do not forget to 👍like, comment👍 and share with your friends👨‍👨‍👦‍👦🥳️.

Before we start here is a great saying by the Kotlin inventor:

"I wanted a better language than Java, so I started experimenting with one which could run on a JVM but which would be less syntactically verbose, more expressive, and which would remove some of the error-proneness of the Java type system. The result of this experimentation was the Kotlin programming language."
JetBrains co-founder and Kotlin inventor, Andrey Breslav.

Programming is a fascinating scale that allows you to talk to computers.
A program is simply a set of instructions created using a programming language that a computer must follow.
A programming language is a little like a bridge that we use to talk to computers and people.
Programming languages are classified into levels;

i. Low-level programming language: This is a machine language with zeros and ones. It is clear to be understood by a computer CPU.

ii. High-level programming language: This language needs to be interpreted that is converted to binary code that a CPU will be able to work with.
Kotlin is one of the high-level languages that need to be interpreted. Since its announcement by Google as the official language for developing android native apps, Kotlin has gained and continues to gain popularity in the field over the previously used Java programming language.
Some of the reasons Kotlin is preferred over Java include :
1.It is concise and standardized hence low code errors.
2.Easier to maintain complex projects due to low code.
3.It is compatible with java hence easy to convert java
code to Kotlin.
4.Kotlin handles errors that crash Android apps better
than java.
In addition, you might be wondering what else Kotlin could do apart from developing Android apps. Here are some of the fields Kotlin is gaining popularity :

Back-end web development: modern features that have been
added to kotlin have enabled the language to be used on
the server side since applications can scale quickly.
Kotlin also uses Spring frameworks used in java which
makes it easy for developers to work well with it.

Full-stack web development: Kotlin/JS allows developers to
access powerful browsers and web APIs in a type-safe
fashion. They can write front-end code in the same language
that they used for back-end code, and it’ll be compiled
into JavaScript to run in the browser.

Data Science: Data Scientists have always used Java to crunch numbers, detect trends, and make predictions — so it only makes sense that Kotlin would find a home in data science as well.

Multi-platform mobile development: In the coming future one Kotlin code base would be used to compile and run apps not only in Android but also in iPhones and Apple watches. This project is currently in the alpha testing stage.

In this module, we will cover the following objectives :

Variables, values, and type in kotlin
Numbers in kotlin
Using texts in kotlin
Boolean values and Operations
Conditional statements in Kotlin.
Loops in Kotlin

1.Variables, values, and type in kotlin

Variables are containers used to store data values in Kotlin. Variables can change the values that it stores. They are abbreviated as var. Variables can be reassigned.

fun main (){
    //Ok! val cannot be reassigned
   var name = "John"
   name = "Sharon"
              }

Val is an abbreviation of value. You can use this modifier to specialize variables that cannot be changed. In other words code will not start if you try to assign new value.

fun main (){
    //Error! val cannot be reassigned
   val name = "John"
   name = "Sharon"
              }

Values are grouped into types:

i. Strings - represent values in texts. eg mountain
ii. Integer - represents real numbers. eg 56
iii. Double - represents numbers with decimal places. eg 45.0
iv. Boolean - represents a true or a false value. eg 5 == 6 is false

Some of the reasons we explicitly use val
1. Val is used for readability such that the reader can understand the written code.
2. With val it is enough to view its declaration to know which value it is.
3. Val minimizes the number of unnecessary variable changes which increases the readability of your code.
```
     fun main () {
     val age : String = "" + 42 + ""
       }
```
There are a few reasons to use the explicit variable type. One is readability. Sometimes the right side of the assignment might be complicated and specifying a type to makes it easier to understand your code.
```
fun main () {
var x : Any = "ABC"
println(x) // ABC
x = 123
println(X) // 123
x = true
println(x) // true
           }
```
One of the reasons you specify type is when you need a value to include multiple subtypes.
For instance Any is a data type that includes all other types. So String, Int, and Boolean are all subtypes of Any. With the type of Any, you can assign it any value you've learned about so far.

2. Numbers in Kotlin

There are four basic types of operations used in kotlin which include :
i.Int
ii. Float
iii.Double
iv. Long
Integer: it represents real whole numbers that can either be positive or negative. We add a minus sign in front of an integer to make it negative. Integers have a limited size of over two billion.
Long: represents a number type that can accommodate numbers over nine quintillions to create a long value. We add a suffix L after the number.
Double: It contains a number that operates with a decimal part. It holds a number made up of two parts. It contains the integer part and a decimal. It can hold up to 15 to 16 decimal places. A double is more precise than a float. This is because a double occupies twice memory as an integer.
Float: It holds up to 7 to 8 decimal places. We create this number by using the suffix F after the number.
Kotlin can be used to can be used for basic math operations. eg

 println(1+3*2) output = 7
 println((1+3)*2) output = 8

Parenthesis are used to override the normal math precedents to create a particular calculation.
Transformational functions are used to transform one number type to another. We use the to prefix and the type you want. eg

 fun main () {
val num1 : Int = 10
val num2 : Long = num1.toLong()
val num3 : Double = num2.toDouble()
val num4 : String = num3.toString()
val num5 : Float = num3.toFloat()
println(num1)
println(num2)
println(num3)
println(num4)
println(num5)
              }

The output of the first print statement is 10
The output of the second print statement is 10
The output of the third print statement is 10.0
The output of the fourth print statement is 10.0
The output of the fifth print statement is 10.0

In kotlin, the remainder operation is represented by a modulus sign(%). It represents what would be left if you divide an integer by another integer.

 fun main () {
println(10%3)// 1
println(12%4)// 0
println(17%5)// 2
// The sign of the result is always the same as the sign of the left side.
println(-1%3) // -1
println(1%-3) // 1
println(-1%-3) // -1
}

When you carry out operations between;

Integer and Integer the result will be an Integer
Integer and Long the result will be a Long
Decimal and Integer or Decimal the result will be an
Decimal
Float and Integer the result will be an Float
Float and Double the result will be an Double

Division operation between two integers results into an integer. If the calculation results in a decimal part of this operation is lost.
To ensure fractions are retained, transform one of the values to a double or float before the math operation.

 fun main () {
       val a = 5
       val b = 2
       println(a/b)
       println(a.toDouble()/b)
              }

The output of the first print is 2
The output of the second print is 2.5

Augmented Assignment

Variables defined with var can have their value changed.

fun main () {
var num = 10
println(num)
//reassigning num
num = 20
println(num)
}

The output of the first print is 10
The output of the second print is 20

We can also increase value through different operations. Instead of using a = a + b we can use a += b. This implies to all the other operations that we increment by using the operation sign next to an equals sign.

fun main () {
var num = 10
num += 20
println(num)
num -= 5
println(num)
num *= 4
println(num)
num /= 50
println(num)
}

The output of the first print is 30 because we are adding 10 to our initial value which was 20 resulting in 30.
The output of the second print is 25 because we are subtracting 5 from the result of the above operation which was 30 resulting in 25.
The output of the third print is 100 because we are multiplying 4 by the result of the above operation which was 25 resulting in 100.
The output of the fourth print is 2 because we are dividing 50 by the result of the above operation which was 100 resulting in 2.

Prefix and postfix operation

In Kotlin there are different ways to add and subtract. We can either use a postfix or a prefix to do an increment. In postfix, the execution is done after the operations are evaluated.

fun main () {
var a = 5
var num = 6 + a++
println(num)
}

The output will be 11 because num takes the value of a and adds it before a++ increments 5 to 6.

In Prefix operation works differently. The prefix operation is executed before the equation is evaluated.

fun main () {
var a = 5
var num = 6 + ++a
println(num)
}

The output will be 12 because a++ takes the value of a then add 1 to it such that now a++holds 6 as a value which is added to6 stored in the variable num.

3. Using texts in Kotlin

Char is an abbreviation of character. In kotlin character is defined by placing it inside a set of single quotes. var mychar : Char = 'a'
In programming characters are represented by numbers because a computer understands binary codes which are made up of zeros and ones.
Unicode is a special table that is used to map each character to a unique number. It supports 144,697 characters.
A string _is a sequence of characters. It can be empty or have one or more characters including spaces and commas. String value is specified through _double quotes. Strings are immutable.
If your text contains multiple lines, it is also possible to define this in a string variable in kotlin by delimiting the text with tripple quotes.

fun main () {
val myString = """Hello world! My name is Daniel Brian. 
I love android development with kotlin."""
println(myString)
}

The output of the print statement is:
Hello world! My name is Daniel Brian. I love android development with kotlin.

String has built-in code which can be used to access the information about them such as the keyword length. The length keyword is used to access the number of characters in a string.

fun main () {
val name = "Simpsonville"
println(name.length)
}

The output of the print is 12 showing that the string Simpsonville has 12 characters.
String template allows you to include a variable in a string. To do this you use a dollar sign in the variable name.

fun main () {
val name = "Simpsonville"
val age = 20
println("My name is $name I am $age years old.")
}

The output of the print statement is: My name is Simpsonville I am 20 years old.

When you use $(dollar sign) without brackets you only inline a variable value not the rest of an expression.

fun main () {
val num1 = 50
val num2 = 20
println(" $num1 + $num2 = ${num1 + num2}")
}

The output of the print statement is 50 + 20 = {num1 + num2} but after we put the dollar sign the output changes to 50 + 20 = 70

To convert a Char to a String using the toString() function.

fun main () {
val myChar = "H"
val myLongStrong = myChar.toString()
println(myLongStrong)
}

The output is: H

Appending to string

To add additional text to the end of a string, we use the plus operator(+). This does not change the existing string variable but creates new string variable.

fun main () {
val name1 = "Google!!"
val name2 = "I love " + name1
println(name2)
}

The output of the code is I love Google!!

Searching Strings

The string type has multiple functions for searching its content. We can search the first letters of a word or the last letters.

fun main () {
val name = "Google"
val startWithGo = name.startsWith("Go")
val endWithMe = name.endWithMe("me")
println(startWithGo)
println(endWithMe)
}

The output of the first println is true because the name Google start with the character Go else the output will be false.
The output of the second println is false because the name Google doesn't end with the letters "me". It could be trueif the last letters indicated would be le

We can use variable name.first() to get the first character of a variable or variable name.last() to get the last character of a variable.

fun main () {
val name = "Google"
val nameIsFirst = name.first()
val nameIsLast = name.last()
println(nameIsFirst)
println(nameIsLast)
}

The output of the code will be G and e respectively.

Manipulating Strings

We can use the uppercase and the lowercase methods to manipulate strings to capital letters and small letters.

fun main () {
val name = "Google"
val nameIsFirst = name.uppercase()
val nameIsLast = name.lowercase()
println(nameIsFirst)
println(nameIsLast)
}

The output of the first println is GOOGLE while the output of the second println is google

We can also get the position of all the letters in string through the substring function.

fun main () {
val name = "Google"
val nameIsLast = name.substring(1)
println(nameIsLast)
}

The output of the code above is oogle because the substring prints from the index referenced inside the function which is 1.

4. Boolean values and Operations

Boolean has two possible values true and false and can be used to tell whether something is true or not.
When you compare two values, the result is of either the == operator or the equals() when comparing strings.

fun main () {
val num = 45
val num1 = 56
val output = num.equals(num1)
println(output)
// when using the == operator
println(45 == 56)
}

The output of the above code is false because 45 is not equal to 56

To check if two values are not equal we can use exclamation mark and equals sign(!=)

fun main () {
// when using the != operator
println(45 != 56)
}

The output of the above code is true because 45 is not equal to 56
In addition we can use other operators such as the greater and the less than signs followed by an equal sign to check if certain numbers are equal or not.

Note: The output of the below code is given in boolean next to the println statement.

fun main () {
println(45 < 56) // true  
println(45 > 56) //false
println(45 <= 56) //true
println(45 >= 56) //false
}

Logical operations : Boolean

The and operator (&&)

The and-operator returns true when the conditions given are both true else it returns false.

The or operator (||)

The or operator returns false when both of the conditions given are false else it returns true. The not operator(!)
It negates the boolean value. It turns true into false and false into true.

fun main () {
val isAmazing = true
println(!isAmazing)//false
val isBoring = false
println(!isBoring)//true
}

The output of the above code is false for the first print statement and true for the second statement.

A good analogy for the logical operator not is a minus before a number. It turns a number into a positive and a positive to a negative.

fun main () {
val num = 1
println(-num)//-1
}

The output is a negative integer -1

In programming, you can use negation multiple times. Even number of negations returns the boolean being negated while odd number of negations returns the opposite of the boolean provided.

fun main () {
println(!true)//false
println(!!true)//true
println(!!!true)//false
println(!!!!true)//true
}

5. Conditions in Kotlin

If condition

The syntax for the if condition is

if(condition){ println(specify what to be printed) }
Every line in the body of a statement starts with four additional spaces known as indent and the whitespaces which improves code readability.

 fun main () {
val accountType = "free"
    if(accountType == "free")
    println("show adds")
}

The output of the above code will be showing adds since the the condition is met.
If - else condition

An if-else statement can be used as an expression in other words, to return a value that can be stored in a variable. The returned value is the value returned by the body block that was chosen.
Inside if else bodies you can include more than one statement. The value returned by the body is the last expression it has.

fun main() {
    val accountMoney = true
    val tip: Double = if (accountMoney) {
        println("You can withdraw")
        89.0
        90.0
        100.0
    } else {
        println("Sorry, I am broke")
        0.0
    }
    println(tip)
}

The output will be You can withdraw 100.0

If- else- if

It is a structure that checks condition one after the other until it finds the first one that is fulfilled, and calls its body.
It is not popular in Kotlin because there is better alternative, called the when statement.

fun main() {
 println("Is it going to rain?")
    val probability = 70
    if (probability <= 40) {
        println("Unlikely")

    } else if (probability <= 80){
        println("Likely")
             }
    else if(probability <100){
        println("Yes")
    }
   else{
       println("what?")
   } 
}

The output of the code is likely

When condition statement

It starts with the keyword when then open the curly braces. Inside the curly braces, write a condition and the body that should be executed.

when {
condition -> {body to be executed}
condition -> {body to be executed}
else -> {body to be executed}
}

The when statement can be used as an expression inprder to produce a value. When statement must have an else block so that it can have something to return incase no other block is chosen.

fun main() {
    println("Is it going to rain?")
    val probability = 70
    val text = when{
        probability <= 40 -> "unlikely"
         probability <= 80 -> "unlikely"
         probability <= 100 -> "unlikely"
        else -> "what?"
    }
    println(text)
}

The output of the above code is Unlikely.

If you add a value in brackets after the when keyword, then in each branch, kotlin compares this value to others.

fun main() {
    val number = 80
    when(number){
         70-> {println("missed hit") }
         80,90,100-> {println("Hit with value $number") }
         110-> {println("critical hit") }
    }
  }

The output of the code is Hit with value 80

We can use the when statements with the range check. The syntax starts with the in keyword, and then specify either a collection or a range that might contain the value or not.

fun main() {
   val number = 99
   val text = when(number){
         70-> {println("missed hit") }
         in 80..100-> {println("Hit with value $number") }
         110-> {println("critical hit") }
         else -> "unsupported"
    }
  println(text)
}

6. Loops in Kotlin

Loops allow the execution of one or more statements until a condition is met. It can be used multiple times.
If the path of execution steps into an if condition, it checks the predicate. If it returns true the control flow continues to the next line.
Predicate is a function or an expression that returns a boolean.
The difference between a loop and the if conditions is that loops can be executed more than once.
There are three types of loops;
- While loop
- For loop
- Nested loop

While loop

The while loop is similar to the if statement but you use the while keyword instead of if.
The syntax for the while loop //initialize the counter while(condition){ //put the code here // increment or decrement counter }
The difference between the while loop and the if condition is that the while loop can call its body more than once. If condition will never call its body more than once.

fun main() {
    var number = 99
   while(number <= 120){
      if(number%2 == 0)
          println(number)
          number++;
      }
 }

The code above prints the even numbers between 99 and 120

We can also use the while loop to print a sequence.

 fun main() {
    var number = 99
   while(number < 120){
          println("$number")
          number = number+3;
      }
 }

The sequence created increases by 3 until the maximum number set is reached.

For loop

For loops are mostly used to iterate over group of elements.

 fun main() {
    var listOfnumber = listOf(99,102,105,108,111,114,117) 
   for(number in listOfnumber){
       println("On of the numbers in the list is $number")
   }
 }

The output of the code above is;

On of the numbers in the list is 99
On of the numbers in the list is 102
On of the numbers in the list is 105
On of the numbers in the list is 108
On of the numbers in the list is 111
On of the numbers in the list is 114
On of the numbers in the list is 117

The for loop can be used to iterate over numbers in both a closed and open range.
In closed range, we use .. to print the numbers given. The last value given in a loop is printed. It shows the range.

fun main() {
    //closed range 
for(number in 91..100){
       println(number)
   }
}

The output of code will print numbers between 91 to 100.

In open range, we use until to print the numbers given. The last value given in a loop is not printed.

fun main() {
    //open range 
for(number in 91 until 100){
       println(number)
   }
}

The output of code will print numbers between 91 to 99.

The for loop can be used to increment and decrement an iteration through step keyword and downTo keyword.

fun main() {
    //closed range 
for(number in 91 until 100  step 3){
       println(number)
   }
}

The output of the above code is 91,94,97. The step keyword increases a number by three after every iteration.

fun main() {
    for(number in 100 downTo 90){
       print(number)
   }
}

The output of the above code will be printed from 100 backward to 90. We can also move backward with a certain number of steps using the step keyword as shown below.

fun main() {
    for(number in 100 downTo 90 step 3){
       println(number)
   }
}

The output of the code will be 100,97,94,91

Nested Loop

This is a loop inside another loop.
The outer loop prints the number of rows while the inner loop prints the body.

fun main() {
    for(i in 1..5){
    for(j in 1..i){
        print("*")
    }
    println()
   }
}

The output of the above code will print a triangle of stars.

*
**
***
****
*****

Thank you for taking the time to read my article. I hope the ending left you with a lasting impression and that you will return for more thought-provoking content in Android and Kotlin in the future.

Be on the watch for modules two and three where we will deep dive into functions, classes and advanced classes in Kotlin. See you soon

Introduction to Android Studio, Project Structure, and Emulation.

Daniel Brian — Thu, 01 Dec 2022 12:22:55 +0000

I am very happy about Android obviously. I use Android, and it’s actually made cellphones very usable.” ~ Linus Torvald.

Hellooooo🥳️🥳️🥳️I am glad🤗 that you have joined me again in this Android development journey🚀. If you haven't read the The Fundamentals of Android Development article ensure you go through it to caught up with us. Do not forget to 👍like, comment👍 and share with your friends👨‍👨‍👦‍👦🥳️.

Article Objectives

In this article, we're going to look at:

Emulators and Android OS images and their role in Android app development.
Main activity and manifest code in relation to the project structure of Android apps.
Gradle and its role in project building in Android Studio
The folder structure of an Android project, and its contents including the res and layout folders.

Emulators

An emulator is a computer program that's designed to imitate another kind of device.
While different types of emulators have unique ways of operating, the overall goal remains the same;

It allows you to test your app without having to install them on the physical devices you designed them for.
It imitates the Android devices your App is designed for
It replicates the experience of different hardware or software.

Emulation requires high computing resources therefore it's important to ensure your machine has enough storage space and random access memory for it to run effectively.
There are several commercial and open-source emulators available for most of the operating systems in the market. eg

Blue stacks: allows you to run Android Apps on operating systems like Windows and Mac. It is also free to use.
Appetite.io: is a web-based emulator that allows you to use iOS applications on any PC.
Super Nintendo Entertainment System(SNES):It makes gaming possible through playing old video games on modern HD televisions.

Android Virtual Device

Android Virtual Device makes it possible for you to test and optimize different mobile apps developed for different devices and operating systems.
It allows you to define the various features of a physical device, such as an android phone that you want to create and simulate in the android emulator.
To access the AVD interface in Android Studio click the three-dotted menu in the top right for more actions. Select virtual device manager which opens in a new window. In this window, there are two major features:
Create a new device button: this will allow you to add another device to the list of previously created virtual devices.
There are also other icons in the top right hand used for various actions.
- Play button: it will run the emulator in a virtual device.
- Pencil button: clicking it allows you to edit and save changes made to the properties of the virtual device.
If you click on the triangular drop-down menu on the top right hand, actions range from duplicating to deleting a selected virtual device display.
In case you don't see the three-dotted menu you can click the more action menu in the center of the displayed window.

Mobile CPU architecture

In order to develop and deploy apps for different mobile devices, the Central Processing Unit (CPU) architecture must be considered.

What is a CPU?
A CPU is a translator between the hardware and software of a device that translates high-level software instructions to native machine language.

The are three major CPU components used in smartphones which include;
- ARM: It is the most common and properly optimized for its battery use.
- ARM64: is an evolution of the original ARM architecture that supports 64-bit processing for more powerful computing and it’s quickly becoming the standard in newer devices.
- x86: it is a bit more powerful than the ARM CPUs, but not quite as battery-friendly.
ARM better embodies a mobile-first mentality, with simple instruction sets, efficiency, and low power consumption. It requires fewer transistors and frees up that hardware space more than makes up for the use of RAM in a mobile device.

Operating System Images

Android OS images help you leverage features of any Operating system to give your users the best experience with your app.
OS images help you to enjoy the built-in features of any Operating system using the API level which uniquely identifies new features released for a particular OS.
Currently the most recent Android OS images available for developers in Android Studio range from version 8, code name Oatmeal Cookie released in 2017 to version 13, code-named Tiramisu. More specifically, after the release of Oatmeal Cookie in 2017 came Pistachio Ice Cream in 2018, Quince Tart in 2019, and Red Velvet Cake in 2020. These were followed by Snow Cone in 2021, Snow Cone V2 in March 2022, and Tiramisu.
To access the Android OS images, click the Three dotted menu icon on the upper right-hand side to access more actions. Then click on Virtual Device Manager. On the Device Manager page, click Create Device. This opens the virtual device configuration where you can create an emulator.

Configuring an Emulator
Emulators are a safe place to test your code, especially at the beginning of the design. Nevertheless, emulators require some configuration in order to function properly.
Avid properties required to configure an AVD to an emulator in Android Studio.
- Specify what you want the device to be called

- Select the landscape or portrait mode

- State the number of processor cores to be used

- Override the default RAM value
To access the virtual device manager in Android Studio click the three-dotted menu in the top right corner then click the new device which will open a new window enabling you to choose the device you want to emulate.
In this window, you have the option to change the device and system, choose the device portrait or landscape and specify RAM and additional memory from the advanced settings.

Common Libraries and Packages

Why use libraries?

Libraries extend the capabilities of the Android software development kit (SDK), allowing you to use code written by other developers.
These open-source libraries are hosted on an external server and are downloaded by the build system, Gradle, when you are building a project.

Types of Libraries

Image loading: It helps to avoid high memory consumption caused by loading multiple images at the same time. eg Fresco provides a smooth scrolling experience while an image is loading due to smart caching to minimize storage overhead.
Videos: ExoPlayers offers an alternative to Android's MediaPlayer API due to its ease of customization when playing Audio and Video locally or online.
Networking: Mobile apps need some sort of network to communicate with each other. Retrofit provides you with a great way to make internet calls within your application.

Android Studio and Project Structure

Project Structure

New projects in Android Studio generate files and folders that contain everything that is required for an app to run from source code and assets to test code and build configurations.
These basic folders and files consist of:
- Navigation bar: It allows you to access the project folders and files.
- Sample app folder: It is the root directory for project folders and files.
- .gradle folder: This is the toolkit that guides the project-building process of Gradle. It contains all configurations and files used by Gradle to build your project. Though they are automatically generated they can be deleted.
- .idea folder: It is used to store specific project metadata which tells the app how to use the data it describes. It contains configuration files and data for specific functional areas.
- App folder: It contains the source code related to the project. Here you write your code, create the user interface, and store assets eg images.
- Gradle folder: It consists of a set of tools for developers to build, test, and run applications.
The Gradle folder contains subfolders and files which include;
- .gitignore file: It specifies which files to be excluded from your repository systems eg GitHub.
- build.gradle: It is used to specify and manage the configuration options common to all sub-projects folders.

- Gradlew: It is used by the Gradle Android studio build
system. It is created once and is updated whenever a new
feature or plugin is required to build a project.
- local.properties file: It contains information specific
to your local configuration. It is not pushed to GitHub
because it contains sensitive information.
- settings.gradle file: It handles the various settings
for projects and modules. It also displays third part
libraries.

Main Activity

One of the most fundamental parts of an Android App is the main activity class. It is generated together with other folders and files in Android Studio. An app will always have one activity class no matter how small in terms of code and scalability.
MainActivity.kt file is the entry point for your app where kotlin code is displayed which is integral to the behavior of your app.
An Android app is usually made of multiple activities, sometimes called screens, that together form the user experience. These activities are represented by an activity class whose function is to respond to user input.
Each activity class contains a layout that holds different pieces of a user interface or UI together so that the user can interact with an app. This means that the activity class is the gateway through which a user can interact dynamically with an Android app's UI.
The main Activity class is the first screen that displays when a user displays an App.
The Oncreate() function is the entry point for your app to run successfully. Its role is to create the view and initialize the actions of the activity. This function is necessary to create an app successfully.

Gradle

It enables Android Studio to run an application project and compile many different files and folders.
The set of build configuration files defines:
- How the project is developed
- Dependencies for the project
- Results or results of the compilation process.
For every Android project, two build.gradle files are generated. The first Gradle settings apply to every module in the project. The second module-level settings apply to app modules.
A module is a collection of the source file and build settings that allow you to divide your projects into different units of functionalities.
Lets examine the build.gradle file.



1. apply plugin: 'com.android.application'

2. android{
3. default Config{...}
4. build Types{...}
        }
5. dependencies{...}

The android block in 2 above contains information about your project eg the OS version of your app.
The default Config in 3 above allows you to specify the minimum OS version, version number, application unique ID and other configuration settings.
The dependencies in 4 above specifies what the third party you wish to include in your app.
Gradle can be started manually through the commandline tool. The commands issued include:
- ./gradlew build- It is used to build projects when read to run an app.
- ./gradlew clean - It is used to delete contents of building directory.
- ./gradlew wrapper - It allows you to see gradle operations in the background.

Android Manifest

It is generated once a new project is launched. AndroidManifest.xml file contains essential information which includes, your activity, your receiver, and the service and providers. This defines the permissions that you need to access protected parts of the OS.
- Application tag: It specifies the theme of the application of the user interface, icon, and label can be defined.
- Activity tag: It defines all the activities to be present in an application.
- Intent filter: It specifies the initial running of the application.

Resource folder

It contains the form of files and files and static content that your code uses, such as colors and animations.
Resources available include string, color, dimension, and font
- String: It enables you to define the text in the res/value/string.xml file.
- Color: It is defined in the color.xml. It helps you manage your colors so that they are accessible across the app.
- Dimension: It allows you to manage all your dimensions in one place using dimensions.xml.
- Font: It is used to manage all the fonts you use within your entire app project.
These resources play an important role in your app compatibility.
If you want to show congratulations in your app



    <resources>
    <string name = "message">Congratulations!!.<string>
        </resources>

These folder lets you manage, change and access your resources globally across your app.

Project Files

They allow you to access the entire file structure of a project including all files hidden within folders from the Android view.
These project files include
- .build/- It contains files generated after a project build occurs.
- .libs/ - It contains private and third-party libraries used within the app.
- src/ - It contains all code and resource files for the module in its subdirectories.
- androidTest/ - It contains code for testing features of the app.
- test/- it contains the unit testing code, with unit tests executed on the computer.
- main/- It contains Android code and resources for testing and production deployment.
- AndroidManifest.xml - It describes specific information about your app and its activity.
- java/- It contains java and kotlin related code files.
- gen/ - It contains the java files generated by android studio, which is required for the app to build successfully.
- res/ - It contains application resources eg image files, font, dimension, and layout files.
- assets/ - It contains files that should be compiled into an.apk file.
You can navigate the directory using URLs and read files.

🚀🚀Thank you for following me along this journey🥳️🥳️ !!

The Fundamentals of Android Development.

Daniel Brian — Thu, 10 Nov 2022 20:39:41 +0000

Learning objectives

Provide an overview of the difference between mobile apps and mobile websites.
Explain how the mobile Operating system works.
The Android Operating system.
Introduction to Android development.

Mobile Platforms
A mobile app is an installable software that runs on a smartphone device. Mobile apps use the device's hardware, and software features and usually provide an efficient, more intuitive, and seamless user experience.

What is the difference between a mobile app and a mobile website?

A mobile app is software that runs on a hardware device whereas a mobile website works on a mobile app and does not involve any hardware to be functional.

What are the advantages of mobile apps and a mobile website?

Mobile app

Faster than mobile websites
Can access resources eg location, Bluetooth, etc.
Can work without internet access

Mobile website

Cheap to build and maintain
Need not to be built from scratch to be compatible with other platforms
No approval is required from Appstore

Note:To determine whether to develop a mobile website or mobile app always ask yourself what specific actions you expect your product to perform.

How does a Mobile OS work

The most fundamental software for any mobile device is its OS. An OS is designed to coordinate communications that occur between the hardware and apps of mobile devices. It manages the overall experiences of an app.

Mobile operating system

A mobile OS typically starts up when a device powers on, displaying different application icons and user interface (UI) elements to users.

Uses of Operating system

Allows smartphones, tablets, and personal digital assistants (PDAs) to run applications.
OS provides a channel with which applications can access device resources such as the processor, memory, Wi-Fi, Bluetooth, and more.

The most common operating systems are Android and iOS.

Android

Android is a mobile OS that was released in 2008.
Android OS is based on a modified version of the Linux kernel and is an open-source software which means anyone can modify it.
Android OS was built primarily for smartphones, Chromebook, Android TV, and Android Auto, as well as wearables such as smartwatches.
Android has built-in sensors such as gyroscopes and accelerometers, which gives users a multi-touch experience.

iOS

iOS is Apple’s proprietary OS that runs on the iPhone, iPad, and other mobile devices
Same as Android, iOS has built-in sensors such as gyroscopes and accelerometers, which gives users a multi-touch experience through several actions such as swiping, pulling, and tapping, and users can seamlessly interact with the screen.
With the rise in popularity of iOS, developers now have more controls and access to its features.

Other mobile operating systems include kaiOS which runs on Mozilla Firefox, SailfishOS from Jolla, and Huawei's HarmonyOS which was released in 2019 and runs on a microkernel that Huawei developed. Mostly used in IoT devices.

Android Platforms

Being the most used operating system in the world, Android is not limited to only mobile devices. Android is also used to power other devices due to its openness to others.
Android platforms include, Chromebook, Android TV, Android Auto, and WearOS.

Chromebook

Chromebooks are portable laptops that have support for running Android apps, which gives them more features.
Chromebooks operate on Google's ChromeOS.
Ability to use convertible form factors to not necessarily build apps from scratch for phones and tablets from ChromeOS.

Android TV

Android TV is designed to bring the mobile experience to your TV.
The voice control feature of the TV allows you to have complete control over your devices.

Android Auto

It allows you to connect your phone to your car display.
It automatically shows your apps on your car display and makes it possible for you to get driving directions and navigate seamlessly.
Android Auto is made to help you stay focused on the road.

WearOS

WearOS is Google's Android OS that is specifically designed to power smartwatches and other wearables.
The early release of WearOS allowed watching owners to install WearOS apps through their mobile phones from the google play store.

Introduction to Android Development

Android Languages

In the world of Android development, Java and Kotlin are both extremely popular programming languages.
Java, which was released by Sun Microsystems in 1995 while Kotlin was introduced by JetBrains in 2011.

-Kotlin has officially become the preferred language for Android app development due to the following reasons;
1. It is concise and standardized hence low code errors.
2. Easier to maintain complex projects due to low code.
3. It is compatible with java hence easy to convert java
code to Kotlin.
4. Kotlin handles errors that crash Android apps better
than java.

The Android OS

Android is a Linux-based OS primarily designed for touchscreen mobile devices such as smartphones and tablets.
Some of the unique features and characteristics of the Android OS include:

Near-field communication: This feature makes it easy for electronic devices to communicate over short distances.
Wi-Fi: With this feature, users can connect to various wireless access points around them due to these in-built technologies that support Wi-Fi protocols.
Custom home screen: Android OS allows you to further personalize your home screen the way you like it.
Widgets: Used for home-screen customization to give you a glance view of users' most important data.
App downloads: users can unlock the full potential of the Android operating system through app downloads.
Custom ROMS: Android can use customized and modified versions of Android OS to access features of a recent on an older device.

The Android OS Architecture

Consists of components that Android needs to be functional.
Android is built on top of an open-source Linux kernel and other C and C++ libraries exposed via application framework services.
The Android OS is a stack of software components roughly divided into five sections:
1. Applications
2. Application frameworks
3. Android runtime
4. Platform Libraries
5. Linux Kernel
These are separated into 4 layers, as shown in the architecture diagram below.

Android App Cheatsheet

To get started with developing an app, you need a clear understanding of relevant concepts.
These concepts include:

Top-level component

Enables apps to connect to the internet, make calls, and take pictures through BroadcastReceiver, ContentProvider, and Service and activity accessible in Android SDK.

Activity Components

These are activities present for content users to interact with on the screen.
Single activity architecture pattern allows one activity or a relatively small number of activities to be used for an entire app.

Android views

This is the design interface that occupies a rectangular area on the screen and is responsible for drawing and event handling. It displays text, images, and more.

Android layout files

In Android, each layout is represented by an XML file. These plain text files serve as blueprints for the interface that your application presents to the user.

Project files

Android Project Files belong to one of three main categories: configuration,code, and resource. Configuration files define the project structure, code files provide the logic, and resource files provide essentially everything else.

Anatomy of An Android App

This basically looks into the components that go in when creating an App.

An Android app is made up of four major components that serve as the building blocks of any Android app in the market.
The four major components include:

Activities: This is the entry point of users that represent a single user. It allows you to place UI components, widgets, or user interfaces on a single screen. eg a music player app may have an activity that shows you a list of your favorite songs, another activity that allows you to play a specific song, and another which shows you a list of trending songs.
Services: They run in the background and constantly update the data sources and activities with the latest changes. It also performs tasks when users are not active on applications. eg A good example of a service is chatting with someone whilst listening to music.
Broadcast Receiver: Its purpose is to respond to messages from other applications or systems in real time. eg,imagine you're enjoying your favorite song on your music app when you get a notification that you're running low on battery power.
Content providers: It's responsible for sharing data between applications. eg A typical example is a social media app that allows users to share their images online.

These Android components are coupled by a configuration file called AndroidManifest.xml. It is used to specify each component and how they interact with each other.

Extensible Markup Language(XML)

XML (Extensible Markup Language) is used in the presentation of different kinds of data. Its main function is to create data formats that are used to encode information for documentation, records, transactions, and several other data formats.
For an XML document to be valid, the following conditions must be fulfilled:

The document must be well-formed.
The document must comply with all the rules of the XML syntax.

THE END.

Thank you for taking the time to go through the article!!

BIG O NOTATION AND TIME COMPLEXITY.

Daniel Brian — Tue, 05 Jul 2022 07:41:25 +0000

Hello👋👋.Before we embark on this amazing article be sure to check out my last wonderful 🙂article on Data Structures and algorithms 101.

In this article, we will learn everything that we need to know about Big O notation and how you can use it to improve your ability to create efficient algorithms.

Big O notation is used to classify algorithms based on how fast they grow or decline. It is used to analyze the efficiency of an algorithm as its input approaches infinity.

For Example:

Let's say we have a dentist and she takes 30 minutes to attend to one patient. As her line of patients increases, the time that it takes to treat all of the patients will scale linearly with the number of patients waiting in the line.

This gives us a general understanding of how long our dentist would take to attend to any number of patients since she uses a constant amount of time, which is 30 minutes to treat each patient. With this in mind, we can categorize his efficiency as linear or as we say in big O terms big O of n (Big O(n)), where n is equal to the number of patients, the time that it takes for her to finish her work scales linearly or proportionally with the number of patients.

We can use the same technique to determine the general idea of how a function's time efficiency scales by categorizing a given function's efficiency in the same way as the dentist's efficiency. Let's create an easily comprehensible function that scales similarly to the dentist.

1. Finding the sum of numbers in a given array.

            given_array = [1,4,3,2,...,10]
            def find_sum(given_array):
            total = 0
            for each i in given_array:
            total+=i
            return total

One may ask how does the runtime of a function grow?
we run our functions to generate a bunch of arrays with various sizes as our inputs. These were:[5,7,9,7,8],[4,9,8,6,3],[1,9,7,1,10,7,6,7,9,4],[6,9,7,5,6,1,5,6,6,7]

Using these randomly generated arrays as input we run our function many times to find the average time it takes to run our function in each of n where n is the number of elements in a given array.

Note:
The X-axis represents the number of elements and the Y-axis represents the time in microsecond it takes to run a function.

From the graph, this is known as linear time complexity represented as O(n). Time complexity is a way of showing how the runtime of a function increases as the size of the input increases.

Other time complexities include:

1.Constant time: This is where the time to run a function does not increase with increase as the input increases. It is represented as O(1).

Example:
   given_array=[1,4,3,2,...,10]
   def stupid_function(given_array):
   total = 0:
   return total

When we run this function with various sizes of array inputs the result is as shown below.

Our constant c = 0.115 and it's the fastest-growing time.

2. Quadratic time: This is where the time to run function increases the way a quadratic function increases. It is represented as O(n^2).

Example:
   array_2d = [[1,4,3],     [[1,4,3,1],
               [3,1,9],      [3,1,9,4],
               [0,5,2]].     [0,5,2,6],
                             [4,5,7,8]].
  1. def find_sun_2d(array_2d):
  2.     total = 0
  3.  for each row in array_2d:
  4.  for each i in row:
  5.     total += i
  6.  return total

-Lines 2,5 and 6 take the same amount of time to run and thus have a constant time. In addition, we have 2 double for loops in our example which we assume do exactly the same thing. This would give us
T = O(1) + n^2 * O + O(1)
=O(n^2).

Thank you for Having time for my Article.🤗🥰️🎉

Thank you for taking your time to read 🤗🥳Happy learning😇🌟.

Data Structure and Algorithms 101.

Daniel Brian — Tue, 21 Jun 2022 16:49:45 +0000

What is Data Structure?

Data Structures allows you to organize your data in such a way it enables you to store collections of data, relate them and perform operations on them accordingly.

Types of Data Structures

1.Built-in/Primitive data structures: They store data of only one type. They include:

a)List: Lists can have heterogeneous data types in them. They can be mutable that is they can be changed. We use Square brackets to create lists.

Example:
a=['apple','banana','pear']
#We can add another fruit into the lists through
a.append(orange)
print(a)
#When we run this in any IDE; a=['apple','banana','pear','orange']

b)Tuples : They are not mutable. They are faster than lists. We use regular brackets to create tuples.

b=(3,4,5)
print(b)
solution:(3,4,5)

c)Dictionary : They hold key value pairs. We use curly brackets to initialize dictionaries. Dictionaries are mutable.

c={1:'python',2:'java'}
print(c)
solution: {1:'python',2:'java'}

d)Sets: These are unordered collection of unique elements. We use curly brackets to initialize sets. Sets are mutable.

d = {2,3,4,2}
print(d)
solution: {2,3,4}
#This is because sets do not repeat same elements inside it.

2. User-defined/derived/non-primitive data Structures: They are data of more than one type. They include;

a)Stacks: The data that is entered last will be the first one to be accessed. They are built using array structure and have operations namely push which adds an element to the collection and pop which removes elements from a collection. They are used in applications such as recursive programming, reversing words etc.

b)Queues: This is a linear data structure based on the principle of first in first out. They are also built using an array structure and operations can be done on them. They are used in the application of traffic congestion management and in operating systems for job scheduling.

c)Trees: This is a non-linear data structure that has roots and nodes. Roots are where the data originates while nodes are any point where data is accessible to us. The node to proceed is the parent and the latter is the child. Trees are widely used in Html pages and are efficient for searching purposes.

d)Linked lists: These are liner data structures t are not stored concurrently but are linked together through pointers. The node of a list composes of data and a pointer. They are used in image viewing applications and music player applications.

e)Graphs: They are used to store data collection of points and edges. Many applications such as google maps and uber use graphs to find the least path in order to maximize profits.

f)Hashmaps: They are the same as what directions are in python. They are used to implement applications such as phonebooks and populate data.

What are Algorithms?

Algorithms are rules or instructions which are formulated in a finite sequential order to solve problems. They provide pseudocode for problems.

Important things to note when writing algorithms.
-Figure out what is the exact problem
-Determine where you need to start
-Determine where you need to stop
-Formulate the intermediate steps
-Review your steps

Elements of a good Algorithm
-Steps should be finite, clear, and understandable
-Clear and precise description of inputs and outputs
-The algorithm should be flexible
-The steps should make use of general programming fundamentals

Algorithm classes
There are three types;
i)Divide and Conquer - Divides the problem into subparts and solves the subparts separately.
ii)Dynamic programming - Divides the problem into subparts remembers the results of the sub-parts and applies them to similar ones.
iii)Greedy Algorithms - Involves taking the easiest step while solving a problem without worrying about the complexity of the future steps.

Tree Traversal Algorithms
There are three types of tree traversals:
i)In-order traversal: refers to visiting the left nodes followed by the root and then right nodes.

ii)Pre-ordered traversal: refers to visiting the root nodes followed by the left nodes and then right nodes.

iii)Post-order traversal: refers to visiting the left nodes followed by the right nodes and then the root node.

Sorting Algorithms
It is used to sort data in some given order. It can be classified into five steps.
i)Merge sort: The given list is first divided into smaller lists and compares to adjacent lists and records in the desired sequence.
ii)Bubble sort: is a comparison algorithm that first compares and sorts adjacent elements if they are not in the specified order.
iii)Insertion sort: Picks one element of the given list at a time and places it at the exact position where it is to be placed.
iv)Selection sort: Picks one element of a given list at a time and places it at the exact spot where it is placed.
v)Shell sort: allows you to sort elements apart from each other.

Searching Algorithms
Searching algorithms are used to search for or fetch elements present in some given dataset. There are many types of search algorithms; Linear search, Binary search, Exponential search, and interpolation search.

Algorithm analysis
a)A prior analysis: where all factors are assumed to be constant and do affect the implementation.
b)A posterior analysis: The actual values like time complexity or execution on time of an algorithm, and space complexity are gathered.

Thank you for taking your time to read 🤗🥳Happy learning😇🌟.

FAKE NEWS DETECTION WITH PYTHON

Daniel Brian — Sun, 01 May 2022 20:51:17 +0000

Fake news is one of the biggest problems with online social platforms.We can using machine learning for fake news detection. In this article, I will walk you through the task of Fake News Detection with Machine Learning using Python.Here is the basic workflow.

#we're loading data into our notebook
#we load in the necessary libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import warnings
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB

After importing the relevant libraries we have to load in our d

#importing our data through pandas
data=pd.read_csv('/content/drive/MyDrive/news.csv')

After loading the data, let us examine it. It is usually not recommended to throw all the data into a predictive model without first understanding the data. this would often help us improving our model.

#we check our first five rows and columns
data.head()

Missing data values can really mess our model. It's crucial to check whether there are some missing data and fill them. For our case we didnt have any missing values.

#To check whether our data have missing values
data.isnull().sum()

Machine learning algorithms cannot understand texts(categorical values)and thus we have to convert them to numeric data.

We will convert our 'label' into 1 and 0 using the lamda function.

data['label'] = data['label'].apply(lambda x: 1 if x == 'REAL' else 0)

For our other categorical features we will use function dummies from pandas library.

dummies=pd.get_dummies(data[['title','text']])

Afterwards we split our data into x and y variables.

#we split our data into x and y
x=data.drop('label',axis=1)
y=data['label']

Lastly we will fit our model using RandomForestClassifier.

from sklearn.naive_bayes import MultinomialNB
from sklearn.model_selection import train_test_split

np.random.seed(42)
x_train,x_test,y_train,y_test=train_test_split(dummies,y,test_size=0.2)
model=MultinomialNB()
model.fit(x_train,y_train)
model.score(x_test,y_test)

So this is how we can train a machine learning model for the task of fake news detection by using the Python programming language.I hope you liked this article on the task of Fake News detection with machine learning using Python.

Python 101 : The Ultimate Python Tutorial For Beginners

Daniel Brian — Sun, 24 Apr 2022 20:23:42 +0000

What is python programming?🤔

Python is a high level programming language. It emphasizes code reusability with the use of significant indentation. It was designed by Guido Van Rossum on 20th February 1991.

Applications of python programming

Python programming is widely used. These are some of the ways it is majorly used in:

Web development
Game development
Machine learning and Artificial Intelligence
Data Science and Data visualization
Desktop Applications
Automation

Advantages of using python programming language

It is easy to use
It's improved productivity
It's an interpreted language
It's dynamically typed
It's free and open-source

Python installation

Visit https://www.python.org/downloads/[](url)
Select your Operating system
Select the release or version, and click on it to download.
Double click on the file to execute and install. For window mark "add to system paths" An alternative way to install python on Linux is to run

> sudo apt install python3 or sudo apt install python on the terminal

Variables in python
A variable is a reserved memory location to store variables. There are four types of variables;

Integers
Long Integer
Float
String

There are rules which are followed when declaring variables which are;

Keywords cannot be used to name variables.

Example: def = 5
# This is incorrect because def is a keyword in python

Must start with a letter or underscore character.

Example: a)variable = name
         b)@variable = name
 #when executing this type of code a will be executed but b wont be executed because it doesn't start with letter or underscore.

Variables are case sensitive, (age, Age, and AGE) are different variables

Example: #When you declare a variable it must be consistent in you code.
i) age = 15
ii) Age = 14
#the output of age will not be the same with that of Age

Can only contain alpha-numeric character and underscore(A- Z,0-9, _)

Example:
     sum = $400
     sum = 400
  #sum is executable while $um is not because dollar sign is non-alphernumeric

Variable cannot start with a number.

Example 
num1 = 7
2num = 8
# 2num is not executable because variables cannot start with numbers.

Literals in python

Literals refers to data stored in variables. Different types of literals include:

  1. Boolean literals
  2. Special literals
  3. String literals
  4. Numeric literals
  5. Literal collections

1. Boolean literals
They are only two: True, False.

Example:
games= [soccer,tennis,rugby]
print(soccer in games)
True
print(badminton in games)
False

2.Special characters

Python contains one special literal. "None", it is used to define a null variable. If "None" is compared with anything else than "None" it will return false.

3. String literals
These are characters that are surrounded by single or double quotes.

#In single quote
name = 'Daniel Brian'

#In double quotes
name = "Daniel Brian"

4.Numerical literals
They are of different types;
Complex
Integers
Float

Complex These are numbers having both a real and imaginary part in the form of x + 5j, where x is real and y is imaginary.
Float These are both positive and negative numbers with floating. point numbers(with decimals).

 num =0.256784

Integers These are both positive and negative integers without floating point numbers.

a = 28

4. Literal collections
These are;
a)List:Its an ordered sequence of data.They are mutable meaning if you want to change anything in a list you can change.

Example:
 A=["Earth","Mars","Jupiter"]

b)Tuples: is a sequence of immutable sequence objects.

Example:
mytuple = ("apple", "banana", "cherry")

c)Dictionaries: They are special characters which allows one to store information in key-value pairs

Example:
monthconversions={
"Jan":"January"}

d)Set:They are used to store multiple items in a single variable.

 Example:
>>> A = {1, 2, 3, 4, 5} >>> B = {4, 5, 6, 7, 8}