Mostrando entradas con la etiqueta java. Mostrar todas las entradas
Mostrando entradas con la etiqueta java. Mostrar todas las entradas

domingo, 22 de enero de 2017

Curso de Java clase 12 Los Threads


(No olvides suscribirte)

Los Threads

    Si queremos hacer un reloj, una animación, o crear una especie de evento personalizado, necesitamos crear un proceso paralelo a nuestro "Main" ya que cualquier cosa que coloquemos ahí se va a ejecutar en orden, por lo que podría impedir que se ejecute el resto del código. La solución es usar Threads que nos permiten crear procesos paralelos, que se ejecutan sin causar interrupción alguna en nuestro "Main", en el video de arriba aprenderás a hacer lo ya mencionado, y a continuación podrás descargar los códigos fuente realizados en el tutorial

Códigos fuente

   GUI.java
  

domingo, 8 de enero de 2017

Juego de Anagrama en Java



Juego de Anagrama

  Un anagrama (del griego ἀνά -ana-, prefijo que significa "de vuelta", y γράμμα -gramma-, "letra") es una palabra o frase que resulta de la transposición de letras de otra palabra o frase. Dicho de otra forma, una palabra es anagrama de otra si las dos tienen las mismas letras, con el mismo número de apariciones, pero en un orden diferente. Por ejemplo, las palabras amor y mora son anagramas porque las dos se componen de las mismas letras: a, m, o y r.

  Sabiendo lo que es un anagrama podemos entender mejor de lo que se trata el juego, simplemente vamos a tomar una palabra aleatoria de un archivo de texto con muchas palabras, la desordenamos, y luego deberemos adivinar de que palabra se trata, un juego que pone a prueba nuestras neuronas, tanto al escribirlo como al jugarlo

Descargas



Enlaces sociales



domingo, 11 de diciembre de 2016

Cual es la diferencia entre Swing y AWT para crear GUIs en Java


(No olvides suscribirte)

AWT vs Swing

    Ambas forman parte del grupo de librerías que en Java nos permiten construir nuestra propia interfaz gráfica, pero ¿Acaso una de ellas es mejor que la otra? empecemos diciendo que AWT es realmente el método "viejo", ya que fue la primera librería proporcionada por Java para crear nuestra propia GUI, Swing por otro lado sería el método "nuevo" ya que llegó con la intención de subsanar los inconvenientes que representaba AWT, estos inconvenientes solo se evidenciaban bajo el concepto de multiplataforma de Java, observa la tabla a continuación :


AWT Swing
Usa componentes del S.O. Dibuja sus propios componentes
El S.O. maneja los eventos Java maneja los eventos
La apariencia cambia con el S.O Tienen la misma apariencia en cualquier S.O.
La apariencia es estática Se puede personalizar con los Look & Feel

  Luego de ver esta tabla y el video que encabeza esta entrada, nos queda claro el principal inconveniente al usar AWT, en cada sistema operativo nuestra interfaz va a tener una apariencia diferente y es posible que incluso parte del comportamiento sea diferente también, ya que los eventos son manejados por el sistema operativo, esto hacía que desarrollar aplicaciones con interfaz gráfica en Java fuera algo tedioso, había que verificar que servía y que no en cada sistema, por lo que el eslogan de java: "Escribe una vez y ejecútalo donde quieras" se veía un poco afectado.

sábado, 3 de diciembre de 2016

Como hacer Ventanas en Java, introducción a las GUI Clase 9


Para ver en Youtube clic aquí
Para ver la lista de reproducción completa clic aquí
(No olvides suscribirte)


Ventana básica en Java

   En este tutorial principalmente se enseña a hacer una ventana básica, esto a modo de introducción a la creación de interfaces gráficas. Existen 3 modos de crear ventanas en Java, en el video se tratarán  los 3, la primera con swing, luego con awt y por último usando el diseñador de Netbeans, en este caso estamos usando igualmente swing pero con la ayuda del diseñador es mucho más simple.

Elementos Swing

  Aquí solo compartiré una referencia para que observen los diferentes elementos Swing que se pueden colocar en una ventana, la página está en inglés pero es una guía visual así que no es necesario leer mucho, en el tutorial dedicado al tema de los componentes profundizaremos mas al respecto

