asi es en tutorial como se ve la mvj de java 17 de bellsoft liberica

asi se ajusta el tamaño final de la app en la clase main

1—añadir fotos en botones sin jfoenix and Jbuton que no
son compatibles con jpro-one:
ES LO MAS FACIL DEL MUNDO. NO HAY QUE HACER NADA POR CODIGO. TODO ES DESDE EL
FXML METIENDO, UN IMAGE VIEW, IGUAL QUE LA FOTO POR DEFECTO O EN INSTANTE T=0
ANTES DE PULSAR UN BOTON EN UN IMAGEVIEW:
Índice.

1. tarros gordos, empaquetado distribucion y ofuscacion de aplicaciones(6)

2. Instalar manualmente Maven en Windows 10 (7)
3. modelo-vista-controlador.(3)
4. Generacion rapida de modelos en el modelo-vista-controlador mvc(1)
5. Guis avanzados alertbox y eventos javafx(11)
6. menuBar javafx(6)
7. Guis final, Canvas, real time plot con charts y clase Math(19)
8. Tableview and menus interfaces. (3)
9. Programacion con clases Abstractas. Métodos numéricos. Corrección fallo copia-pega archivos
fxml o gui, y porque no podía crear nuevos programas (4)
10. Conexión javafx arduino atraves de librería jssc. Ejemplo de adicion de librerías externas(5)
11. Archivos modulares y no modulares con Maven. Gradle y gradle modular (11)
12. ecosistema de Java, Jakarta EE9 y programadores front end backend y fullstack developer(23)
13. Estudio del paquete de netbeans calculo Númerico. Calibración y funciones(31)
14. Calculo matricial(16)
15. Test ciencia de datos (3)
16. MATRICES DE ROTACIÓN 3D Y TEOREMAS DE EULER Y RODRIGUES (5).
17. Javaswing con jframe (8)
18. Tutorial swing escrito a lo processing sin jframe (13)
19. Lenguaje mysql y configuracion sql acceso exterior. (8)
20. Curso mysql y lenguaje sql workbench. (27)
tarros gordos, empaquetado distribucion y ofuscacion de
aplicaciones
el contexto en el que empieza este tutorial, es en el narrar que no vale la pena invertir esfuerzo en
un lenguaje de programación que no se puede ofuscar o blindar para proteger el código.

Java17 puede empaquetarse y ofuscarse de una forma no muy complicada.

Lo primero que tenemos que tener claro, es que toda aplicación para distribución debe hacerse
frasco gordo (fatjar) con el plugin de Maven de springboot en nuestro pom: en dicho proyecto
podemos quitar los module-info, que ya no hacen mas que molestar, y no se necesita otra clase
principal mas que App. Así que ponemos al final de nuestro pom:

Con esto, al darle clean and build me da error, pero en netbeansproyect library acceso directo a los
proyectos, se consigue un segundo jar, que porta todas las librerías.
Recordamos que obtener las class de java o código, es tan sencillo como coger un jar y
descomprimirlo con winrar. Ni decompiladores necesitas.

Este método nos va bien para ver las librerías que lleva el fatjar, y ya vemos que es un componente
que corre automáticamente en nuestro equipo, pero que si lo exportamos a otro, pej, mi maquina
virtualbox w10 con java8, es incapaz de correr allí.

Todo fatjar, para distribuirse, debe de ir con su maquina virtual de java empotrada, motivo por el
cual aparece jpackage.

Jpackage es un complemento introducido en java14 para distribuir y empaquetar aplicaciones java

para distintas plataformas.

Tras el fatjar que te da error de construcción, vamos al cmd, y introducimos:

jpackage --type msi --name MyAApp --vendor softwaregroup --input C:\MyApp --main-jar MyApp.jar
--icon C:\MyApp\app-icon.ico --win-shortcut --win-menu

** nota recordamos que hay que desinstalar la versión de pruebas previa para hacer otra instalación
tras formar el nuevo jpackage.

y me generará, en la dirección donde este trabajando el cmd, un instalador tipo msi de Microsoft,
que al ejecutarlo, me genera un archivo .exe (el ejecutable) con un runtime o maquina virtual, y una
carpeta app donde lleva el fatjar dentro. También esta el icono. Esta aplicación se instala en mis
archivos, y disponemos de un acceso directo.

Para ello, le decimos que genere aplicación MyAApp, que esta en C:\MyApp folder, que dentro
contiene nuestro jar que se llama MyApp.jar y donde también esta el icono en ese path absoluto, y
que me genere un acceso directo .exe al escritorio.
 ---- tutorial launch4j

Launch4j y jpackage son cosas distintas. Jpackage, te forme un exe o un msi, lo que hace
es un wrapper del archivo fatjar, añadiendo la maquina virtual de javafx 17 en que se
construyó, y así independientemente de la configuración de java del cliente, la app se
distribuye y funciona. También se ofrece está posibilidad de jpackage, porque el cliente
tiene acceso al fatjar, y por ende al código, al descomprimirlo con unzip. En ambos, exe o
msi, crea una carpeta en c:/archivos de programa/nombredemiApp/bin== aquí estará el fat
jar
En contrapartida, Launch4j te deja opción de hacer un wrapp de un fatjar, o solo
empaquetar sin distribuir paquete. Es decir, no instala nada. Hace un portable, y el código
es inaccesible. Es un exe que con 2 clicks se ejecuta mágicamente si hace nada.
Y como se hace esto?: metes en una carpeta1 en el escritorio la app.jar (fatjar), el icono
de la app y ahí es donde irá el archivo de salida. No hacer sobre el escritorio, igual que el
Jpackage, porque empieza a absorber todo lo que pilla en el escritorio y te genera app de
40 gb.

Una vez le hayas dado a la ruletita, se genera un archivo con extensión cfg (o xls) y lo
guardas en el escritorio mismo, y ahora la app, si te dejará pulsar el botón play. Ya está.
para esto, obviamente, tenenos que tener jmods configurado.

¿Cómo se configura?

Descargamos de la pagina de gluon javafx jmods 17, y lo metemos en c:\ archivos de

programas\java

Luego bajamos el set de herramientas wix 3.1 o superior.

Y esto lo introducimos como variable del sistema.

Hacemos esto para el usuario y el equipo.

Recordamos que a veces, las variables de entorno, java_home mas concretamente, se
enganchan…. Hemos de borrar las versiones de java que no nos interesan, las variables de
entorno, e incluso, setearlas: setx -m JAVA_HOME "C:\Program Files\Java\liberica jdk-17.0.1-full"

¿Cómo sabemos que esta bien configurado?

Como vemos, esto de empaquetar aplicaciones, para Windows, o Linux, es importante, ya que
generamos la maquina virtual de java que viaja con nuestro fatjar que ya contiene las libreria (de
unos 100 mb), pero aun así, en el desempaquetado, en la carpeta App, el usuario tiene acceso al
fat jar, y con una simple descompilacion con winrar, es capaz de obtener el código.

Solución, OFUSCAR EL CODIGO, PARA ello usaremos proguard en su versión 7.2 o superior,
que ya soporta java 17 y javafx. Este es un software de difícil uso, pero tenemos videos de
su funcionamiento en el servidor.
Si desea mantener los métodos en una determinada clase sin confundirse, debe configurar lo
siguiente
Instalar manualmente Maven en Windows 10

Comencemos bajas el instalador del jdk17.01 y el te instala la ruta y todo.

Luego el sdk javafx 17.01 de gluon openjavafx.io y lo pones en

c:/programfiles/java a la misma altura del jdk:

3 instalamos netbeans 12.6. y scene builder 2.0 de la página de gluon. ya

podemos empezar con Maven.

Descargar Maven

El enlace para descargar Maven es el

siguiente http://maven.apache.org/download.cgi#Installation en el apartado files aparecen los
enlaces de de descarga elige los binarios. Luego los descomprimes esta carpet y la pones en la raíz
c:/maven3.8.1

Ahora editamos las variables del sistema de Maven.

Se abrirá una ventana llamada propiedades del sistema ,presiona el boton llamado variables de
entorno .
Se abrirá otra ventana en la cual en el aparatado que se llama variables del sistema presiona el botón
Se abrirá un formulario el cual se deberá llenar de la siguiente manera en el nombre de la variable
digita MAVEN_HOME y en valor de la variable digita la ruta donde esta la carpeta de maven que se
descomprimio. Presiona el botón aceptar .

Ahora hay que editar la variable de entorno llamado path y añade

M2= %M2_HOME%\bin

M2_HOME= C:\apache-maven-3.2.2

Path ...; C:\apache-maven-3.8.4\bin; ...

Ahora probemos si la intalacion fue exitosa para ello es necesario abril la consola de comados
,presiona CTR +R y en la ventana que parece digita cmd y presiona aceptar .

Java -version.

-
los pasos anteriores.
HELLO WORLD EN PROYECTO MAVEN NO MODULAR.

Maven
Siga estos pasos para crear un proyecto no modular JavaFX y use las herramientas
de Maven para construirlo y ejecutarlo. Alternativamente, puede descargar un
proyecto similar desde aquí .

1. Crea un proyecto Maven

Puede seleccionar cualquier Java with Maven -> Simple JavaFX Maven
Archetypeproyecto o Java with Maven -> FXML JavaFX Maven Archetypesi su
proyecto utiliza FXML.

Proporcione el nombre del proyecto, me gusta hellofxy una

ubicación. Proporcione el groupId, me gusta org.openjfxy el nombre del paquete,
me gusta org.openjfx.hellofx. Opcionalmente, puede establecer el javafx-
versionen 17 y el javafx-maven-plugin-versionen 0.0.8 :
haga clic en finalizar y el proyecto se creará y abrirá.

2. Verifique el pom
Puede encontrar el archivo pom generado aquí .

Verifique que incluya las dependencias javafx.controlsy javafx.fxml, actualice

su versión a 17 y verifique que incluya javafx-maven-plugin(actualice la versión
a 0.0.8 ). Tenga en cuenta que Maven administra las dependencias requeridas:
agregará javafx.basey javafx.graphicsque son requeridas
por javafx.controlsy javafx.fxml, pero lo más importante, agregará el
clasificador requerido según su plataforma, descargando los archivos jar de
plataforma específicos. Como para cualquier otra dependencia de maven,
estos .m2archivos jar se pueden encontrar en el repositorio local .
Para un proyecto no modular, puede eliminar el module-info.javaarchivo.

3. Ejecuta el proyecto
Haga clic Run -> Run Projectpara ejecutar el proyecto. Tenga en cuenta que el
proyecto Maven ya incluye un nbactions.xmlarchivo que asigna la runacción
al javafx:runobjetivo.

Nota: En caso de JAVA_HOMEque no esté configurado en 11 o superior, la ejecución

del proyecto podría fallar. Para evitarlo, se puede añadir el correcto javaorden al
javafx-maven-plugin: . <configuration><executable>/path/to/jdk-
16/bin/java</executable></configuration>
También puede abrir una terminal y escribir mvn clean javafx:run para ejecutar
el proyecto.

MODULAR CON MAVEN:

Maven
Siga estos pasos para crear un proyecto modular JavaFX y use las herramientas de
Maven para construirlo y ejecutarlo. Alternativamente, puede descargar un proyecto
similar desde aquí .
-→ modelo-vista-controlador.
1) creamos la gui, y click derecho en el .fxml crear controlador.java.
2) ejemplo de gui para el ejercicio de la calculadora. Poner textbox3 inferior como no editable.

Hay que darle un id o nombre a cada uno de los textbox 1,2 y 3 aunque no lleven evento asociado.
Ahora, en el evento generado del controlador,capturamos y metemos en variables enteras lo que venga
del textbox, y ponemos bajo sentencia try-catch excepción para blindar el código.
3) creación nueva javaclass llamada suma: click derecho árbol lateral, javaclass.
Primero, tras definir
public class suma {
private int a;
private int b;

}
Lo primero es crear un constructor. Click derecho/insert code/constructor/ponemos en tick positivo
pestañas de las 2 variables.

2) lo segundo, crear getters and setters de las 2 variables. Click derecho, señalar las 2 variables y ya esta.
3) crear el método que será retornable al controlador que llame al modelo.
Resumen de todo dentro de la clase:

Como vemos el método public int suma(){ return a+b} se escribe así y es realmente sencillo.
4) llamar desde el evento de controlador al modelo, meter alert y reescribir en textlabel3.

Cambiar color un panel. En el ejemplo de la calculadora, la cosa también está implementada.

Class controlador 2 implements initializable… requisito sinequanon que el controlador implemente el
método inicializable o método inferior de abajo.
// aquí uso la herramienta del processing captura del color. Y ya está
public void initialize(URL url, ResourceBundle rb) {
BackgroundFill fill=new BackgroundFill(Color.web("#E8CA5B"),CornerRadii.EMPTY,Insets.EMPTY);
Background naranja=new Background(fill);
pane.setBackground(naranja);
}
◼ Esto sería extrapolable a las clases de métodos numéricos de java.
Generacion rapida de modelos en el modelo-vista-controlador mvc.
Nueva java class, y defines los elementos involucrados y click derecho:

Pero, el cursador, debe estar dentro de los {} del método de la clase en este caso pedidos, si no, no
aparece nada. Estando dentro enseguida la imagen izq. Generamos constructor y getters and setters.
Y tachan, modelo construido en menos de un minuto. En estos “mateos” típicos del controlador, también
puede expresarse la condición que puede haber libros del mismo autor del mismo año, o mismo genero.
Esto se hará con los equals o no equals.
1. Guis avanzados y eventos javafx.

g1- CHECK BOX:

USANDO EL MODELO-VISTA-CONTRALADOR, METEMOS LA VISTA (PANTALLA IZQ SCENE BUILDER) Y CLICK DERECHO
EN NETBEANS, CREAR CONTROLES EN ESE ARCHIVO DE SCENE BUILDER Y CREA EL CODIGO DEL CONTROLADOR,
(DERECHA) BAJO LO CUAL AÑADIMOS LO DE ABAJO. LUEGO EL ES EL CODIGO JAVA DE HERENCIA, POR EJEMPLO LOS
ARCHIVOS DE CALCULO NUMÉRICO.

Radiobutton: es muy similar. La diferencia con checkbotton es que no se pueden señalar 2 a la vez:

3. combobox o choicebox como aquí le llaman, no existe diferencia? Ver documentales ken.
https://www.youtube.com/channel/UCTOlGyde8NA1rfUAZXaBjrg/videos
4- slider.
5- spiner:esto es un spiner.

Código spinner:

@FXML /* al importarse o crear el controlador click derecho fxml si edito sale esto 2 clicks
veo la vista*/

private Spinner<String> spinner1;

private final ObservableList<String> lista2=

FXCollections.observableArrayList("ingenieria","fisica","quimica","biologia");

SpinnerValueFactory<String> curso= new SpinnerValueFactory.ListSpinnerValueFactory(lista2);

public void initialize(URL url, ResourceBundle rb) {

/*podra el spinner tambien clonarse igual que el combobox*/

lista2.addAll("ingenieria","fisica","quimica","biologia");

spinner1.setValueFactory(curso);

}
AlertBox dialog and confirm dialog:
7- text input dialog.

Al pulsar ok, me sale lo de insertar la clave de activación del jtext pej:

En cuanto a layouts:
Tabpanel es esto:
Compilación y programación de tareas.
Lo primero: ejecución del objeto creado con maven: nos movemos en el cmd hasta la carpeta de nuestro proyecto, y
allí:

$ cd Onedrive cd desktop cd mavenproyecto2

/etc/init.d/apache2 stop

$ mvn clean javafx:run

y asi corren los proyecto javafx como el proyecto2 en Windows 10 o Linux.

y enfatizo esto ultimo de Linux, y lo enfatizo pq heroku o servidor web con constructor de herramientas es un stack
Ubuntu 20.04 LTS

javafx en raspberry pi (projecto ant o maven):

java -jar aplicacion.jar --module-path /usr/lib/jvm/openjfx11/lib/ --add-modules javafx.controls,javafx.fxml

y esto da igual que sea ant o maven.

Explotación servidor jpro.

$ users/juanf : cd mavensinexplotarmio.

$ (estoy en mi carpeta): mvn jpro:run

// esta es la orden maven que ejecuta la explotación y arranque local del servidor. Para Una vez nuestro proyecto se
web en el navegador, ejecutamos:

$ (estoy en mi carpeta): mvn jpro:release

// y se genera un archivo.zip en target/al lado del archivo .jar del proyecto, que es el que arrancaremos siempre con
un script de bash. Ese zip lo descomprimo en desktop y me muevo a la carpeta: C:// carpetadescomprimida(o
mavenexplotado)/bash ./bin/restart.sh y ya esta el servidor funcionando. 1) Si ahora pongo localmente en
navegador: 192.168.1.250:8080 veo mi aplicación. 2) si abro el router nat: 192.168.1.250:8080 como puerto interno
y 8080 como externo con seguridad intermedia, al teclear desde el 4g o navegador exterior:
electricidadvalencia22.duckdns.org:8080 ya veo mi aplicación y además superrapido. Y Trinity nada.

Ahora habría que crear un script en Windows de bash para que arranque automáticamente el servidor siempre que
arranque el servidor x86.
Programador de tareas/crear tarea básica/al iniciar sesión
 ➔ Limitaciones de Guis de javafx sobre navegador en jpro.
Vamos a ver que cuando ejecutamos una aplicación jpro, sobre cualquier navegador. .sucede lo siguiente:

1) botón close no va. Solo va cierre de ventana.

2) label no llama al teclado de androide.
3) no existen multiples forms superpuestos, es decir, alert dialog, confirm alert dialog, textinput dialog,
etc…. No van. Solo existe una capa física de la aplicación.
El resto parece funcionar bien.

Objetivo, superar este problema para conseguir la autentica aplicación javafx sobre jpro o
navagador al stilo javascript front end+html+css. ¿Como lo hacemos? Haciendo un
wrapper html.
Primero vamos a hacer funcionar esta aplicación .jar mvc nativa con maven que funciona

dándole simplemente al run o tras el clean and built envuelta en jpro.

menuBar javafx.

Previsualizo a ver como queda.

Voy a la barra inferior del menubar, e inserto pestañas:

Con copia y pega del menúItem es suficiente, pero arriba, en la pestaña de menús, que no de de
controls donde esta el menú, podemos arrastrar menú ítems: luego, les damos nombre en id

También les damos evento:

Luego, make controller, y llevamos todos los eventos al controlador.

Filechooser: text área, listview and image view: en ese orden

Make controller. Metemos un text área para un solo archivo de selección, y un text área para
varios o un listview. Puedo meter también un imageview si quiero visualizar los png.
Si quiero un selector de multiples archivos usando el textarea.
Y si quiero usar el listview:

+}}} al final del texto.

Para el imageview o navegador visualizador de imágenes.

A JavaFX FileChooser class (javafx.stage.FileChooser) is a dialog that enables the user to

select one or more files via a file explorer from the user's local computer. The JavaFX FileChooser
is implemented in the class javafx.stage.FileChooser. In this
JavaFX FileChooser tutorial I will show you how to use the JavaFX FileChooser dialog.

Creating a DirectoryChooser
DirectoryChooser directoryChooser = new DirectoryChooser();
directoryChooser.setInitialDirectory(new File("src"));
File selectedDirectory = directoryChooser.showDialog(null);
------→ Guis final, Canvas, real time plot con charts y clase Math.
0) error copia y pega .fxml mas controller que no te deja construir app. Si no edito, y otra cosa: un evento,
jamas puede ser igual al texto del label o al id que demos a ese componente, sino fallo.

Deploy en multiplatform arm64,arm32hf o v7:

--module-path “c:\Program Files\java\javafx-sdk-15.0.1\lib”--add-modules javafx.controls,javafx.fxml

1) tooltips
Montamos una gui Pane típica como las que venimos montando, dándole id al textbox sobre el cual ira el tooltip:

