I. Introducción:
Este sería el tercer post en serie, sobre mi experiencia en Kotlin, ciertamente un programador podría preguntarse si vale la pena o no aprender Kotlin, dado que está montado sobre la máquina virtual de Java, realmente, Java como todos los lenguajes proporciona ventajas y desventajas, los que hemos programado en él, las conocemos indiferentemente que nos guste o no este lenguaje. Con Kotlin, puede suceder lo mismo, algunos les gustará y otros lo odiarán, sin embargo dado la albitrariedad de Google sobre Android y el desinterés de Oracle por mantener un Java modernizado, nos queda coquetear con Kotlin, aunque sea solo por curiosidad.
Entre las desventajas que he notado, ha sido que la comunidad de Kotlin es muy pequeña, y encontrar soluciones a problemas específicos suele tardarse más que en Java, y a veces queda uno insatisfecho, ya que dicha solución no es la de nuestro problema. Otra desventaja es el compilador, muy lento, más que el de Java, ya que Kotlin lo que hace es "traducir" los archivos .kt a .class de la Java Virtual Machíne (JVM), lo que desesperaría a muchos programadores.
Entre las ventajas se encuentra que con unos cuantos días de prueba y error, es posible aprender la sintáxis básica, por lo menos hasta donde he avanzado, no me he puesto a adentrarme en el oscuro mundo de las funciones lambda, eso quedará para otro post. En este post veremos un experimento con las librerías gráficas de Java, naturalmente, mi código es experimental y nada elegante, he visto algunos ejemplos en Internet, pero quería probar un poco por mí mismo, entre el éxito y la frustración.
Una cosa importante que noté, es que los programas .jar, generados con Kotlin, solamente corren en la máquina virtual de java 8, con java 9 es posible correr aplicaciones de consola de texto, pero no aquellos con librería gráficas de java: awt y swing. De mi parte le resta algo de puntaje al Kotlin, no obstante veremos más adelante cuando tenga más experiencia en el lenguaje.
II. Librería personal
Para llamar las funciones de java utilicé un ejemplo del Libro Big Java de Cay Horstmann, que me pareció pequeño, hasta que al compilarlo me dio varios dolores de cabeza, la jerarquía de archivos quedó de la siguiente manera:
directorio raíz: /
librería: /windows
Archivo: /windows/rectangleFrame.kt
//Paquetería
package windows
//Librerías para RectangleFrame
import java.awt.*
import java.awt.event.*
import javax.swing.*
//Clase RectanglePanel que extiende JPanel
class RectanglePanel: JPanel() {
//Declaración de constantes internas
val BOX_X: Int = 50
val BOX_Y: Int = 50
val BOX_WIDTH: Int = 120
val BOX_HEIGTH: Int = 130
val PANEL_WIDTH: Int = 300
val PANEL_HEIGHT: Int = 300
val dimension = Dimension(PANEL_WIDTH, PANEL_HEIGHT)
val box:Rectangle = Rectangle(BOX_X, BOX_Y, BOX_WIDTH, BOX_HEIGTH)
//Requerido para llamar la función de Java:
init{
setPreferredSize(dimension)
}
//Las funciones importadas y sobrecargadas requieren del operador override
override fun paintComponent(g: Graphics) {
super.paintComponent(g)
var g2: Graphics2D = g as Graphics2D
g2.draw(box)
}
//la sobrecarga requiere la palabra override
override fun setLocation(x: Int, y: Int) {
box.setLocation(x, y)
repaint()
}
}
//Clase RectangleFrame que extiende a JFrame()
class RectangleFrame: JFrame()
{
//Inicialización de objetos heredados de la clase escrita arriba
val rectPanel: RectanglePanel = RectanglePanel()
//Constructor Primario (La clase) para llamar funciones Java
init{
createControlPanel()
pack()
}
private fun createControlPanel(){
var xField = JTextField(5)
var yField = JTextField(5)
val moveButton = JButton("Move")
//Action Listener: se requiere de definirla con el operador object:
moveButton.addActionListener(object: ActionListener {
override fun actionPerformed(event: ActionEvent){
val x: Int = xField.getText().toInt()
val y: Int = yField.getText().toInt()
rectPanel.setLocation(x, y)
}
})//Fin ActionListener
val xLabel: JLabel = JLabel("x= ")
val yLabel: JLabel = JLabel("y= ")
val controlPanel: JPanel = JPanel()
controlPanel.add(xLabel)
controlPanel.add(xField)
controlPanel.add(yLabel)
controlPanel.add(yField)
controlPanel.add(moveButton)
getContentPane().add(controlPanel, BorderLayout.SOUTH)
}
}
Archivo: /SwingKotlin.kt
//Importación de librerías JAVA
import javax.swing.JFrame
import windows.*
//Main LOOP
fun main(args: Array<String>){
val appFrame: RectangleFrame = RectangleFrame()
appFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
appFrame.setVisible(true) //Sustituto de .show()
}
III. Salida Final
Una vez compilada la maraña de código, repito, que hay que verlo traducido a funciones lambda para ver si queda algo más elegante, por ahora, es lo que me ha funcionado a mí. Dado que solo corre en JMV 8, tuve que desinstalar JVM9 e instalar la máquina virtual que servía:
IV.Conclusiones
- Luego de probar Kotlin unos días, no podría dar un rechazo o una aceptación definitiva, en especial porque no he estudiado las funciones lambdas, las cuales quedarán para otro post.
- Si puedo decir que al menos el compilador es algo lento ya que "traduce" de Kotlin a .class de Java
- Encontrar soluciones viables para un proyecto puede ser algo más difícil, ya que la comunidad Kotlin tiene apenas unos 6 años de gestación, comparado con los más de 25 años del Java.
- Java no morirá con Kotlin dado que éste usa las librerías del primero.
- Habrá que esperar este año para ver que deciden los programadores de Android si Java sigue reinando, o es destronado por Kotlin.
- No he utilizado ningún IDE, a lo mejor se simplifica el trabajo, probaré algunos más adelante con Kotlin.
- Lo siguiente será ver que tal es Kotlin en Android, pero eso será otro día.
Post Anteriores:
I. Instalación - Compilación:
II. Variables - Import
Bibliografía:
Horstmann, C. (2002) Big Java, San José, CA: John Wiley & Co.