Tutorial Kotlin para iniciantes (exemplos)

História de Kotlin

Aqui estão marcos importantes da história de Kotlin:

Ano	Evento
2016	Kotlin v1.0 foi lançado
2017	Anúncio do Google sobre suporte de primeira classe para Kotlin no Android
2018	Kotlin v1.2 vem com complemento de distribuição de códigos entre JVM e JavaScript
2019	O Google anunciou Kotlin como sua linguagem de programação preferida para Android Desenvolvedores de aplicativos
2021	Em 20 de setembro de 2021, o Kotlin v1.5.31 foi lançado.

Razões para usar Kotlin

Aqui estão alguns motivos importantes pelos quais o Kotlin é amplamente usado:

• Kotlin é uma linguagem de tipo estatístico muito fácil de ler e escrever.
• Os programas Kotlin não exigem ponto e vírgula em seus programas. Isso torna o código mais fácil e legível.
• Este idioma permite a troca e utilização de informações de Java de várias maneiras. Além disso, Java e o código Kotlin podem coexistir no mesmo projeto.
• O sistema de tipos do Kotlin visa eliminar NullPointerException do código.
• Você levará menos tempo para escrever um novo código em Kotlin. É ainda mais fácil implantar código Kotlin e mantê-lo em escala.

Características do Kotlin

Aqui estão alguns recursos do Kotlin que darão a você certeza do caminho de progresso da linguagem de programação.

Codificação aparada:

Kotlin é uma linguagem de programação baseada em OOPs onde a linha de código pode ser reduzida em até 40%, o que torna o Kotlin uma escolha ideal para software ou desenvolvimento web.

Código aberto:

Kotlin para Android utiliza JVM e combina os recursos de OOPs e programação orientada funcional.

Compilação rápida:

é fácil compilar o código ao trabalhar com Kotlin, o que resulta em melhor desempenho para o desenvolvimento Android, e também explicará qual tipo de função de dados pode ser usada em todo o código.

Funções de extensão:

Kotlin pode oferecer suporte a uma variedade de funções de extensão sem fazer nenhuma alteração no código. ajuda a tornar o código existente mais atraente e magnífico para os desenvolvedores.

Por exemplo:

Fun String.removeFirstLastChar():
String = this.substring(1, this.length -1)

Este código ajudará a reduzir o primeiro e o último caractere da string, podemos aplicá-lo como:

Val string1 = "Today is cloudy."
Val string2 = string1.removeFirstLastChar()

Segurança Nula:

Em Kotlin, o sistema distingue entre referências nulas e referências não nulas, conforme mostrado no exemplo Kotlin abaixo.

Por exemplo, uma variável String não pode conter nulo:

Var string1: String = "Today is Sunday"
String1 = null  // compilation error
To permit null, we can adjoin the nullable variable :
Var string2: String? = "Today is Sunday"
String2 = null
print(string2)

Interoperável:

O código Kotlin pode ser usado por Java e Java códigos podem ser usados ​​com Kotlin. Então, se você tem conhecimento sobre OOPs programação, é fácil mudar para o desenvolvimento em Kotlin. Além disso, se houver alguns aplicativos escritos em Java, então eles podem ser usados ​​com o ambiente do Kotlin.

Ferramentas robustas:

Como Java, o código Kotlin também pode ser escrito usando IDE ou a interface de linha de comando. É fácil trabalhar com IDE e os erros de sintaxe também são reduzidos drasticamente. Ao mesmo tempo, quando você trabalha com uma interface de linha de comando, o código deve ser compilado primeiro.

Elenco inteligente:

A transmissão inteligente basicamente ajuda a reduzir os custos de aplicação e melhora sua velocidade ou desempenho. Ele funciona no gerenciamento da eficiência do código usando conversão de tipo ou valores imutáveis.

Por exemplo, se a string for identificada, seu comprimento e contagem podem ser encontrados com a ajuda da função Smart Cast:

Val string1: Any = "Today is Monday"
when(string1)
{
is String  -> string1.length
Is Int -> string1.inc()
}

Baixo custo de adoção:

Kotlin é preferido pelas empresas devido ao custo perdido de adoção. Mais importante ainda, é fácil de aprender pelos desenvolvedores, especialmente tendo experiência em programação.

Configuração do ambiente Kotlin

A seguir estão as etapas que ajudam você a configurar um ambiente de trabalho instalando o Kotlin.

