Muy bueno hasta ahora. Pero, sere honesto, el toque humano, es mejor. No me gusta estar viendo letras y que me lean, siento que estoy pagando demasiado po un "audio libro". Espero, este no sea el nuevo formato de paltzi.

Me encanta esta forma de enseñar. Personalmente me sirve muchísimo para repasar conceptos y la forma rápida de hablar que tiene Freddy, lo hace el doble de entretenido. Well Done!

En mi opinión era mejor el anterior curso de introducción a Java, es de la gran Anahi salgado (Lastima que ya no hace mas cursos en platzi), el curso no es visible pero sigue estando disponible (Les recomiendo agregarlo a un ruta personalizada, así ya no se pierde). Por si les sirve para comparar ambos formatos de curso, y ya deciden cual es mejor para ustedes <<https://platzi.com/clases/old/java-basico/>>

va muy rapido prefiro la forma anterior de enseñar me siento un poco perdido

Muy avanzado este curso, parece que esta para gente que ya saber programar, yo soy nuevo, y no entiendo nada.

Es justo lo que estaba buscando ya que solo queria repasar mis conocimientos en java. No me parece buena si estan comenzando con el lenguaje pero si, si quieren repasar los conceptos de java. No me encanta tanto el formato, ver tanto texto lo hace sentir algo saturado pero el poder buscar informacion especifica por el texto me parece genial

Este curso parece dirigido a personas que ya tienen una inmersión con JAVA en el pasado, me parece que el profesor no tiene pedagogía para enseñar desde cero, leyendo y mencionando las cosas por encima y de una manera muy rápida, nisiquiera se observa construyendo el código el mismo. Definitivamente, un fracaso. Otra experiencia muy diferente tuve con el curso de Front-End con JavaScript.

Me gusta el contenido, pero siento que falta una parte práctica e interactiva que me ayude a entender y a equivocarme para aprender del error. Si solo me quedo viendo cómo otra persona lee, siento que estoy pagando demasiado para alguien que recién está comenzando. ¿Por qué habrán quitado el curso anterior de Anahí? Con ese curso sentía que aprendía mucho más que con este. Además, me pregunto si realmente hay un ser humano detrás de este curso o si simplemente es producto de una inteligencia artificial.

1 ingreso, numero de cuenta y pin 2\. transacciones a realizar, giros pagos, retiros, avances de t.c consultar saldo, cambiar clave 3\. dependiendo la opcion realizar la operacion 4\. imprimir recibo en pantalla

Amo este nuevo formato, me ayuda a pensar mas

Seria bastante util poder ver en recursos todo el codigo que se mostro, no el texto, ni eso, SOLO el codigo