Id: textbox1

En miscelanius, arrastramos el tooltip al textbox1:

Esto le genera una serie de ventanas con la propiedad tooltip:

E igual modo, tootip propertie está dentro de

Ahora en el tooltip properties, debemos indicar el texto que quiero que me indique cuando pase el mouse por
arriba.

Al tooltip también hay que darle id.

Ahora, click derecho en .fxml, y el controller simplemente debe ser:

Sorpresa, solo hay un evento, el del botón que se prentende lanzar y ya está, no hay nada nada mas que indicador

@FXML

Private Tooltip ttPassword;

2) hiperlinks: nos interesa unos hiperlinks que nos muestren otros forms antes que páginas web
externas.
Montamos la gui, como siempre,

Le damos id y evento a ese hiperlink en la pesta de abajo.

Vamos a trabajar, ya que estamos el cambio de un .jpg a otro con un simple hiperlink, así como de un form
a otro.

En imageView, solo hay 2 cosas interesantes que hacer:

1) igual que cuando pongo un label, puedo poner un set text que en lugar que ponga label, ponga juan,
pues aquí lo mismo, puedo poner ya una imagen como “texto de seteo” y luego darle propiedades view
true o false según pulse hiperlink.
2) darle id al ImageView, pero no evento¡¡¡¡¡¡¡

Ahora Abrimos una nueva carpeta en el ide de netbeans, y arrastramos los iconos .jpeg recortados con
recortes a la carpeta nueva, y ya están importados.

Click derecho, make controller, aparecería como: 3 hiperlinks y un viewer en el ejemplo.

Si yo quisiera lanzar forms através de hiperlinks, haría:
App.setRoot("secondary"); y ya esta ¡¡¡¡¡ igual que para un botón.

3) Canvas class:
MAS FACIL QUE EN PROCESSING TODAVIA. Vamos a primary.fxml y añadimos miscellaneus/canvas y shapes.
Deben quedar asi las dependencias. Yo por ejemplo, he dibujado.

Esto es muy facil. Se meten lineas verticales, horizontales, puedo controlar el stroke, x and y position, el text,
position etc… colour, etc…. Todo es configurable. Es muy facil. Entre las pestañas properties y layout, puedo
gestionarlo todo.

Esto no se puede anclar y manipular como bloques. Has de editar mas o menos cada línea horizontal y vertical una a
una, no se puede hacer copia pegas de 2 en 2. Además, tampoco existe posibilidad de anclar todo como un objeto,
pero si puedo desplazar conjuntos enteros seleccionándolo todo.

4) charts: decir, en cuanto a los charts, que el único que nos gusta un poco, es:

Pero ciertamente, todo lo que no sea editable por el anterior metodo, nada. Así que no voy a aprender charts.

Voy a aprender a hacer tickevents, y graficar una linea roja en la canva anterior.

5) animations.

Ver el video: http://192.168.1.250/wp-content/uploads/2021/08/JavaFX-animations-.mp4

Ahí podemos estudiar entre otras, animations que va tras la main class javafx App extends aplication{
} es decir, va en el primaryController
package application;

import java.net.URL;

import java.util.ResourceBundle;

import javafx.animation.FadeTransition;

import javafx.animation.Interpolator;

import javafx.animation.RotateTransition;

import javafx.animation.ScaleTransition;

import javafx.animation.TranslateTransition;

import javafx.fxml.FXML;

import javafx.fxml.Initializable;
import javafx.scene.image.ImageView;

import javafx.scene.transform.Rotate;

import javafx.util.Duration;

public class Controller implements Initializable{

@FXML

private ImageView myImage;

@Override

public void initialize(URL url, ResourceBundle rb) { /* muy importante observar que la clase animation, va igual que
la carga de color sobre el método initialize, así que ha olvidar aquello de extends app, etc… aunque admitia 2
apellidos*/

// translate

TranslateTransition translate = new TranslateTransition();

translate.setNode(myImage);

translate.setDuration(Duration.millis(1000)); // tiempo duración animación.

translate.setCycleCount(TranslateTransition.INDEFINITE); // numero de simulaciones.

/* translate.setCycleCount(2); */

translate.setByX(500);

translate.setByY(-250);

translate.setAutoReverse(true); // si queremos que vuelva a hacer el giro a su punto inicial reversibilidad.

 translate.play();

/*

// rotate

RotateTransition rotate = new RotateTransition();

rotate.setNode(myImage);

rotate.setDuration(Duration.millis(500));

rotate.setCycleCount(TranslateTransition.INDEFINITE);

rotate.setInterpolator(Interpolator.LINEAR);

rotate.setByAngle(360); // angulo de rotación. Muy interesante para el orientado del cohetecito en cuando
paredes.

rotate.setAxis(Rotate.Z_AXIS);

rotate.play();

// fade // esta para que nuestra imagen pestañee osea, aparezca y desaparezca o sea visible o no en la pantalla.

FadeTransition fade = new FadeTransition();

fade.setNode(myImage);

fade.setDuration(Duration.millis(1000));

fade.setCycleCount(TranslateTransition.INDEFINITE);

fade.setInterpolator(Interpolator.LINEAR);

fade.setFromValue(0);

fade.setToValue(1);

fade.play();

// scale // ensanchamiento o escalizado del Sonic.

ScaleTransition scale = new ScaleTransition();

scale.setNode(myImage);

scale.setDuration(Duration.millis(1000));

scale.setCycleCount(TranslateTransition.INDEFINITE);

scale.setInterpolator(Interpolator.LINEAR);

scale.setByX(2.0);

scale.setByY(2.0);

scale.setAutoReverse(true);

scale.play();

*/
}

} /// las que más vamos a usar son traslate y rotate-

5) nosotros ya tenemos un programa implementado que plotea una funcion matemática animada corriendo por una
curva en el tiempo x. no obstante vemos que la función es linealmente dependiente con el tiempo.

Es decir, para representar el vector velocidad, mas no el vector posición, que puede ser x(t)= at^2

Se llama canvasplot no borrar nunca.

Aquí lo importante seria ajustar la función matemática a nuestra canvas y aprender a dominar las funciones
matemáticas o el matemática ploting.

Vamos a centrarnos en la funcion del coseno y ver el periodo de oscilación en funcion del marco.
private enum NamedFunction {

SIN(x -> Math.sin(2 * Math.PI * x /200)*100+250/** 200 + 200 200 es es descenso en eje y para centrarse*/,
"Sine"),

COS(x -> -Math.cos(2 * Math.PI * x / 100) * 150 + 180, "Cosine"),

LOG(x -> -Math.log(x) * 20 + 320, "Log"); }

Es decir, en el coseno. Al darle al run vemos:

** hay que ajustar la línea de plot el origen y fin.

COS(x -> -Math.cos(2 * Math.PI * x / 100) * 150 + 180, "Cosine"),-- EL +180 ES EL Y0 DE ORIGEN, SI LO QUITO
TODO SE DESPLAZA 180 PIXELES PARA ARRIBA.

VAMOS A VER EL ANCHO DEL CANVAS:

AHORA VEMOS LA REALIDAD DE LOS LAYOUTS. VA COMO C# O TODO JAVA EN GENERAL:

LA ESQUINA SUPERIOR IZQ ES (0,0).

El ancho en pixeles del cuadrante gausiano es: 695-324=371 (layoutx2- layoutx1) poco mas de 360
Resulta se que: COS(x -> Math.cos(2 * Math.PI * x / 100) * 150 + 180, "Cosine")
*150 == amplitud de oscilación pq math.cos =1 pixel respecto al punto yo=180 que es el mas de después respecto
al marco superior rojo +30 --- es decir, que los 150 + esos 30 dan esa sensación de simetría.

2*150/100 =300/100 =3 los 3 pis radianes que tenemos. Es decir las oscilaciones?

Falso: el factor *150 es la amplitud de oscilación respecto al punto y0, que es los 180 de suma.

La demo es ver que la raya ultima de arriba, la de rojo está a 30 de yo. Entonces la frecuencia se puede ver así: hay
un 2*pi=1 oscilacion onda por encima ejex, por debajo eje x por cada 100 pixeles. Yo tengo 370 pixeles, tengo 3.7
osc.

El xini y xfinal del plotaje vienen en la funcion:

if (newFunction != null) {

Plot plot = new Plot(newFunction.getFunction(), 600 =c+a , 327d+b, 235, 600);

// LOS 2 primeros numeros son tamaño del picture box los 2 ultimos son xini y xfinal del plotaje
funcion

Yf aquí expresado es el contrario de la roja de arriba subrayada. Xf es el palote ultimo amarillo fluorescente mas a
la derecha.

O son el picturebox? Realmente parecen lo limites del picture box que esa superajustado a nuestras rayas.
Uso de las expresiones matemáticas o Math.funcion:
Math.exp(10.0)= e^10
Math.atan(angulo)
La función log calcula el logaritmo natural (de base e) de un número
Math.log(Math.E))=1;
Math.pow(10.0,3.5)=10^3.5
Math.abs(x);
Math.sqrt(x);
Los redondeos:
floor Redondeo al entero menor double x = Math.floor(2.5); x = 2.0;

ceil Redondeo al entero mayor double x = Math.ceil(2.5); x = 3.0;

También se puede redondear a decimales declarando las variables como double;

double x = 72.3543;
double y = 0.3498;
System.out.println(x + " es aprox. " + (double)Math.round(x*100)/100);
System.out.println(y + " es aprox. " + (double)Math.round(y*100)/100);

Se obtiene 72.35 y 0.35 como cabría esperar. Fijarse que round devuelve un número entero int que es
necesario promocionar a double para efectuar la división entre 100.

La clase Math define una función denominada random que devuelve un número pseudoaleatorio
comprendido en el intervalo [0.0, 1.0)

System.out.println("Número aleatorio: " + Math.random());

System.out.println("Otro número aleatorio: " + Math.random());

En java no existe ninguna función que nos calcule directamente logaritmos en bases distintas a
10. Para ello habrá que crear nuestra propia función.

Código java (Logaritmos1.java):

//Cálculo de logaritmos en distintas bases.

package logaritmos1;

