reforco_kotlin

Prévia do material em texto

Basico de
E orientação a Objetos
O que vamos aprender?
1. O que é o Kotlin? 
2. Criar e executar um projeto 
3. Variáveis, Tipos e Operações 
4. Nulabilidade 
5. Estruturas de Controle 
6. Funções 
7. Classes 
8. Collections e Lambdas
O que vamos usar?
IntelliJ Community Edition try.kotlinlang.org
OU
https://www.jetbrains.com/idea/download/
https://www.jetbrains.com/idea/download/
https://www.jetbrains.com/idea/download/
https://www.jetbrains.com/idea/download/
https://www.jetbrains.com/idea/download/
https://try.kotlinlang.org/
Material Disponível Online
Código: 
https://github.com/
tommymolto/minicurso-kotlin
https://github.com/tommymolto/minicurso-kotlin
https://github.com/tommymolto/minicurso-kotlin
Review - Aula 1
1. O que é o Kotlin? 
2. Criar e executar um projeto 
3. Variáveis, Tipos e Operações 
4. Nulabilidade 
5. Estruturas de Controle (if, loop, when) 
6. Funções 
7. Classes (class, abstract, interfaces, data) 
8. Collections e Lambdas (collections + lambdas)
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/Variables.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/BasicTypes.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/BasicTypes.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/Nullability.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/ControlFlow-If.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/ControlFlow-Loops.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/ControlFlow-When.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/Functions.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/Classes.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/Classes-Abstract.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/Classes-Interfaces.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/Classes-Data.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/Collections.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
O que é?
Linguagem de programação criada em 2010 pela Jetbrains 
Open Source, licenciada com Apache 2 
Inspirada em linguagens como Java, C#, Groovy e Scala 
Estaticamente tipada 
Funcional e Orientada a Objetos
Filosofia do Kotlin
Pragmática: Resolve problemas do mundo real 
Concisa: Sintaxe expressa claramente a intenção do código 
Segura: Previne certos tipos de erro 
Interoperável: Mantém compatibilidade com o Java
Onde pode ser usado?
Mobile Desktop Web Server
Plataformas Suportadas - JVM
Mobile Desktop Web Server
JVM
Plataformas Suportadas - Android
Mobile Desktop Web Server
Android
Plataformas Suportadas - Javascript
Mobile Desktop Web Server
Javascript
Plataformas Suportadas - Native
Mobile Desktop Web Server
Native
“Talk is cheap. Show me the code.”
Linus Torvalds
Criando um novo projeto no IntelliJ
Clicar com o botão 
direito e selecionar 
“New > Kotlin 
File/Class”
Hello World!
fun main(args: Array<String>){ 
val myName = "Felipe" 
println("Hello World, $myName!") 
}
Rodando o projeto!
Sucesso!
Hello World! - Evoluindo um pouquinho...
fun main(args: Array<String>){ 
val myName = readLine() 
println("Hello World, $myName!") 
}
Variáveis
Declarando uma variável
val myValue = 15 // Declaração de tipo implícita 
val myValue : Int = 15 
var myVariable = 15 // Declaração de tipo implícita 
var myVariable : Int = 15
val
Referência imutável 
Não é possível alterar seu valor 
após sua inicialização 
Corresponde a declaração de uma 
variável final no Java
var 
Referência mutável
Podemos alterar seu valor a 
qualquer momento 
Corresponde a declaração de uma 
variável comum no Java
Tipos
Tipos Básicos
● Números (Int, Long, Byte, Float, Double, Short) 
● String 
● Char 
● Boolean (true ou false) 
● Arrays
Operações
Operações
Tipo Operadores
Aritméticas +, -, *, / e %
Incremento e decremento ++ e --
Atribuição =
Atribuição com “incremento” +=, -=, *=, /= e %=
Igualdade == e !=
Comparação >, <, >=, <=
Lógicos &&, || e !
Nulabilidade
Prevenindo NPE* durante a compilação
val nonNullableVal: String 
nonNullableVal = null / / Não compila
val nullableVal : String? = null
println(nullableVal.length) // Não compila
Indica que a variável é 
Nullable
*NPE = Null Pointer Exception
Corrigindo...
val nonNullableVal: String 
nonNullableVal = "Some String" 
val nullableVal : String? = null 
println(nullableVal?.length) // Imprime null 
Operador “Safe Call” (?.)
Verificando com IF
if (nullableVal != null) { 
println(nullableVal.length)
} else {
println("Empty string.") 
}
Não precisa do “?.”
Operador Elvis ?:
println(nullableVal?.length ?: "Empty string.") 
Equivalente ao “IF” do slide anterior
Estruturas de Decisão
Estrutura de Decisão - if
Convencional 
if (number % 2 == 0) { 
println("$number é um número par") 
} else { 
println("$number é um número ímpar.") 
}
Expressão 
val parity = if (number % 2 == 0) { 
"par" 
} else 
{ "ímp
ar" 
} 
println("$number é um número $parity.")
Estrutura de Decisão - when
Convencional 
when (grade) { 
in 0..4 -> println("Reprovado") 
in 5 until 7 -> println("Recuperação") 
in 7 until 10 -> println("Aprovado") 
10 -> println("Aprovado com honras.") 
else -> println("Aluno esquisito.") 
}
Expressão 
val evaluation = when (grade) 
{ in 0..4 -> "Reprovado" 
in 5 until 7 -> "Recuperação" 
in 7 until 10 -> "Aprovado" 
10 -> "Aprovado com honras." 
else -> "Aluno esquisito." 
} 
println(evaluation)
Estrutura de Decisão - when
Substituindo o IF 
when { 
grade <= 4 -> println("Reprovado") 
grade < 7 -> println("Recuperação") 
grade < 9 -> println("Aprovado") 
else -> println("Aprovado com honras.") 
}
Estruturas de Repetição
Estrutura de Repetição - for
Intervalo Exclusivo 
for (i in 1..10) { 
println(i) 
}
Intervalo Exclusivo 
for (i in 1 until 10) { 
println(i) 
}
Intervalo com Incremento 
for (i in 1..10 step 2) { 
println(i) 
}
Ordem Inversa 
for (i in 10 downTo 1) { 
println(i) 
}
Estrutura de Repetição - for
Percorrendo Array 
for (element in array) { 
println(fruit) 
} 
Percorrendo Array com Índices 
for ((index, value) in array.withIndex()) { 
println("[$index]: $value") 
}
Percorrendo Array Invertido 
for (element in array.reversedArray()) { 
println(fruit) 
} 
ForEach (Ranges, Array e Collections) 
(1..10).forEach { println(it) }
Estrutura de Repetição - while e do..while
var i = 1 
while (i <= 10) { 
println(i++) 
}
while do..while
var i = 1 
do { 
println(i++) 
} while (i <= 10)
Funções
Funções - Declaração
Convencional 
fun sum(a: Int, b: Int): Int { 
return a + b 
}
Expressãofun multiply(a: Int, b: Int) = a * b
Função sem Retorno 
fun printSum(a: Int, b: Int) { 
println("$a + $b = ${sum(a, b)}") 
}
Função sem Retorno (Unit explícito) 
fun printMultiply(a: Int, b: Int): Unit = 
println("$a * $b = ${multiply(a, b)}")
Funções - Declaração
Função com Número de Parâmetros 
Variável 
fun average(vararg numbers: Int): Float { 
if (numbers.isNotEmpty()) { 
val totalSum = numbers.sum() 
return totalSum.toFloat() / 
numbers.size.toFloat() 
} 
return 0F 
}
Função com Parâmetros Padrão 
fun printName(name: String = "Anônimo"){ 
println(name) 
}
Funções - Invocação 
val num = sum(42, 18) 
printSum(15, 10)
printSum(b = 10, a = 15) // Parâmetros nomeados 
val average = average(12, 10, 44, 99, 123) 
printName() 
printName("Felipe")
Links para aprofundar
1. O que é o Kotlin? Link 1, Link 2 
2. Criar e executar um projeto Link 1 
3. Variáveis, Tipos e Operações Link 1, Link 2 
4. Nulabilidade Link 1, Link 2 
5. Estruturas de Controle Link 1, Link 2 
6. Funções Link 1, Link 2 
https://speakerdeck.com/svtk/1-intro-kotlin-workshop
https://speakerdeck.com/svtk/1-intro-kotlin-workshop
https://speakerdeck.com/svtk/1-intro-kotlin-workshop
https://kotlinlang.org/
https://kotlinlang.org/
https://kotlinlang.org/
https://beginnersbook.com/2017/12/create-and-run-your-first-kotlin-project-in-intellij-idea/
https://beginnersbook.com/2017/12/create-and-run-your-first-kotlin-project-in-intellij-idea/
https://beginnersbook.com/2017/12/create-and-run-your-first-kotlin-project-in-intellij-idea/
https://kotlinlang.org/docs/reference/basic-types.html
https://kotlinlang.org/docs/reference/basic-types.html
https://kotlinlang.org/docs/reference/basic-types.html
https://speakerdeck.com/svtk/4-kotlin-types-kotlin-workshop
https://speakerdeck.com/svtk/4-kotlin-types-kotlin-workshop
https://speakerdeck.com/svtk/4-kotlin-types-kotlin-workshop
https://kotlinlang.org/docs/reference/null-safety.html
https://kotlinlang.org/docs/reference/null-safety.html
https://kotlinlang.org/docs/reference/null-safety.html
https://speakerdeck.com/svtk/2-nullable-types-in-kotlin-kotlin-workshop
https://speakerdeck.com/svtk/2-nullable-types-in-kotlin-kotlin-workshop
https://speakerdeck.com/svtk/2-nullable-types-in-kotlin-kotlin-workshop
https://kotlinlang.org/docs/reference/control-flow.html
https://kotlinlang.org/docs/reference/control-flow.html
https://www.programiz.com/kotlin-programming/if-expression
https://www.programiz.com/kotlin-programming/if-expression
https://www.programiz.com/kotlin-programming/if-expression
https://kotlinlang.org/docs/reference/functions.html
https://kotlinlang.org/docs/reference/functions.html
https://www.programiz.com/kotlin-programming/functions
https://www.programiz.com/kotlin-programming/functions
https://www.programiz.com/kotlin-programming/functions
Review - Aula 2
1. Classes - Basico (class, abstract, interfaces, 
data) 
2. Collections e Lambdas (collections + lambdas)
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/Classes.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/Classes-Abstract.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/Classes-Interfaces.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Classes-Data.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/Collections.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Lambdas.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
Conceitos Básicos
⚫ Orientação a Objetos (OO) é uma abordagem de 
programação que procura explorar nosso lado intuitivo. Os 
objetos da computação são análogos aos objetos existentes 
no mundo real. 
⚫ No enfoque de OO, os átomos do processo de computação 
são os objetos que trocam mensagens entre si. 
⚫ Essas mensagens resultam na ativação de métodos, os quais 
realizam as ações necessárias.
Conceitos Básicos
⚫ Os objetos que compartilham uma mesma interface, ou 
seja, respondem as mesmas mensagens, são agrupados 
em classes. 
⚫ Objeto é algo DINÂMICO: é criado por alguém, tem uma 
vida, e morre ou é morto por alguém. Assim, durante a 
execução do sistema, os objetos podem: 
◦ ser construídos 
◦ executar ações 
◦ ser destruídos 
◦ tornar-se inacessíveis
Histórico de Orientação a Objetos (OO)
⚫ A OO surgiu no final da década de 60, quando dois 
cientistas dinamarqueses criaram a linguagem 
Simula (Simulation Language) 
⚫ 1967 - Linguagem de Programação Simula-67- 
conceitos de classe e herança 
⚫ O termo Programação Orientada a Objeto (POO) é 
introduzido com a linguagem Smalltalk (1983)
Histórico de Orientação a Objetos (OO)
⚫ FINS DOS ANOS 80 ⇨ Paradigma de Orientação a Objetos 
◦ abordagem poderosa e prática para o 
desenvolvimento de software 
⚫ Linguagens orientadas a objetos 
◦ Smalltalk (1972), Ada (1983), Eiffel (~1985) 
◦ Object Pascal (1986), Common Lisp (1986), C++ (1986) 
◦ Java (~1990), Phyton (~1990), Perl 5 (2005)
Linguagens orientadas a objetos
⚫ "puras“ – tudo nelas é tratado consistentemente 
como um objeto, desde as primitivas até 
caracteres e pontuação. Exemplos: Smalltalk, 
Eiffel, Ruby. 
⚫ Projetadas para OO, mas com alguns 
elementos procedimentais. Exemplos: Java, 
Python. 
⚫ Linguagens historicamente procedimentais, mas 
que foram estendidas com características OO. 
Exemplos: C++, Fortran 2003, Perl 5.
Fonte: Wikipedia
Vantagens de OO
⚫ abstração de dados: os detalhes referentes às 
representações das classes serão visíveis apenas a seus 
atributos; 
⚫ compatibilidade: as heurísticas para a construção das classes 
e suas interfaces levam a componentes de software que são 
fáceis de combinar; 
⚫ diminuição da complexidade: as classes delimitam-se em 
unidades naturais para a alocação de tarefas de 
desenvolvimento de software;
Vantagens de OO
⚫ reutilização: o encapsulamento dos métodos e 
representação dos dados para a construção de classes 
facilitam o desenvolvimento de software reutilizável, 
auxiliando na produtividade de sistemas; 
⚫ extensibilidade: facilidade de estender o software devido a 
duas razões: 
◦ herança: novas classes são construídas a partir das que já existem; 
◦ as classes formam uma estrutura fracamente acoplada, o que facilita 
alterações; 
⚫ manutenibilidade: a modularização natural em classes 
facilita a realização de alterações no software.
Vantagens de OO
⚫ maior dedicação à fase de análise, preocupando-se 
com a essência do sistema; 
⚫ mesma notação é utilizada desde a fase de análise 
até a implementação.
Frente a essas vantagens, a abordagem OO tem 
provado ser “popular” e eficaz.
Objetos
⚫ Tudo em OO é OBJETO 
◦ Objeto, no mundo físico, é tipicamente um produtor e consumidor de 
itens de informação 
⚫ Definição (mundo do software) 
◦ “Qualquer coisa, real ou abstrata, a respeito da 
qual armazenamos dados e métodos que os 
manipulam” Martin, Odell (1995) 
◦ Abstração de uma entidade do mundo real de modo 
que essa entidade possui várias características
Objetos e Classes
Leitor
nome 
numeroUSP 
dataNascimento
le2: Leitor
nome = Joao da Silva 
numeroUSP = 323232 
dataNascimento= 02/23/1978
le1: Leitor
nome = Maria dos Santos 
numeroUsp = 342343 
dataNascimento = 04/25/1973
objetosclasses
FornoDeMicroondas
capacidade 
potência 
status 
horário
forno1: FornoDeMicroondas
capacidade = 40 
potencia = 600 
status = desligado 
hora = 09:35
Classes
⚫ Agrupamento de objetos similares. 
⚫ Todo objeto é uma instância de uma Classe. 
⚫ Os objetos representados por determinada classe 
diferenciam-se entre si pelos valores de seus atributos. 
⚫ Conjunto de objetos que possuem propriedades 
semelhantes (ATRIBUTOS), o mesmo comportamento 
(MÉTODOS), os mesmos relacionamentos com outros 
objetos e a mesma semântica.
Atributos
◦ Representam um conjunto de informações, ou seja, 
elementos de dados que caracterizam um objeto 
◦ Descrevem as informações que ficam escondidas em um 
objeto para serem exclusivamente manipuladas pelas 
operações daquele objeto 
◦ São variáveis que definem o estado de um objeto, ou seja, 
são entidades que caracterizam os objetos 
◦ Cada objeto possui seu próprio conjunto de atributos
Métodos
◦ São procedimentos definidos e declarados que atuam 
sobre um objeto ou sobre uma classe de objetos 
◦ Métodos são invocados por Mensagens 
◦ Cada objeto possui seu próprio conjunto de métodos
Métodos X Mensagem
le1: Leitor
nome = Maria dos Santos 
numeroUsp = 342343 
dataNascimento = 04/25/1973
le1.alterarNome(‘Rosa Olivera’)
mensagem
método alterarNome(Char[30] novoNome) 
Inicio 
nome := novoNome; 
Fim
método
Atributos e Métodos
Atributos
Métodos
Automóvel
proprietári
o marca 
placa 
ano
registrar 
transferir_Proprietário 
mudar_Placa
Abstração
⚫ Processo pelo qual conceitos gerais são formulados a 
partir de conceitos específicos. 
⚫ Detalhes são ignorados, para nos concentrarmos nas 
características essenciais dos objetos de uma coleção
Abstração
Encapsulamento
⚫ permite que certas características ou propriedades 
dos objetos de uma classe não possam ser vistas ou 
modificadas externamente, ou seja, ocultam-se as 
características internas do objeto 
◦ outras classes só podem acessar os atributos de 
uma classe invocando os métodos públicos; 
◦ restringe a visibilidade do objeto, mas facilita o reuso
Conceitos Básicos
⚫ Associações entre Classes
Proprietário
nome 
endereço 
telefone
consultar 
incluir
Automóvel
pr
op
rie
tár
io 
ma
rca 
 