¿Que son las Layouts?

  Las layouts son simplemente una forma de decirle a Java como organizar los elementos que vamos colocando en cada ventana, cada layout de dice el tamaño y la ubicación que debe tener cada elemento, a continuación las layouts mas comunes:
  • BoderLayout: Permite organizar los elementos usando puntos cardinales, norte, sur, este y oeste
  • BoxLayout: Crea columnas o filas de elementos
  • FlowLayout: Organiza los elementos en lineas, con tamaño justo para su contenido
  • GridLayout: Podemos crear una matriz para colocar los elementos en ella, el tamaño será lo que ocupe cada celda
  • GridBagLayout: Es uno de los mas sofisticados, al igual que el de arriba nos permite crear una matriz, pero aquí podemos especificar que un elemento ocupe dos celdas, o que su tamaño no cubra la celda entera
  Aquí se intentó explicar las layouts de forma muy resumida, en futuras clases se hablará mas profundamente acerca de este tema, faltaron algunos layouts por mencionar, puedes ver una referencia completa en este enlace (está en inglés):

WindowAdapter

  Es la clase que permite sobrescribir los métodos que se llaman en un evento de ventana, a continuación una descripción de cada uno:
  • windowActivated: Cuando la ventana se activa
  • windowColsed: Cuando la ventana es cerrada
  • windowClosing: Cuando la ventana se esta cerrando
  • windowDesactivated: Cuando la ventana se desactiva
  • windowsDeiconified: Cuando la ventana se des-iconifica
  • windowGainedFocus: Cuando gana el foco
  • windowIconified: Cuando la se iconifica
  • windowLostFocus: Cuando la ventana pierde el foco
  • windowOpened: Cuando se abre la ventana
  • windowStateChanged: Cuando cambia el estado de la ventana
Mas info aquí

Descarga los ejemplos del Blog





domingo, 2 de octubre de 2016

Listas enlazadas en Java


Para ver en youtube clic aquí
Para más videos como este clic aquí
(No olvides suscribirte)


¿Que es una estructura de Datos?

    Son formas particulares de organizar los datos para que estos se puedan utilizar de forma eficiente, se pueden utilizar en variedad de aplicaciones, pero existen ciertos tipos que son altamente especializados en tareas especificas. Son un medio para manejar grandes cantidades de datos como por ejemplo en Bases de Datos

La lista enlazada

  Si queremos guardar diferentes datos de información variada, que está de alguna manera relacionada entre sí, puede ser de mucha utilidad el uso de Arrays.


   Si la cantidad de información a almacenar es fija no tendremos ningún problema, pero si necesitamos agregar constantemente elementos, tenemos un problema. Siempre podríamos crear una Array enorme mas allá de nuestras necesidades, pero eso podría traducirse en desperdicio de memoria.
  La lista enlazada nos permite crear una estructura eficiente, ya que solicita memoria de acuerdo a las necesidades, y sencilla, ya que descubrirás que no es para nada difícil de hacer, funciona como un Array en donde no tenemos límite de elementos a almacenar.

¿Java no contiene ya algo así de forma pre-establecida?

  Si, tenemos a "LinkedList", "ArrayList", "Vector" y varios otros, pero saber como crearla es importante en tu proceso de aprendizaje como programador, aprender a construirla te permitirá y creando estructuras cada vez más complejas y además conocerás como estas estructuras trabajan "bajo el capó".

Otras estructuras similares

Las Colas

   Las colas son como las listas enlazadas, almacenan varios elementos, pero estas se rigen por una regla muy especifica, que para entenderla, podemos hacer una analogía con el mundo real. Cuando estas en el banco o en el supermercado esperando para pagar, estas en una "fila" o "cola", en donde el primero en llegar es el primero en salir. En las colas podemos almacenar la cantidad que queramos de elementos, al igual que con las listas enlazadas, pero solo podemos obtener elementos de acuerdo al orden que estos fueron agregados, tal cual una fila o cola, el primero en ser ingresado en la cola será el primero en salir
  Los sistemas operativos son muy dependientes de estas estructuras, el ejemplo más sencillo de entender es la cola de impresión

Las pilas

  Al igual que las colas, estas tienen un análogo en el mundo real, cuando colocas varios papeles uno encima de otro ¿Que obtienes? una pila de papeles, y la única forma de sacar hojas de la pila es quitando primero las de arriba. En las pilas los últimos en ingresar son los primeros en salir, esto permite diversas aplicaciones como por ejemplo invertir el orden de un grupo de elementos.