public class Logaritmos1 {

public static void main(String[] args) {

int num = 5;
int base =5;

System.out.println("Logaritmo de 5 en base " + base + " = " + log(num, base));

private static Double log(double num, int base) {

return (Math.log10(num) / Math.log10(base));
}
}

Resultado: Logaritmo de 5 en base 5 = 1.0

Recordamos: log(10^x)=x*log(10)=x pq log(10)=1 y que log(a*b)=log(a)+log(b)
E idem para divisones y potencias negativas.

Recordamos que el empleo de Math en mayúsculas, va de fuera para dentro, como en

mathematica. Observa el siguiente ejemplo.

perimetro=2*n*Math.sqrt(2.0-Math.sqrt(4.0-(perimetro/n)*(perimetro/n)));

◼ Ejercicio; ordenar de menor a mayor y de mayor a menor, un conjunto de número:

Dado que Math.max(x,y)me da el mayor o máximo de entre 2 numeros, que son x e y en este caso y
que Math.min(x,y)me da el mínimo entre 2 números:

public void obtenerDatos(){

Scanner leer = new Scanner(System.in);

System.out.print("Introduzca el total de numeros que desea ingresar: ");

int totNum = leer.nextInt();

int[] num = new int[totNum];

System.out.println("Introduzca " + totNum + " numero(s): ");

for(int i = 0; i < num.length; i++){

System.out.print("Numero " + (i+1) + ": ");

num[i] = leer.nextInt();
}

System.out.println("\nLos numeros ingresados SIN ORDENAR son: ");

for(int i = 0; i < num.length; i++){
System.out.println(num[i]);
}

//////////////////////////////
Arrays.sort(num);
////////////////////////////
System.out.println("\nLos numeros ingresados ORDENADOS ASCENDENTEMENTE son: ");

for(int i = 0; i < num.length; i++){

System.out.println(num[i]);

System.out.println("\nLos numeros ingresados ORDENADOS DESCENDENTEMENTE son: ");

for(int i =num.length-1; i>=0; i--){

System.out.println(num[i]);
}

}
5) Finalmente queda analizar sobre la clase gráfica tick_animation. Es decir, los charts.
Bien, tenemos un proyecto, que es un tick evento cada 500ms de una funcion integrado en un char , en
este caso, coseno(x) que tiene la dimensión o acople en ventana que deseamos, y a la cual hemos
aprendido le podemos cargar los dibujos copia y pega, de la clase canvas.
Esta clase, esta además sobre el form1, con lo cual podemos seguir haciendo otros forms, y además el
evento empieza, no esta sobre inicialize, sino sobre el botón begin running
En lo que andamos ahora es en canviar los colores de la línea, y cambiar lo tiempos de autorefresco de los
ticks y para y limpiar la simulación.
Para los plots de física, poder representar a tiempo real (ticks de un segundo) una funcion matemática (ej,
t^2 es importante)

Código:
import java.util.concurrent.atomic.AtomicInteger;
import javafx.scene.control.ComboBox;

public class PrimaryController implements Initializable {

AtomicInteger tick = new AtomicInteger(0);

private boolean exit;

//private ScheduledExecutorService scheduledExecutorService;

// vemos que aquí finalmente no hemos requerido del Scheduled executor, que nos servia para sincronizar
hora a tiempo real.
final int WINDOW_SIZE=10;
double valorcoseno;
double x;

@FXML
private Button primaryButton;

@FXML
private Button btnbegin;
@FXML
private Button btnstop;
@FXML
private Button btnclear;
@FXML

private Pane pane1;

@FXML
public LineChart<String, Number> chart1;
@FXML
 private NumberAxis ejey_cantidad;
@FXML

private CategoryAxis ejex_tiempo;

public double corrercoseno(){ // la funcion matemática a plotear

x=x+1;
valorcoseno=Math.pow(x, 2) ;
return valorcoseno;

@Override
public void initialize(URL url, ResourceBundle rb) {
}
@FXML

private void switchToSecondary(ActionEvent event) throws IOException {

App.setRoot("secundary");
}

@FXML
private void begin(ActionEvent event) { // el botón btn begin, inicializa variable y lanza método run
// que es un temporizador.
valorcoseno=0;

x=0;
exit = false;
run();

}
// execution of thread starts from run() method
public void run()

{
// PrimaryController.chart1.setTitle("Realtime JavaFX Charts");
chart1.setAnimated(false); // disable animations
 //defining a series to display data
XYChart.Series<String, Number> series = new XYChart.Series<>();
series.setName("Data Series");

// add series to chart

chart1.getData().add(series);
Thread updateThread = new Thread(() -> { // lanzado del temporizador/hilo llamado updateThread
while (!exit) {

try {
String txt=(tick.incrementAndGet()+"");
Thread.sleep(500);
// Platform.runLater(() -> series.getData().add(new
XYChart.Data<>(tick.incrementAndGet(),(int)corrercoseno() )));
Platform.runLater(() -> series.getData().add(new XYChart.Data<>(txt,corrercoseno() )));
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
// System.out.println(name + " Stopped.");
updateThread.setDaemon(true);
updateThread.start();
}
// for stopping the thread

@FXML
private void clear(ActionEvent event) {
chart1.getData().clear();

}
@FXML
private void stopi(ActionEvent event) {
exit = true;

}
}

Representación de t*t en tiempo real.

tableview and menus interfaces
Bueno, el método principal del tableView, tras el make controller, es el showbooks.
Vamos a ver lo que ha montado ken. Metemos 2 numeros en los txtbox del tabl 1 y el botón, los
suma, y pasa el resultado al tab 2, y en el tab 2, hay otro botón, que me los retorna al uno.

Hemos de darle id, a cada uno de los tabpanes (subpaneles, y al tabpanel principal.

Al mas importante que hay que darle id no es los subtabs, sino al tabpane principal. Le
llamaremos tp (tabpanel ) y es necesario para el getselectiomodel y seleccionar el tab adecuado
Como identidad, le damos tp. Acordarse del click derecho, make controller.
Programacion con clases Abstractas. Métodos numéricos. Corrección fallo copia-pega
archivos fxml o gui, y porque no podía crear nuevos programas de jpro.
1) ojito al copia y pega de las Guis de otros proyectos de netbeans, es decir, a los archivos de escen Buider .fxml, si
hago un copia pega fxml se hereda en fxml edition el paquete antiguo y esta en rojo error y no carga la app aunque
sea nueva. Netbeans es incapaz, para tu paquete, de señalarte esto en rojo. Por esto no podíamos implementar
ídem projecto jpro.

2) procedemos a la metodología de implementación por clases para los ejemplos de calculo numérico. Empezamos
por regula-falsi. La estructura de programas debe ser:

App principal el launcher, es el de siempre, no se toca, el objetivo, es lanzar el PrimaryController (tras fxml click
derecho make controller)

Muy importante: la clase PrimaryController, jamas debe ser una clase abstracta. Las clases abstractas, son las clases
Hijas pero PrimaryController, no debe ser abstracta, sino, no puede construir.

Entonces, como lo hacemos?? Veamos el ejemplo de PrimaryController.java resumido:

// click derecho make controller archivo escene builder.

import javafx.scene.layout.Pane; // zona de los imports.

import javafx.scene.paint.Color;
public class PrimaryController extends Ecuacion implements Initializable {

// el atributo de color del fondo implements Initializable, también puede ponerse.

// no debe extenderse la clase App o la de la clase principal. Debe Extenderse, la clase abstracta hija. Fíjate que
arriba figura en gris…..

@FXML

private TextField lbla; // zona definición componentes fxml

@FXML

private void resultado(ActionEvent event) { // el evento llama a funcion de otra clase. Throws IOexception.

Funcion f=new Funcion();

try{

this.lbla.setText("solución "+f.puntoMedio(0.7, 0.8));

}catch(RaizExcepcion ex){

// System.out.println(ex.getMessage());

Alert alert=new Alert(Alert.AlertType.WARNING);

alert.setTitle("warning");

alert.setHeaderText("no hsy raices");

alert.showAndWait();

}
}

// este método vacio de acontinuación, diría que es la parte mas importante del código. Es un método, que hace que
el chivato o luz roja de decirle a la clase PrimaryController, No se haga abstracta. Si quitara esto, no me deja
compilar si la clases principal, no la hago abstracta. Y Entonces, nada funcionaria.

@Override

public double f(double x) {

throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods,
choose Tools | Templates.

public void initialize(URL url, ResourceBundle rb) { // atributo fondo de color.

BackgroundFill fill=new BackgroundFill(Color.web("#E8CA5B"),CornerRadii.EMPTY,Insets.EMPTY);

Background naranja=new Background(fill);

Pane.setBackground(naranja); }}

// clase abstracta hija Ecuacion.java. esta clase suele ser la que lleva el método principal.

package com.mycompany.newtonclases;
// no imports aquí.

public abstract class Ecuacion {

protected static final double CERO=1e-10;

protected static final double ERROR=0.001;

protected final int MAXITER=200;

public double puntoMedio(double a, double b) throws RaizExcepcion{

double m, ym;

int iter=0;

do{

m=(a+b)/2;

ym=f(m);

if(Math.abs(ym)<CERO) break;

if(Math.abs((a-b)/m)<ERROR) break;

if((f(a)*ym)<0) b=m;

else a=m;

iter++;

}while(iter<MAXITER);

if(iter==MAXITER){

throw new RaizExcepcion("No se ha encontrado la raíz");

return m;

abstract public double f(double x);

class RaizExcepcion extends Exception {

public RaizExcepcion(String s) {

super(s);

}
Public class funcion. Estudiemosla

package com.mycompany.newtonclases;

public class Funcion extends PrimaryController{

public double f(double x){

return(x-Math.cos(x));

// otra cosa muy importante: la clase primaryController, debe ser lo mas publica (o protected) que se pueda,
evitando usar argumentos private, sino las dependencias no llegaran a las subclases, y no se podrá implementar.

Fíjate, el método, en lugar de ser private, así como los argumentos, son todos public, no private.

@FXML

public TextField lbla;

@FXML

public Button btnresultado;

@FXML

public TextField lblb;

@FXML

public TextField lblc;

public double a;

public double b;

public int n;

public double h=(b-a)/(2*n);

/**

* Initializes the controller class.

*/

// abstract public double f(double x, double y);

// abstract public double c(double x);

// abstract public double d(double x);

@FXML

protected void resultado(ActionEvent event) {

//
Conexión javafx arduino atraves de librería jssc.
Ejemplo de adicion de librerías externas.
Bien, vamos a unir un programa de javafx17 con uno de Arduino.
Necesitaremos añadir la librería jssc la última que haya(java simple serial conector). Nos bajamos el .jar de
Maven central o github, y como siempre que añadimos librería:

Y cuando se haya agregado, instalar manualmente:

Y aparecerá un Brower en el que buscaremos la librería externa. Una vez hecho, esto, añadimos el
siguiente código en el primary controller:
Perfecto, ahora falta la interfaz grafica, y la parte de Arduino:

Luego, lo que haremos es es quitar esta clase scanner y poner una interfaz gráfica:
Para ello, hemos de modificar un poco mas el código:
Aquí es lo que se pretende es que tras buscar el puerto y darle a conectar, la introducción de una
contraseña correcta, me habilite el disparo de led o apertura caja fuerte. Esos círculos, son los intentos, si
hay 3 intentos fallidos, los 3 circulos se ponen en rojo, y la caja fuerte no se puede abrir.
Cuando se introduce la contraseña correcta, los 3 leds se encienden en verde, y se muestra el estado de
otro led.
Introduciríamos un combobox, y un observable list.

Quitamos la clase escanner y el metodo conectar quedaria:

conexión de los círculos con la lectural del evento puerto serie.

Y la ulterior conectividad
Archivos modulares y no modulares con
Maven. Gradle y gradle modular.

***** recordamos que todo archivo modular, se inicia como un archivo normal acorde
especificacions de openjavafx.io es decir, configuración con Maven fxml…., y es pom posterior el
del parent-directory, el que los arreplegara a todos bajo un único archivo.

5.1. Generación de un proyecto Java simple no modular. Aquí

explicamos el inicio automático con Maven.
Para construir un proyecto Java simple, ejecutemos el siguiente comando:
mvn archetype:generate
-DgroupId=org.baeldung
-DartifactId=org.baeldung.java
-DarchetypeArtifactId=maven-archetype-quickstart
-DinteractiveMode=false

El groupId es un parámetro que indica el grupo o la persona que creó un proyecto, que
suele ser un nombre de dominio de empresa invertido. El artefactoId es el nombre del
paquete base usado en el proyecto, y usamos el arquetipo estándar .
Dado que no especificamos la versión ni el tipo de paquete, estos se establecerán en
los valores predeterminados: la versión se establecerá en 1.0-SNAPSHOT y el
paquete se establecerá en jar .
Si no sabe qué parámetros proporcionar, siempre puede
especificar interactiveMode = true , de modo que Maven solicite todos los
parámetros necesarios.

Una vez que se completa el comando, tenemos un proyecto Java que contiene una
clase App.java , que es solo un programa simple "Hello World", en
la carpeta src/main/java .
También tenemos una clase de prueba de ejemplo en src/test/java . El pom.xml de
este proyecto se verá similar a esto:
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>org.baeldung</groupId>
<artifactId>org.baeldung.java</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>org.baeldung.java</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
 <artifactId>junit</artifactId>
<version>4.1.2</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

Como puede ver, la dependencia de junit se proporciona de forma predeterminada.

5.2. Compilar y empaquetar un proyecto

El siguiente paso es compilar el proyecto:
mvn compile
Maven ejecutará todas las fases del ciclo de vida que necesita la fase
de compilación para construir las fuentes del proyecto. Si desea ejecutar solo la fase
de prueba , puede utilizar:
mvn test
Ahora invoquemos la fase del paquete , que producirá el archivo jar compilado :
mvn package

5.3. Ejecutar una aplicación

Finalmente, vamos a ejecutar nuestro proyecto Java con el exec-maven-
plugin . Configuremos los complementos necesarios en el pom.xml :
<build>
<sourceDirectory>src</sourceDirectory>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.6.1</version>
<configuration>
<source>1.8</source> --→ cuidado: java 8, aunque es
//retrocompatible por eso se ejecuta en mi ide de netbeans.
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>3.0.0</version>
<configuration>
<mainClass>org.baeldung.java.App</mainClass>
</configuration>
</plugin>
</plugins>
</build>
El primer complemento, maven-compiler-plugin , es responsable de compilar el código
fuente utilizando la versión 1.8 de Java. El complemento exec-maven busca la clase
principal en nuestro proyecto.
Para ejecutar la aplicación ejecutamos el siguiente comando:
mvn exec:java

6. Proyectos de varios módulos

El mecanismo en Maven que maneja proyectos de múltiples módulos (también
llamados proyectos de agregación ) se llama Reactor .
El Reactor recopila todos los módulos disponibles para construir, luego clasifica los
proyectos en el orden de construcción correcto y, finalmente, los construye uno por
uno.
Veamos cómo crear un proyecto principal de varios módulos.

6.1. Crear proyecto principal

En primer lugar, necesitamos crear un proyecto principal. Para crear un nuevo
proyecto con el nombre padre-proyecto, usamos el siguiente comando:
mvn archetype:generate -DgroupId=org.baeldung -DartifactId=parent-project

A continuación, actualizamos el tipo de paquete dentro del archivo pom.xml para

indicar que se trata de un módulo principal :
<packaging>pom</packaging>

6.2. Crear proyectos de submódulos

Con packaging se indica el tipo de empaquetado que hay que hacer con el proyecto.
Podemos usar jar, war, ear, pom.

En el siguiente paso, creamos proyectos de submódulos desde el directorio

del proyecto principal :
// el parent, generado arriba, el empaquetado lo cambio a pom, por tanto no es
ejecutable por si. En el ide de netbeans, tras compilado, etc….. solo 1 y 3 podemos
ejecutar con la jre tras el empaquetado jpackage y fatjars.
cd parent-project
mvn archetype:generate -DgroupId=org.baeldung -DartifactId=core //jar
mvn archetype:generate -DgroupId=org.baeldung -DartifactId=service //jar
mvn archetype:generate -DgroupId=org.baeldung -DartifactId=webapp // war

Para verificar si creamos los submódulos correctamente, buscamos en el

archivo parent-project pom.xml , donde deberíamos ver tres módulos:
<modules>
<module>core</module>
<module>service</module>
<module>webapp</module>
</modules>
Además, se agregará una sección principal en el pom.xml de cada submódulo :
<parent>
<groupId>org.baeldung</groupId>
<artifactId>parent-project</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>

6.3. Habilitar la gestión de dependencias en el proyecto principal

La gestión de dependencias es un mecanismo para centralizar la información de
dependencias para un proyecto padre de varios módulos y sus hijos.
Cuando tiene un conjunto de proyectos o módulos que heredan un padre común,
puede poner toda la información necesaria sobre las dependencias en
el archivo pom.xml común. Esto simplificará las referencias a los artefactos en
los POM secundarios .
Echemos un vistazo al pom.xml de un padre de muestra :
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.3.5.RELEASE</version>
</dependency>
//...
</dependencies>
</dependencyManagement>
Al declarar la versión spring-core en el padre, todos los submódulos que dependen
de spring-core pueden declarar la dependencia utilizando solo groupId y artefactoId , y
la versión se heredará:
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
</dependency>
//...
</dependencies>
Cada vez que llamamos al generador, debemos decirle con que maquina hacerlo, en
este caso, le dije que 1856, el espejo de lo que me pide.

Luego en la versión del arquetipo, siempre la misma la ultima la

8
Luego te pedirá versión y “y”:

versión pondremos la 1.0 y en Y: : enter

El fichero pom.xml es donde vamos a describir nuestro proyecto.

$ mvn compile – compila el proyecto y deja el resultado en target/classes

• $ mvn test – compila los test y los ejecuta

• $ mvn package – empaqueta el proyecto y lo dejará en taget/autentiaNegocio-
1.0-SNAPSHOT.jar
• $ mvn install – guarda el proyecto en el repositorio

Este repositorio está situado en <USER_HOME>/.m2/repository (aunque Maven

nos permite cambiar esta localización por defecto.

• $ mvn clean – borra el directorio de salida (target)

Los comandos son:

:<goal>. Available lifecycle phases are: validate, initialize, generate-sources, process-

sources, generate-resources, process-resources, compile, process-classes, generate-test-
sources, process-test-sources, generate-test-resources, process-test-resources, test-
compile, process-test-classes, test, prepare-package, package, pre-integration-test,
integration-test, post-integration-test, verify, install, deploy, pre-clean, clean, post-clean,
pre-site, site, post-site, site-deploy+ ---- deploy es para installer el war en el servidor.
Y se ejecuta con mvn exec:java

Gradle:

Las dependencias, se instalan desde Maven central para gradle.

Tenemos que ir a build, y

Estructura genérica del gradle-build ----------------------- → equivalente al archivo pom o

constructor. Las dependencias se ponen ahí.
Ejecución: vas al directorio raíz donde este este archivo build, al igual que en Maven ivamos
al pom y
./gradlew jproRun
O para un jar o javafx:
gradlew.bat --configure-on-demand -x check run
Por ejemplo, en jpro, nos dicen:
El problema, es que a la hora de usar javafx, malo gradle, hay que decirle las dependencias y donde estamos. 1.

1. Crea un proyecto Gradle

Crea un Java with Gradle -> Java Applicationproyecto.

Proporcione el nombre del proyecto, como HelloFXy una ubicación para el proyecto, proporcione
el nombre del paquete, como org.openjfxy la clase principal, como MainApp. Finalmente,
seleccione Initialize Gradle Wrapper.
El proyecto se crea y se abre.

Nota: actualmente, el complemento Gradle de JavaFX requiere que el contenedor de gradle esté
configurado en un valor máximo de 6.3. Establezca el valor de distributionUrlen consecuencia en
el gradle/wrapper/gradle-wrapper.propertiesarchivo.

2. Modificar la compilación
Edite el build.gradlearchivo y reemplácelo con este archivo de compilación .

Podemos declarar los módulos JavaFX requeridos en el build.gradle archivo usando el

complemento Gradle de JavaFX:

javafx {
version = "17"
modules = [ 'javafx.controls', 'javafx.fxml' ]
}

Nota: si NetBeans se ejecuta con un JDK inferior a 11, es posible que el complemento no funcione. Edite
el netbeans/etc/netbeans.confarchivo y configure en netbeans_jdkhomeconsecuencia, o haga lo mismo
con el ~/.gradle/gradle.propertiesarchivo, configurando org.gradle.java.home.
Guarde el proyecto y obtendrá las dependencias de JavaFX.

En cuanto a cualquier otra dependencia de Gradle, estos archivos jar se pueden encontrar en
el .gradlerepositorio local.

3. Agrega el código fuente

Según esta clase MainApp , agregue su contenido a la clase principal del proyecto. Luego agregue
el controlador y el FXML y los archivos css .
4. Ejecutar el proyecto
Puede ejecutar directamente desde el Run Projectbotón. Pero también puede seleccionar
el build.gradlearchivo y visualizar la ventana del Navegador. Cree el proyecto con Build ->
buildy haga clic en Application -> run para ejecutar el proyecto.

También puede abrir una terminal y ejecutar: gradlew run

Esto es para javafx. Para java mas fácil aun.
ecosistema de Java, Jakarta EE9 y programadores front end
backend y fullstack developer
tipos de desarrollo web: portales infojobs, wallapop, etc…. lo que sea:

desarrollo web front end: html,css,javascript o solamente javascript¡¡¡

React, vue, Angular, son frameworks de JAVASCRIPT, NO DE JAVA. TU NO VAS A APRENDER ESO
Y oracle sql, y oracle, la mas importante.
Por tanto en industria : frontend = javascript
Backend: java o php.
Luego esta el full Stack developer, que es front end +backend = maquina.

Yo aspire solo a ser programador backend, porque no quiero aprender javascript.

aunque esten springboot para java-swing o jpro-one para javafx como implementadores de
servidores frontend pues de ellos obtenemos html+css+javascript Estamos muy lejos de usar
aquello componentes, vue, react,angular javascript, etc…..

Springboot, realmente,además, es un backend o conector de aquella capa

html+css+jss al servidor, en lugar de php, usando java.

Con jpro-one, serias un fullstack developer, pues implementas las 2 capas, pero las
app, distan mucho de ser tan vistosas como las conseguidas con javascript y estos
frameworks.

Hoja de ruta de aprendizaje pues: swing (java) + springboot for swing.

Jakarta EE 9.1: compatible con java11

Jakarta EE 9.1

Esta revisión menor solo añade Java 11 como requisito. La publicación del curso comenzó antes
de esta versión y ya se usaba Java 11, así que la vamos a ignorar y no habrá actualizaciones hasta
la llegada y difusión de Jakarta EE 10.

Servidores de aplicaciones

Desde una perspectiva práctica, la definición de Jakarta EE como un simple conjunto de APIs
estandarizadas no es suficiente. Tenemos una para trabajar con bases de datos relacionales, otra
orientada al desarrollo de servicios REST, un par relativas a la notación JSON… pero
necesitamos la integración de todas ellas si queremos crear una aplicación completa. Vamos a
dedicar mucho tiempo a ensamblar las piezas si no tenemos una plataforma de desarrollo que
provea todo lo necesario.

Pues bien, esta plataforma existe y no podía haberse diseñado mejor: es una especificación
llamada Jakarta EE Platform. Se asume que nos referimos a ella cuando simplemente hablamos
de Jakarta EE. Sus implementaciones resultan especiales: son servidores de aplicaciones en los
que se puede desplegar (ejecutar) cualquier aplicación basada en la versión y perfil de
JEE\Jakarta EE con las que el servidor sea compatible. Para conseguirlo, deben incluir tanto las
APIs como las implementaciones de todas las especificaciones. No tenemos que preocuparnos
por seleccionarlas y empaquetarlas en nuestros proyectos y, lo más importante, ya están
integradas para que funcionen en perfecta armonía.
Esta imagen subraya el requerimiento anterior. Todo lo que una aplicación necesite de Jakarta
EE está en el servidor.
De acuerdo a lo que ya sabemos, los servidores de aplicaciones son intercambiables si la
aplicación solo usa las APIs del estándar. Otro asunto son las configuraciones y la
administración, dependientes de cada uno.

No obstante, la realidad es más árida. En demasiadas ocasiones tendremos que utilizar

características específicas del servidor, o más bien de las implementaciones que incluye, porque
son de gran ayuda (ya cité el caso de Hibernate ORM). Esto provoca que terminemos
desarrollando para un servidor específico. A veces, varios de ellos incorporan las mismas
implementaciones de algunas especificaciones, así que podemos utilizarlas manteniendo cierto
nivel de portabilidad. ¿Y si queremos usar una implementación distinta a la que proporciona el
servidor? No hay una respuesta universal a esta cuestión y depende de cada caso en concreto,
aunque suele ser factible.

Algunos servidores compatibles con Jakarta EE. Fuente: web Jakarta EE

Tal y como muestra la imagen, existe una amplia variedad de servidores de aplicaciones y
algunos ya son compatibles con Jakarta EE 9. En este curso voy a optar por uno de código abierto
llamado WildFly (*). Si bien no dispongo de datos sobre su cuota de mercado, es con diferencia
el que más he encontrado a lo largo de mi andadura profesional. Lo desarrolla la compañía Red
Hat, todo un coloso del mundo Open Source, quienes lo utilizan como base de JBoss Enterprise
Application Platform (JBoss EAP), servidor de aplicaciones con soporte comercial.

(*) Hasta 2013, WildFly se llamaba JBoss AS, y muchos todavía utilizan este nombre.

Otras alternativas de código abierto a considerar son Apache TomEE, Payara Server, Open
Liberty y GlassFish. Este último forma parte de la donación de Oracle a la Fundación Eclipse. Es
la implementación de referencia de JEE y, en cierto modo, lo sigue siendo para Jakarta EE pues
los TCK se basan en sus librerías y debería ser el primer servidor compatible con cada nueva
versión.
Para concluir esta sección, me gustaría señalar un error muy común. Los servidores de
aplicaciones Jakarta EE \JEE suelen confundirse con servidores tan populares como Apache
Tomcat y Eclipse Jetty que solo ofrecen las características imprescindibles para desplegar
aplicaciones web. La distinción la haremos atendiendo a la clasificación del producto: son
servidores, pero no «de aplicaciones». Si se quiere usar en ellos una especificación, la aplicación
debe incluirla (API e implementación).

- Instalación del software: instamos en nuestra maquina virtual java 11 y netbeans y por
ende la variable de entorno de Maven.

WildFly

En el capítulo anterior ya comentamos que WildFly será nuestro servidor de aplicaciones

Jakarta EE. En concreto, la versión 22 (la 23 ahora mismo es una beta), variedad Preview,
porque la «estándar» todavía no es compatible con Jakarta EE 9. Oficialmente, se recomienda
utilizar WildFly 22 con Java 11. La versión mínima es Java 8, y debería ir bien con Java 13.

No hay que realizar ninguna instalación, tan solo descargar y descomprimir. En la próxima
entrega mostraré varias formas de desplegar aplicaciones en este servidor.

Revisemos la estructura de carpetas de un proyecto Maven de tipo web. Es importante conocerla

bien.

• src/main. Aquí están los ficheros con las fuentes («sources»), divididos en tres grupos.
▪ java. Es el código fuente.
▪ resources. «Recursos» que utiliza el código, como por ejemplo
ficheros .properties, y que forman parte del classpath. Cuando la aplicación se
empaqueta en un artefacto, el contenido de esta carpeta se copia de forma
recursiva en la raíz del directorio en el que se ubican los ficheros .java ya
compilados en .class.

La carpeta META-INF contiene los ficheros requeridos por algunas

especificaciones como, por ejemplo, el archivo persistence.xml. Al
 empaquetarse la aplicación, Maven crea en ella el fichero MANIFEST.MF con
detalles sobre la compilación, así como otros que contienen información
acerca de las dependencias -librerías que usa el proyecto- definidas en
el pom.xml.
▪ webapp. Los ficheros de «recursos» específicos de una aplicación
web: html, css, JavaScript, imágenes, etc. Dentro encontramos la carpeta
especial WEB-INF. En el artefacto .war, en esta carpeta se copia el código
fuente compilado (classes), las librerías de las dependencias (lib) y cualquier
fichero que hayamos puesto en esa ruta.
• src/test. Todos los recursos utilizados en exclusiva para implementar las pruebas. No
estarán presentes en el empaquetado final de la aplicación.
• target. Es la carpeta de trabajo. En ella se generan, entre otros, los ficheros con el
código compilado, artefactos intermedios e informes de la ejecución de pruebas.
Aunque siempre esté ahí, en realidad no forma parte del proyecto y debe excluirse del
sistema de control de versiones.
En la raíz del proyecto (la estructura de carpetas que acabamos de describir), se encuentra el
fichero pom.xml. Lo usamos para definir, entre otra información, cómo se construye el artefacto
y las dependencias que utiliza.
<project xmlns="http://maven.apache.org/POM/4.0.0 "
1
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
2
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/x
3
<modelVersion>4.0.0</modelVersion>
4
5
<groupId>com.danielme.jakartaee</groupId>
6
<artifactId>hello</artifactId>
7
<version>1.0-SNAPSHOT</version>
8
<packaging>war</packaging>
9
10
<properties>
11
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
12
<maven.compiler.release>11</maven.compiler.release>
13
<jakarta-ee.version>9.0.0</jakarta-ee.version>
14
<maven.compiler.version>3.8.1</maven.compiler.version>
15
<maven.war.version>3.3.1</maven.war.version>
16
</properties>
17
18
19 <build>
20 <finalName>hello</finalName>
21
22 <plugins>
23
24 <plugin>
25 <groupId>org.apache.maven.plugins</groupId>
26 <artifactId>maven-war-plugin</artifactId>
27 <version>${maven.war.version}</version>
28 </plugin>
29
30 <plugin>
31 <groupId>org.apache.maven.plugins</groupId>
32 <artifactId>maven-compiler-plugin</artifactId>
33 <version>${maven.compiler.version}</version>
34
</plugin>
35
36
</plugins>
37
</build>
38
<dependencies>
39
<dependency>
40
<groupId>jakarta.platform</groupId>
41
<artifactId>jakarta.jakartaee-api</artifactId>
42
<version>${jakarta-ee.version}</version>
43
<scope>provided</scope>
44
</dependency>
45
46
47 </dependencies>

48</project>
49
50
51

El ejemplo anterior de fichero pom.xml contiene una configuración básica para una aplicación
web basada en Jakarta EE. De hecho, pertenece al proyecto de ejemplo hello con el que vamos a
trabajar en este capítulo. Analicemos brevemente su contenido.
• Los datos que caracterizan al proyecto.
▪ groupId: Es el identificador de la organización o persona que lo desarrolla.
La costumbre es utilizar una ruta de paquetes. En mi caso, es la dirección
invertida de mi blog, criterio muy habitual (org.apache, org.hibernate,
com.liferay, etc).
▪ artifactId: El identificador específico del proyecto, y único para un
mismo groupId. En definitiva, su nombre.
 ▪ version: La versión actual. Iré actualizando y ampliando los ejemplos del
curso pero no cambiaré su versión, de ahí que haya añadido el
sufijo SNAPSHOT («instantánea») para que Maven sepa que se trata del
código más reciente de la 1.0.0.
▪ packaging: El tipo de artefacto a generar. El predeterminado es jar, así que
ponemos war.
• El artefacto con la aplicación se llamará «hello.war» (finalName). Si no proporcionamos
el nombre, Maven lo compondrá con los valores de artifactId y version (hello-1.0-
SNAPSHOT.war)
• Las librerías de Maven (plugins) que vamos a utilizar para construir el artefacto. Hay
dos: uno lo genera (maven-war-plugin) y el otro compila el código (maven-compiler-
plugin) para la versión de Java especificada con la propiedad maven.compiler.release. No
es necesario declarar estos plugins si no se va a realizar ninguna configuración de los
mismos, pero recomiendo hacerlo para indicar su versión y así evitar sorpresas
desagradables. De lo contrario, Maven utiliza unas versiones bastante antiguas.
• Me gusta definir variables en el bloque properties con los números de versiones. La idea
es reutilizarlas si tenemos varios módulos de una misma librería que comparten la
numeración. Otra ventaja es que vemos de un vistazo todas las librerías y versiones.
Entre las propiedades, fijémonos en project.build.sourceEncoding. La utiliza el
plugin maven-resources-plugin para establecer la codificación de los ficheros.
Recomiendo definirla con el valor UTF-8 y así evitar problemas causados por usar el
proyecto tanto en Windows como en Linux. Obsérvese que acabo de mencionar un plugin
que no aparece en el pom: no necesitamos realizar ninguna configuración adicional y
Maven ya lo utiliza. En este caso concreto, indicar el número de versión no me parece tan
relevante como en los casos de maven-war-plugin y maven-compiler-plugin.
• El punto de mayor interés son las dependencias. Por omisión, y al igual que los plugins,
se descargan de los repositorios centrales de Maven, un auténtico paraíso de librerías
de código abierto que podemos inspeccionar con la web mvnrepository.com. Estas
dependencias no son sino artefactos y se van guardando en nuestro equipo en un
«repositorio local» para evitar descargarlas cada vez que sean necesarias.
Hay dos alternativas a la hora de añadir las dependencias con las APIs de Jakarta EE.

1. Utilizar una «superdependencia» que incluye un conjunto de especificaciones. Podemos

incluirlas todas (jakarta.jakartaee-api), o bien las utilizadas de forma habitual en el
desarrollo de aplicaciones web con jakarta.jakartaee-web-api, el llamado perfil web
(Jakarta EE Web Profile) del que hablamos en su momento.
2. Definir solo las correspondientes a las especificaciones que necesitemos. Tendríamos
algo tal que así.
<dependency>
1
2
<groupId>jakarta.persistence</groupId>
3 <artifactId>jakarta.persistence-api</artifactId>
4 <version>3.0.0</version>
5
<scope>provided</scope>
6</dependency>
7<dependency>
8 <groupId>jakarta.ws.rs</groupId>
9 <artifactId>jakarta.ws.rs-api</artifactId>
10 <version>3.0.0</version>
11 <scope>provided</scope>
12</dependency>

Lo habitual es decidirse por la primera opción. La razón es muy sencilla y se explicó en el capítulo
dos: todas las dependencias de Jakarta EE son de tipo «provided» porque están disponibles,
tanto las APIs como sus implementaciones, en el entorno de ejecución (el servidor). No se
empaquetan en la aplicación (la carpeta /WEB-INF/lib en hello.war), así que lo más cómodo es
hacer que todas las APIs estén a nuestra disposición e ir usando lo que necesitemos. Otra ventaja
es la sencillez del pom.
Con el pom anterior ya tenemos el proyecto hello listo para ser publicado, pero es un «cascarón
vacío» que no hace nada. Demasiado triste; vamos a añadir alguna funcionalidad. Por ejemplo,
la página principal de la aplicación que se verá cuando accedamos su dirección raíz. Tenemos
que crearla en el fichero /src/main/webapp/index.html.
1<!DOCTYPE html>
2<html lang="es">
3
4 <head>
5 <meta charset="UTF-8">
6 <meta name="viewport" content="width=device-width, initial-scale=1">
7 <title>Hello</title>
8
<link rel='icon' href='img/favicon.png' type='image/x-icon'>
9
<style>
10
body {
11
max-width: max-content;
12
margin: auto;
13
text-align: center;
14
}
15
</style>
16
</head>
17
18
19 <body>

20
21 <h1>Hello - Jakarta EE</h1>

22
23 <img src="img/jakartaee.png">
24
25 </body>
26
 </html>
Las líneas marcadas son de especial interés porque enlazan imágenes situadas en la
carpeta /src/main/webapp/static/img. Con la excepción del contenido de WEB-INF, todos los
ficheros de webapp son accesibles vía web añadiendo su ruta relativa a la url raíz que la
aplicación tiene en el servidor, por ejemplo {url aplicación}/img/jakartaee.png.

Comencemos a utilizar Jakarta EE con una de las especificaciones más importantes: Jakarta
Servlet, API que gestiona peticiones y respuestas HTTP. Es la base de todas las aplicaciones web
Java y, aunque casi nunca la usaremos directamente, siempre está ahí, por ejemplo «oculta»
detrás de Jakarta Server Faces o Jakarta REST. La veremos con detalle en el capítulo
correspondiente. Por ahora, es suficiente con saber que un servlet, definido de forma sencilla y
práctica, es una clase que recibe una petición HTTP y devuelve una respuesta, por ejemplo una
cadena con el HTML de una página web.
A continuación se muestra el servlet que vamos a usar. Una petición de tipo GET realizada a la
dirección indicada en la anotación @WebServlet provoca la invocación del método doGet en el
que recibimos dos objetos que modelan la petición (request) y la respuesta asociada (response).
Esta última consiste en una cadena de texto tal y como especifica el content-type.
1
2package com.danielme.jakartaee.hello;
3
4import jakarta.servlet.ServletException;
5import jakarta.servlet.annotation.WebServlet;
6import jakarta.servlet.http.HttpServlet;
7import jakarta.servlet.http.HttpServletRequest;
8import jakarta.servlet.http.HttpServletResponse;
9
10import java.io.IOException;
11import java.io.PrintWriter;
12
13@WebServlet("/helloServlet")
14public class HelloServlet extends HttpServlet {
15
16 private static final String HELLO_MESSAGE = "Jakarta EE rocks!!";
17
18 @Override
19 protected void doGet(HttpServletRequest request, HttpServletResponse response)
20 throws ServletException, IOException {
21 PrintWriter printWriter = response.getWriter();
22 response.setContentType("text/plain;charset=UTF-8");
23 printWriter.print(HELLO_MESSAGE);
24
}
25
}
La siguiente imagen ofrece una visión general del funcionamiento de la aplicación que hemos
construido.

A través del protocolo HTTP, por ejemplo usando un navegador, llega la petición GET al servidor
quien determinará el servlet que debe atenderla. Su método service se invocará como parte de un
flujo de trabajo que puede implicar a varios servlets. En algún momento se llama a nuestro
método doGet.
Todo lo anterior es realizado por un componente denominado «contenedor de servlet» (servlet
container), requisito de la especificación. Este elemento forma parte del servidor web que debe
incluir, valga la redundancia, todo servidor capaz de ejecutar aplicaciones web Java aunque no
sea compatible con Jakarta EE. En el caso de WildFly, se trata de Undertow. Este nombre nos
será muy familiar pues aparecerá con frecuencia en los registros de la bitácora (logs).
Construcción y despliegue

Manual (Maven)

Veamos ahora cómo publicar la aplicación en WildFly (este proceso es distinto en cada servidor).
En primer lugar, generamos el artefacto .war. Mencioné en el capítulo anterior que el proyecto
incluye el wrapper de Maven, un script que permite utilizar una versión concreta sin instalarla
en el equipo. El wrapper en sí mismo es un fichero .jar ubicado en una carpeta oculta.

Lanzamos el ejecutable de Maven, ya sea con el wrapper dentro del proyecto (mvnw) o bien el
instalado en el equipo (mvn), y solicitamos las acciones (goals) que necesitamos.

(Linux) ./mvnw clean package

(Windows) mvnw.cmd clean package

Clean borra el contenido de target con el fin de asegurar que la aplicación se genera desde cero.
Por su parte, package crea el artefacto realizando las tareas necesarias, lo cual incluye la
compilación del código y la ejecución de las pruebas si las hubiera. Si todo va bien, veremos algo
como lo siguiente.

El resultado está en target.

Nuestra aplicación es hello.war. Recuérdese que este nombre y el formato están definidos en
el pom.xml. El tamaño del fichero es ridículo a pesar de que tenemos disponible en el proyecto
todas las APIs de Jakarta EE. Asimismo, sabemos que es un archivo comprimido, y si el lector
es curioso puede ver su contenido con una utilidad de compresión. Llama la atención la
carpeta WEB-INF classes porque no la tenemos en el proyecto. Contiene la estructura de carpetas
de /src/main/resources tal cual y los compilados de /src/main/java.

¡Ya casi estamos! Ahora es el turno de WildFly. Lo iniciamos ejecutando el script standalone (*)
ubicado en la carpeta bin dentro del directorio donde lo hayamos descomprimido.
Usamos standalone.sh en Linux y standalone.bat en Windows. El script ejecuta el servidor con la
versión de Java que tengamos configurada en el sistema operativo. Admite algunos parámetros
que ya iremos viendo cuando los necesitemos.
(*) WildFly tiene dos modos de ejecución: independiente (standalone) o formando parte de un
clúster (dominio). En el curso solo usaremos el primero.

La publicación de hello.war puede hacerse con la consola de administración de la que hablaré al

final del capítulo, o bien copiándolo en la carpeta /standalone/deployments de WildFly. En
ambos casos, en la bitácora (log) del servidor podemos seguir el despliegue del war. Las salidas
predeterminadas para el log son la terminal en la que se ejecuta el servidor y el
fichero {wildfly}/standalone/log/server.log.
16:14:14,960 INFO [org.jboss.as.server] (ServerService Thread Pool -- 44) WFLYSRV0010: Deployed "hello.war" (runtime-
name : "hello.war")

Aprenderemos a trabajar con el sistema de logging de WildFly en el próximo capítulo.

El siguiente video muestra todo el proceso en Linux.

WildFly -o Undertow, si somos rigurosos- «escucha» en la url http://localhost:8080, y en esa

dirección nos muestra una pantalla de bienvenida.

La aplicación está accesible dentro de ella con el nombre del fichero .war.
Probemos el servlet que escucha en la dirección http://localhost:8080/hello/helloServlet .

Detenemos WildFly cerrando la ventana de la terminal o consola en la que se está ejecutando.

También es posible abrir la herramienta de administración para línea de comandos, conocida
como CLI (command line interface) con jboss-cli.sh o jboss-cli.bat, según corresponda, y lanzar
dentro de ella el comando shutdown. Al iniciar CLI, ejecutamos el comando connect para que se
conecte a una instancia de WildFly que esté en ejecución en nuestra máquina. Adjunto un video
para que se vea más claro.
CLI no está limitado a servidores locales y permite administrar cualquiera indicando en el
comando connect su dirección y puerto de administración. Si hiciera falta, nos solicitará las
credenciales de un usuario administrador (veremos esto al final del capítulo).

Es importante que nos familiaricemos con esta poderosa herramienta que usaremos de forma
recurrente a lo largo del curso.

Eclipse

En demasiadas ocasiones, si queremos disfrutar en Eclipse de funcionalidades que IntelliJ

ofrece de serie tenemos que instalar complementos o plugins. En el caso de WildFly,
necesitamos JBoss Tools, conjunto de utilidades oficiales de Red Hat disponibles en
el Marketplace (Help->Eclipse Marketplace…).
Este componente incluye muchos módulos y su instalación completa puede tardar bastante.
Ahora mismo solo vamos a necesitar «JBoss AS, WildFly & EAP Server Tools», pero recomiendo
tener paciencia e instalarlas todas. En cualquier caso, tras instalar y reiniciar Eclipse,
importamos el proyecto con la opción File->Import->Existing Maven Projects.
Es suficiente con indicar la carpeta con el proyecto.

Podemos navegar por sus ficheros y librerías con el explorador que aparece a la izquierda. A
diferencia de IntelliJ, en una misma ventana de Eclipse se muestran múltiples proyectos: todos
los pertenecientes al espacio de trabajo («workspace») seleccionado. Nada nos impide abrir otra
instancia de Eclipse y escoger un workspace distinto.

Comprobemos la JDK que Eclipse usa para compilar hello. Queremos que sea OpenJDK 11, y si
su instalación no está registrada tendremos que añadirla. Abrimos el menú contextual del
proyecto en el explorador para pulsar Properties. Nos vamos a la sección «Java Build Path», en
concreto la pestaña «Libraries».

Marcamos la JRE que aparece y pulsamos Edit para mostrar la pantalla de selección.

Hay tres alternativas.

• Execution Enviroment. Aquí no seleccionamos una instalación de Java, sino un «entorno

de ejecución» (Java 11, Java 15, etc). Eclipse aplica la versión de Java configurada para
el entorno.
• Alternate JRE. Indicamos una instalación de Java.
• Workspace Default. La predeterminada en el IDE en cada momento para todo el espacio
de trabajo.
Dado que queremos forzar el uso de una versión concreta, marcamos la segunda opción y la
seleccionamos del desplegable. Si no aparece en el listado, con «Installed JREs..» se muestra
una pantalla con las disponibles desde la que podemos añadir una nueva instalación con Add….

A continuación, intentemos desplegar hello con la opción «Run As» de la barra de herramientas
(botón «play» en un círculo verde) o con el menú contextual (botón derecho del ratón)
desplegable desde la carpeta con el nombre del proyecto en el explorador. También podemos
hacer el despliegue en modo depuración con el icono del «bichito».

Al ser la primera vez, carecemos de una configuración para hacer el despliegue, así que el
asistente nos pedirá definir un servidor. Seleccionamos nuestra versión de WildFly. Si vamos a
usar una muy reciente es posible que falte. Es el caso de la captura siguiente donde la más actual
es la 21 a pesar de que en ese momento ya se había publicado la 22. Cuando nos encontremos
ante esta situación, además de intentar actualizar JBoss Tools, seleccionamos la versión más
alta. Por experiencia, no suele haber problemas.
Al final del asistente, indicamos el directorio de instalación de WildFly (también tenemos la
posibilidad de descargar la versión seleccionada en la pantalla anterior), y la JDK de Java 11 que
se usará para ejecutarlo.
Eclipse procederá a realizar el despliegue de forma inmediata. En la vista Console tenemos la
salida del servidor.

Para utilizar el servidor, nos vamos a la vista Servers. Si no aparece, la activamos en el

menú Window->Show View->Server. En esta pantalla lo arrancamos -incluso en modo
depuración- y detenemos, aunque estas órdenes también las tenemos en la barra de acciones
principal del IDE. Además, con el menú contextual de esta vista podemos añadir más servidores
y agregar o eliminar artefactos a los mismos. Los servidores se configuran para todo el espacio
de trabajo y pueden usarse con cualquiera de sus proyectos.

En la captura anterior se ve la pantalla de configuración del servidor, mostrada al hacer doble

clic en él. El despliegue de los cambios que vayamos realizando mientras el servidor está en
ejecución se personaliza en la sección «Publishing». Con las opciones predeterminadas, las
modificaciones de ficheros que no sean código Java, por ejemplo HTML, se aplican cuando los
archivos se guardan. Por el contrario, los cambios de código implican un despliegue completo,
algo que podemos ordenar desde el menú contextual del proyecto dentro de la vista Servers con
«Full Publish», o, de forma poco elegante, reiniciando WildFly.
Resulta más cómodo utilizar el atajo de teclado «Control+Shift+y», y pulsar «f» justo después.
Es un decir porque la combinación es complicada, así que recomiendo cambiarla por una más
práctica accediendo con Window->Preferences a la configuración de Eclipse, en concreto
a General>Keys.
Consola de administración de WildFly

WildFly incluye una consola de administración, disponible en http://localhost:9990/console.

Entre otras muchas funcionalidades, permite desplegar y retirar artefactos. Antes de utilizarla
por primera vez, es necesario configurar sus usuarios con el script {WILDFLY}/bin/add/add-user,
el .sh en Linux y el .bat en Windows. El siguiente video muestra cómo habilitar un típico usuario
administrador llamado admin. Es obligatorio crear una contraseña.
La aplicación está en la pantalla «Deployments». Podemos eliminarla o desplegar cualquier otro
artefacto.

Además de la interfaz web, el sistema de administración ofrece una API REST en la

dirección http://localhost:9990/management. No la usaremos directamente, pero será necesaria
cuando implementemos pruebas automáticas que hagan uso de WildFly.

Código de ejemplo

El código de ejemplo para este capítulo se encuentra en GitHub (todos los proyectos están en
un único repositorio). Contiene un fichero Dockerfile correspondiente a otro capítulo. Para más
información sobre cómo utilizar GitHub, consultar este artículo.
Estudio del paquete de netbeans calculo Númerico. Calibración y funciones.
Nuestro paquete .rar tiene 18 aplicaciones. Veamoslas.
1) Gui: (3)→ canvas plot, una animación ok, tick animación, y proyecto Maven 1. Que es el de jpro
pero en local. (jdk16) recordamos que jpro solo va sobre jdk 11 y lo he quitado. Cuando llegue el
jdk17 usare los2. Testadas.
2) Raicesmultiple p(x) y raíces complejas de p(x) (2). → Tma fundamental del algebra. Testadas.
3) Cramer y multiplicación de matrices. Testadas.(2)
4) Regresión lineal y cuadrática a chicuadrado (2)
5) Integral simple simpsom y doble (2)
6) Edos primer orden individiduales, sistemas y segundo orden, individual y sistemas (x4)
7) Derivación y optimización de funciones por el criterio de la derivada(1).
8) Interpolación de newton y FFT (2)
Recordamos que en C# también disponemos del algoritmo de Dantzing (meter simplex en lupa de
windows), el cual no hemos conseguido implementar en java, ni transformar de c# a java, pero que lo
estudiaremos.
 1) Edos y sistemas de edos de primer y de segundo orden. Fundamento
matemático.
Se demuestra que la resolución de un paso h de una edo por el procedimiento de runge-kutta es:

Sea una ecuación diferencial de primer orden, con la condición inicial

Se elige una anchura de paso h, y se calculan cuatro números k1, k2, k3, k4 de acuerdo con el
procedimiento esquematizado en la tabla adjunta. Según el procedimiento ordinario de Runge-
Kutta, a partir del valor de x en el instante t se determina el valor de x en el
instante t+h mediante la fórmula que figura en la última fila de dicha tabla.

En la clase Funcion derivada de RungeKutta describimos el modelo físico particular,

redefiniendo la función f(x, t). Consideremos la ecuación diferencial que describe la
desintegración de una sustancia radioactiva en otra estable.

La llamada a la función resolver se efectuará desde un objeto de la clase derivada Funcion.

Se nos pedirá los siguientes datos: el estado inicial, es decir, el número de núcleos x0 en el
instante inicial t0, el instante final t en el que queremos calcular el nuevo estado del
sistema x, y el paso h para resolver numéricamente la ecuación diferencial. La función
miembro resolver devuelve el número de núcleos quedan sin desintegrar en dicho
instante t.
 Comparamos el valor exacto y el valor aproximado, tomando como paso h el valor 0.5, el
número inicial de núcleos, 5000, y el instante t, 20. Se obtiene para el resultado aproximado
676 y para el resultado exacto 676, lo que nos confirma la exactitud del procedimiento de
Runge-Kutta.
// valor exacto
x=(int)(x0*Math.exp(-0.1*t));
System.out.println("valor exacto de x "+(int)x);

Sistemas de ecuaciones de primer orden:

El procedimiento de Runge-Kutta es igualmente efectivo en la resolución de ecuaciones

diferenciales de primer orden. Sea el sistema

El procedimiento de aplicación del método de Runge-Kutta a cada una de las ecuaciones

diferenciales, con las condiciones iniciales

Ejemplo:
Continuando con el ejemplo de la desintegración radioactiva consideremos ahora, una serie
radioactiva de tres elementos en la que, una sustancia radiactiva A se desintegra y se
transforma en otra sustancia radiactiva B, que a su vez se desintegra y se transforma en una
sustancia C estable. Las ecuaciones diferenciales que gobiernan el proceso y sus soluciones
analíticas son, respectivamente,

La solución analítica que aparece a la derecha, se ha obtenido con las condiciones iniciales t=0,
x=x0 e y=0. La segunda solución se obtiene siempre que a sea distinto de b. En el caso de
que a sea igual a b, la solución analítica para y es
La interpretación del sistema de ecuaciones diferenciales no es complicada. En la unidad de
tiempo, desaparecen ax núcleos de la sustancia A al desintegrarse (primera ecuación). En la
unidad de tiempo, se producen ax núcleos de la sustancia B, y a su vez desaparecen bx núcleos
de la sustancia B que al desintegrarse se transforman en núcleos de la sustancia C estable
(segunda ecuación).

Para codificar este ejemplo, primero se han de definir las funciones f, g en la clase
derivada Funcion de la clase abstracta RungeKutta.

Definimos el estado inicial en el instante t0=0, el número de núcleos de la sustancia radiactiva

A, suponemos que no hay inicialmente núcleos de sustancia B. Establecemos el instante t en el
que deseamos conocer el número de núcleos que hay de la sustancia A, y el número de núcleos
de la sustancia B, llamando a la función resolver desde un objeto de la clase Funcion.

Como en el apartado anterior fijamos el número de núcleos de la sustancia A en 5000, y el de la

B ningún núcleo. El valor del paso h lo tomamos como 0.5. Los resultados aproximados para el
instante t=20 están en concordancia con los obtenidos a partir del resultado exacto, como queda
reflejado en la tabla adjunta

t=20 Aproximado Exacto

A 676 676
B 585 585
Así que de momento el .jar edos individuales primer orden ok.

El resultado de sistemas de edos primer orden:

Por tanto hasta ahora, va todo bien, estos 2 estan calibrados.

Podemos experimentar con un oscilador de frecuencia angular=de 2 rad/s, calculemos la
posición y la velocidad del oscilador en el instante t= 2s, tomando como paso h el valor de 0.01.
double h=0.01; //paso
double w0=2.0; //frecuencia propia oscilaciones libres
double t=2.0; //resolver la e. d. hasta este instante
//Situación inicial
double x0=1.5; //posición inicial
double v0=0.0; //velocidad inicial
Estado es=new Estado(0.0, x0, v0);
Al ejecutar en netbeans edo simple primer orden

¿se corresponde esto con?

4) ejemplo de sistemas de ecuaciones de segundo orden: el movimiento planetario.
Uno de los ejemplos más interesantes de resolución de un sistema de ecuaciones diferenciales de
segundo orden es la descripción del movimiento de los planetas, el cual tiene una solución
analítica sencilla en coordenadas polares. La trayectoria seguida por un planeta es una cónica,
una elipse en particular, en uno de cuyos focos está el centro fijo de fuerzas, el Sol. En la figura,
se muestra la fuerza que ejerce el Sol sobre un planeta, inversamente proporcional al cuadrado
de las distancias que separan sus centros, y también se muestran sus componentes rectangulares

Uno de los problemas del tratamiento numérico con ordenador, es la de reducir el problema a
números simples e inteligibles por el usuario de un vistazo. Las masa de los planetas y del Sol
son números muy grandes: la masa de la Tierra es 5.98 1024 kg., y 1.98 1030 kg. la del Sol. La
distancia media entre la Tierra y el Sol es también muy grande 1.49 1011 m. y la constante G es
muy pequeña 6.67 10-11 en el Sistema Internacional de Unidades. Podemos simplificar el
problema numérico, refiriéndonos a un hipotético Sol cuya masa sea tal que el
producto GM=1 o bien, que se ha cambiado la escala de los tiempos de modo que se cumpla
esta condición. Teniendo en cuenta que la aceleración es la derivada segunda de la posición, el
sistema de dos ecuaciones diferenciales de segundo orden quedará
Esto esta bien seguro vamos. Están todos calibrados. Ahora lo que hay es que hacer correr
un evento de tick que vaya generando cada uno de los pasos, y almacenar la variable en un
vector y plotearlo.
MULTIPLICACION MATRICIAL Y SISTEMAS DE ECUACIONES: PERFECTO: I*I=I

Este programa calcula la matriz inversa, y resuelve el sistema de ecuaciones por el método
de la matriz inversa: A-1*A=A-1*d donde d es el vector de soluciones.
 ◼ Raíces polinomiales y teorema fundamental del algebra (2) perfecto:
Solución de la funcion prueba debe ser +-2 y levernier o obtención de raíces complejas
también.

Recordamos el teorema fundamental del algebra:

En una ecuación de segundo grado con coeficientes reales ax2 + bx + c = 0 si el
discriminante es negativo no tiene soluciones reales y las raíces son complejas conjugadas:

La interpretación geométrica es que la parábola no corta al eje OX siendo el eje de simetría y el

vértice:

Si el discriminante >=0, las raíces son lineales, y son calculados, las multiples
soluciones, por regula falsi,
Transformada rápida de Fourier: FFT
La transformada rápida de Fourier, conocida por la abreviatura FFT (del inglés Fast Fourier
Transform) es un algoritmo eficiente que permite calcular la transformada de Fourier
discreta (DFT) y su inversa.

DFT de 4 puntos correspondiente a la secuencia x [0= 1, x1= 0, x2= 0, x3= 1

N= numero de muestras, n el subíndice del numero,fíjate que el sumando va con n, y k el

del coeficiente que esta en el lado izquierdo.

N=4 k = 0,1,2, 3

la fase

Reconstruccion de la señal:
Si la frecuencia de muestreo son 8 kHz, el correspondiente periodo

será df = = 2 kHz. Por lo tanto X1= Xdf = 2 kHz, X2 = X2. df  =

4 kHz, X[3 = X3.df =6 kHz. En la Figura 7.5. se representa |X k | y en función de k

n = 0, 1, 2, 3
LOS RESULTADOS SON 100% COINCIDENTES. Y ESTE EJEMPLO SERA EL QUE NOS SERVIRÁ PARA CALIBRAR
EL ALGORITMO, Y ES PERFECTO.
En lugar de usar la notación compleja también se puede usar la real:

Funcion de Fourier continua en el tiempo:

1) Serie de Fourier no es igual que transformada de Fourier.

La clase que puede transforma los vector 1+j en senos y cosenos es

public double modulo(){

return Math.sqrt(real*real+imag*imag);
}
public double argumento(){
double angulo=Math.atan2(imag, real);
if(angulo<0) angulo=2*Math.PI+angulo;
return angulo*180/Math.PI;
}
2) transformada de Fourier. Es una serie de Fourier para cada uno de los infinitos puntos que
componen la funcion.

◼ Pasa igual que con el tema de minimización/optimización de funciones usando derivadas o

simplex, y el algoritmo de dantzing. Puede llevarnos a confunsión, pero obtener la FFT, es
obtener las DFT (transformadas discretas de fourier y sus inversas). NO HAY FUNCIONES
INVOLUCRADAS AQUÍ. Los puntos pueden ser recogidas en un vector, y ploteadas con
una línea smoot o interpolante. Así es como se muestrea la señal.
 También veremos que son algoritmos muy distintos el del simplex de dantzing, y el del
minimax o de optimización de funciones (ver mi algoritmo como he definido métodos
funcion(), derivada(), doble_derivada() , y iguala_máximo() y iguala_mínimo() que son
llamados por evento de botón.

➔Resolución integral definida con el método de lo trapecios.

➔
➔ Resolución integrales dobles:

Si aplicamos el procedimiento de Simpson, se divide el intervalo [a, b] en un número par

de intervalos, el área en los dos primeros intervalos es:
 ➔ ALGORITMO DE DANTZING Y EJEMPLOS: este no lo podemos implementar
en java sino en c#

Existe un problema muy común en programación lineal que consiste en hallar los
valores que hacen máxima o mínima una función lineal, dadas una serie de restricciones
para dichos valores. Por ejemplo, puede tratarse de hallar una función de coste mínimo
o de máxima producción. Para ello, existe un algoritmo desarrollado en 1947 por George
Dantzig, llamado Simplex, que permite realizar dichos cálculos de una forma simple y
efectiva.

La función de la cual queremos hallar el valor máximo o mínimo se llama función

objetivo, y debe ser una función lineal de n variables, de la forma:

A1x1 + A2x2 + … + Anxn

Siendo los An cualquier número positivo o negativo.

Las restricciones son una cantidad cualquiera de condiciones, en forma

de inecuaciones, que deben cumplir las variables para que la solución sea válida. Si se
trata de maximizar la función, se deben expresar de la siguiente manera:

Para maximizar función objetivo: B1x1 + B2x2 + … + Bnxn <= C

Mientras que si lo que queremos es minimizarla, se deben escribir de la forma:

Para minimizar función objetivo: B1x1 + B2x2 + … + Bnxn >= C

Donde los Bn y C pueden ser cualquier número positivo, negativo o 0.

En este enlace podéis encontrar una explicación matemática del método Simplex, y en
este otro podéis descargar el proyecto Simplex, con el código de ejemplo que acompaña
a este artículo, escrito en CSharp con Visual Studio 2013.

El manejo de la aplicación es muy sencillo, basta con escribir la ecuación y sus

restricciones, una en cada línea:
En la primera línea se debe escribir la función objetivo, y en las siguientes
las restricciones, sin límite de número, sin dejar líneas en blanco. Como la inecuación
cambia en función de que se trate de maximizar o minimizar la función, he sustituido los
símbolos <= y >= por el signo :, que se tomará por uno de los anteriores, según
corresponda.

Una vez escritas las ecuaciones, se debe pulsar el botón Build para compilarlas, y, a
continuación, ya se puede pulsar el botón Maximize o Minimize para que el programa
proporcione los valores de las variables que hacen máxima o mínima la función con las
restricciones dadas.

Al darle a minimize, me devuelve:

Y al darle a maximize:

Ie, para maximizar la función, o obtener el máximo beneficio monetareo, no se debe

producir a, y si el x2 y x3 en esas proporciones. Y el máximo valor posible es 600. El
máximo aréa posible entre las 3 rectas que se cortant.

Ver el siguiente ejemplo:

EJEMPLO DE APLICACIÓN DEL MÉTODO SIMPLEX

La empresa AXUS S.A. desea conocer la cantidad de productos A, B y C a producir para maximizar el
beneficio, si cada unidad vendida genera en utilidad $150, $210 y $130 por unidad respectivamente.
 Cada producto pasa por 3 mesas de trabajo, restringiendo la cantidad de unidades producidas debido al
tiempo disponible en cada una de ellas. La siguiente tabla muestra el tiempo requerido por unidad de cada
producto en cada mesa y el tiempo total disponible semanalmente (tiempo dado en minutos):

Tiempo Tiempo Tiempo

requerido requerido requerido
Mesa 1 Mesa 2 Mesa 3

Producto 1 10 12 8

Producto 2 15 17 9

Producto 3 7 7 8

Tiempo total 3300 3500 2900

disponible por mesa

Se supone que cada unidad producida es vendida automáticamente. Determinar la combinación de

productos que maximicen la utilidad para la compañía.
Una vez analizado el enunciado el lector procederá a crear el modelo matemático.

PLANTEAMIENTO DEL MODELO

x1= unidades producto A
x2= unidades producto B
x3= unidades producto C
Función Objetivo (F.O.):
Max. Z = $150X1 + $210X2 + $130X3
S.A.:
10X1 + 15X2 + 7X3 <= 3300 Minutos
12X1 + 17X2 + 7X3 <= 3500 Minutos
8X1 + 9X2 + 8X3 <= 2900 Minutos
X1 , X2 , X3 >= 0

Explicación del modelo:

· La función objetivo representa la utilidad obtenida por cada unidad de producto A,B y C.
· La primera restricción nos indica que el tiempo requerido para los tres productos en la Mesa 1 debe ser
menor a 3300 minutos.
· La segunda restricción establece que el tiempo requerido para los tres productos en la Mesa 2 debe ser
menor a 3500 minutos.
· La tercera restricción nos indica que el tiempo requerido para los tres productos en la Mesa 3 debe ser
menor a 2900 minutos.

SOLUCIÓN
Resolveremos este planteamiento a través del método Simplex. Nuestro primer paso será convertir
nuestro modelo a la forma estándar, agregando variables de holgura en las restricciones donde sea
necesario. El modelo queda de la siguiente manera:
Max. Z = 150 X1 + 210 X2 + 130 X3
10 X1+ 15 X2 + 7 X3+X4= 3300
12 X1 + 17 X2 + 7 X3 +x5 = 3500
8 X1 + 9 X2 + 8 X3+x6 = 2900
Xi >= 0 i=1,6
 X1=0

X2=105.4795

X3=243.8656

X4=10.958

Z= 53849.32

INTERPRETACIÓN:
La solución nos indica que para alcanzar la ganancia óptima posible se tendrán que producir 105
unidades del producto B y 243 del producto C, el producto A no debe ser producido. Además
tendremos que en la Mesa 1 habrá un sobrante de 10.958 minutos, y que en la Mesa 2 y 3 se utilizará
el tiempo disponible en su totalidad.

Vamos a analizar estos resultados.

En las tres primeras columnas están los coeficientes de las restricciones, en las
primeras filas, y, en la última, los de la función objetivo. En las tres columnas siguientes
la base canónica, en este caso de tres dimensiones, pues existen tres restricciones.
En la última columna están las constantes que limitan los valores y el valor final de la
función, en la última fila, que comienza con el valor 0.

El algoritmo está definido para maximizar la función, por lo que, si lo que queremos en
minimizarla, la debemos reescribir de manera que se convierta en un problema de
maximización, convirtiendo la función objetivo Z = AX, con las restricciones BX >= C,
en la función Z = CY, con las restricciones BY <= A.

Ejemplo número 2 de optimización de funciones:

Una empresa elabora cereales integrales y cereales especiales para dieta (cerealestipo A y tipo B,
respectivamente, a partir de ahora). Sabemos que dispone parasu elaboracion de 150 g de trigo y 100 g de
cebada diariamente. Ademas, el horario de fabricacion es de 80 minutos al dia. Tambien sabemos que para
hacer un paquete de cereales tipo A necesitan 5 g de trigo, 2 g de cebada y 4 minutos de trabajo, y para
hacer un paquete de cereales tipo B necesitan 2 g de trigo, 3 g de cebada y 2 minutos de trabajo. Adem_as,
el precio por el que se venden es 12 euros para cada paquete de cereales tipo A y 8 euros para cada
paquete de cerales tipo B. Vamos a plantear un problema que maximice el neto obtenido al vender

Ejemplo 3 el problema del transporte:

Solución al problema del transporte:

Comentario sobre los resultados obtenidos:
Solucion:
X=4, y=9, f(min)=1.52
Comentarios sobre los resultados obtenidos computacionalmente:
 ➔ Metodo de la interpolación de newton:

Podemos probar por ejemplo la interpolación lineal para el valor 1.5, que resulta ser

Efectivamente, al ser una recta, podemos ver que este valor es

igual a el punto medio entre ambos (más el punto inicial,
 ➔ Minimos cuadrados y regresión lineal:
1) Regresión lineal y medidas estadísticas: aquí hay 2 projectos netbeans
distintos de minimización por chi-cuadrado: a recta o a curva.
Experimentalmente, cuando tenemos una distribución de datos de variable continua (no entramos a
binomiales o de variables discretas si o no o de n estados), a lo que se intenta ajustar, o se intenta estudiar,
es a ver si es una distribución normal o de gaus. Si falla, o la distribución no es normal, se ajusta a una de
polinomio caracteristico = regresión lineal o sofisticada. La más básica es la recta lineal (primer metodo) y
si no a polinomio sofisticado.
El método de la regresión lineal, es el que nosotros conocemos como xicuadrado. También los hay para
funciones o p(x) mas complejos, cuadráticas, etc….. exponenciales y log se aproximan a lineales.
medidas estadísticas:

a) La media estadística:

b) Medidas de dispersión o desviación media.