placa
ano
registrar 
transferir_Proprietário 
mudar_Placa
possui
Herança
◦ mecanismo que permite que características comuns a diversas 
classes sejam colocadas em uma classe base, ou superclasse. 
◦ As propriedades da superclasse não precisam ser repetidas em 
cada subclasse. 
◦ Por exemplo, JanelaRolante e JanelaFixa são subclasses de Janela. 
Elas herdam as propriedades de Janela, como uma região visível na 
tela. JanelaRolante acrescenta uma barra de paginação e um 
afastamento.
Estudante
GENERALIZAÇÃO
ESPECIALIZAÇÃO 
(herança)
Superclasse
Estudante 
de Pós- 
Graduação
Estudante 
de 
Graduação
Subclasse
Herança: Generalização/Especialização
Herança
A Gas
temperatura
Forno
capacidade
Microondas
horario
potencia
Elétrico
voltagem
A Lenha
quantMaxLenha
Analógico Digital
Camping
Acendimento com Fósforo
Acendimento Elétrico
Herança Múltipla
Existe mais de uma superclasse, ou seja, uma classe é 
declarada como uma subclasse de uma ou mais 
superclasses.
Estudante
data_ingresso
Funcionário
data_admissão 
salario
Leitor da Biblioteca 
num_cadastro
Polimorfismo
⚫ O Polimorfismo geralmente representa a qualidade ou 
estado de um objeto ser capaz de assumir diferentes 
formas. 
⚫ Mais especificamente, propriedade segundo o qual vários 
métodos podem existir com o mesmo nome. 
◦ Ao receber uma mensagem para efetuar uma Operação, é o objeto 
quem determina como a operação deve ser efetuada; 
◦ Permite a criação de várias classes com interfaces idênticas, porém 
objetos e implementações diferentes.
Polimorfismo
⚫ Exemplos: 
◦ O operador “+” pode ser usado com inteiros, 
pontos- flutuantes ou strings. 
◦ A operação mover pode atuar diferentemente nas 
classes Janela e PeçadeXadrez.
Classes
Declarando uma classe no Kotlin
class Person(val name: String, private val birthYear: Int) { 
init {
println("Initializing Person with name $name")
}
constructor(name: String, birthYear: Int, isMarried: Boolean) : this(name, birthYear) { 
this.isMarried = isMarried 
}
// Definindo uma propriedade com o get customizado
val age: Int
get() { 
return LocalDateTime.now().year - birthYear 
}
var isMarried: Boolean = false
private set // Atribuição apenas dentro da classe 
}
Construtor Primário com Propriedades
Bloco de inicialização
Construtor Secundário sem 
propriedades
Propriedade com get customizado
Propriedade com set privado
Criando uma instância
val person1 = Person("Felipe", 1987) 
val person2 = Person("Bruna", 1989, false)
Modificadores de Visibilidade
Modificadores de Visibilidade
Modificador Visibilidade
public
Visível de qualquer local. É o modificador 
de visibilidade padrão
protected Visível apenas para Classes e Sub-Classes
private Visível apenas para classe
internal Visível apenas no módulo
Interfaces
Declarando uma interface
interface Shape { 
fun getArea(): Double 
fun printArea() { 
val formattedArea = "%.2f".format(getArea()) 
println("${javaClass.simpleName} area: $formattedArea") 
} 
}
Declarando implementações
class Circle(private val radius: Double) : Shape { 
override fun getArea(): Double { 
return Math.PI * radius * radius 
} 
} 
open class Rectangle(private val width: Double, private val height: Double) : Shape 
{ override fun getArea() = width * height 
} 
class Square(side: Double) : Rectangle(side, side)
Classes Abstratas
Declarando uma classe abstrata
abstract class Animal { 
protected abstract val sound: String 
fun doSound() { 
println("${javaClass.simpleName} says $sound.") 
} 
}
Declarando extensões
class Dog : Animal() 
{ override val sound = 
"AU" 
fun howl() { 
println("${javaClass.simpleName} says AUUUUUUUUUU") 
} 
} 
class Cat : Animal() { 
override val sound = "MIAU" 
fun pur() { 
println("${javaClass.simpleName} says RRRRRRRRRR") 
} 
}
Modificador Data
// Modificador data “cria” automaticamente os métodos “equals”, “hashCode” e “toString” 
data class Human(val name: String, val birthYear: Int, val isMarried: Boolean = false) 
val human = Human("Felipe", 1987) 
val human2 = Human("Felipe", 1987) 
val human3 = Human("Fulano", 1999) 
println(human) // Imprime Human(name=Felipe, birthYear=1987, isMarried=false) 
println(human == human2) // Imprime true 
println(human == human3) // Imprime false
Modificador Data
Review - Aula 3
1. Collections e Lambdas (collections + lambdas) 
2. Métodos avançados
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/Collections.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Lambdas.kt
https://github.com/tommymolto/minicurso-kotlin/tree/master/src/br/edu/infnet/aulakotlin/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
Collections
Listas
Listas Imutáveis 
var list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9) 
println("List elements: $list") 
println("Is list empty? ${list.isEmpty()}") 
println("List size: ${list.size}") 
println("Print element atposition 3: ${list[3]}") 
list = listOf() / / Cria uma lista vazia
Listas Mutáveis 
val list = mutableListOf(1, 2, 3, 4, 5, 6, 7, 8, 9) 
list[0] = 2 / / [2,2,3,4,5,6,7,8,9] 
list.add(10) / / [2,2,3,4,5,6,7,8,9,10] 
list += 15 / / [2,2,3,4,5,6,7,8,9,10,15] 
list.removeAt(0) / / [2,3,4,5,6,7,8,9,10] 
list.remove(9) / / [2,3,4,5,6,7,8,10] 
list.clear() / / []
Sets
São similares às Lists, porém não permitem a existência de dois elementos 
duplicados no seu conjunto. 
Sets não permitem o acesso de seus elementos através de índices.
Maps
Maps Imutáveis 
val map = mapOf( 
"First" to 1, 
"Second" to 2, 
"Third" to 3) 
println("Map elements: $map") 
println("Map keys: ${map.keys}") 
println("Map values: ${map.values}") 
println("Is map empty? ${map.isEmpty()}") 
println("Map size: ${map.size}") 
println("Map contains key: ${map.containsKey(key)}") 
println("Value with key '$key': ${map[key]}")
Maps Mutáveis 
val map = mutableMapOf( 
"First" to 1, 
"Second" to 2, 
"Third" to 3) 
mutableMap["Sixth"] = 6 // Adicionando valor 
mutableMap += "Seventh" to 7 // Adicionando valor 
mutableMap["Third"] = 8 //Alterando valor 
mutableMap.remove("Second") // Removendo valor
Lambdas
Lambdas
São funções que podem ser armazenadas em variáveis, passadas como 
argumentos ou retornadas de outras funções. 
Podem ser usadas como parâmetros ou retorno de Higher-Order Functions. 
Um bom exemplo de aplicações dos lambdas são as operações disponíveis 
pelas coleções do Kotlin
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
https://github.com/felipepedroso/minicurso-kotlin/blob/master/src/br/pedroso/minikourse/Collections-Lambdas.kt
Lambdas
Declarando uma função como variável 
val addition: (Int, Int) -> Int = { a: Int, b: Int -> a 
+ b } 
val subtraction = { a: Int, b: Int -> a - b } 
Invocando a função 
println(addition(num1, num2)) 
println(addition.invoke(num1, num2))
Declarando uma High-Order Function 
fun calculate(a: Int, b: Int, calcFunction: (Int, Int) -> Int): Int { 
return calcFunction.invoke(a, b) 
}
Utilizando uma High-Order Function 
println(calculate(num1, num2, addition))
Funções - Declaração
Executando uma High-Order Function com 
“Lambda Anônimo” 
var result: Int = calculate(num1, num2) { a, b -> 
(a * a) + (b * b) 
}
Executando uma High-Order Function com 
uma função declarada 
fun otherFunnyOperation(a: Int, b: Int): Int { 
return (a + a) * (b + b) 
} 
var result = calculate(num1, num2, 
::otherFunnyOperation)
Links para aprofundar
1. Classes Link 1, Link 2, Link 3 
2. Collections e Lambdas Link 1, Link 2
https://kotlinlang.org/docs/reference/classes.html
https://kotlinlang.org/docs/reference/classes.html
https://speakerdeck.com/svtk/3-object-oriented-programming-in-kotlin-kotlin-workshop
https://speakerdeck.com/svtk/3-object-oriented-programming-in-kotlin-kotlin-workshop
https://www.programiz.com/kotlin-programming/class-objects
https://www.programiz.com/kotlin-programming/class-objects
https://www.programiz.com/kotlin-programming/class-objects
https://speakerdeck.com/svtk/5-functional-programming-kotlin-workshop
https://speakerdeck.com/svtk/5-functional-programming-kotlin-workshop
https://speakerdeck.com/svtk/5-functional-programming-kotlin-workshop
https://kotlinlang.org/docs/reference/lambdas.html
https://kotlinlang.org/docs/reference/lambdas.html
https://kotlinlang.org/docs/reference/lambdas.html