Cosas del video ¿Que es "This"?

  Se usa para referenciar a la clase misma, desde dentro de ella, por ejemplo si tenemos un método con parámetro "dato", como en el video, pero la clase también posee una variable "dato" ¿Como hace Java para diferenciarlos? si decimos "this.dato" nos estamos refiriendo a la variable de la clase y con "dato" (Dentro del método en cuestión) nos estamos refiriendo al parámetro del método.

Códigos fuente

Nota: Luego de hacer clic en el enlace se abrirá una nueva pestaña, luego debes esperar unos segundos a que aparezca el botón de "saltar publicidad", debes hacer clic en ese botón y deberías ser llevado al archivo en cuestión


jueves, 26 de mayo de 2016

Java Serie de Ejercicios: Introducción


Para ir a la lista de reporducción del curso haz click aquí

   Hoy empezamos una nueva serie de videos que forman parte del curso de Java, si viste el video que acompaña esta entrada ya sabes de que se trata, de todas formas explico que en estos videos se les va a invitar a realizar ciertas practicas con el fin de que afiancen y practiquen conocimientos adquiridos durante el curso.

Pendiente en las clases

  Antes de publicar un video de ejercicios, en la clase correspondiente yo colocaré un aviso, de modo que una vez publicada dicha clase le seguirá el ejercicio, en las diapositivas del video aparecerá algo como lo siguiente:

  Si al momento de ver el video ya esta disponible el ejercicio yo colocaré un enlace directamente en el video.

El código fuente

  Como dije en el video (si no lo has visto click aquí) se te va a invitar a pausar el video para que tu mismo intentes realizar la práctica, aquí en el blog encontraras algunas pistas en dado caso de que necesites alguna orientación. Por último en la misma entrada con las pistas, colocaré el código fuente para que lo descargues.

Sobre el juego que acabas de ver

  Si sigues el curso en su totalidad aprenderás a hacer eso y mucho mas, así que animo.

martes, 24 de mayo de 2016

Curso de Java Clase 1: Las Variables, tipos de datos y nuestro primer programa

Para ver el video que acompaña esta entrada haz click aquí
Para ir a la primera clase haz click aquí
Para ir a la lista de reproducción de Youtube haz click aquí

¿Cuando usar el "punto y coma" ?

  Después de haber visto el video, si fuiste lo suficientemente observador habrás notado que hay sitios de nuestro código que finalizan con punto y coma y hay otros que no

  Entonces ¿Cuando finalizar con punto y coma en java? La respuesta es muy simple, se finalizan todas las sentencias pero no la declaraciones de bloque. Las declaraciones de bloque son todas aquellas que seguidas de su nombre tienen llaves de apertura y cierre ( { y }) y una o varias lineas de código dentro de estas llaves. Si es una sentencia de linea deberá siempre y obligatoria mente terminar en punto y coma. En las imágenes de arriba vemos que "public class" y el metodo "main", son declaraciones de bloque, ya que tienen su nombre seguido de las llaves con código dentro de las mismas, el resto de código son sentencias de linea.

Declarar Varias Variables

  Si queremos declarar varias variables que tienen el mismo tipo de dato, como por ejemplo lo siguiente:
int numero1 = 5;
int numero2 = 10;
int numero3 = 15;

  Podemos resumir estas 3 lineas de código en una sola de la siguiente forma:
int numero1 = 5, numero2 = 10, numero3 = 15;
Como acabamos de ver, iniciamos como es normal indicando el tipo de dato, luego separamos por comas cada variable y al finalizar terminamos con punto y coma ya que es una sentencia de linea. También es valido crear las variables del mismo modo que acabamos de ver pero sin asignarle valores  de la siguiente forma:
int numero1, numero2, numero3;
  Luego para utilizar estas variables habrá que asignarle algún valor, como por ejemplo:
numero1 = 5;
Ya no es necesario declarar el tipo de dato porque la variable ya fue creada.

La clase System

La clase "System" contiene otras clases y metodos útiles, pero es de destacar que su principal función son las operaciones básicas de entrada y salida, ejemplo de esto es "System.out" que ya utilizamos para hacer una salida en consola