Se denomina desviación, a la diferencia entre un valor y la media aritmética de la serie

estadística, di=xi-<x>. La desviación media es la media aritmética de los valores absolutos de
todas las desviaciones. Su fórmula es

La desviación cuadrática media es la raíz cuadrada de la varianza, es decir, de la media

aritmética de los cuadrados de las desviaciones respecto a la media.

Lo que vamos a hacer es pasar nuestras distribuciones (yi,xi) inicialmente a estudiar si la funcion es
gausiana o normal, para eso se debe cumplir que:
Es decir, y(x)=(1/(2*Math(pi)*Math.Sqrt(desv.cuadraticamedia)))*Math(Exp(-(x-media)* (x-
media)/(2*desv.cuadraticamedia)) -- ya aprenderemos a usar la clase Math ostia.

esta es la funcion normal para un set de datos

Mi programa estadística_gausiana, me da, mu=media y desv.cuadratica media.
Teorema: Simplemente con que se demuestre que

Esta es la condición que el ajuste es gausiano.

Se puede hacer también que:
Entonces, simplemente con un algoritmo:
Cuantos valores pertenecen al intervalo <= /sigma/??
For (int i=0; i<=dataset.lenght;i++){
Int n=0;
If (xi<=media -abs(Math.sqrt(cuadraticamedia){
N++;
}
Return n;
}
Igual para n2 y n3 es decir para 2sigma y 3 sigma.
Si n<=dataset.lenght*0.683 -- se cumple

Si n2<= dataset.lenght*0.955
Si n3<= dataset.lenght*0.997
entonces esta distribución es gausiana.

Es decir, toda distribución que cumpla estos contajes, se ajusta a lo de arriba, y con los parámetros que nos
da nuestra clase o proyecto estadística, podemos ajustar y ya la tenemos.
Otras distribuciones chulas en variable continua:
El siguiente paso, es la determinación de la dependencia funcional entre las dos variables x e y que no son
gaussianas. que mejor ajusta a la distribución bidimensional. Se denomina regresión lineal cuando la función
es lineal, es decir, requiere la determinación de dos parámetros: la pendiente y la ordenada en el origen de la
recta de regresión, y=ax+b.

La regresión nos permite además, determinar el grado de dependencia de las series de valores X e Y,
prediciendo el valor y estimado que se obtendría para un valor x que no esté en la distribución.

Vamos a determinar la ecuación de la recta que mejor ajusta a los datos representados en la
figura. Se denomina error ei a la diferencia yi-y, entre el valor observado yi, y el valor
ajustado y= axi+b, tal como se ve en la figura inferior. El criterio de ajuste se toma como aquél
en el que la desviación cuadrática media sea mínima, es decir, debe de ser mínima la suma. Este
método de minimización, se llama chi-cuadrado, y sigue el teorema de la máxima verosimilitud,
o que el mejor ajuste posible de los coeficientes de la curva lineal o cuadrática, y=ax^2+bx+c es
el que se obtiene de la resolución de un sistema de ecuaciones por el método de la inversa,
obtenidos por esta minimización.

El extremos de una función: máximo o mínimo se obtiene cuando las derivadas de s respecto
de a y de b sean nulas. Lo que da lugar a un sistema de dos ecuaciones con dos incógnitas del

que se despeja a y b.
El coeficiente de correlación es otra técnica de estudiar la distribución bidimensional, que nos
indica la intensidad o grado de dependencia entre las variables X e Y. El coeficiente de
correlación r es un número que se obtiene mediante la fórmula.

El numerador es el producto de las desviaciones de los valores X e Y respecto de sus valores

medios. En el denominador tenemos las desviaciones cuadráticas medias de X y de Y.
El coeficiente de correlación puede valer cualquier número comprendido entre -1 y +1.

• Cuando r=1, la correlación lineal es perfecta, directa.

• Cuando r=-1, la correlación lineal es perfecta, inversa

• Cuando r=0, no existe correlación alguna, independencia total de los valores X e Y

Variantes de la regresión lineal

• La función potencial y=c·xa

Se puede trasformar en

Si usamos las nuevas variables X=log x e Y=log y, obtenemos la relación lineal

Y=aX+b.

Donde b=log c
 Método de los mínimos cuadrados. Polinomio aproximador

Supongamos que hemos medido un conjunto de pares de datos (xi, yi) en una experiencia, por
ejemplo, la posición de un móvil en ciertos instantes de tiempo.

Queremos obtener una función y=f(x) que se ajuste lo mejor posible a los valores
experimentales. Se pueden ensayar muchas funciones, rectas, polinomios, funciones potenciales
o logarítmicas.

Una vez establecido la función a ajustar se determinan sus parámetros, en el caso de un

polinomio, serán los coeficientes del polinomio de modo que los datos experimentales se
desvíen lo menos posible de la fórmula empírica.

La función más sencilla es la función lineal y=ax+b que hemos tratado en la página anterior. El
procedimiento de ajustar los datos experimentales a una línea recta se denomina regresión lineal

Polinomio aproximador

Queremos aproximar un polinomio de grado n, a un conjunto de m pares de datos (xi, yi) de

modo que n m.

Sea el polinomio

P(x)=a0+a1x+a2x2+...anxn

Se calcula la cantidad

Para obtener los valores de los coeficientes del polinomio aproximador se tienen que determinar
los valores de los coeficientes a0, a1, a2, ...an de forma que la cantidad S tome un valor mínimo.

hagamos las derivadas parciales de S respecto de a0, a1, a2, ...an iguales a cero. Este método de
minimización se llama el chi-cuadrado.

(1)

Obtenemos un sistema de n+1 ecuaciones con n+1 incógnitas, a0, a1, a2, ...an

Ejemplo:
Supongamos que tenemos 4 pares de datos y que queremos ajustarlos al polinomio de segundo
grado y=a0+a1x+a2x2

Ie. Se obtiene el siguiente sistema de n+1 ecuaciones con n+1 incógnitas

(3)

Si todos los puntos son distintos, el sistema de ecuaciones tiene una solución única.
Calculo matricial:
Suma de matrices:

elemento a
elemento

Propiedades suma matricial:

3) producto de matrices:

Se recuerda que el producto matricial, no cumple la propiedad conmutativa:

 asi pues, A*B!=B*A

2) matrices especiales:
Desarrollo de determinantes superior a 3x3:

1- El valor de un determinante no se altera cuando se cambian las filas por las

columnas.

2- Si se cambian entre sí dos filas el valor del determinante cambia de signo

(análogamente con las columnas).

3- Un determinante que tiene dos filas (o dos columnas) iguales es cero.

4- Multiplicando a todos los elementos de una fila (o columna) por α, el
determinante
queda multiplicado por α.

5- Si en un determinante los elementos de una fila o columna son múltiplos de los

de
otra, el valor del determinante es cero.

6- Un determinante en el cual una fila (o columna) es combinación lineal de otra es

nulo.

7- Si una fila (o columna) tiene todos sus elementos nulos, el determinante es cero.

8- Si a una fila (o columna) se le suma otra multiplicada por un escalar el

determinante
no varía.

9- A⋅ B = A ⋅ B ∀ A, B∈Enxn (K).
Método de gauss-jordan.
A la hora de calcular el valor de un determinante de orden elevado o a la hora de
resolver un sistema de ecuaciones mediante el método de Gauss, por ejemplo, se
realizan sobre las líneas de la matriz o sobre las ecuaciones del sistema una serie de
operaciones que son conocidas con el nombre de operaciones o transformaciones
elementales.

Definición. Se dice que se ha realizado una transformación elemental de filas sobre

una matriz A∈Emxn(K) si se ha realizado una de las operaciones siguientes:
1. Intercambiar la fila i-ésima de A por la fila j-ésima de A: Fi~Fj
2. Reemplazar la fila i-ésima de A por la fila i-ésima de A multiplicada por λ: λFi donde
λ∈K-{0} (es decir, λ es no nulo).
3. Reemplazar la fila i-ésima de A por la fila i-ésima más la fila j-ésima multiplicada por
λ : Fi+λFj donde λ∈K-{0}.
Cuando las operaciones se realizan sobre las columnas de la matriz se dice que se ha
realizado una transformación elemental de columnas sobre A.

El problema central del álgebra lineal es la resolución de sistemas de ecuaciones

simultáneas. El caso más importante, y el más simple, es aquél en el que el número de
incógnitas es igual al número de ecuaciones.
Existen varios métodos para la resolución de dichos sistemas de ecuaciones: el
método de Cramer, el método de eliminación, el de sustitución, etc. De todos ellos el
más engorroso es el método de Cramer, que involucra el cálculo de numerosos
determinantes, y por lo tanto cuantiosas multiplicaciones (por ejemplo, cuando el
número de incógnitas es 5 es necesario hacer 1440 operaciones para resolver el problema. Aquí se va a
profundizar en el método de eliminación, en concreto en el
denominado algoritmo de Eliminación Gaussiana. Antes de abordar la resolución de sistemas es
conveniente repasar algunas definiciones.
Sea el sistema de ecuaciones:

Este sistema es escalonado y se puede resolver de forma simple. La última ecuación

muestra que x3=-1. Sustituyendo este valor en la segunda ecuación se obtiene x2=1.
Finalmente sustituyendo los valores de x2 y x3 en la primera ecuación se obtiene que
x1 = 4.

Ahora se procede a despejar y ya está el método de gauss-jordan.

Discusión de la existencia de soluciones: sea el siguiente ejemplo de sistemas de ecuaciones y su matriz
ampliada. Aplicamos gauss jordan y.

1) Sistema compatible determinado

Este sistema, es aquel que tiene una única solución, es decir, las dos rectas se cortan en un sólo
punto del plano.
2) Sistema Compatible Indeterminado (SCI): posee infinitas soluciones. Son aquellos sistemas que
poseen las mismas soluciones aunque posean distinto número de ecuaciones.