Etapa 1) Instalar Java

Como discutimos anteriormente, Kotlin é baseado em Java, então você tem que instalar Java primeiro ao planejar a adoção do Kotlin. Consulte nosso Java Tutorial de instalação.

Etapa 2) Instalar Java IDEs

Felizmente, existem vários Java IDEs escolher a partir de. Aqui fornecemos links para download para tornar as coisas um pouco mais fáceis para você.

• Para baixar o Eclipse, clique aqui.
• Para baixar o NetBeans, clique aqui.
• Para baixar o IntelliJ, clique aqui.

Neste tutorial Kotlin, usaremos Eclipse.

Etapa 3) Instale o Kotlin

Para instalar Kotlin em Eclipse, vá para a seção Ajuda em Eclipse E clique no Eclipse Opção de mercado.

Agora, digite a palavra-chave Kotlin na caixa de pesquisa. Clique na opção Ir para listar o plugin. Ele lhe dará um link do plug-in Kotlin, você precisa instalar o plug-in a partir do link fornecido.

Por favor reinicie o Eclipse IDE, assim que a instalação for concluída. Você pode encontrar um ícone de atalho no canto superior direito de Eclipse IDE. É um método de acesso rápido.

Outra maneira de acessar Kotlin em Eclipse IDE é, vá para o Windows, Perspectives, Open Perspectives, então escolha a opção Others. Aqui, você pode verificar uma lista de plugins instalados posteriormente, conforme mostrado abaixo.

Depois de verificar a instalação do Kotlin, vamos criar o primeiro programa Kotlin na próxima etapa.

Etapa 4) Primeiro programa Kotlin

Comece com seu primeiro projeto Kotlin. No menu Arquivo, escolha a opção Novo, selecione outras e comece com um novo projeto Kotlin da lista.

Agora você precisa definir um nome para o projeto e está pronto para trabalhar com Kotlin.

Com estes passos simples, é fácil baixar Eclipse e Kotlin em seu sistema e escreva seu primeiro programa Kotlin imediatamente.

Archiarquitetura de Kotlin

Uma arquitetura bem construída é importante para que uma aplicação possa ampliar seus recursos e atender às expectativas da base de usuários finais. Kotlin possui sua própria arquitetura peculiar e distinta para alocar memória e obter resultados de qualidade para desenvolvedores e usuários finais.

As corrotinas e classes de Kotlin arquitetam o núcleo de forma a produzir menos código clichê, amplificar o desempenho e reforçar a eficiência. Há uma variedade de cenários em que o compilador Kotlin pode reagir de maneira diferente, especialmente quando está reservando vários tipos de linguagens.

No diagrama de arquitetura, fica claro que a execução do código é feita em três etapas fáceis.

1. Na primeira etapa, o arquivo “.kt” ou kotlin é adicionado ao compilador.
2. Na segunda etapa, o compilador Kotlin converte o código em bytecode.
3. Na terceira etapa, o bytecode é colocado em Java Máquina virtual e executado pela JVM.

Quando alguns arquivos codificados de bytes operam na JVM, eles ativam a comunicação mútua entre si, e é por isso que o recurso em Kotlin chamado interoperabilidade para java também nasce

A transpiração de Kotlin para JavaO script acontece quando o Kotlin tem como alvo JavaRoteiro.

Quando o JavaO alvo do script é escolhido, qualquer código de Kotlin que faça parte da biblioteca que navega com Kotlin é então espalhado com JavaRoteiro. No entanto, o Java O Development Kit (JDK) ou qualquer biblioteca Java usada está excluído.

Um arquivo não-Kotlin não é levado em consideração durante tal operação. Ao direcionar JavaO arquivo .kt do script é convertido em ES5.1 pelo compilador Kotlin para gerar um código consistente para JavaScript. O compilador Kotlin se esforça para obter uma saída de tamanho ideal, interoperabilidade com o módulo existente, mesma funcionalidade com a biblioteca padrão e saída que é JavaRoteiro legível.

Fica claro na discussão que os compiladores Kotlin podem criar um código mais eficiente, competente e independente que resulta ainda em um produto de software de alto desempenho.

Variável Kotlin

Variáveis ​​são usadas para armazenar dados a serem manipulados e referenciados no programa. É fundamentalmente uma unidade de armazenamento de dados e rotulagem que aguarda um alias expositivo para que o programa seja simples de ler e fácil de entender. Em outras palavras, podemos dizer que as variáveis ​​são os recipientes para coletar informações.