¿Que es "System.in" ?

 Habrás podido notar que "out" no es el único miembro de la clase "System", entre las muchas cosas que aparecen "in" es una de ellas, si sabes suficiente inglés, te estarás preguntando: Si out es salida en consola ¿in será entrada de datos? Felicidades si te haces esta pregunta, significa que haz explorado el código, la respuesta es afirmativa, pero el uso de "System.in" es un poco mas complejo y por lo tanto ese tema será desarrollado en una próxima clase.

Sobre el nombre de las Variables

 Hay ciertas reglas que son validas no solo para Java si no para casi cualquier lenguaje de programación. En cuanto al nombre de las variables tenemos lo siguiente:
  1. Las variables no pueden contener: Espacios en blanco, tildes y cualquier caracter especial excepto el guión bajo. Ejemplo numero&palabra
  2. No pueden comenzar con un número: El nombre de la variable puede empezar solamente con alguna letra o con el guión bajo. Ejemplo 1numero
  3. Si pueden contener números siempre cuando no esten al inicio: Puedes crear una variable cuyo nombre contenga números, pero estos nunca pueden ir al inicio. En el video creamos varias variables de este tipo. Ejemplo numero1
  4. No pueden llamarse igual que alguna palabra reservada de Java: Un ejemplo de esto es la palabra "System" que como ya vimos nos permite acceder a operaciones de entrada y salida, como es obvio no podemos ponerle este nombre a una variable y lo mismo es valido para cualquier palabra reservada.
  5. Las variables distinguen entre mayusculas y minusculas: Esto es super importante, ya que variables con los siguientes nombres: Numero, numero, NUMERO o numeRo, van a ser reconocidas por java como variables TOTALMENTE diferentes

Los tipos de dato

  El tipo de dato es un concepto utilizado no solo en Java si no en casi cualquier lenguaje de programación, al declarar un tipo de dato le estamos diciendo en el lenguaje que valor vamos a guardar en la variable que estamos a punto de declarar, por ejemplo:
String nombre = "Manuel";
 Aquí queremos guardar en la variable "nombre" el valor "Manuel", entonces decimos en el lenguaje, que queremos una variable de tipo String, lo que voy a poner a continuación no es valido :
String nombre = 15;
Estamos intentando asignar un valor del tipo "int" pero declarando un tipo "String", Netbeans en esta caso nos va a dar un error

Los tipos de dato mas comunes y sus especificaciones

   Los tipos de dato en Java se pueden clasificar en "primitivos" y "de tipo objeto", esto va a quedar mas claro cuando veamos "Orientación a Objetos", por ahora solo hablaremos del espacio que ocupan en memoria y del rango de valores que pueden almacenar

Primitivos :
  • byte: Puede almacenar valores de tipo entero, ocupa un byte en memoria y solo puede tener valores del rango que de -128 a 127
  • short: Puede almacenar valores de tipo entero, ocupa 2 bytes en memoria y su rango va de -32768 a 32767
  • int: Puede almacenar valores de tipo entero, ocupa 4 bytes y su rango va de  -231 hasta 231 
  • long: Puede almacenar valores de tipo entero, ocupa 8 bytes, y su rango va de -263 hasta 263 
  • float: Sirve para almacenar decimales simples, ocupa 4 bytes y su rango escapa de los alcances de esta clase, solo diremos que es muy grande
  • double: Sirve para almacenar decimales simples, ocupa 8 bytes y su rango al igual que float, por ahora solo diremos que es muy grande
  • boolean: Aquí solo podremos guardar valores lógicos, verdadero y falso, para ello usaremos las palabras "true" para verdadero y "false" para falso, representa un bit de información pero su tamaño no es algo definido de forma precisa
  • char: Sirve para guardar un carácter, específicamente uno solo y ocupa 2 bytes de información, no hablaré del rango de este tipo en esta clase ya que escapa de los alcances de la misma, solo ten en cuenta que puedes guardar un solo carácter de cualquier tipo
De tipo objeto :
  Este tipo de dato es un poco mas complejo así que no los voy a nombrar a todos, también por cuestiones de espacio ya que son muchos. El espacio en memoria que puede ocupar un objeto en Java o en cualquier lenguaje, puede variar por diferentes factores, así que en este apartado no tiene sentido hablar de memoria, por esta vez solo hablaremos de un tipo de dato:
  • String: Aquí podemos almacenar cadenas de texto completas, sin límite de duración y con cualquier carácter que queramos.