Finalmente, un sistema incompatible, es en el que no existen puntos de corte, es decir, las líneas
viajan en paralelo.
AQUÍ, EN EL TEOREMA DE ROCHÉ, ES DONDE SACAMOS EL RANGO DE LA MATRIZ
AMPLIADA, MATRIZ DE COEFICIENTES, ETC…. Y ASÍ SABEMOS COMO ES EL SISTEMA.

EJ DEL TEOREMA DE ROCHÉ.

Observación: Un problema que se puede presentar durante el proceso de

triangularización es que nos encontremos con un coeficiente nulo como pivote que va
a ser empleado para anular el resto de coeficientes de la columna que se encuentran
por debajo de dicha posición. En la práctica efectuaremos un cambio de filas en la
matriz de tal manera que dicho coeficiente nulo sea sustituido por otro distinto de cero.
Es importante darse cuenta de que siempre deberemos sustituir la fila actual por otra
que se encuentre por debajo de ella para no perder el escalonamiento ya obtenido en
las filas anteriores. ASÍ RESOLVEMOS EL PROBLEMA EN LA TRIANGULARIZACION DE GAUS
JORDAN.

Ej aplicación teorema de Rouché-frobenius.

1. El sistema Ax=b es compatible si, y solo si, rango(A) = rango(A|b)