No Kotlin, todas as variáveis ​​devem ser declaradas. No entanto, se alguma variável não for declarada, será um erro de sintaxe. Além disso, a declaração da variável determina o tipo de dados que permitimos armazenar na variável. No Kotlin, variáveis ​​podem ser definidas usando palavras-chave val e var. Aqui está a sintaxe de declaração de variáveis ​​em Kotlin:

Var day = "Monday"
Var number = 3

Aqui, declaramos a variável local dia cujo valor é “Monday' e cujo tipo é String e outra variável local number cujo valor é 3 e cujo tipo é Int porque aqui o literal é do tipo inteiro que é 3.

Variáveis ​​locais são normalmente declaradas e inicializadas simultaneamente. Também podemos realizar certas operações ao inicializar a variável Kotlin.

Podemos realizar uma operação na variável do mesmo tipo de dados, pois aqui num1 e num2 são do mesmo tipo de dados que é Int, enquanto day é do tipo de dados string. Portanto, ele mostrará um erro. Aqui está outra técnica de como você pode definir variáveis ​​​​em Kotlin.

var day : String = "GURU99"
var num : Int = 100

Vamos ver como as palavras-chave var e val são diferentes umas das outras.

Vari:

Var é como uma variável genérica usada em qualquer linguagem de programação que pode ser utilizada várias vezes em um único programa. Além disso, você pode alterar seu valor a qualquer momento em um programa. Portanto, é conhecida como variável mutável.

Aqui está um exemplo de variável mutável em Kotlin:

var num1 = 10
Var num2 = 20
Num1 = 20
print(num1 + num2) // output : 40

Aqui, o valor de num1 que é 20 é substituído pelo valor anterior de num1 que é 10. Portanto, a saída de num1 + num2 é 40 em vez de 30.

Valor:

Val é como uma variável constante e você não pode alterar seu valor posteriormente no programa, que também não pode ser atribuído várias vezes em um único programa e pode ser usado apenas uma vez em um programa específico. Portanto, é conhecida como uma variável imutável.

Aqui está um exemplo de programa Kotlin de variáveis ​​imutáveis ​​em Kotlin:

Val num1 = 10
Var num2 = 20

Aqui, o valor de num1 que é 10 não pode ser substituído pelo novo valor de num1 que é 20, pois é do tipo val que é constante. Portanto, a saída é 30 em vez de 40.

Note: no Kotlin, variáveis ​​imutáveis ​​são preferidas às variáveis ​​mutáveis.

Tipos de dados em Kotlin

Os tipos de dados são conjuntos de valores relacionáveis ​​e descrevem as operações que podem ser operadas neles. Semelhante a outras linguagens de programação, Kotlin também tem seu conjunto predefinido de tipos de dados como Int, Boolean, Char, Double, etc.

No Kotlin, todo tipo de dados é considerado um objeto.

Agora, neste tutorial básico do Kotlin, vamos nos aprofundar nos tipos de dados predefinidos usados ​​no Kotlin.

Numbers :

Kotlin fornece um conjunto de tipos de dados integrados conhecidos como números, que são subcategorizados como inteiros e pontos flutuantes. Numbers.

Inteiros:

Inteiros são a categoria de números que possui quatro tipos:

Formato	Tamanho (bits)	Valor mínimo	Valor máximo
Byte	8	-128	127
Baixo	16	-32768	32767
int	32	-2,147,483,648 (-231)	2,147,483,647 (231 - 1)
longo	64	-9,223,372,036,854,775,808 (-263)	9,223,372,036,854,775,807 (263 - 1)

Ponto flutuante Numbers :

Ponto flutuante Numbers são os números não inteiros que carregam alguns valores decimais.

Float: Float é um valor de ponto flutuante de precisão simples de 32 bits.

Exemplo: var: flutuante x = 3.25600

Double: Double é um valor de ponto flutuante de precisão dupla de 64 bits.

Exemplo: var: Double y = 2456.345587

Booleanos:

O tipo de dados booleanos em Kotlin é significativo para representar os valores lógicos. Existem apenas dois valores possíveis em Booleano que são verdadeiros ou falsos.

Por exemplo: val dia = verdadeiro

Val dia2 = falso

Personagem :