Fin de esta clase, si te gusta mi material puedes apoyarme suscribiendote a mi canal de Youtube
dandole me gusta al video y compartiendo el blog.

domingo, 22 de mayo de 2016

Curso de Java: Introducción

  Para ver el video que acompaña esta entrada haz click aquí
   Al querer aprender java lo primero que nos viene a la mente es ¿Qué es Java? si abrimos google y buscamos java nos aparecen principalmente dos cosas, la descarga de un software y un lenguaje de programación, entonces nos viene a la mente la pregunta ¿Qué es entonces Java? La repuesta es ambos, pero para poder explicar esto primero tenemos que ver algunos conceptos básicos sobre lenguajes de programación en general.
  Dos preguntas importantes: ¿Qué es un programa? ¿Qué es un lenguaje de programación?
  •          Un programa: Son básicamente una serie de instrucciones que la computadora puede ejecutar
  •          Un lenguaje de programación: Son la forma o el lenguaje en el que están escritas estas instrucciones

Sabiendo esto podemos dividir los lenguajes en varias categorías, esto porque la máquina no habla español o inglés, si no habla un lenguaje que no es natural para el ser humano, por lo que clasificamos los lenguajes según su nivel de comprensibilidad para el ser humano
  •          Lenguajes de bajo nivel: Aquí tenemos al lenguaje de máquina que no es comprensible o no es natural para el ser humano
  •          Lenguajes de alto nivel: Son los lenguajes de programación, como java, c, c++, c#


Sabiendo esto ya podemos introducir lo que es la compilación, que no es nada más que el proceso de convertir o traducir un lenguaje de alto nivel a uno de bajo nivel, o lo que es lo mismo, a partir de un lenguaje que el humano puede entender, crear un lenguaje que la máquina pueda entender.
  La compilación tiene una pequeña desventaja, el lenguaje de máquina no es igual para todas las plataformas, es por eso que programas que son para Linux normalmente no funcionan en Windows o programas que son para Mac solo funcionan en Mac
  Aquí es donde explicamos que es ese software también llamado Java. Cuando escribimos un programa java y luego lo compilamos, no estamos compilando al lenguaje de nuestra máquina, si no al lenguaje de la máquina virtual java, este programa que instalamos es una máquina virtual que va ejecutar nuestros programas java ya compilados. Esto es una ventaja ya que siempre y cuando tengamos la máquina virtual de java instalada podemos ejecutar cualquier programa java, sin importar si fue hecho en Linux, Mac o Windows. Podemos decir que el programa se ejecuta en la máquina virtual. Este lenguaje intermedio se llama bytecode
De aquí proviene el slogan de Java: “Escribe una vez, ejecútalo en todas partes”

Breve Historia de java

  Java fue originalmente desarrollado y lanzado al público por James Gosling y la Sun Micro System en 1995 y desde sus inicios fue diseñado para ejecutarse con tan pocas dependencias de implementación como fuera posible, es con datos del 2012 uno de los lenguajes de programación más populares, habiéndose registrado 10 millones de usuarios reportados.
  No se tiene certeza de donde deriva su nombre, al principio se le llamó Oak, por un árbol de roble que había en las afueras de las oficinas, luego se llamó Green y por último obtuvo su actual nombre. Hay varias hipótesis sobre el origen del nombre “Java”, algunos sostienen que podría tratarse de un acrónimo de los nombres de los diseñadores James Gosling, Artur Vann Hoff y Andy Bechtolsheim, otros que podría tratarse de Just Another Vague Acronym, que significa “tan solo otro acrónimo vago”, pero la hipótesis más plausible es que su nombre de deriva de un tipo de café disponible una cafetería cercana, lo que explica también por qué su logo representa una taza de café caliente
Java es un mundo
   Con java no solo podemos hacer programas que corran en nuestro escritorio, sino también páginas web dinámicas (JSP) aplicaciones del lado del servidor (Servlets) Rich Internet aplications (applets) y sistemas embebidos ya que es posible encontrar pequeños dispositivos capaces de ejecutar java de forma nativa, podemos encontrar java en teléfonos móviles, sintonizadores de TV e incluso tarjetas inteligentes (JavaCard)