2. El sistema Ax=b es compatible determinado si, y solo si, rango(A) =
rango(A|b)= n.
3. El sistema Ax=b es compatible indeterminado si, y solo si, rango(A) =
rango(A|b) <n.
4. El sistema Ax=b es incompatible indeterminado si, y solo si, rango(A) ¡=
rango(A|b)

Ejemplo aplicación teorema de roché:

Ejemplo 2
La matriz ampliada del sistema es

Mediante operaciones elementales fila, obtenemos que la matriz forma escalonada

reducida (FER) equivalente a la matriz anterior es

De la forma de la matriz deducimos que los rangos de las matrices ampliada y

coeficientes coinciden y es 2, aunque es menor que el numero de incognitas:

Por el teorema de Rouche-Frobenius, como los rangos coinciden pero son menores
que el numero de incognitas, el sistema es compatible indeterminado.

De la propia FER(A|b)FER(A|b) obtenemos el conjunto de soluciones del sistema:

Es decir,

Ejemplo del cálculo del rango de una matriz por determinantes

1 Dada la matriz, calcular su rango, rango.

Solución:

De acuerdo a los pasos anteriores podemos realizar lo siguiente.

1 Suprimimos la tercera columna porque es combinación lineal de las dos primeras:

.

2 Comprobamos si tiene rango mayor o igual que , para ello se tiene que cumplir que al menos un
elemento de la matriz no sea cero y por tanto su determinante no será nulo.

3 Tendrá rango mayor o igual que si existe alguna submatriz cuadrada de orden , tal que su
determinante no sea nulo.

4 Tendrá rango mayor o igual que si existe alguna submatriz cuadrada de orden , tal que su
determinante no sea nulo.

Como todos los determinantes de las submatrices son nulos, tienen rango menor que , por tanto rango=2.
Método de cramer:

Métodos del algebra no lineal:

El algebra matricial y lineal, es un subconjunto muy pequeño dentro del algebra. Pueden darse también
ecuaciones cuadráticas, inversas (1/x, o x-1, x-2, logx, ex, etc….. )como miembros que acompañan a la
matriz de coeficientes, al final, todo quedará en manos de 3 metodos de resolución: método de sustitución,
de reducción y de cambio de variable.

CASO 1: Si una de las ecuaciones es lineal y la otra no lineal:

En este caso utilizaremos siempre el método de sustitución:

Como podemos observar, en este caso la segunda ecuación es una ecuación lineal,
por tanto seguiremos los pasos que vimos en el método de sustitución:
1º. Despejamos una de las incógnitas en la ecuación lineal (ahora no podemos elegir
la que queramos).
2ªecuación: y = 7- x
2º. Sustituimos su valor en la primera ecuación:

3º. Obtenemos una ecuación de segundo grado en una de las incógnitas (en este caso
en x), la desarrollamos y resolvemos utilizando la fórmula conocida:

4º. Por último, como hemos obtenido dos valores de x, sustituimos en la ecuación que
obtuvimos en el primer paso, obteniendo también dos valores de y:
Si x=3, y = 7-3=4
Si x=4, y = 7-3=4

5º. Las soluciones del sistema son: (3,4) y (4,3).

CASO 2: Si ambas ecuaciones son no lineales y ambas incógnitas son de

segundo grado o en ambas ecuaciones la incógnita de segundo grado es la
misma:
En este caso podemos resolver el sistema utilizando el método de reducción, aunque
la ecuación que nos quede tras eliminar una de las incógnitas será una ecuación se
segundo grado:
1º. Para poder eliminar una de las incógnitas (la x, por ejemplo) multiplicamos la
primera ecuación por 2, y la segunda ecuación por -3.

2º. Resolvemos la ecuación que es una ecuación de segundo grado incompleta que
nos da dos soluciones, que luego sustituiríamos en una de las ecuaciones para halla
los valores de x.

3º. Como las raíces nos salen negativas, el sistema no tiene solución.

CASO 3: Ambas son ecuaciones no lineales, pero no de segundo grado, sino

utilizando alguna función, ya sean logaritmos, exponenciales o la función
inversa.
En este caso, resolveremos el sistema utilizando un método nuevo: el cambio de
variable. Gracias a este método obtenemos un sistema más fácil de manejar,
reduciéndose a uno de los casos anteriores:

1º. Realizamos el cambio de variable apropiado:

u=1/x, v=1/y.
2º. Escribimos el sistema en función de u y v:

3º. Como podemos observar, es un sistema del tipo que hemos mencionado en el caso
1, luego lo resolvemos por el método de sustitución. Por el que obtenemos los
siguientes valores:
Si v = 2, u = 3,
Si v = -3, u = -2.
4º. Por último tenemos que deshacer el cambio: x=1/u, y=1/v. Por tanto las soluciones
que obtenemos son: (1/3, 1/2) y (-1/2, -1/3)

5) aplicación de todo esto al calculo numérico: ¿Qué necesitamos realmente?

Pues 1) resolución de matrices de algebra lineal, pues al ser un minúsculo

subconjunto del algebra, no tiene caso abordarlos todos.
2) multiplicación de matrices (por el tema de las rotaciones) esto si, lo único,
multiplicarlo por matrices de senos y cosenos.
3) obtención determinante y ¿matriz transpuesta? No. Bonitos ejercicios de
comprobación de propiedades, pero eso no sirve para nada. Para obtener matrices
inversas.
4- diagonalización?? Diagonalizar matrices, solo sirve para cuando queremos hacer
potencias de matrices una matriz diagonalizada desde la original, es una matriz
semejante basada en autovalores y vectores propios, muy sencillos de calcular,

◼ Nuestros algoritmos numéricos en javafx: (java) se basa en la obtención de la

matriz inversa, es decir, obtiene determinante y traspuesta apartir de la matriz
original,y de ahí resuelve. También involucra el producto matricial.

Si no existe matriz inversa: es porque el sistema es incompatible!!!! Es decir, no

tiene solución, y nuestro programa nos dará una excepción de java.

El algoritmo en que se basa nuestra resolución de sistemas de ecuaciones, es el de

la matriz inversa:

Supongamos que tenemos un sistema de nn ecuaciones lineales con nn incógnitas.

Podemos representar el sistema de forma matricial como

donde

• La matriz AA es de dimensión nxnnxn y contiene en cada fila los coeficientes

de las incógnitas de cada ecuación.
• La matriz xx es de dimensión nx1nx1 (una columna) y contiene
las nn incógnitas del sistema.
• La matriz bb es de dimensión nx1nx1 y contiene los términos independientes
de las ecuaciones.

Si el sistema tiene una única solución (es compatible determinado), entonces la

matriz AA es regular (determinante distinto de 0) y, por tanto, existe su matriz
inversa A−1.

Entonces, podemos multiplicar toda la ecuación por la inversa de A−1A−1:

Es decir, si la matriz AA es regular, entonces la matriz columna resultante del

producto matricial A−1⋅bA−1·b contiene la solución del sistema Ax=bAx=b.
 Ejemplo: Sistema de 3 ecuaciones con 3 incógnitas (3x3)

Ver solución

La matriz de coeficientes del sistema es

Es una matriz regular porque su determinante es 14. Su matriz inversa es

La matriz de términos independientes del sistema es

Calculamos la solución del sistema multiplicando las matrices A−1A−1 y bb:

Por tanto, la solución del sistema es

aaa
MATRICES DE ROTACIÓN 3D Y TEOREMAS DE EULER Y RODRIGUES.

Como podemos en en el pdf JAVAFX3D.pdf de javafx, mediante una simple GUI, que mediante scroll bar, mueva un
angulo tecta, y un eje, que puede ser (1,1,1)

// crear un cubo 3D, anchura, altura y profundidad

Box box = new Box(300, 300, 300);
box.setRotate(45);
box.setRotationAxis(new Point3D(1, 1, 0));
box.setMaterial(mat);
esto es equivalente al uso del generador de Rodrigues:
Este generador, puede generar cada una de las rotaciones en los 3 ejes, o entorno a un eje 3d.
No Obstante, NO SE PUEDE MEDIANTE UNA ÚNICA ROTACIÓN CON 1 EJE 3D Y UN ÚNICO ANGULO DE
EULER EN SENTIDO ANTIHORARIO POR NATURALEZA, SEGÚN LA LEY DE LA MANO DERECHA, GENERAR
O DESCRIBIR LA EVOLUCIÓN 3D DE UNA ROTACIÓN.
PARA ESO NECESITAMOS EL GRUPO DE LAS ROTACIONES.
SE DEFINE, PARA TODO CUERPO, QUE PRESENTA UN CM, 3 ANGULOS DE EULER: ALPHA, BETA, GAMMA.

ROLL, EL DE LA DIMENSIÓN MAS LARGA COLA CABEZA, PITCH, EL QUE ATRAVIESA DE ALA A ALA, Y LUEGO EL YAW EL
OTRO.
(X2 (X1
Y2 = Rxyz(abc Euler angulos) * Y1
Z2) Z1)

es decir, un punto (x0,y0,z10)=X(0) (3) perteneciente a un solido, tras rotarlo Alpha según x primero, beta
según y luego y gamma según z, es el punto (x2,y2,z2)== X(1) (3) . Se comprueba que la aplicación de n giros,
independientemente del eje que sea, se traduce en un nuevo producto matricial con su angulo de Euler.
( 1 0 0 )
Ejemplo: Rx(a=30) = ( 0 (sqr3)/2 -0.5 )
( 0 0.5 (sqr3)/2 )
Es decir: X (6)(3) (posición de un punto del solido x,y,z tras 6 giros)=Rz2*Rx3*Ry1*Rz1*Rx2*Rx1
(3) primero conforme alpha1 ejex, luego conforme alpha2 otra vez ejex, luego
Es decir, hemos girado X (0)
conforme gamma1 eje z, luego beta1 eje y , luego alfa eje x y luego de nuevo gamma 2 eje z.
Si primero hago una rotación antihoraria de 30 grados en el ejex y luego hago otra de otros 30 en el eje x,
el producto de las 2 matrices = = en resultado a aplicar una única matriz de rotación de 60 grados
antihorarios en el eje x. pero es el producto de las 2 matrices, no la suma. Y así para los 3 angulos de Euler.

Es fácil ver que

(1
Rx(a=30 grados) * 0 es decir RX(a)* eje ux hace roll en dicho eje y no rotación, y solo sobre los otros
0)

2 ejes hace la rotación identidad (subcolumnas de arriba). Igualmente sucede de aplicar Ry subre
uy=(0,1,0) columna.

Rotaciones inversas de Euler.

Es dada una matriz numérica de Euler, encontrar que grados a girado.
Se demuestra que Alpha y gamma (solo faltaría beta) donde cB= coseno de beta
R21 y R11 son elementos de la matriz conocidos.