Os caracteres em Kotlin são representados com a ajuda da palavra-chave chamada char. Em Kotlin, aspas simples representam a declaração de char. Em Java, char às vezes são usados ​​como números que não são possíveis em Kotlin.

Por exemplo:

val onechar = 'x'
print(onechar) //  output : x
Val onedigit = '7'
print(onedigit) // output : 7

Conversão de tipo Kotlin ou fundição de tipo Kotlin

Conversão de tipo é um procedimento de conversão de um tipo de variável de dados em outra variável de tipo de dados. É enormemente conhecido como Type Casting.

Eminentemente, em Java, há suporte para conversão implícita de tipo de tipo ou tipo implícito de conversão de tipo de um tipo de dados menor para um tipo de dados maior.

For Example : int abc = 15;
Long bcd = abc; // compiles successfully

No entanto, no kotlin, a conversão implícita de um tipo de dados menor em um tipo de dados maior não é suportada, pois o tipo de dados int não pode ser convertido implicitamente em um tipo de dados longo.

For Example : var abc = 15
Val bcd : Long = abc // error

No entanto, no Kotlin, a conversão de tipo é feita explicitamente. Aí vem a orientação de funções auxiliares que orientam a conversão de uma variável de tipo de dados para outra.

Existem certas funções auxiliares que são pré-propriedades para a conversão de um tipo de dados para outro:

toInt()

toByte()

paraCurto()

paraChar()

paraLong()

flutuar()

paraDouble()

For Example : var abc = 15
Val bcd : Long = abc.toLong() // compiles successfully

Kotlin Operatoros

Operaoperadores são caracteres ou símbolos especiais e importantes que asseguram as operações em operandos que têm variáveis ​​e valores. Em Kotlin, há um conjunto de operadores que são usados ​​em diferentes operações, como operações aritméticas, operações de atribuição, operações de comparação, etc.

Aritmética Operatores:

Operadores aritméticos são usados ​​para adição, subtração, multiplicação, divisão e módulo.

Operator	Significado
+	Adição (também usada para concatenação de strings)
-	Subtração Operator
*	Multiplicação Operator
/	Divisão Operator
%	Módulo Operator

Por exemplo:

var x = 10
var y = 20
var z = ( ( x + y ) * ( x + y ) ) / 2     

Aqui a saída do código a seguir é 45.

Comparação Operatores:

O operador de comparação é usado para comparar dois valores, duas variáveis ​​ou dois números. É usado com o símbolo maior que ( > ), menor que o símbolo ( < ) e igual ao símbolo ( ==), diferente do símbolo ( != ), maior que igual ao símbolo ( >= ), menor que igual a símbolo (<=). Sempre resulta em verdadeiro ou falso.

Por exemplo:

var x = 10
Var y =20
Var z = x < y // Output : true
Var w = x > y // Output : false
Var m = x == y // Output : false

Atribuição Operatores:

Atribuição Operators são usados ​​para atribuir os valores operados aritméticos. É usado com os símbolos como +=, -=, *=, /=, %=.

Por exemplo:

var x = 10
var y = 20
var x + = y // Output : 30
Var y - = x // Output : 10
Var x * = y // Output : 200

Incremento e Decremento Operatores:

Operadores de incremento e decremento são usados ​​para aumentar e diminuir os valores da variável ou número. É usado com a ajuda de símbolos como ++ e —.

Existem dois tipos de incremento e decremento: pré-incremento ++a, pós-incremento a++, pré-decremento –b, pós-decremento b–.

Por exemplo:

var a = 10
var b = 20
var c = a++ // Output: 11
var d = b— //Output : 19     

Matrizes Kotlin

Um Array é o conjunto homogêneo de tipos de dados e é um dos tipos de dados mais fundamentais que é usado para armazenar os mesmos tipos de dados no local de memória contíguo. Um Array é significativo para a organização de dados em qualquer linguagem de programação, de modo que vários dados armazenados em um único local sejam fáceis de pesquisar ou classificar.

No Kotlin, os arrays são uma colaboração mutável dos mesmos tipos de dados, em vez de serem tipos de dados nativos.

Aqui estão algumas propriedades de um array em Kotlin

• O tamanho do array não pode ser alterado depois de declarado.
• Matrizes em Kotlin são mutáveis.
• As matrizes são armazenadas em locais de memória contíguos.
• Um array pode ser acessado com a ajuda de índices como a[1], a[2], et – cetera.
• O índice de um array começa com zero que é a[0].