¿Qué podemos hacer con Java?
ü  Una página web de compras electrónicas, como amazon.com o mercadolibre.com usando JSP y los Servlets
ü  Una página de juegos como MiniJuegos.com, usando los applets que son mini programas que se ejecutan en el navegador
ü  Un software de inventario y facturación para una tienda como aplicación de escritorio
ü  Aplicaciones para Android, las aplicaciones para Android se escriben en Java, pero usando unas librerías especificas
ü  Programar el funcionamiento de las tarjetas que se usan bien sea para abrir las puertas de las habitaciones de hotel o incluso tarjetas débito y crédito de los bancos (JavaCard)
El entorno de desarrollo
El entorno que vamos a usar en el curso va a ser Netbeans, pero también existen otros entornos de desarrollo, eres libre de elegir el que más te guste o se adapte a tus necesidades, a continuación, enlaces de descarga de algunos IDE Java populares:
Netbeans con el JDK incorporado
Netbeans sin el JDK, si deseas instalar Netbeans y el JDK aparte

domingo, 2 de marzo de 2014

Control de varios servos Arduino + Java +RXTX

En esta entrada les muestro un simple programa escrito en java y la librería para conexión serial RXTX, que envía parámetros a un Arduino con 3 servomotores conectados, el programa a través de una serie de "Sliders" controla con precisión los servos desde la computadora, tiene varios campos de texto con los cuales puedes establecer con exactitud el angulo que quieres colocar en el servo, incluso puedes mover los 3 servos al mismo tiempo al colocar los ángulos y luego presionar el botón enviar, para ver un demo del programa en accion : https://www.youtube.com/watch?v=R-7sTBZKypY&feature=youtu.be

   El programa esta compuesto de 3 clases, Gui.java, Multiservo.java y map.java

GUI.java :

import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;

public class GUI extends KeyAdapter implements ActionListener, ChangeListener {

    JFrame vt = new JFrame("Servos");
    JLabel txt1 = new JLabel("Selecciona el puerto de tu Arduino");
    String[] puertosOp = {"COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9",};
    JComboBox puertosSelec = new JComboBox(puertosOp);
    JPanel panel1 = new JPanel();

    JSlider motor1 = new JSlider(JSlider.VERTICAL, 0, 180, 0);
    JTextField manual1 = new JTextField(3);
    JPanel m1 = new JPanel();
    JSlider motor2 = new JSlider(JSlider.VERTICAL, 0, 180, 0);
    JTextField manual2 = new JTextField(3);
    JPanel m2 = new JPanel();
    JSlider motor3 = new JSlider(JSlider.VERTICAL, 0, 180, 0);
    JTextField manual3 = new JTextField(3);
    JPanel m3 = new JPanel();

    JPanel panel2 = new JPanel();

    JButton enviar = new JButton("Enviar");
    JPanel panel3 = new JPanel();

    MultiServo conexion;

    GUI() {
        vt.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        vt.setResizable(false);
        vt.setLayout(new BorderLayout());
        vt.add(panel1, BorderLayout.NORTH);
        vt.add(panel2, BorderLayout.CENTER);

        panel1.add(txt1);
        panel1.add(puertosSelec);
        puertosSelec.addActionListener(this);

        panel2.add(m1);
        panel2.add(new JLabel("    "));
        panel2.add(m2);
        panel2.add(new JLabel("    "));
        panel2.add(m3);

        m1.setLayout(new BorderLayout());
        m1.add(motor1, BorderLayout.CENTER);
        m1.add(manual1, BorderLayout.SOUTH);
        motor1.addChangeListener(this);
        manual1.addKeyListener(this);

        m2.setLayout(new BorderLayout());
        m2.add(motor2, BorderLayout.CENTER);
        m2.add(manual2, BorderLayout.SOUTH);
        motor2.addChangeListener(this);
        manual2.addKeyListener(this);

        m3.setLayout(new BorderLayout());
        m3.add(motor3, BorderLayout.CENTER);
        m3.add(manual3, BorderLayout.SOUTH);
        motor3.addChangeListener(this);
        manual3.addKeyListener(this);

        vt.add(panel3, BorderLayout.SOUTH);
        panel3.add(enviar);
        enviar.addActionListener(this);
        motor1.setEnabled(false);
        motor2.setEnabled(false);
        motor3.setEnabled(false);
        manual1.setEditable(false);
        manual2.setEditable(false);
        manual3.setEditable(false);
        vt.pack();
        vt.setVisible(true);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        Object f = e.getSource();
        if (f == puertosSelec) {
            motor1.setEnabled(true);
            motor2.setEnabled(true);
            motor3.setEnabled(true);
            String op = (String) puertosSelec.getSelectedItem();
            conexion = new MultiServo(op);

            manual1.setEditable(true);
            manual2.setEditable(true);
            manual3.setEditable(true);
         
            puertosSelec.setEnabled(false);
        }
        if (f == enviar) {
            String val;
            val = manual1.getText();
            motor1.setValue(Integer.parseInt(val));

            val = manual2.getText();
            motor2.setValue(Integer.parseInt(val));

            val = manual3.getText();
            motor3.setValue(Integer.parseInt(val));
        }
    }