Finalmente CB o coseno de beta:

es decir, puede tener 2 posibles sentidos.

Recordamos que siempre es Beta el primer angulo que debemos despejar.

Ejercicio:

Sea la matriz de rotación R que me transforma el eje cartesiano azul (inicial) en el morado (final), es decir, que me lo
rota.

Calcular los angulos de Euler que producen dicho efecto apartir de la martriz de rotación.

La matriz de rotación se calcula, teniendo (x2,y2, z2) y (x1,y1,z1)

Hemos dicho que:

(X2 (X1
Y2 = Rxyz(abc Euler angulos) * Y1
Z2) Z1)
Es decir: Y=AX donde Y y X son vectores, y A una matriz.
2) javaswing con jpanels:
1) Acción de botón: aquí si pulsamos aparece un nuevo jdialog diciendo

el jdialog solo se arrastrara al frame y no se vera nada

2) Jcombobox, jlist: combobox no es ni radiobutton ni checkbox, que te lias.

Al darle a click derecho, propiedades, es donde le damos nombre a los ítems, y ponemos los
que queramos:

Button jbutton2, le damos click derecho, primer evento actionperformed y this.dispose();

Será salir
Con este método de jbutton 1, añadimos en el combobox los componentes que yo ponga
en los JtextField (textform). Si quisiera hacer lo contrario?? Que es lo normal.
jTextField1.addItem(jcombobox1.get)??
veamoslo, añadiendo un tercer botón y una jlist:

Para empezar: el cambio de color, se hace, volcando sobre el JFrame, el Jpanel1, y

cambiando ahí sus propiedades, y click derecho, absolute layout mas comodidad.
Si queremos pasarlo a un jtextfield.

Esta es la única manera.

Checkbox y mensajes de aviso o tooltips == JoptionPane. Ya tengo un elemento menos que
prevolcar y simplemente, lo llamaría así.
Hay un bug: si seleccionamos los 3 checkbox, y le damos al botón de ver en jTextlabel:
Solo aparece el último. Una manera de subsanar eso, es definir el comportamiento:

If(JCheckBox1.isSelected()==true && JCheckBox2.isSelected()==true){

JOptionPane.showMessageDialog(“has seleccionado mas de 1”)
}
If(JCheckBox1.isSelected()==true && JCheckBox3.isSelected()==true){
JOptionPane.showMessageDialog(“has seleccionado mas de 1”)
} idem
Y si los 3 idem.
Jradiobutton:

Jtextarea:
Slider:
Y con esto ya:
definimos una variable de tipo int global y:

Fíjate que hemos quitado el evento de botón de capturar. Ahora el status bar:
Menúbar:

Aquí hay que arrastrar los componentes de menú item a la pestaña introducida.
Ahora, igual que cualquiercomponente, se definen sus propiedades y sus eventos.
Dispose(), sabe.
Java Swing escrito: el tutorial.
Crear un Jframe (o pagina.)

Jlabels:

Genera siguiente imagen. Con un dude.png añadido a src

3- jpanels:

4- buttons:
Un poco mas completo seria: // pongo el label que cargara el png primero, como false, luego creo el botón, y en el
método pulsar, me enciende la imagen en el label o aparece el label. Ojo a label.setBounds, que es quien me da la
posición x e y de la esquina izquierda superior, y luego ya el tamaño.
Veamos las posiciones.

Efectivamente, primero se determinan posición x e y y luego ancho y alto.

// confirmamos pues que la referencia es la la esquina inferior izquiera. Fíjate el botón

(100,100) y lable (150,250)

Joption pane:
Para coger una de los 2 estados true or false en una variable o un string:

En este inputdialog lo introduciras, y será capturado en una variable string

Esto es solo el de abajo, el showinputdialog

Jlabel submit.

Fíjate como el orden en que se van mencionando los componentes se van introduciendo.

--- combobox:
Aquí podemos decirlo que en lugar que lo saque por consola:

Label1.setText(comboboxBox.getSelectedItem());

Ojo al
Slider demo:
Radiobutton:
El evento del radiobutton seria:

Checkbox:

** No existe hibridación o paso del javaSwing awt o escrito, al de ventanas o jpanels que
describimos a continuación (como tampoco lo existe a javafx o scenebuilder)

--- menuBar:
Ahora lo mismo para las otras pestañas, y los eventos.

El evento exit es funcional. Load debería lanzar filechooser, y save se implementa a golpe
de atajo de teclado. El a programado nemotécnicos a atajos de teclado, pero no, lo esta
haciendo para que el comportamiento sea real.
Como poner el file chooser en Swing.
configuracion mariadb acceso clientes remotos

como siempre, la comunicación aplicación crud javafx (local)—servidor(remoto) se basa en una

configuración preliminar del servidor o host de la base de datos mariadb a la que acceder.

Paso 1: Permitir a MySQL escuchar tráfico externo

A fin de habilitar un acceso remoto a MySQL es necesario que se habilite la escucha de direcciones
IP externas.

Para activar esto, abre tu archivo mysqld.cnf:

sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf o

sudo nano /etc/mysql/mariadb.conf.d/50server.conf
Allr debes ubicar la lrnea que empieza con la directiva bind-address.

Por defecto, el valor asignado es 127.0.0.1.Esto significa que el servidor permitirá únicamente
conexiones locales. tienes que cambiar esta directiva a 0.0.0.0:

lc-messages-dir = /usr/share/mysql
skip-external-locking
#
# Instead of skip-networking the default is now to listen only on
# localhost which is more compatible and is not less secure.
bind-address = 0.0.0.0

Y luego:

sudo systemctl restart mysql

este mismo archive en Windows 10 (y 11) esta en:

C:/Windows/System32/drivers/etc

Ya entra a mariadb y raspberry por pep/beberagu y jose 9876 mariadb has quitado muchas
medidas de seguridad para acceso a ddbb del servidor y la ddbb general maríadb instalada
para el acceso remoto por javafx.
2) hemos de crear al usuario jose@192.168.1.250--> en nuestra base de datos mysql para que
este pueda acceder. Esto es importante.
No es lo mismo el usuario jose@localhost que jose@192.168.1.250 que es el que va a entrar en
el servidor 192.168.1.234 pero desde el 192.168.1.250. hasta que no hagas eso, no podras entrar
desde tu aplicación java.
Además, si sustituyes esto por jose@% estas creando un usuario que tiene acceso desde
cualquier ip remota.

Recordamos comandos de creación de usuarios, bases de datos, tablas, etc….esto

es un resumen de los comandos de uso del lenguaje mysql.
mysql -u root -p // para acceder como root con password, cambiar por usuario.
Hemos creado o existe user jose@localhost B3antior y josep@192.168.1.250 B3antior con todos
los privilegios. Evita entrar con root.
Para ver todos los usuarios disponibles en la base de datos, hay que poner:
|Mariadb> select User from mysql.user; así tal cual. Ojo a los ; tras las instrucciones.
También se pueden definir usuarios josep@192.168.1.% para rangos enteros de subred.
create database productos2;
show databases;
use productos2 ------------------------ selecciono la base de datos productos.
Para salir: quit; #o exit;
Para ver las tablas de la ddbb productos: show tables; tras use productos.

• DROP DATABASE [base-de-datos] // esto es para borrar la base de datos.

Cambiar contraseña usuario passwor: hemos de entrar por el usuario root.

UPDATE mysql.user SET Password=PASSWORD(‘NuevaContraseña’) WHERE USER=’nombreUsuario’ AND

Host=”NombreHost”; // esto se aplica al usuario root como medida seguridad.
FLUSH PRIVILEGES;

Recordamos que en mariadb de mi ah-w6-tv, usuario es root, password: 9876

Ahora vamos a crear al usuario Josep que accede desde 192.168.1.250

CREATE USER 'josep'@'192.168.1.234' IDENTIFIED BY 'B3antior'; // con su clave y todo.

CREATE USER 'juanf'@'%' IDENTIFIED BY 'B4antior'; // creamos un usuario que tiene acceso desde
cualquier ip

****** vamos a darles permisos a estos usuarios:

GRANT ALL PRIVILEGES ON *.* TO 'josep'@'192.168.1.250' WITH GRANT OPTION;

// despues siempre has de poner: FLUSH PRIVILEGES;

// sino los datos no se guardan.
Y systemctl restart mariadb
// también pueden ser selectivos los permisos.
 • Para ver la estructura de una base de datos: DESCRIBE [tabla]
• Para ver todos los índices de una tabla: SHOW INDEX FROM [tabla]

CREATE TABLE libros(

id int AUTO_INCREMENT PRIMARY KEY,
titulo VARCHAR(35) UNIQUE,
autor varchar(35),
ano int ,
paginas int ,
);

Ahora aqui podriamos empezar a explicar un poco sobre la estructura del lenguaje sql, consultas y
queries y tal, pero no perdamos el hilo que lo que estamos explicando es la configuración del
servidor para permitir acceso externo.
3) comprobación que el Puerto de escucha de mysql/mariadb es el 3306 y abrir el cortafuegos
para así permitirlo.

netstat -tap | grep -i mysql

si me da otra cosa como:

root@mariadbserver:/etc/mysql/mariadb.conf.d# netstat -tap | grep -i

mysql tcp 0 0 0.0.0.0:mysql 0.0.0.0:* LISTEN 33749/mysqld
hemos de cambiarlo, al 3306:

esto se hace en el archivo arriba explicado: /etc/mysql/mariadb.conf/50server.conf donde habrá

un apartado para configurar el puerto.
En el caso de la imagen superior, todo lo que tenemos que hacer es desmarcarlo.
Ahora hemos de autorizar al firewall para poder acceder:

sudo ufw allow 3306/tcp

configurando Firewall #

El último paso es configurar su firewall para permitir el tráfico en el

puerto 3306 (Puerto predeterminado de MySQL) desde las máquinas remotas.

Iptables #

Si está utilizando iptables como su firewall, el siguiente comando permitirá el acceso

desde cualquier dirección IP en Internet al puerto MySQL. Esto es muy i nseguro.

sudo iptables -A INPUT -p tcp --destination-port 3306 -j ACCEPT

Permitir el acceso desde una dirección IP específica:

sudo iptables -A INPUT -s 10.8.0.5 -p tcp --destination-port 3306 -j ACCEPT

UFW #

UFW es la herramienta de firewall predeterminada en Ubuntu. Para permitir el acceso

desde cualquier dirección IP en Internet (muy inseguro), ejecute:
sudo ufw allow 3306/tcp

Permitir el acceso desde una dirección IP específica:

sudo ufw allow from 192.168.1.250 to any port 3306

4) comprobación que mi servidor (tvbox-raspberry) es accessible desde otra maquina remota.

Se puede hacer con mysqlworkbench o con alguna aplicación móvil instalada en bluestacks en
nuestra maquina local:

Yo descargue DBCliente
También figura la base de datos con la que queremos hacer conexión. Le damos al botón testea
conexión, y me dice desde mi red local ip/ethernet o wifi si puedo acceder o no. Desde el móvil,
desde luego, no voy a poder acceder, pq no tiene ip 192.168.1.250, entonces para el usuario
arriba definido, no puedo entrar seguro, pero al instalarla en el pc, sin problema. Asi veo si hay
conexión con servidor mysql, veo las tablas de dicha database, las queries, aquí puedo cambiar
parámetros de la conexión para enlace hasta nueva database, etc…

◼ AHORA SI: LENGUAJE SQL: maríadb usa ; sino la introduces en un renglón, luego
puedes.

Usuarios: privilegios:
Existen diferentes tipos de privilegios que podemos asignar a los usuarios de un SGBD con
MySQL/MariaDB. A continuación se detallan todos ellos y que hace cada uno de ellos:

• ALL PRIVILEGES: Como vimos antes, esto le otorgaría a un usuario de MySQL acceso completo a una
base de datos designada (o si no se selecciona ninguna base de datos, acceso global a todo el
sistema)
• CREATE: Permite crear nuevas tablas o bases de datos
• DROP: Permite eliminar tablas o bases de datos
• DELETE: Permite eliminar filas de las tablas
• INSERT: Permite insertar filas en las tablas
• SELECT: Les permite usar el comando SELECT para leer las bases de datos
• UPDATE: Permite actualizar las filas de las tablas
• GRANT OPTION: Permite otorgar o eliminar privilegios de otros usuarios

Si queremos conceder todos los privilegios al usuario "antonio" y en la base de datos "test",
ejecutaremos:

MariaDB [(none)]> GRANT ALL PRIVILEGES ON test.* TO 'antonio'@'localhost';

Query OK, 0 rows affected (0.017 sec)

Volvemos a mostrar la lista de privilegios del usuario y vemos que ahora aparecen nuevos
privilegios sobre la base de datos "test":

MariaDB [(none)]> SHOW GRANTS FOR 'antonio'@'localhost';

+
+
| Grants for antonio@localhost

+
+
| GRANT USAGE ON *.* TO `antonio`@`localhost` IDENTIFIED BY PASSWORD '*E31BAC86033F438E42D17F5D
F3815C36C657D253' |
| GRANT ALL PRIVILEGES ON `test`.* TO `antonio`@`localhost`

+
+
2 rows in set (0.001 sec)

Si queremos conceder permisos de insertar, actualizar, borrar y listar al usuario "antonio" en la base de
datos "gestco", ejecutaremos:
MariaDB [(none)]> GRANT INSERT,UPDATE,DELETE,SELECT ON gestco.* TO 'antonio'@'localhost';
Query OK, 0 rows affected (0.029 sec)

ALTER TABLE Customers ADD Email varchar(255); //añadimos columna email tipo
barachar a la tabla customers.
ALTER TABLE Customers DROP COLUMN Email;

Queries: este lenguaje de consulta es comun para todos los motores de búsqueda: mysql, Oracle,
mariadb, postgre, sqlmicrosoft.

SELECT Nombre, Apellidos, FROM ddbb.Datos_Clientes;

SELECT columna1 FROM ddbb.nombre_tabla WHERE NOT condición1 AND/OR condición2;
SELECT columna_1FROM nombre_tabla WHERE nombre_columna BETWEEN valor_1 AND valor_2;
SELECT columna1FROM nombre_tabla WHERE columna1 LIKE '%caracteres_a_buscar%';
****************************

UPDATE tabla1 SET columna1 = valor1, columna2 = valor2 WHERE condición;

DELETE FROM tabla1 WHERE condición;
INSERT INTO tabla1 (columna1, columna2) VALUES (valor1, valor2);

SQL NO distinguen entíe mayúsculas y minúsculas: En este tutoíial encontíaíás todos los comandos SQLen
mayúsculas. Algunos lenguajes sql teíminan con ; punto y coma paía finalizaí instíucción. Este es el caso de
maíiadb.

Vamos a añadir una nueva columna que es precios:

ALTER table pproductos ADD precio int(10);

INSERT INTO pproductos VALUES ('1','tomate_frito_solis','30');
Ahora la borraremos
SELECT * FROM shop ORDER BY article; --- para ver todo lo que tengo en la tabla por id
MYSQL WORKBENCH:
Campo= columna de una tabla, registro= fila o conjunto de valores de los campos.
Entrar: lo mas fácil del mundo: en el + conexión: ip=192.168.1.250 port: 3307 es mariadb en local, ssl no, root y
contraseña 9876. El wamp encendido para esto.

Test ok, y ok. La hacemos, y nos lleva a la pantalla.

Las exploramos solo con tocar sus pestañas, es decir, atraves de gui. Podemos ver hasta sus columnas, es decir, su
estructura de campos.

Ahora vamos a verlas. Para crear una consulta en mysql workbench, hemos de señalar o subrayar el código a
ejecutar: si están así en azul, y las ejecutamos, obtenemos respuesta. Si están en blanco, haz lo que quieras que no.

Eso sirve para regular el flujo de los scripts que quieres ir ejecutando. Pero existe un atajo de teclado sin seleccionar:

CRTL+BLOQ MAYUS+ENTER
Señalando una línea o script borras lo que deseas, y si el script es erroneo, o si seleccionas los anteriores
verdes que eran validos, también desaparecen del lienzo, y tienes que volver a ejecutarlos. Es un flujo.

Recuerda, select * from table order by id para ver elementos por id.
Botones importantes:

El clear de abajo, es para no ver el historial de scripting acertado o fallido, y el refresh del costado, es para ver los
cambios en el servidor.

Vamos a crear una nueva y darle campos.

Para ejecutar el código, le damos al rallito de arriba.

Creamos 2 tablas mas: la segunda de ellas, directores, la vamos a relacionar con la primera mediante llave foránea.
(relacional.)

Ahora nos faltaría crear la tabla relacional, pues entre película y director hay una relación de muchos a muchos, 1
pelicula puede tener muchos actores, y un actor puede trabajar en muchas películas, entonces vamos a crear una
tabla intermedia, llamada actores películas. A lo que queremos llegar es a este esquema.

Con las tabla ya creada por scripting, tras refresco, vamos a ingeniería reversa, y es donde vemos el
esquema anterior via next, next, selección mi ddbb, next, next, y asi sacamos este esquema.
Otro ejemplo: sea el siguiente diagrama de flujo del modelo relacional de la ddbb.

Queremos una base de datos, relacional en que un cliente compra productos, que son suministrados por un
proveedor. Obvio el elemento común es el producto. Hay 2 acciones, una que es entrada en el almacen o suministro
por nuestro proveedor, y otro que es la salida hacia el cliente.

Hacemos la tabla cliente:

Y el proveedor
Los pondremos todos como not null o NN
Si nos fijamos en el esquema, se nos dice como es la relación:

Entre clientes y productos: muchos clientes pueden comprar muchos productos o mucho productos
pueden pertenecer a muchos clientes. Sin embargo, un producto, id único, es suministrado por un único
proveedor.
Venimos a la sección de aquí abajo, y cogemos a los vinculadores:

Le pincho al vinculador, le pincho a una tabla, y a la otra y mágicamente, se genera la tabla intermedia.
La cual vamos a llamar compras. Veamos sus claves foráneas.

Ósea, que están ok sus claves foráneas.

Ahora:

Que lo creamos dándole:

Donde vemos que se me genera un nuevo campo proveedor nif.

Fíjate que existen 2 tipos de líneas relacionales: a trazos, y continuas.
Ahora, que ya esta todo creado, debemos exportar el modelo a script sql:
File//export//forward Engineer sql script y aparece otro menu: donde señalamos los 2
primeros. Le doy nombre myscript.ventas1. y le damos a los 3 puntitos derecha para darle
ruta de guardado, en este caso, se grabara en mis documentos.

Luego siguiente, y Volver al entorno de scripts: para cogerlo.

Pincho en la casita:

Voy a mi conexión. Fíjate que ahora entiendo el entorno de mysql: tengo

arriba entorno de scripts, y debajo graficos o modelos.
Le doy a mi conexión de wamplocal. Y tacatá, error en escritura. No se me
permite exportar el script. Sin embargo: hago copiar en el block de notas la
pantalla 3 de previsualización del script, justo la que me da el error. Y pegar
en la nueva ddbb. El error se corrige de igual modo dando nombre al script y
ruta en mis documentos. Luego

Importar sql y listo.

Y ya me importa el script completo. De las 2 formas podemos hacerlo. Idem resultado.

Ahora ya, le doy al rayito de arriba, y me ejecuta todo es script, y me crea la ddbb
relacional. Vemos que esta todo ok.
 arriba señalado el refresco.
Bien, vamos a ver como exportar e importar ddbb a servidores:

Muy importante exportar estructura y datos.

Vale, chupado exportar ddbb datos + estructura. Volcado sql la vamos a llamar.
Mas dificil es importar. Si tenemos workbench en el servidor remoto, importar, y chupado.
Si tenemos phpmyadmin, abrir nueva ddbb, importar sql, y chupado.
Lo malo es un servidor arm que no podamos tener ninguno de los 2.
Vale, vamos a instalar mysql en arm64 servidor debian 10:
~$ wget https://files.phpmyadmin.net/phpMyAdmin/5.1.1/phpMyAdmin-5.1.1-all-
languages.tar.xz