Em Kotlin, um array pode ser definido em dois métodos diferentes

Usando a função arrayOf():

Em Kotlin, há um grande uso de funções de biblioteca. Uma dessas funções de biblioteca é a função arrayOf(), que é usada para definir um array passando os valores das variáveis ​​para a função.

Por exemplo: Declaração implícita de tipo de array usando a função arrayOf()

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

Por exemplo: Digite explicitamente a declaração do array usando a função arrayOf().

Val y = arrayOf<Int>(1,2,3,4,5,6,7,8,9)

Usando o construtor Array:

Em Kotlin, existe uma classe com o nome Array. Portanto, é viável usar um array do construtor para criar um array. A matriz no construtor contém dois parâmetros principais.

Qual é o índice de um array em Kotlin?

A função onde um índice de array é aceitável para retornar o valor inicial do índice.

Por exemplo:

val abc = Array(7 , { i -> i*1})

Aqui, o valor do array é 7 e a expressão lambda é usada para inicializar os valores do elemento.

Existem também vários métodos para acessar e modificar os arrays usando determinadas funções. Portanto, existem duas funções membro get() e set(), que são usadas para acessar objetos do array de classe.

Por exemplo:

val x = arrayOf(10,20,30,40,50,60,70,80,90)
val y = x.get(0) // Output 10

Aqui, a saída é 10, pois o valor no índice 0 do array é 10

Nota: get() aceita apenas valores únicos

Por exemplo:

val x = arrayOf(10,20,30,40,50,60,70.80.90)
val y = x.set(2, 3) //

Saída: 30 40

Aqui, a saída é 30 e 40, pois o valor no índice 2 do array é 30 e no índice 3 é 40.

Nota: set() aceita vários valores de um array.

Strings Kotlin

Uma string é um tipo de dados básico em qualquer linguagem de programação. Uma string nada mais é do que uma sequência de caracteres. A classe String representa cadeias de caracteres. No Kotlin, todas as strings são objetos da classe String, o que significa que literais de string são implementados como instâncias da classe.

Sintaxe:

 Val myString = "Hey there!"

Coleção Kotlin

Uma coleção contém vários objetos de tipo semelhante e esses objetos da coleção são chamados de elementos ou itens. A coleta pode ajudar a armazenar, recuperar, manipular e agregar dados.

Tipos de coleções:

Coleção imutável

Este tipo de coleção oferece suporte a funcionalidades somente leitura. Não se pode modificar seus elementos.

Os métodos incluem:

• Lista – listOf() e listOf ()
• Definir – setOf()
• Mapa – mapOf()

Coleção Mutável

Ele suporta funcionalidade de leitura e gravação.

Os métodos incluem

• Lista – mutableListOf(),arrayListOf() e ArrayList
• Definir – mutableSetOf(), hashSetOf()
• Mapa – mutableMapOf(), hashMapOf() e HashMap

Funções Kotlin

Funções em qualquer linguagem de programação são um grupo de instruções semelhantes designadas para executar uma tarefa específica. As funções permitem que um programa o divida em vários pequenos blocos de código. Essa divisão do código aumenta a legibilidade e a reutilização do código e torna o programa fácil de gerenciar.

Como Kotlin é conhecido como uma linguagem de tipo estaticamente. Aqui, a palavra-chave 'fun' é usada para declarar uma função. No Kotlin, existem dois tipos de funções que dependem unicamente de sua disponibilidade na biblioteca padrão ou na definição do usuário. Eles são:

• Função de biblioteca padrão
• Função definida pelo usuário

Agora, vamos discuti-los em detalhes com exemplos de código Kotlin.

Função de biblioteca padrão

São funções de biblioteca integradas que podem ser definidas implicitamente e disponíveis para uso.

Por exemplo 2:

fun main(args: Array<String>){  
var number = 9  
var result = Math.sqrt(number.toDouble())  
print("$result")  
}  

Saída:

3.0

sqrt() é uma função definida na biblioteca que retorna a raiz quadrada de um número.

A função print() imprime a mensagem em um fluxo de saída padrão.

Função definida pelo usuário

Como o nome sugere, essas funções geralmente são criadas pelos usuários e podem ser utilizadas para programação avançada.

Aqui, as funções são declaradas usando a palavra-chave ‘fun’.

Por exemplo 3:

