Skip to content

30.0.0.14.e - Añadir contenido post tipos de datos #146

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
May 11, 2023
Merged

30.0.0.14.e - Añadir contenido post tipos de datos #146

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
109 changes: 109 additions & 0 deletions _posts/javaSE/JDK_JRE_JVM/2023-05-11-JVM.md
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,109 @@
---
layout: single
title: Java - JVM
date: 2023-05-11
classes: wide
toc: true
toc_label: "Tabla de contenido"
toc_icon: "clipboard-list"
header:
teaser: /assets/images/java/logo-java-2.jpg
categories:
- java
- java-manual
tags:
- java-JVM
page_css:
- /assets/css/mi-css.css
---

## Concepto

* ``JVM (Java Virtual Machine)``

* Motor en **tiempo de ejecución**

* Se utiliza para **ejecutar aplicaciones** Java

* Actua como **maquina virtual** que permite que el código ``Java`` se ejecute en cualquier sistema para ``Java``

* ``WORA`` **( White Once Run EveryWhere)**

## Funcionamiento

* Cuando el compilador compila un archivo ``.java`` genera un archivo ``.class`` que contiene ``byte-code``

* ``Byte-code``

* ``Lenguaje intermedio`` **más abstracto** que el ``lenguaje máquina``

* Utilizado como ``archivo binario`` el cual contiene un ``programa ejecutable`` similar a un **módulo objeto**

* Es un ``archivo binario`` producido por el ``compilador`` cuyo contenido es el ``código objeto`` o ``código máquina``

### Ejemplo de Byte-code

* Ejemplo visual simplificado del bytecode de Java

```arduino
Compiled from "Example.java"
public class Example {
public static void main(java.lang.String[]);
Code:
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3 // String Hola, mundo!
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
}
```

* Muestra el bytecode para una clase llamada "Example" con un método estático "main" que imprime "Hola, mundo!" en la consola

* Cada línea de código bytecode comienza con un número y una instrucción

* Ejemplo

* "0: getstatic" indica que la instrucción en la posición 0 es "getstatic"

* Se pueden incluir referencias a constantes o etiquetas como "#2" y "#3" que se resuelven durante la ejecución

* Esto es un ejemplo simplificado , el bytecode real generado por el compilador de Java más complejo

### Ejemplo de Byte-code en formato Hexadecimal

* Cuando se compila este código el ``compilador Java`` genera el siguiente ``byte-code`` ``( formato hexadecimal )``

```python
CA FE BA BE 00 00 00 34 00 1D 0A 00 06 00 0F 09
00 10 00 11 08 00 12 0A 00 13 00 14 07 00 15 07
00 16 01 00 06 3C 69 6E 69 74 3E 01 00 03 28 29
56 ...
```

* Este ``byte-code`` se almacena en un archivo ``.class`` y puede ser ejecutado por la ``JVM``

* Este archivo ``.class`` pasa por varios pasos cuando se ejecuta

* Estos pasos describen la ``arquitectura`` de la ``JVM``

* ``JVM`` tiene varios **subsistemas** como el ``Java Class Loader`` el cual es responsable de **cargar**, **enlazar** e **inicializar** el archivo ``.class``

* Durante la incorporación del ``cargador de clases`` , lee el archivo ``.class`` que genera los ``datos binarios`` y los guarda en el **área de métodos**

* Por cada archivo ``.class`` el ``JVM`` almacena la información como el nombre calificado de la **clase cargada** y su **clase primaria inmediata**

* El archivo ``.class`` está relacionado con

* ``Class``

* ``Interface``

* ``Enum``

* Con información sobre ``modificadores`` , ``variables`` y ``métodos``

* Después de cargar el archivo ``.class`` la ``JVM`` crea un objeto de tipo ``Class`` para representar este archivo en la ``memoria heap``

* Este ``objeto Class`` puede ser **utilizado** por el programador para obtener información de **nivel de clase** como **nombre de clase** , nombre principal, métodos e información de variable

* Tiene un motor de ejecución ``(Execution Engine)`` que ejecuta el ``byte-code``
52 changes: 45 additions & 7 deletions ...ts/javaSE/operadores_delimitadores_basicos/2023-05-10-tipos-de-datos-basicos.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -21,22 +21,60 @@ page_css:

## Conceptos

### Operadores

* Elementos que se utilizan para almacenar un valor concreto con el cual realizar **operaciones matemáticas** y **booleanas**

* Permiten definir operaciones los cuales se van a procesar en un programa

