1. Clases y Constructores
class Person {
var alive: Boolean = true
fun die(){
alive=false
}
}
fun main(){
var a:Person = Person()
println(a.alive)
a.die()
println(a.alive)
}
Constructor primario:
El constructor primario se define directamente en la declaración de la clase. Puede incluir parámetros y se utiliza para inicializar los atributos de la clase.
class Persona(val nombre: String, val edad: Int) {
// Código adicional de la clase
}
Constructor secundario: Además del constructor primario, Kotlin también permite definir constructores secundarios en la clase. Los constructores secundarios se crean utilizando la palabra clave constructor y pueden proporcionar diferentes formas de inicializar un objeto.
class Persona {
var nombre: String = ""
var edad: Int = 0
constructor(nombre: String, edad: Int) {
this.nombre = nombre
this.edad = edad
}
}
class Person(var name:String, var passport: String?) {
var alive: Boolean = true
fun die(){
alive=false;
}
}
var javi:Person = Person("Javi","A123456")
javi.die()
println(javi.name)
println(javi.passport)
println(javi.alive)
class Person(var name:String = "Anonimo", var passport: String? = null) {
var alive: Boolean = true
fun die(){
alive=false;
}
}
var javi:Person = Person("Javi","A123456")
javi.die()
println(javi.name) //Javi
println(javi.passport) //A123456
println(javi.alive) //false
var maria:Person = Person()
println(maria.name) //Anonimo
println(maria.passport) //null
2. get y set
class Pokemon ( var n:String = "Pok") {
private var name:String = n
private var attackPower: Float = 50f
constructor(n: String, aP: Float) : this() {
this.name=n
this.attackPower=aP
}
fun getName():String {return this.name}
fun getAttackPower():Float {return this.attackPower}
fun setName(n:String) {this.name=n}
fun setAttackPower(a:Float) {this.attackPower=a}
}
fun main(){
var b1: Pokemon=Pokemon()
println(b1.getName())
println(b1.getAttackPower())
var b2:Pokemon=Pokemon("P1")
println(b2.getName())
println(b2.getAttackPower())
var b3:Pokemon=Pokemon("P2",99f)
println(b3.getName())
println(b3.getAttackPower())
b3.setName("P99")
println(b3.getName())
}
3. Herencia y Polimorfismo
open class Animal(val nombre: String, val edad: Int) {
open fun hacerSonido() {
println("El animal hace un sonido.")
}
}
class Perro(nombre: String, edad: Int) : Animal(nombre, edad) {
override fun hacerSonido() {
println("El perro ladra.")
}
}
class Gato(nombre: String, edad: Int) : Animal(nombre, edad) {
override fun hacerSonido() {
println("El gato maulla.")
}
}
fun main() {
val perro = Perro("Fido", 3)
val gato = Gato("Pelusa", 2)
perro.hacerSonido() // Imprime "El perro ladra."
gato.hacerSonido() // Imprime "El gato maulla."
}
Herencia
open class Person(var name:String = "Anonimo", var passport: String? = null) {
var alive: Boolean = true
fun die(){
alive=false;
}
}
class Athlete(name:String, passport:String, var sport:String):Person(name,passport)
var pele:Athlete= Athlete("Pele","A3333","Futbol")
println(pele.name) //Pele
println(pele.passport) //A3333
println(pele.sport) //Futbol
println(pele.alive) //true
pele.die()
println(pele.alive) //false
Super
La palabra clave super se utiliza en la herencia para hacer referencia a la implementación de un método o propiedad en la clase base. Permite acceder y llamar a la implementación de la clase base desde una clase derivada.
open class Animal {
open fun hacerSonido() {
println("El animal hace un sonido.")
}
}
class Perro : Animal() {
override fun hacerSonido() {
super.hacerSonido() // Llama a la implementación de hacerSonido() de la clase base
println("Además, el perro ladra.")
}
}
fun main() {
val perro = Perro()
perro.hacerSonido()
4. Clases abstractas
En Kotlin, una clase abstracta es una clase que no se puede instanciar directamente, pero que sirve como base para otras clases. Puede contener tanto métodos abstractos como métodos concretos. Una clase abstracta se declara utilizando la palabra clave abstract
abstract class Figura {
abstract fun calcularArea(): Double
fun imprimirDescripcion() {
println("Esta es una figura.")
}
}
class Rectangulo(val base: Double, val altura: Double) : Figura() {
override fun calcularArea(): Double {
return base * altura
}
}
fun main() {
val rectangulo = Rectangulo(5.0, 3.0)
rectangulo.imprimirDescripcion()
val area = rectangulo.calcularArea()
println("El área del rectángulo es: $area")
}
5. Interfaces
Una interfaz es una estructura que define un conjunto de métodos y propiedades que deben ser implementados por las clases que la implementen. Una interfaz se declara utilizando la palabra clave interface. En Kotlin no hay multiherencia, pero una clase puede heredar de diferentes interfaces, o de una clase e interfaces
interface Vehiculo {
fun acelerar()
fun frenar()
}
class Coche : Vehiculo {
override fun acelerar() {
println("El coche está acelerando.")
}
override fun frenar() {
println("El coche está frenando.")
}
}
class Moto : Vehiculo {
override fun acelerar() {
println("La moto está acelerando.")
}
override fun frenar() {
println("La moto está frenando.")
}
}
fun main() {
val coche = Coche()
val moto = Moto()
coche.acelerar()
coche.frenar()
moto.acelerar()
moto.frenar()
}
interface Figura {
val color: String // Propiedad abstracta
fun calcularArea(): Double // Método abstracto
fun dibujar() { // Método concreto
println("Dibujando la figura...")
}
}
class Rectangulo(override val color: String, val base: Double, val altura: Double) : Figura {
override fun calcularArea(): Double {
return base * altura
}
}
class Circulo(override val color: String, val radio: Double) : Figura {
override fun calcularArea(): Double {
return Math.PI * radio * radio
}
}
fun main() {
val rectangulo = Rectangulo("Rojo", 5.0, 3.0)
val circulo = Circulo("Azul", 2.5)
rectangulo.dibujar()
println("El área del rectángulo es: ${rectangulo.calcularArea()}, color: ${rectangulo.color}")
circulo.dibujar()
println("El área del círculo es: ${circulo.calcularArea()}, color: ${circulo.color}")
}
6. Clases como propiedad
class Persona {
var nombre: String = ""
var direccion: Direccion = Direccion()
}
class Direccion {
var calle: String = ""
var ciudad: String = ""
var codigoPostal: String = ""
fun mostrarDir(){
println("Direccion: ${this.calle}, ${this.ciudad}, ${this.codigoPostal}")
}
}
fun main() {
val persona = Persona()
persona.nombre = "Juan"
persona.direccion.calle = "Calle Principal"
persona.direccion.ciudad = "Ciudad Ejemplo"
persona.direccion.codigoPostal = "12345"
println("Nombre: ${persona.nombre}")
persona.direccion.mostrarDir()
println("Dirección: ${persona.direccion.calle}, ${persona.direccion.ciudad}, ${persona.direccion.codigoPostal}")
}
7. Clases anidades e inner
Clases anidadas:
Una clase anidada está completamente contenida dentro de la clase externa.
No tiene acceso a los miembros no estáticos de la clase externa a menos que se cree una instancia de la clase externa.
No tiene acceso a la referencia this de la clase externa.
No necesita una instancia de la clase externa para ser instanciada.
Por defecto, es una clase estática, lo que significa que no tiene acceso a los miembros no estáticos de la clase externa.
class ClaseExterna {
private val mensajeExterno = "Mensaje desde la clase externa"
class ClaseAnidada {
fun imprimirMensaje() {
println("Mensaje desde la clase anidada")
}
}
}
fun main() {
val claseAnidada = ClaseExterna.ClaseAnidada()
claseAnidada.imprimirMensaje()
}
Clases internas (inner classes):
Una clase interna está asociada a una instancia específica de la clase externa.
Puede acceder a los miembros no estáticos de la clase externa, incluso a los privados.
Tiene acceso a la referencia this de la clase externa.
Necesita una instancia de la clase externa para ser instanciada.
Se declara utilizando la palabra clave inner.
class ClaseExterna {
private val mensajeExterno = "Mensaje desde la clase externa"
inner class ClaseInterna {
fun imprimirMensaje() {
println("Mensaje desde la clase interna: $mensajeExterno")
}
}
}
fun main() {
val claseExterna = ClaseExterna()
val claseInterna = claseExterna.ClaseInterna()
claseInterna.imprimirMensaje()
}
class SubClasses {
private var name="PADRE"
fun presentar(): String { return this.name}
class Anidada{
private val nameAnidada = "ANIDADA"
fun presentar(): String {return this.nameAnidada}
}
inner class Interna{
private val nameInterna="INTERNA"
fun presentar(): String {return "Hola, soy ${this.nameInterna}, hija de ${name}"}
}
}
fun main() {
var ani=SubClasses.Anidada()
println(ani.presentar())
var inn=SubClasses().Interna()
println(inn.presentar())
var sc:SubClasses=SubClasses()
println(sc.presentar())
}
8. Objeto anónimos
Te permite crear una instancia de un objeto con su propia implementación de métodos y propiedades sin definir una clase separada.
fun main() {
val persona = object {
var nombre: String = "Juan"
var edad: Int = 30
fun saludar() {
println("¡Hola! Mi nombre es $nombre y tengo $edad años.")
}
}
persona.saludar()
}
object ff{
var apodo="Fer"
fun saludo(){println("Hola, me llaman $apodo")}
}
fun main() {
ff.saludo()
ff.apodo="FFF"
ff.saludo()
}
9. Data class
Una data class es una clase especializada que se utiliza principalmente para representar datos. Proporciona automáticamente una implementación predeterminada de ciertos métodos, como toString(), equals(), hashCode(),
data class Persona(val nombre: String, val edad: Int)
fun main() {
val persona = Persona("Juan", 30)
println(persona.nombre) // Imprime "Juan"
println(persona.edad) // Imprime 30
}
data class Persona(val nombre: String, val edad: Int)
fun main() {
val persona = Persona("Juan", 30)
val (nombre, edad) = persona
println(nombre) // Imprime "Juan"
println(edad) // Imprime 30
}
data class Superhero(
var superhero:String,
var publisher:String,
var realName:String,
var photo:String
)
var superheros:MutableList<Superhero> = mutableListOf()
superheros.add(Superhero("Spiderman", "Marvel", "Peter Parker", "https://javigomez.org/ESIC/spiderman.jpg"))
superheros.add(Superhero("Daredevil", "Marvel", "Matthew Michael Murdock", "https://javigomez.org/ESIC/daredevil.jpg"))
superheros.add(Superhero("Wolverine", "Marvel", "James Howlett", "https://javigomez.org/ESIC/logan.jpeg"))
superheros.add(Superhero("Batman", "DC", "Bruce Wayne", "https://javigomez.org/ESIC/batman.jpg"))
superheros.add(Superhero("Thor", "Marvel", "Thor Odinson", "https://javigomez.org/ESIC/thor.jpg"))
superheros.add(Superhero("Flash", "DC", "Jay Garrick", "https://javigomez.org/ESIC/flash.png"))
superheros.add(Superhero("Green Lantern", "DC", "Alan Scott", "https://javigomez.org/ESIC/green-lantern.jpg"))
superheros.add(Superhero("Wonder Woman", "DC", "Princess Diana", "https://javigomez.org/ESIC/wonder_woman.jpg"))
10. enum class
Un enum (enumeración) es una forma de definir un tipo de datos que representa un conjunto fijo de valores constantes
enum class DiaSemana {
LUNES,
MARTES,
MIÉRCOLES,
JUEVES,
VIERNES,
SÁBADO,
DOMINGO
}
fun main() {
val dia = DiaSemana.MIÉRCOLES
println("Hoy es $dia") // Imprime "Hoy es MIÉRCOLES"
}
fun obtenerMensaje(dia: DiaSemana): String {
return when (dia) {
DiaSemana.LUNES -> "¡Ánimo, es lunes!"
DiaSemana.VIERNES -> "¡Por fin es viernes!"
else -> "Es otro día de la semana"
}
}
fun main() {
val dia = DiaSemana.LUNES
val mensaje = obtenerMensaje(dia)
println(mensaje) // Imprime "¡Ánimo, es lunes!"
}
enum class dias {
LUNES, MARTES, MIERCOLES, JUEVES, VIERNES, SABADO, DOMINGO;
fun saludo():String{
when (this){
LUNES->return "Ya es lunes"
MARTES->return "Es martes"
MIERCOLES-> return "Mitad"
JUEVES-> return "Juernes"
VIERNES-> return "Viernes por fin"
else -> return "Fin de semana"
}
}
}
var hoy:dias=dias.MARTES
var semana = dias.values()
for (i in semana) println(i)
println(dias.valueOf("MIERCOLES")) //MIERCOLES
println(hoy.name) //MARTES
println(hoy.ordinal)//1
println(hoy.saludo()) //Es martes
enum class dias (val laboral:Boolean, val jornada:Int){
LUNES(true,8), MARTES(true,8), MIERCOLES(true,8),
JUEVES(true,8), VIERNES(true,6),
SABADO(false,0), DOMINGO(false,0);
fun saludo():String{
when (this){
LUNES->return "Ya es lunes"
MARTES->return "Es martes"
MIERCOLES-> return "Mitad"
JUEVES-> return "Juernes"
VIERNES-> return "Viernes por fin"
else -> return "Fin de semana"
}
}
var hoy:dias=dias.MARTES
var semana = dias.values()
for (i in semana) println(i)
println(dias.valueOf("MIERCOLES")) //MIERCOLES
println(hoy.name) //MARTES
println(hoy.ordinal)//1
println(hoy.saludo()) //Es martes
println(hoy.laboral) //true
println(hoy.jornada) //8