fun functionName(){
//body of the code
}

Aqui, chamamos a função para executar códigos dentro do corpo functionName()

Exemplos de funções Kotlin:

fun main(args: Array<String>){  
    sum()  
    print("code after sum")  
}  
fun sum(){  
    var num1 =8  
    var num2 = 9  
    println("sum = "+(num1+num2))  
}  

Saída:

soma = 17

código após soma

Tratamento de exceções em Kotlin

Exceção em programação é definida como um problema de tempo de execução que ocorre no programa, levando-o ao encerramento. Esse problema pode ocorrer devido a menos espaço de memória, matriz fora de ligação e condições como divisão por zero. Para reduzir esses tipos de problemas na execução de código, é usado o tratamento de exceções.

O tratamento de exceções é definido como a técnica que trata dos problemas de tempo de execução e também mantém o fluxo do programa durante a execução.

Kotlin usa a expressão 'throw' para lançar um objeto de exceção. Aqui todas as classes de exceção são descendentes da classe Throwable.

Throw MyException(“lança exceção”)

Existem quatro tipos de exceções no tratamento de exceções. Eles são:

• try – Este bloco contém instruções que podem criar a exceção. É sempre seguido por catch ou finalmente ou ambos.
• catch – captura uma exceção lançada do bloco try.
• finalmente – Sempre verifica se a exceção foi tratada ou não.
• throw – É usado para lançar uma exceção explicitamente.

Tente pegar:

No bloco try-catch no tratamento de exceções, o bloco try envolve o código, que pode lançar uma exceção e o bloco catch captura a expressão e a trata.

Sintaxe do bloco try catch:

try{    
//code with exception    
}catch(e: SomeException){  
//code handling exception  
}    

Sintaxe de try com bloco finalmente

try{    
//code with exception    
}finally{  
// code finally block  
}   

Finalmente:

Em Kolin, o bloco final sempre verifica se a exceção foi tratada ou não, tornando-se uma declaração muito importante de tratamento de exceções.

Por exemplo 4:

Neste trecho de código, a exceção ocorre e é tratada.

fun main (args: Array<String>){  
    try {  	
        val data =  9/ 0  
        println(data)  
    } catch (e: ArithmeticException) {  
        println(e)  
    } finally {  
        println("finally block executes")  
    }  
    println("write next code")  
}  

Saída:

java.lang.ArithmeticException: / by zero
finally block executes
write next code

Lançar:

O bloco Throw lança uma exceção explícita. Além disso, é usado para lançar exceções personalizadas.

Sintaxe:

Throw SomeException()

Throw SomeException()

Exemplo:

fun main(args: Array<String>) {
    try{
        println("Exception is not thrown yet")
        throw Exception("Everything is not well")
        println("Exception is thrown")
    }
    catch(e: Exception){
        println(e)

    }
    finally{
        println("You can't ignore me")
    }
}

Saída:

Segurança nula de Kotlin

Os tipos de sistemas que suportam Kotlin distinguem principalmente entre as referências que podem transportar referências anuláveis ​​e aquelas que não podem transportar referências anuláveis. Kotlin é uma linguagem de segurança nula que visa eliminar a exceção de ponteiro nulo ou referência nula do código, que é deliberadamente conhecido como A BillErro do dólar de íon.

O obstáculo mais convencional de muitos linguagens de programação é que ao acessar um membro de uma referência nula, o resultado é uma NullPointerException, o que pode ser por causa de !! operador ou este construtor usado em outro lugar e passado em outro ponto do código. A propriedade anulável requer confirmação para a verificação de nulos sempre antes de sua utilização.

No Kotlin, o sistema distingue entre referências nulas e referências não nulas.

Por exemplo, uma variável String não pode conter nulo:

Por exemplo 5:

fun main(args: Array<String>){
    var x: String = "GURU99 is the only place where you will get maximum technical content!" // Not Null by default
    println("x is : $x")
    // You cannot assign null variable to not-nullable variables 
    // a=null // it will give compilation error
    var y: String? = "Thanks for visiting GURU99" 
// Nullable Variable
    println("y is : $y")
    y = null
    println("y is : $y")
}

Saída:

OOPs Kotlin

A abordagem de programação orientada a objetos permite que um trecho de código complexo seja dividido em blocos de código menores por meio da criação de objetos. Esses objetos compartilham mutuamente duas características: estado e comportamento.