```js //------------------------------------------------------// //----- SCRIPT GUIA DE OPERACIONES BASICAS EN JAVA -----// package com.platzi; // librerias import java.util.Arrays; //-- CLASE PRINCIPAL (clase principal con el nombre del archivo ,java)--// public class Main { // definicion de constantes globales public interface Constantes { int VALOR_1 = 10; int VALOR_2 = 20; } // variable estatica dentro de la clase public static final int VALOR_CONSTANTE = 10; // declaracion de funcion public static String toString(char[] a) { // Creating object of String class String string = new String(a); return string; } //-- script principal --// public static void main(String[] args) { // mensaje de bienvenida System.out.println("Hello world!"); // variable estatica System.out.println("variable estatica: " + VALOR_CONSTANTE); // constante global System.out.println("constante estatica 1: " + Constantes.VALOR_1); System.out.println("constante estatica 2: " + Constantes.VALOR_2); //----------- TIPOS DE VARIABLES -------------// System.out.println("---------------------------------------"); System.out.println("-------- TIPOS DE VARIABLES -----------"); /* * int: emplea 4 bytes de almacenamiento * El rango de valores que puede representar va de -2**31 a 2**31-1. */ int numero = 102; System.out.println("int: " + numero); /* * short: emplea 2 bytes de almacenamiento * El rango de valores (desde -32,768 hasta 32,767). */ short numero2 = 102; System.out.println("short: " + numero2); /* * byte: emplea 1 byte de almacenamiento * El rango de valores de -128 a 127. */ byte numero3 = 16; System.out.println("byte: " + numero3); /* * long: emplea 8 byte de almacenamiento * El rango de valores de -2**63 a 2**63-1. */ long numero4 = -2147483648L; System.out.println("long: " + numero4); /* * float: emplea 32 bits de almacenamiento * El rango de valores de 3.4e−038 to 3.4e+038. */ float numero5 = 301.782f; System.out.println("float: " + numero5); /* * double: emplea 64 bits de almacenamiento * El rango de valores de 1.7e-308 to 1.7e+308. */ double numero6 = 301.782d; System.out.println("double: " + numero6); /* * JAVA NO TIENE FORMATO UNSIGNED * SE RECOMIENDA USAR FORMATOS COMO LONG */ /* * boolean: toma el valor de true/false * almacena 1 bit */ boolean estado = true; System.out.println("boolean: " + estado); /* * char: ualquier tipo de valor alfanumérico, es decir, compuesto por 2 byte. Puede * almacenar cualquier caracter unicode (letras, números, símbolos, etc.). * Se puede inicializar utilizando las comillas simples '' para indicar el caracter * directamente, o mediante su representación equivalente en la tabla ASCII. */ char caracter1 = '#'; char caracter2 = 35; // equivalente en decimal char caracter3 = 0x23; // equivalente en hexadecimal System.out.println(caracter1); System.out.println(caracter2); System.out.println(caracter3); /* * string: es una coleccion de caracteres * */ String s1="java"; // se crea un string Java literal char ch[]={'s','t','r','i','n','g','s'}; String s2=new String(ch); // convertir char array a string String s3=new String("example"); // se crea un Java string por new keyword System.out.println(s1); System.out.println(s2); System.out.println(s3); //--------- ARITMETICA ---------// System.out.println("---------------------------------------"); System.out.println("-------- ARITMETICA -----------"); /* * (+) - Suma. * (-) - Resta. * (*) - Multiplicación. * (/) - División. * (%) - Residuo. Solo resultará al realizarlo sobre números enteros. */ System.out.println("suma: " + (5 + 27)); System.out.println("resta: " + (27 - 5)); System.out.println("multiplicacion: " + (32*2)); float divis = 8.0f / 3.0f; System.out.println("division: " + divis); int res = 15 % 4; // Residuo de (15 / 4) ... (4 x 3 = 12, sobran 3 para 15) System.out.println("residuo: " + res); /* * Asignaciones compuestas * Es una forma compacta de asignar valores a variables elaborando una * operación aritmética conjuntamente: */ System.out.println("asignacion compuesta"); int i = 10; System.out.println("i: " + i); System.out.println("i++: " + (i++)); System.out.println("i--: " + (i--)); System.out.println("i += 3: " + (i +=3) ); System.out.println("i -= 4: " + (i -=4) ); System.out.println("i *= 3: " + (i *=3) ); System.out.println("i /= 5: " + (i /=5) ); /* * - Operadores lógicos y de comparación * * A diferencia de las operaciones aritméticas, las operaciones lógicas * o de comparación se ejecutan de derecha a izquierda. * * - (&&) --> AND * - (||) --> OR * - (!) --> NOT * - (==) --> equals * - (!=) --> not equals * - (<) --> less than * - (>) --> greater than * - (<=) --> less or equal than * - (>=) --> greater or equal than */ System.out.println("(5 < 9): " + (5 < 9) ); System.out.println("(2 != -3): " + (2 != -3) ); System.out.println("(9 >= 7 && true == false): " + (9 >= 7 && true == false) ); //--------- MATEMATICA ---------// System.out.println("---------------------------------------"); System.out.println("-------- MATEMATICA -----------"); // variables ejemplo double x = 28; double y = 4; // maximo System.out.println("Maximum number of x and y is: " + Math.max(x, y)); // raiz System.out.println("Square root of y is: " + Math.sqrt(y)); // pow System.out.println("Power of x and y is: " + Math.pow(x, y)); // log System.out.println("Logarithm of x is: " + Math.log(x)); // log10 System.out.println("Logarithm of x is: " + Math.log10(x)); // exp System.out.println("exp of a is: " + Math.exp(x)); // trigonometria double a = 30; // converting values to radian double b = Math.toRadians(a); System.out.println("radian: " + b); System.out.println("Sine value of a is: " + Math.sin(a)); System.out.println("Cosine value of a is: " + Math.cos(a)); System.out.println("Tangent value of a is: " + Math.tan(a)); System.out.println("Sine value of a is: " + Math.sinh(a)); System.out.println("Cosine value of a is: " + Math.cosh(a)); System.out.println("Tangent value of a is: " + Math.tanh(a)); //--------- ARREGLOS ---------// System.out.println("---------------------------------------"); System.out.println("-------- ARREGLOS -----------"); /* * Son un conjunto de variables bajo una misma dirección en memoria y que * pertenecen al mismo tipo (int, char, bool, etc). * * Existen dos formas de definir la cantidad de elementos que el arreglo * tendrá: */ /* * - Por declaración: * * En este caso, si se consulta un índice del arreglo, como p. ej. arreglo1[3], * tendrá un valor basura aleatorio. */ int arreglo1[] = new int[10]; System.out.println("arreglo1 usando declaracion: " + arreglo1); /* * - Por asignación: * * Que un arreglo tenga determinada cantidad de elementos no quiere decir que * se tengan usar todos. Pueden definirse 5 elementos y usar solo 2. Lo anterior * es posible mas sin embargo no es recomendable. */ int arreglo2[] = {33,3,4,5}; System.out.println("arreglo1 usando declaracion: " + arreglo2[1]); // array de cadenas String[] nombres = {"Alice", "Bob", "Charlie"}; System.out.println(nombres[1]); // matriz int[][] matriz = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; System.out.println(matriz[0][1]); // char array char word[] = { 'g', 'e', 'e', 'k', 's', 'f', 'o', 'r', 'g', 'e', 'e', 'k', 's' }; System.out.println(toString(word)); /* * java.util.Arrays * Esta clase proporciona múltiples métodos para manipular Arrays sobre * múltiples tipos de datos T: primitivos (enteros, reales, caracteres y booleanos) * y objetos. */ // copiar array int[] original = {1, 2, 3, 4, 5}; int[] copia = Arrays.copyOf(original, original.length); // Copia el arreglo completo System.out.println(copia[2]); // copiar un rango del array int[] original2 = {1, 2, 3, 4, 5}; int[] copia2 = Arrays.copyOfRange(original2, 1, 4); // Copia desde el índice 1 al 3 System.out.println(copia2[2]); // llenar un array con valores int[] numeros = new int[5]; Arrays.fill(numeros, 42); // Llena el arreglo con el valor 42 // compara dos arrays int[] arreglo3 = {1, 2, 3}; int[] arreglo4 = {1, 2, 3}; boolean sonIguales = Arrays.equals(arreglo3, arreglo4); // Retorna true si los arreglos son iguales System.out.println(sonIguales); // buscar un elemento int[] numeros2 = {1, 3, 5, 7, 9}; int indice = Arrays.binarySearch(numeros2, 5); // Busca el valor 5 en el arreglo System.out.println(indice); /* * ejemplos de arreglos multidimensional: * * 2D * int[][] twoD_arr = new int[10][20]; * * int[][] arr = {{1, 2}, {3, 4}}; * arr[0][0] = 1; * * * 3D * int[][][] threeD_arr = new int[10][20][30]; * * int[][][] arr = { { { 1, 2 }, { 3, 4 } }, { { 5, 6 }, { 7, 8 } } }; * * * arr[0][0][0] = 1; */ /* * java tiene una opcion de manejar arrays dentro de un array * llamada jagged array * * int arr_name[][] = new int[][] { new int[] {10, 20, 30 ,40}, new int[] {50, 60, 70, 80, 90, 100}, new int[] {110, 120} }; * * * */ } } ```//------------------------------------------------------////----- SCRIPT GUIA DE OPERACIONES BASICAS EN JAVA -----// package com.platzi; // libreriasimport java.util.Arrays; //-- CLASE PRINCIPAL (clase principal con el nombre del archivo ,java)--//public class Main {     // definicion de constantes globales    public interface Constantes {        int VALOR\_1 = 10;        int VALOR\_2 = 20;    }     // variable estatica dentro de la clase    public static final int VALOR\_CONSTANTE = 10;     // declaracion de funcion    public static String toString(char\[] a)    {        // Creating object of String class        String string = new String(a);         return string;    }     //-- script principal --//    public static void main(String\[] args) {         // mensaje de bienvenida        System.out.println("Hello world!");         // variable estatica        System.out.println("variable estatica: " + VALOR\_CONSTANTE);         // constante global        System.out.println("constante estatica 1: " + Constantes.VALOR\_1);        System.out.println("constante estatica 2: " + Constantes.VALOR\_2);         //----------- TIPOS DE VARIABLES -------------//        System.out.println("---------------------------------------");        System.out.println("-------- TIPOS DE VARIABLES -----------");         /\*         \* int: emplea 4 bytes de almacenamiento          \* El rango de valores que puede representar va de -2\*\*31 a 2\*\*31-1.         \*/        int numero = 102;        System.out.println("int: " + numero);         /\*         \* short: emplea 2 bytes de almacenamiento          \* El rango de valores (desde -32,768 hasta 32,767).         \*/        short numero2 = 102;        System.out.println("short: " + numero2);         /\*         \* byte: emplea 1 byte de almacenamiento          \* El rango de valores de -128 a 127.         \*/        byte numero3 = 16;        System.out.println("byte: " + numero3);         /\*         \* long: emplea 8 byte de almacenamiento          \* El rango de valores de -2\*\*63 a 2\*\*63-1.         \*/        long numero4 = -2147483648L;        System.out.println("long: " + numero4);         /\*         \* float: emplea 32 bits de almacenamiento          \* El rango de valores de 3.4e−038 to 3.4e+038.         \*/        float numero5 = 301.782f;        System.out.println("float: " + numero5);         /\*         \* double: emplea 64 bits de almacenamiento          \* El rango de valores de 1.7e-308 to 1.7e+308.         \*/        double numero6 = 301.782d;        System.out.println("double: " + numero6);         /\*         \* JAVA NO TIENE FORMATO UNSIGNED         \* SE RECOMIENDA USAR FORMATOS COMO LONG         \*/          /\*         \* boolean: toma el valor de true/false         \* almacena 1 bit         \*/        boolean estado = true;        System.out.println("boolean: " + estado);         /\*         \* char: ualquier tipo de valor alfanumérico, es decir, compuesto por 2 byte. Puede         \* almacenar cualquier caracter unicode (letras, números, símbolos, etc.).         \* Se puede inicializar utilizando las comillas simples '' para indicar el caracter         \* directamente, o mediante su representación equivalente en la tabla ASCII.         \*/        char caracter1 = '#';        char caracter2 = 35; // equivalente en decimal        char caracter3 = 0x23; // equivalente en hexadecimal        System.out.println(caracter1);         System.out.println(caracter2);         System.out.println(caracter3);         /\*         \* string: es una coleccion de caracteres         \*          \*/        String s1="java"; // se crea un string Java literal            char ch\[]={'s','t','r','i','n','g','s'};            String s2=new String(ch); // convertir char array a string            String s3=new String("example"); // se  crea un Java string por new keyword            System.out.println(s1);            System.out.println(s2);            System.out.println(s3);           //--------- ARITMETICA ---------//        System.out.println("---------------------------------------");        System.out.println("-------- ARITMETICA -----------");         /\*          \* (+) - Suma.         \* (-) - Resta.         \* (\*) - Multiplicación.         \* (/) - División.         \* (%) - Residuo. Solo resultará al realizarlo sobre números enteros.         \*/         System.out.println("suma: " + (5 + 27));          System.out.println("resta: " + (27 - 5));         System.out.println("multiplicacion: " + (32\*2));         float divis = 8.0f / 3.0f;        System.out.println("division: " + divis);         int res = 15 % 4;        // Residuo de (15 / 4) ... (4 x 3 = 12, sobran 3 para 15)        System.out.println("residuo: " + res);         /\*         \* Asignaciones compuestas         \* Es una forma compacta de asignar valores a variables elaborando una         \* operación aritmética conjuntamente:         \*/        System.out.println("asignacion compuesta");        int i = 10;        System.out.println("i: " + i);        System.out.println("i++: " + (i++));        System.out.println("i--: " + (i--));        System.out.println("i += 3: " + (i +=3) );        System.out.println("i -= 4: " + (i -=4) );        System.out.println("i \*= 3: " + (i \*=3) );        System.out.println("i /= 5: " + (i /=5) );         /\*         \* - Operadores lógicos y de comparación          \*          \* A diferencia de las operaciones aritméticas, las operaciones lógicas         \* o de comparación se ejecutan de derecha a izquierda.         \*          \* - (&&) --> AND          \* - (||) --> OR         \* - (!)  --> NOT         \* - (==) --> equals         \* - (!=) --> not equals         \* - (<)  --> less than         \* - (>)  --> greater than         \* - (<=) --> less or equal than         \* - (>=) --> greater  or equal than         \*/          System.out.println("(5 < 9): " + (5 < 9) );         System.out.println("(2 != -3): " + (2 != -3) );         System.out.println("(9 >= 7 && true == false): " + (9 >= 7 && true == false) );         //--------- MATEMATICA ---------//        System.out.println("---------------------------------------");        System.out.println("-------- MATEMATICA -----------");         // variables ejemplo        double x = 28;            double y = 4;           // maximo        System.out.println("Maximum number of x and y is: " + Math.max(x, y));                // raiz        System.out.println("Square root of y is: " + Math.sqrt(y));         // pow        System.out.println("Power of x and y is: " + Math.pow(x, y));         // log        System.out.println("Logarithm of x is: " + Math.log(x));         // log10        System.out.println("Logarithm of x is: " + Math.log10(x));         // exp        System.out.println("exp of a is: " + Math.exp(x));         // trigonometria        double a = 30;                      // converting values to radian            double b = Math.toRadians(a);         System.out.println("radian: " + b);        System.out.println("Sine value of a is: " + Math.sin(a));        System.out.println("Cosine value of a is: " + Math.cos(a));          System.out.println("Tangent value of a is: " + Math.tan(a));         System.out.println("Sine value of a is: " + Math.sinh(a));            System.out.println("Cosine value of a is: " + Math.cosh(a));          System.out.println("Tangent value of a is: " + Math.tanh(a));         //--------- ARREGLOS ---------//        System.out.println("---------------------------------------");        System.out.println("-------- ARREGLOS -----------");         /\*          \* Son un conjunto de variables bajo una misma dirección en memoria y que         \* pertenecen al mismo tipo (int, char, bool, etc).         \*          \* Existen dos formas de definir la cantidad de elementos que el arreglo         \* tendrá:         \*/         /\*        \* - Por declaración:        \*         \* En este caso, si se consulta un índice del arreglo, como p. ej. arreglo1\[3],        \* tendrá un valor basura aleatorio.        \*/                int arreglo1\[] = new int\[10];        System.out.println("arreglo1 usando declaracion: " + arreglo1);         /\*        \* - Por asignación:        \*         \* Que un arreglo tenga determinada cantidad de elementos no quiere decir que        \* se tengan usar todos. Pueden definirse 5 elementos y usar solo 2. Lo anterior        \* es posible mas sin embargo no es recomendable.        \*/        int arreglo2\[] = {33,3,4,5};        System.out.println("arreglo1 usando declaracion: " + arreglo2\[1]);         // array de cadenas        String\[] nombres = {"Alice", "Bob", "Charlie"};        System.out.println(nombres\[1]);         // matriz        int\[]\[] matriz = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};        System.out.println(matriz\[0]\[1]);         // char array        char word\[] = { 'g', 'e', 'e', 'k', 's', 'f', 'o',                     'r', 'g', 'e', 'e', 'k', 's' };                System.out.println(toString(word));         /\*         \* java.util.Arrays         \* Esta clase proporciona múltiples métodos para manipular Arrays sobre          \* múltiples tipos de datos T: primitivos (enteros, reales, caracteres y booleanos)          \* y objetos.         \*/         // copiar array        int\[] original = {1, 2, 3, 4, 5};        int\[] copia = Arrays.copyOf(original, original.length); // Copia el arreglo completo        System.out.println(copia\[2]);         // copiar un rango del array        int\[] original2 = {1, 2, 3, 4, 5};        int\[] copia2 = Arrays.copyOfRange(original2, 1, 4); // Copia desde el índice 1 al 3        System.out.println(copia2\[2]);         // llenar un array con valores        int\[] numeros = new int\[5];        Arrays.fill(numeros, 42); // Llena el arreglo con el valor 42         // compara dos arrays        int\[] arreglo3 = {1, 2, 3};        int\[] arreglo4 = {1, 2, 3};        boolean sonIguales = Arrays.equals(arreglo3, arreglo4); // Retorna true si los arreglos son iguales        System.out.println(sonIguales);         // buscar un elemento        int\[] numeros2 = {1, 3, 5, 7, 9};        int indice = Arrays.binarySearch(numeros2, 5); // Busca el valor 5 en el arreglo        System.out.println(indice);         /\*         \* ejemplos de arreglos multidimensional:         \*          \* 2D         \* int\[]\[] twoD\_arr = new int\[10]\[20];         \*          \* int\[]\[] arr = {{1, 2}, {3, 4}};         \* arr\[0]\[0] = 1;         \*          \*          \* 3D         \* int\[]\[]\[] threeD\_arr = new int\[10]\[20]\[30];         \*          \* int\[]\[]\[] arr = { { { 1, 2 }, { 3, 4 } }, { { 5, 6 }, { 7, 8 } } };         \*          \*          \* arr\[0]\[0]\[0] = 1;         \*/         /\*         \* java tiene una opcion de manejar arrays dentro de un array         \* llamada jagged array         \*          \* int arr\_name\[]\[] = new int\[]\[]  {                                  new int\[] {10, 20, 30 ,40},                                  new int\[] {50, 60, 70, 80, 90, 100},                                  new int\[] {110, 120}                                      };         \*          \*          \*          \*/     }}