    @Override
    public void stateChanged(ChangeEvent e) {
        Object f = e.getSource();
        String val;
        if (f == motor1) {
            val = String.valueOf(motor1.getValue());
            conexion.enviar(Map.rTres(motor1.getValue()));
            manual1.setText(val);
        }
        if (f == motor2) {
            val = String.valueOf(motor2.getValue());
            conexion.enviar(Map.rTres(motor2.getValue()) + 85);
            manual2.setText(val);
        }
        if (f == motor3) {
            val = String.valueOf(motor3.getValue());
            conexion.enviar(Map.rTres(motor3.getValue()) + 170);
            manual3.setText(val);
        }
    }

    @Override
    public void keyReleased(KeyEvent e) {
        Object f = e.getSource();
        int tecla = e.getKeyCode();
        String val;
        if (f == manual1 && tecla == KeyEvent.VK_ENTER) {
            val = manual1.getText();
            motor1.setValue(Integer.parseInt(val));
        }
        if (f == manual2 && tecla == KeyEvent.VK_ENTER) {
            val = manual2.getText();
            motor2.setValue(Integer.parseInt(val));
        }
        if (f == manual3 && tecla == KeyEvent.VK_ENTER) {
            val = manual3.getText();
            motor3.setValue(Integer.parseInt(val));
        }
    }
}

MultiServo.java :


import gnu.io.*;
import java.io.IOException;
import java.io.PrintStream;
import java.util.Enumeration;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;
public class MultiServo {
Enumeration listaPuertos = CommPortIdentifier.getPortIdentifiers();
CommPortIdentifier puertoId ;
PrintStream arduinoOut ;
SerialPort puerto;
MultiServo(String pto){
    while(listaPuertos.hasMoreElements()){
        puertoId = (CommPortIdentifier)listaPuertos.nextElement();
        if(puertoId.getName().equals(pto)){
            break;
        }
    }
    try {
        puerto = (SerialPort)puertoId.open("Serial", 1000);
        puerto.setSerialPortParams(28800, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
        arduinoOut = new PrintStream(puerto.getOutputStream());
    } catch (PortInUseException | IOException | UnsupportedCommOperationException ex) {
        Logger.getLogger(MultiServo.class.getName()).log(Level.SEVERE, null, ex);
    }
}

public void enviar(int num){
    arduinoOut.write(num);
}
    public static void main(String[] args) {
       GUI app = new GUI();
    }
 
}

Map.java:

public class Map {
    static int rTres(int n){
        //85 x n/180
        int resultado = (85*n)/180;
        return resultado;
    }
}


Esto es el programa en java, ahora falta el sketch para el Arduino, aqui esta:

#include <Servo.h>
Servo motor1;
Servo motor2;
Servo motor3;
int num;
int mov;

void setup(){
  Serial.begin(28800);
  motor1.attach(9);
  motor1.write(0);

  motor2.attach(10);
  motor2.write(0);

  motor3.attach(11);
  motor3.write(0);
}

void loop(){
  if(Serial.available()>0){
    num = Serial.read();
    if(num >=0 && num <85){
      mov = map(num, 0, 84, 0, 180);
      motor1.write(mov);
    }
    if(num >=85 && num <170){
      mov = map(num, 85, 169, 0, 180);
      motor2.write(mov);
    }
    if(num >=170 && num <= 255){
      mov = map(num, 170, 255, 0, 180);
      motor3.write(mov);
    }
  }
}