| **Tipos de Datos** | **Alcance** o **Rango** |
| --- | --- |
| ``byte`` | **-128** a **127** ``(1 Byte)``|
| ``short`` | **-32768** a **32767** ``(2 Bytes)`` |
| ``int`` | **-2147483648** a **2147483647** ``(4 bytes )`` |
| ``long`` | **-9223372036854775808** a **9223372036854775807** ``(8 Bytes)`` |
| ``byte`` | **-128** a **127** ``( 1 Byte)``|
| ``short`` | **-32768** a **32767** ``( 2 Bytes)`` |
| ``int`` | **-2147483648** a **2147483647** ``( 4 bytes )`` |
| ``long`` | **-9223372036854775808** a **9223372036854775807** ``( 8 Bytes)`` |
| ``char`` | **'\u0000'** a **'\uffff'** , ambos incluidos el cual es lo mismo que de **0** a **65535** , 1 letra |
| ``boolean`` | **0** o **1** ``(1 bit)`` |
| ``boolean`` | **0** o **1** ``( 1 bit)`` |
| ``float`` | **4 Bytes**, punto flotante |
| ``double`` | **8 Bytes**, punto flotante |
| ``String`` | **No es un tipo de datos básico** , es un **objeto básico** en si mismo, el cual contiene propiedades y métodos, pero el lenguaje Java permite definir un nuevo objeto con el delimitador (") por lo que podemos concatenar texto utilizando el operador (+) con los nombres de los objetos de tipo String y otros los trozos de texto delimitados con (")
| ``String`` | **No es un tipo de datos básico** <br> Es un **objeto básico** en si mismo, el cual contiene propiedades y métodos, pero el lenguaje ``Java`` permite definir un nuevo objeto con el ``delimitador(")`` por lo que podemos concatenar texto utilizando el ``operador(+)`` con los nombres de los objetos de tipo ``String`` y otros los trozos de texto delimitados con ``(")``
| | |

### Delimitadores


| **Operador** | **Datos** | **Acción** |
| --- | --- |--- |
| ``+`` | ``String`` | Une cadena de caracteres "texto" ``( concatenador )`` |
| ``+`` | ``número`` | Suma |
| ``-`` | ``número`` | Invierte el signo del número |
| ``-`` | ``número`` | Resta |
| ``*`` | ``número`` | Multiplica y tiene prioridad sobre la suma y la resta |
| ``/`` | ``número`` | Divide y tiene prioridad sobre la suma y la resta |
| ``%`` | ``numero`` | Devuelve el ``resto`` de la ``division`` del ``operador derecho`` por el ``izquierdo`` |
| ``!`` | ``booleano`` | El operador ``NOT`` **booleano** |
| ``~`` | ``número`` | Invierte ``bit`` por ``bit`` el operando de la derecha |
| ``&`` | ``entero`` o ``booleano`` | El operador ``AND`` , booleano ``bit`` por ``bit`` del elemento a la ``izquierda`` contra el de la ``derecha`` |
| ``&&`` | **Cualquier** | El operador ``AND`` condicional |
| &vert; | ``entero`` o ``booleano`` | El operador ``OR``, booleano ``bit`` por ``bit`` del elemento a la ``izquierda`` de la ``derecha`` |
| &vert; &vert; | **Cualquier** | El operador ``OR`` condicional |
| &lt; &lt; | ``número`` | Desplaza los ``bits`` hacia la ``izquierda`` la cantidad de la ``derecha`` |
| &gt; &gt; | ``número`` | Desplaza los ``bits`` hacia la ``derecha`` la cantidad de la ``derecha`` |
| &vert; &vert; &vert; | ``número`` | Desplaza los ``bits`` hacia la ``derecha`` pero no conserva el signo |
| ``=`` | **Cualquier** | Asigna al elemento de la ``izquierda``, el de la ``derecha``
| ``==`` | **Cualquier** | El ``operador condicional`` de igualdad , devuelve verdadero si ``derecha`` e ``izquierda`` es lo mismo |
| ``<`` | ``Básicos`` | Menor que , devuelve verdadero si ``izquierda`` es menor que ``derecha`` |
| ``<=`` | ``Básicos`` | Menor o igual que , devuelve verdadero si ``izquierda`` es menor o igual que ``derecha`` |
| ``>`` | ``Básicos`` | Mayor que , devuelve verdadero si ``izquierda`` es mayor que ``derecha`` |
| ``>=`` | ``Básicos`` | Mayor o igual que, devuelve verdadero si ``izquierda`` es mayor o igual que ``derecha``
| ``(op)=`` | ``Básicos`` | Hace la operación op ``[+,-,*,/.etc..]`` entre los dos operandos y el resultado lo guarda en el de la ``izquierda``
| ``var++`` | ``Básicos`` | Incrementa en uno la variable ``var``
| ``var--`` | ``Básicos`` | Decrementa en uno la variable ``var``
| ``.`` | ``objetos`` | Separa e invoca los nombres de los ``objetos`` , ``propiedades`` , ``métodos`` , ``nombres`` y jerarquía de ``clases``
| ``(int)`` | ``tipo de datos`` | Convierte un tipo de datos a ``entero`` , si reemplazamos ``int`` por una ``clase`` de objetos, podemos siempre y cuando sea correcto convertir al ``tipo de datos`` indicado entre paréntesis
| ``,`` | **Cualquier** | Separa argumentos de un ``método`` o ``procedimiento``
| ``;`` | **Cualquier** | Termina una línea de orden
| ``//`` | **Cualquier** | Empieza una línea de comentario
| ``/* */`` | **Cualquier** | Delimitan un trozo de texto como comentario
| ``/** */`` | **Cualquier** | Delimitan un trozo de texto como documentación para ``JavaDoc``
| ``{}`` | **Cualquier** | Delimitan un ``bloque de código`` de una estructura de datos
| ``()`` | **Cualquier** | Asocia una ``operación`` teniendo prioridad o en caso de un ``método`` agrupa los ``argumentos`` separados por comas