Los comentarios que no son de agrado son borrados por el moderador. Me puede referir un curso de java basico para gente que recien va empezar en la programacion.

### **Tipos de Datos en Java** En Java, los tipos de datos se dividen en **tipos primitivos** y **tipos de referencia**. #### **1. Tipos Primitivos** Los tipos primitivos en Java son ocho y representan los valores más básicos: TipoTamañoValores posiblesEjemplo`byte`8 bits-128 a 127`byte edad = 25;short`16 bits-32,768 a 32,767`short numero = 1500;int`32 bits-2³¹ a 2³¹-1`int contador = 100000;long`64 bits-2⁶³ a 2⁶³-1`long estrellas = 1000000000L;float`32 bits±3.4E-38 a ±3.4E+38`float precio = 10.99f;double`64 bits±1.7E-308 a ±1.7E+308`double altura = 1.75;char`16 bitsCaracteres Unicode (Ejemplo: 'A', 'B', '1', '$')`char letra = 'A';boolean`1 bit`true` o `falseboolean activo = true;` #### **2. Tipos de Referencia** Los tipos de referencia son aquellos que hacen referencia a objetos en la memoria. Ejemplos: * **Clases** (`String`, `Scanner`, `ArrayList`, etc.) * **Interfaces** * **Arreglos (**`int[]`**,** `String[]`**, etc.)** * **Cadenas (**`String`**)** * **Objetos personalizados** (Ejemplo: `class Persona`) Ejemplo: String nombre = "Kevin"; int\[] numeros = {1, 2, 3, 4, 5}; ### **Operadores en Java** Java tiene varios tipos de operadores, categorizados según su uso: #### **1. Operadores Aritméticos** Se usan para realizar operaciones matemáticas: OperadorDescripciónEjemplo (`a = 10, b = 5`)`+`Suma`a + b` → `15-`Resta`a - b` → `5*`Multiplicación`a * b` → `50/`División`a / b` → `2%`Módulo (resto de la división)`a % b` → `0` Ejemplo: int suma = 10 + 5; // 15 int division = 10 / 2; // 5 #### **2. Operadores de Asignación** Asignan valores a las variables: OperadorDescripciónEjemplo`=`Asignación simple`a = 10;+=`Suma y asignación`a += 5;` (equivale a `a = a + 5;`)`-=`Resta y asignación`a -= 5;` (equivale a `a = a - 5;`)`*=`Multiplicación y asignación`a *= 5;` (equivale a `a = a * 5;`)`/=`División y asignación`a /= 5;` (equivale a `a = a / 5;`)`%=`Módulo y asignación`a %= 5;` (equivale a `a = a % 5;`) Ejemplo: int x = 10; x += 5; // x ahora es 15 #### **3. Operadores Relacionales (Comparación)** Se usan para comparar valores y devuelven un booleano (`true` o `false`). OperadorDescripciónEjemplo (`a = 10, b = 5`)`==`Igual a`a == b` → `false!=`Diferente de`a != b` → `true>`Mayor que`a > b` → `true<`Menor que`a < b` → `false>=`Mayor o igual que`a >= b` → `true<=`Menor o igual que`a <= b` → `false` Ejemplo: boolean esMayor = (10 > 5); // true #### **4. Operadores Lógicos** Se usan para combinar expresiones booleanas. OperadorDescripciónEjemplo (`a = true, b = false`)`&&`AND lógico (ambos deben ser `true`)`a && b` → `false````!`NOT lógico (invierte el valor)`!a` → `false` Ejemplo: boolean resultado = (10 > 5) && (5 < 3); // false #### **5. Operadores Bit a Bit** Se usan para operar a nivel de bits. OperadorDescripciónEjemplo (`a = 5 (0101 en binario), b = 3 (0011 en binario)`)`&`AND bit a bit`a & b` → `0001` (1 en decimal)``OR bit a bit`^`XOR bit a bit`a ^ b` → `0110` (6 en decimal)`~`Complemento bit a bit`~a` → `-6<<`Desplazamiento a la izquierda`a << 1` → `1010` (10 en decimal)`>>`Desplazamiento a la derecha`a >> 1` → `0010` (2 en decimal) Ejemplo: int c = 5 & 3; // 1 #### **6. Operadores de Incremento y Decremento** Se usan para aumentar o disminuir en 1 el valor de una variable. OperadorDescripciónEjemplo (`a = 10`)`++`Incremento en 1`a++` (post-incremento), `++a` (pre-incremento)`--`Decremento en 1`a--` (post-decremento), `--a` (pre-decremento) Ejemplo: int x = 10; x++; // x ahora es 11 #### **7. Operador Ternario** Es un operador condicional de la forma `condición ? valor_si_true : valor_si_false;` Ejemplo: int edad = 20; String mensaje = (edad >= 18) ? "Mayor de edad" : "Menor de edad"; System.out.println(mensaje); // "Mayor de edad" ### **Resumen** * **Tipos de datos**: primitivos (`int`, `double`, `char`, `boolean`, etc.) y de referencia (`String`, `ArrayList`, etc.). * **Operadores**: aritméticos, asignación, comparación, lógicos, bit a bit, incremento/decremento y ternario.