Aqui estão alguns dos elementos OOPs que discutiremos com exemplos de código Kotlin:

• Classe e Objetos
• Construtores
• Herança
• Classe Abstrata

Aula em Kotlin

A primeira, antes de criar um objeto, precisamos definir uma classe que também é conhecida como blueprint do objeto.

Sintaxe:

class ClassName {
    // property
    // member function
    ... .. ...
}

Objetos em Kotlin

Ao definir uma classe, definimos apenas as especificações do objeto, nenhum outro parâmetro como memória ou armazenamento é alocado.

Sintaxe:

var obj1 = ClassName()

Construtores em Kotlin

Um construtor é uma forma de inicializar propriedades de classe. É uma função membro chamada quando um objeto é instanciado. Mas em Kotlin funciona de maneira diferente.

Existem dois tipos de construtores em Kotlin:

Construtor primário: maneira otimizada de inicializar uma classe

Sintaxe:

class myClass(valname: String,varid: Int) {  
    // class body  
}  

Construtor secundário: ajuda a adicionar lógica de inicialização

Herança Kotlin

A herança ocorre quando algumas propriedades da classe pai são adquiridas pela classe filha. A herança é permitida quando duas ou mais classes possuem as mesmas propriedades.

Sintaxe:

open class ParentClass(primary_construct){
    // common code
  }class ChildClass(primary_construct): ParentClass(primary_construct_initializ){
    // ChildClass specific behaviours
  }

Classe abstrata em Kotlin

Uma classe abstrata é uma classe que não pode ser instanciada, mas podemos herdar subclasses delas. A palavra-chave 'abstract' é usada para declarar uma classe abstrata.

Por exemplo 6:

  open class humanbeings { 
    open fun Eat() { 
        println("All Human being Eat") 
    } 
} 
abstract class Animal : humanbeings() { 
    override abstract fun Eat() 
} 
class Cat: Animal(){ 
    override fun Eat() { 
        println("Cats also loves eating") 
    } 
} 
fun main(args: Array<String>){ 
    val lt = humanbeings() 
    lt.Eat() 
    val d = Cat() 
    d.Eat() 
} 

Saída:

O presente e o futuro do Kotlin

O presente:

• Muitas empresas como Netflix, Pinterest e Corda estão usando Kotlin para criar Android apps.
• No curto período de um ano, de 2016 a 2017, Kotlin se tornou altamente popular com recursos de programação incríveis.
• Em 2017, o Google anunciou Kotlin como linguagem de programação oficial para desenvolvimento Android.
• Você pode substituir rapidamente Java código com Kotlin, pois é 100% interoperável com Java e Android.

O futuro:

• Desenvolvimento de jogos multiplataforma
• Desenvolvimento de aplicativos móveis multiplataforma
• Scripts e microsserviços do lado do serviço
• Aprendizado de máquinas & análise de dados

Resumo

• Kotlin é uma linguagem de programação proposta pela JetBrains em 2010 para aplicativos multiplataforma sob a licença Apache 2.0.
• O nome Kotlin é derivado do nome da Ilha Kotlin em uma correspondência semelhante de Java em homenagem ao nome de uma ilha chamada Java.
• Em 2016, a primeira versão v1.0 do Kotlin foi lançada
• Os programas Kotlin não exigem ponto e vírgula em seus programas. Isso torna o código mais fácil e legível.
• Kotlin para Android Developers é uma linguagem de programação baseada em OOPs onde a linha de código pode ser reduzida em até 40%, o que torna o Kotlin uma escolha ideal para software ou desenvolvimento web.
• No Kotlin, todas as variáveis ​​devem ser declaradas usando as palavras-chave var e val.
• Semelhante a outras linguagens de programação, Kotlin também tem seu conjunto predefinido de tipos de dados como Int, Boolean, Char, Double, etc.
• Em Kotlin, existe um conjunto de operadores que são usados ​​em diferentes operações, como operações aritméticas, operações de atribuição, operações de comparação, etc.
• No Kotlin, os arrays são uma colaboração mutável dos mesmos tipos de dados, em vez de serem tipos de dados nativos.
• No Kotlin, os arrays são definidos usando dois métodos – ArrayOF() e Construtores.
• Kotlin é uma linguagem de segurança nula que ajuda a remover a exceção de ponteiro nulo ou referência nula do código, que é deliberadamente chamado de A BillErro do dólar de íon.