La web por defecto de Apache reside en /var/www/html/, por lo que esta será la ruta
donde descomprimiremos el paquete:

~$ sudo tar xf phpMyAdmin-5.1.1-all-languages.tar.xz -C /var/www/html/

La carpeta que se crea tiene un nombre muy largo, lo mejor es crear un enlace simbólico
más corto, o directamente renombrar la carpeta:
~$ sudo mv /var/www/html/phpMyAdmin-5.1.1-all-languages/ /var/www/html/phpmyadmin
Concederemos la propiedad de este directorio al usuario con que corre el servidor web,
para que pueda escribir en él:

~$ sudo chown www-data /var/www/html/phpmyadmin/

Preparación de la base de datos de phpMyAdmin

Ciertas características de phpMyAdmin requieren que la aplicación disponga de su propia
base de datos.

Usaremos el cliente de consola mysql para crear el usuario que manejará esta base de
datos:

~$ mysql -u root -p
Para MariaDB o MySQL 5, creamos el usuario como de costumbre:

> create user pma@localhost identified by 'XXXXXXXX';

Para MySQL 8 especificamos el plugin de autenticación adecuado:

> create user pma@localhost identified with mysql_native_password by 'XXXXXXXX';

Concedemos permisos a este usuario sobre la base de datos de phpMyAdmin:

> grant all privileges on phpmyadmin.* to pma@localhost;

Y ya podemos cerrar el cliente mysql:

> exit

Como los pasos 2 y 3 ya los teníamos antes hechos, y la tabla usuarios existe, vamos a usar el
usuario.

josep@192.168.1.250 B3antior que es el que tiene permisos de acceso a tabla para hacer esto.

También tenemos el usuario: user jose@localhost B3antior que es con el que

parece acerse la conexión remota atraves de mobaxterm ¡!!! Curioso.

grant all privileges on phpmyadmin.* to jose@localhost; +exit

// Tambien hic el del usuario Josep@192.168.1.250 y jamás pude entrar por mobaxterm.
Para inicializar la base de datos necesaria utilizaremos desde consola un archivo SQL
previsto al efecto:

~$ cat /var/www/html/phpmyadmin/sql/volcado.sql | mysql -u jose-p

Se pedirá la contraseña que has especificado antes para el usuario jose@localhost que es
B3antior.

Este archivo volcado, es el sql generado en myworkbench para exportación de la estructura y

los datos, pero para que funcione, hemos de hacer una pequeña modificación, hemos de
agregar en la linea1:

Y arriba en

~$ mysql -u root -p
CREATE DATABASE compra; + exit.

Es decir, he de crear la ddbb en mysql, y he de indicar en la tabla de exportación que se use.

Hmmmmm el nombre debe ser una palabra sin guiones. No me acepto compra-venta.

Y ya esta, entramos de nuevo en workbench local 192.168.1.250 y

Las ddbb de mi servidor.

Bien, ahora queremos dar respuesta a la siguiente pregunta: ¿Qué es ese tipo de conector línea
continua o discontinua de tablas?¿cuando hay que generar tablas intermedias y cuando no?--- es
decir teoría de mysql.
Concepto de clave foránea: La clave foránea identifica una columna o grupo de columnas en una tabla
(tabla hija o referendo) que se refiere a una columna o grupo de columnas en otra tabla (tabla maestra o
referenciada). Las columnas en la tabla referendo deben ser la clave primaria u otra clave candidata en la
tabla referenciada.

La discontinua es solo si la clave foranea no es principal en la otra, por ejemplo, con estas tablas.

USUARIOS
id INT PK
nombre VARCHAR(20)
localidad INT FK

LOCALIDADES
id INT PK
nombre

Localidad VARCHAR(10)NN

usuarios.localidad y localidades.id estarian unidas por una discontinua, porque localidad es FK a id.

Bien, veamoslo en nuestro ejemplo superior.

Dni, código y nif, son las pk. (primary key)

Se genera la table intermedia compra muchos a muchos relacional que relaciona 2 pk, por tanto, ok,
pero la tabla suministra es de 1 a muchos, y liga

Si vemos los 2 ejemplos estudiados de bbdd creadas:

Vemos que siempre es igual:

Tablas de muchos a muchos, necesitamos una tabla intermedia, trazo continuo que liga sus claves
floráneas o rosas con las pk de ambas tablas que conecta. ,

Si es de 1 a muchos, línea discontinua, y no existe tabla intermedia, existe el teorema de la

compresión, que consiste en la sustitución de esa tabla intermedia, por un nuevo campo
en la tabla intermedia: producto y directores.
Vamos a explicar este concepto. Creo 2 tablas y les doy contenido:

Es una tabla de productos informáticos, mouse, teclados, etc…..

Bien, las pk de las 2 tablas son las 2 primeras columnas.
Se demuestra que realmente, yo puedo comprimir dichas 2 tablas en 1 si codTiptproducto
de la tabla 2 la vemos en lugar de pk de una segunda tabla como la fk de la tabla de abajo.

Pk primera columa, fk la cuarta columna. Fk es la columna que referencia otra tabla.esa es

su definición.

Crud: créate, read,update, delete,

CREATE DATABASE databasename;
CREATE TABLE MITABLA;

Relleno de tablas: insert

INSERT INTO table_name (column1, column2, column3, ...)
VALUES (value1, value2, value3, ...); para rellenar las tablas, para nuestro
ejemplos de workbench, si queremos añadir datos a las tabla productos:

Use compra-venta // llamada a la ddbb que contiene tabla PRODUCTOS.

INSERT INTO PRODUCTOS (CodProductos,descripción,precio,tipoProdcutos)
VALUES (7824,Mouse violeta, 42, 1) ; // punto y coma fin de instrucción.

Inspeccion tablas: queries o read,

Use compra-venta
SELECT *(ie, todas las columnas) FROM PRODUCTOS ORDER BY ID;

Orden drop y update, altertable y operaciones entre columnas,

como por ejemplo multiplicarse si son de tipo int o float, y
concatenarse si son de tipo string.
DROP PRODUCTOS IF EXISTS; …. Borrar la table productos si existe.

Or Drop productos simplemente. Para borrar una columna.

To delete a column in a table, use the following syntax (notice that some database
systems don't allow deleting a column):

ALTER TABLE table_name

DROP COLUMN column_name;The following SQL deletes the "Email" column from the
"Customers" table:
Example
ALTER TABLE Customers
DROP COLUMN Email;

The SQL UPDATE Statement

The UPDATE statement is used to modify the existing records in a table.

UPDATE Syntax
UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE condition;

Note: Be careful when updating records in a table! Notice the WHERE clause in
the UPDATE statement. The WHERE clause specifies which record(s) that should be updated. If
you omit the WHERE clause, all records in the table will be updated!

The SQL DELETE Statement

The DELETE statement is used to delete existing records in a table.

DELETE Syntax
DELETE FROM table_name WHERE condition;

Note: Be careful when deleting records in a table! Notice the WHERE clause in
the DELETE statement. The WHERE clause specifies which record(s) should be deleted. If you
omit the WHERE clause, all records in the table will be deleted!

ALTER TABLE - ADD Column (Tambien Servia para borrar columna, recuerda)

To add a column in a table, use the following syntax:

ALTER TABLE table_name

ADD column_name datatype;

The following SQL adds an "Email" column to the "Customers" table:

Example
ALTER TABLE Customers
ADD Email varchar(255);

COUNT() function returns the number of rows that matches a specified criterion.

COUNT() Syntax
SELECT COUNT(column_name)
FROM table_name
WHERE condition;

The AVG() function returns the average value of a numeric column.

AVG() Syntax
SELECT AVG(column_name)
FROM table_name
WHERE condition;

The SUM() function returns the total sum of a numeric column.

SUM() Syntax
SELECT SUM(column_name)
FROM table_name
WHERE condition;

The MIN() function returns the smallest value of the selected column.

The MAX() function returns the largest value of the selected column.

MIN() Syntax
SELECT MIN(column_name)
FROM table_name
WHERE condition;

MAX() Syntax
SELECT MAX(column_name)
FROM table_name
WHERE condition;

The SQL LIKE Operator

The LIKE operator is used in a WHERE clause to search for a specified pattern in a column.

There are two wildcards often used in conjunction with the LIKE operator:

• The percent sign (%) represents zero, one, or multiple characters

• The underscore sign (_) represents one, single character

Note: MS Access uses an asterisk (*) instead of the percent sign (%), and a question
mark (?) instead of the underscore (_).

The percent sign and the underscore can also be used in combinations!

LIKE Syntax
SELECT column1, column2, ...
FROM table_name
WHERE columnN LIKE pattata;

Tip: You can also combine any number of conditions using AND or OR operators.

Here are some examples showing different LIKE operators with '%' and '_' wildcards:

Operadores:

SELECT precio FROM PRODUCTOS ORDER BY ID +30;

SELECT sum(precio+30) from productos where id=11; este si.
Para el usuario 11, ha sumado el precio + 30. Muy importante darle el where usuario, sino, me
calcula, que es lo que hacia el sum, la suma de toda la columna, y le suma 30.

Sumar 2 columnas para un usuario dado:

SELECT sum(precio+precio2) from productos where id=1;
Donde precio y precio2 son 2 columnas numéricas tipo float pej.
Bueno, y asi para estos operadores.

Ejemplo: SELECT * FROM Products WHERE Price > 30;

// muestranos todos campos id, nombre, precios, etc.. de la tabla productos, donde
el campo precio, es mayor que.
SELECT * FROM Customers WHERE City = "London" AND Country = "UK";

Los de arriba son la forma compuestos a esto y que muestran igualdad true or false.

Vamos a explicar la importancia de la ligadura de tablas.

A este apartado le vamos a llamar tablas ligadas vs bigtable. Vamos a observar estas 2 imágenes de abajo.

Arriba una big table, abajo 2 tablas ligadas que equivalen a una bigtable. Al final, la estructura de tablas
ligadas anterior, equivale a una gran tabla.
Teorema de la equivalencia de las tablas ligadas a una gran tabla le llamaremos a esto.
Sin embargo, es muy desventajoso tener la base de datos como una única gran tabla, y es muy ventajoso
tenerla segmentada en varias tablas por varias razones.

1) A la hora de inserción de datos, no tenemos pej que decir que marco Alcañiz va a hacer un nuevo
curso de tantas horas en una localidad dada, definiendo de nuevo todos los datos de este idDni o
usuario. Es un ahorro considerable de memoria en la ddbb y de tiempo en la inserción de datos.
2) Reduce la probabilidad de reducir errores en la inserción de datos.
3) ¿es ventajoso en las busquedas? Si, pq yo puedo introducir un dni que es campo común, y tener 2
pestañas una que me indique la información relativa a los cursos, si es eso lo que me importa, o la
información personal de este alumno, sin que me salga todo el churro duplicado, información
 personal todo el rato, si lo que me importa son los cursos realizados, y viceversa, si lo que quiero
son los datos de contacto del alumno, ni lo tengo que ver mas veces repetido, ni me tiene que
explicar todos los cursos, si es algo que no me interesa. es decir… hace búsquedas mas selectivas.

Pues eso, búsquedas mas selectivas, ahorro de tiempo en el manejo de inserción y

consultas, ahorro de memoria física, etc… por eso se ligan las tablas y no se
trabajan, en corporaciones que trabajan con miles de datos, con bigtables….. pero
vamos que en el modelo de tablas relacionadas, tenemos que tener en la cabeza
que su equivalente total es el de una gran tabla.
H2 embeded database en programa.

1) Nos descargamos de H2.org database, la versión 1.4 del motor h2, tras extraer y tal, lo colocamos en
proyectos netbeans. Tiene la forma:

Entramos en bin:

Y ahí o lanzamos el script h2.bat que me construya el h2 server embeded o lanzamos el conector/interfaz h2-1.4

Al cual, si le hago 2 clicks, me abre la interfaz:

Así tal como esta, lo que me indica, es que hay una ddbb embebida en C:/Users/juanf llamada test.mv.db

A la que se entra con usuario sa y sin contraseña por defecto. Esta estructura esta embebida en la dirección de
arriba, pero no se llama por navegador, solo por el *.jar.
Bueno, si entramos:

Podemos crear la tabla con los parámetros deseados, que se unirá junto con la tabla users de la derecha.

Una vez hecho esto, vamos a C:/Users/juanf/ test.mv.db

Cogemos este archivo, click derecho botón copia, y pegar en el proyecto netbeans donde vayamos a crear la
ddbb portable o embebida, en este caso, H2 proyect.

Y lo ponemos en el directorio raíz. El h2-1.4 jar no hace falta realmente. Ahora, vamos a nuestro proyecto de
netbeans de DAO. Realmente, todos los proyecto de netbeans de escritura, lectura, actualización, borrado y
filtrado de bases de datos, son iguales. Solo cambia el conector, es decir, el programa java o métodos son
genéricos, y la forma del conector es lo que cambia. Ver que es el mismo programa para mysql que para H2
database. Así pues, cogemos el FXML de MYsql o DAO programa, y hacemos copia y pega en el nuevo proyecto,
make controler, y cogemos el Controlador de dicho fxml y le pegamos el código encima:

Eso significa que tenemos la base de datos, con la tabla de la forma estipulada arriba, en la raíz de nuestro
proyecto netbeans, y pues nada, compilar y funcionar.
 V8
Este ejemplo ilustra la inserción de valores de fecha y hora con desplazamientos de zona horaria
en TIMESTAMP y DATETIMEcolumnas usando diferentes time_zone configuraciones y luego
recuperándolos:

mysql> CREATE TABLE ts (

-> id INTEGER NOT NULL AUTO_INCREMENT PRIMARY KEY,
-> col TIMESTAMP NOT NULL
-> ) AUTO_INCREMENT = 1;

mysql> CREATE TABLE dt (

-> id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
-> col DATETIME NOT NULL
-> ) AUTO_INCREMENT = 1;

mysql> SET @@time_zone = 'SYSTEM';

mysql> INSERT INTO ts (col) VALUES ('2020-01-01 10:10:10'),

-> ('2020-01-01 10:10:10+05:30'), ('2020-01-01 10:10:10-08:00');

mysql> SET @@time_zone = '+00:00';

mysql> INSERT INTO ts (col) VALUES ('2020-01-01 10:10:10'),

-> ('2020-01-01 10:10:10+05:30'), ('2020-01-01 10:10:10-08:00');

mysql> SET @@time_zone = 'SYSTEM';

mysql> INSERT INTO dt (col) VALUES ('2020-01-01 10:10:10'),

-> ('2020-01-01 10:10:10+05:30'), ('2020-01-01 10:10:10-08:00');

mysql> SET @@time_zone = '+00:00';

mysql> INSERT INTO dt (col) VALUES ('2020-01-01 10:10:10'),

-> ('2020-01-01 10:10:10+05:30'), ('2020-01-01 10:10:10-08:00');

mysql> SET @@time_zone = 'SYSTEM';

mysql> SELECT @@system_time_zone;

+--------------------+
| @@system_time_zone |
+--------------------+
| EST |
+--------------------+

mysql> SELECT col, UNIX_TIMESTAMP(col) FROM dt ORDER BY id;

+---------------------+---------------------+
| col | UNIX_TIMESTAMP(col) |
+---------------------+---------------------+
| 2020-01-01 10:10:10 | 1577891410 |
| 2019-12-31 23:40:10 | 1577853610 |
| 2020-01-01 13:10:10 | 1577902210 |
| 2020-01-01 10:10:10 | 1577891410 |
| 2020-01-01 04:40:10 | 1577871610 |
| 2020-01-01 18:10:10 | 1577920210 |
+---------------------+---------------------+

mysql> SELECT col, UNIX_TIMESTAMP(col) FROM ts ORDER BY id;

+---------------------+---------------------+
| col | UNIX_TIMESTAMP(col) |
+---------------------+---------------------+
| 2020-01-01 10:10:10 | 1577891410 |
| 2019-12-31 23:40:10 | 1577853610 |
| 2020-01-01 13:10:10 | 1577902210 |
 | 2020-01-01 05:10:10 | 1577873410 |

11.2.2 Los tipos DATE, DATETIME y TIMESTAMP

Los tipos , y están DATE relacionados DATETIME. TIMESTAMP En esta sección se describen sus
características, en qué se parecen y en qué se diferencian. MySQL reconoce valores , y en varios
formatos, que se describen en DATE la DATETIME Sección 9.1.3, “Literales de fecha y hora” . Para
las descripciones de rango y , " compatible " significa que aunque los valores anteriores podrían funcionar,
no hay garantía. TIMESTAMPDATEDATETIME

El DATE tipo se utiliza para valores con una parte de fecha pero sin parte de hora. MySQL recupera y
muestra DATE valores en formato. El rango admitido es de . 'YYYY-MM-DD''1000-01-01''9999-12-31'

El DATETIME tipo se utiliza para valores que contienen partes de fecha y hora. MySQL recupera y
muestra DATETIME valores en formato. El rango admitido es de . 'YYYY-MM-DD hh:mm:ss''1000-01-01
00:00:00''9999-12-31 23:59:59'

El TIMESTAMP tipo de datos se utiliza para valores que contienen partes de fecha y hora. TIMESTAMP
tiene un rango de '1970-01-01 00:00:01'UTC a '2038-01-19 03:14:07'UTC.

la Sección 11.2.5, “Inicialización y actualización automáticas para TIMESTAMP y DATETIME” .

MySQL convierte TIMESTAMP los valores de la zona horaria actual a UTC para el almacenamiento y de
vuelta de UTC a la zona horaria actual para la recuperación. (Esto no ocurre con otros tipos
como DATETIME.) De forma predeterminada, la zona horaria actual para cada conexión es la hora del
servidor. La zona horaria se puede configurar por conexión. Siempre que la configuración de la zona
horaria permanezca constante, obtendrá el mismo valor que almacenó. Si almacena un TIMESTAMP valor
y luego cambia la zona horaria y recupera el valor, el valor recuperado es diferente del valor que
almacenó. Esto ocurre porque no se utilizó la misma zona horaria para la conversión en ambas
direcciones. La zona horaria actual está disponible como el valor de la time_zone variable del
sistema. Para obtener más información, consulte la Sección 5.1.15, “Compatibilidad con la zona horaria del
servidor MySQL” .

En MySQL 8.0.22 y versiones posteriores, puede convertir TIMESTAMP valores a valores UTC DATETIME
al recuperarlos CAST()con el AT TIME ZONE operador, como se muestra aquí:

mysql> SELECT col,

> CAST(col AT TIME ZONE INTERVAL '+00:00' AS DATETIME) AS ut
> FROM ts ORDER BY id;
+---------------------+---------------------+
| col | ut |
+---------------------+---------------------+
| 2020-01-01 10:10:10 | 2020-01-01 15:10:10 |
| 2019-12-31 23:40:10 | 2020-01-01 04:40:10 |
| 2020-01-01 13:10:10 | 2020-01-01 18:10:10 |
| 2020-01-01 10:10:10 | 2020-01-01 15:10:10 |
| 2020-01-01 04:40:10 | 2020-01-01 09:40:10 |
| 2020-01-01 18:10:10 | 2020-01-01 23:10:10 |

Así pues haríamos un ingreso de registro con la fecha actual.

Otro ejemplo:
La manera en que hacemos un registro en la hora y fecha actual es la siguiente. Mira el id de abajo como
la hemos insertado.

** como consultar fecha y hora en mysql.

ejercicio de consulta por fechas
Finalmente, vemos abajo la query o búsqueda bien hecha, tras la consulta. Podríamos haber jugado a
insertar (update) la fecha para el id1, pero bueno…. Las tablas hay que intentar diseñarlas bien desde el
origen.