✅

Esta muy bueno el curso, esa mescla de audios seguidos de texto y videos esta super, seria bueno que no fuera tan rápido, pero esta super...

Aplicar un bucle for para iterar sobre el array transactionAmounts: `for (int cantidad:transactionAmounts){ ` `balance += cantidad;` `}` Sintaxis: * int = tipo de elemento * cantidad = variable temporal * transactionAmounts = Array o Collection BONUS: Diferencia entre Array y Collection * Array se usa cuando conocemos el tamaño de la información, almacena el mismo tipo de datos que pueden ser primitivos u objetos, se accede mediante el índice (array \[i]). * Collection se usa para agregar o eliminar datos de forma dinámica esta estructura de datos es más flexible, se accede por medio del método get(), almacena datos de diferente tipo.

Sip, este curso da muchas cosas por hecho, anahi se tomaba el tiempo de explicar bien las cosas.ahora tengo que buscar externamente que es un char, byte, long y float

La nueva forma viendo el texto para buscar información especifica está super, pero creo que el contenido está saturado de información para las personas que no han tomado otros cursos de programación, por ejemplo de seguro no sabrán que StringBuilder es un objeto y que la palabra reservada nos permite crear dicho objeto, y quien dentro de los paréntesis, van las propiedades que se necesitan para crear dicho objeto.

Que gran curso, nada como buenas bases !!!

![]()Excelente curso | ☆☆☆☆☆ He sentido muy fluida la manera en que explica el profe, además, la lectura en algunos vídeos se apoya de imágenes y de código para reforzar el conocimiento. *Enhorabuena espero que más adelante encontremos otros cursos tan dinámicos como este*. Muchos saludos, comunidad. P.D. El logotipo del ejercicio me pareció una genialidad, 👍!