diff --git a/JavaSCuatri/Clase10POO/Domain/Empleado.java b/JavaSCuatri/Clase10POO/Domain/Empleado.java new file mode 100644 index 00000000..3ec3b5d8 --- /dev/null +++ b/JavaSCuatri/Clase10POO/Domain/Empleado.java @@ -0,0 +1,8 @@ +package Clase10POO.Domain; + +public class Empleado extends Persona{ + @Override + public void imprimir(){ + System.out.println("Metodo imprimir desde la clase hija"); + } +} diff --git a/JavaSCuatri/Clase10POO/Domain/Persona.java b/JavaSCuatri/Clase10POO/Domain/Persona.java new file mode 100644 index 00000000..e1c70990 --- /dev/null +++ b/JavaSCuatri/Clase10POO/Domain/Persona.java @@ -0,0 +1,19 @@ +package Clase10POO.Domain; + +public class Persona { + // atributo + public final static int CONSTANTE_AQUI = 15; + private String nombre; + + public String getNombre() { + return nombre; + } + + public void setNombre(String nombre) { + this.nombre = nombre; + } + + public void imprimir(){ // indicamos que no se altere el comportamiento de las clases hijas + System.out.println("Metodo para imprimir"); + } +} diff --git a/JavaSCuatri/Clase10POO/PalabraFinal/test/TestFinal.java b/JavaSCuatri/Clase10POO/PalabraFinal/test/TestFinal.java new file mode 100644 index 00000000..cde58dca --- /dev/null +++ b/JavaSCuatri/Clase10POO/PalabraFinal/test/TestFinal.java @@ -0,0 +1,30 @@ +package Clase10POO.PalabraFinal.test; + +import Clase10POO.Domain.Persona; + +// Palabra final: dif significados dep donde se aplique: +// - variables: evita cambiar el valor que almacena la variable. +// - metodos: evita que se modifique la definicion o el comportamientode un metodo desde una subclase(hija) +// - clase: evita que se creen clases hijas + +// Normalmente, cuando se trabaja con variables se combina con el modificador de acceso estático +// para convertir una variable en una constaante, es decir, que no se puede modificar su valor, el ejemplo de esto es la clase Math +// en la cual todos sus atributos son de tipo static y final, es por esto q la var pi se conoce como constante + +public class TestFinal { + public static void main(String[] args) { + final int miDni = 32145787; + System.out.println("miDni = " + miDni); + // miDni = 54789451; no deja reasignar + // Persona.CONSTANTE_AQUI = 9; // no se modifica + System.out.println("Mi atributo constante es: " + Persona.CONSTANTE_AQUI); + + // USO DE LA PALABRA FINAL CON OBJETOS.. + final Persona persona1 = new Persona(); // tampoco se puede reasignar una nueva referencia + persona1.setNombre("Juan Mason"); + System.out.println("persona1 nombre = " + persona1.getNombre()); // si se puede mod el contenido del objeto + persona1.setNombre("Andrea"); + System.out.println("persona1 nombre = " + persona1.getNombre()); + } + +} diff --git a/JavaSCuatri/Clase10POO/Paquetes/Codesystem/Utileria.java b/JavaSCuatri/Clase10POO/Paquetes/Codesystem/Utileria.java new file mode 100644 index 00000000..11a70cec --- /dev/null +++ b/JavaSCuatri/Clase10POO/Paquetes/Codesystem/Utileria.java @@ -0,0 +1,7 @@ +package Clase10POO.Paquetes.Codesystem; + +public class Utileria { + public static void imprimir(String s) { + System.out.println("s = " + s); + } +} diff --git a/JavaSCuatri/Clase10POO/Paquetes/test/testUtileria.java b/JavaSCuatri/Clase10POO/Paquetes/test/testUtileria.java new file mode 100644 index 00000000..5fa5a583 --- /dev/null +++ b/JavaSCuatri/Clase10POO/Paquetes/test/testUtileria.java @@ -0,0 +1,12 @@ +package Clase10POO.Paquetes.test; + +import Clase10POO.Paquetes.Codesystem.Utileria; +// import static ar.com.Codesystem.Utileria.imprimir; aplica para metodos estáticos + +public class testUtileria { + public static void main(String[] args) { + Utileria.imprimir("Hola amigos"); + // imprimir("Terminamos en unos minutos"); + // ar.com.Codesystem.Utileria.imprimir("Ahora si estamos terminando") + } +} diff --git a/JavaSCuatri/Clase10POO/operaciones/operaciones.java b/JavaSCuatri/Clase10POO/operaciones/operaciones.java new file mode 100644 index 00000000..e7ed5f4a --- /dev/null +++ b/JavaSCuatri/Clase10POO/operaciones/operaciones.java @@ -0,0 +1,14 @@ +package Clase10POO.operaciones; + +public class operaciones { + // metodos + public static int sumar(int a, int b){ + System.out.println("Método para sumar enteros: "); + return a + b; + } + + public static double sumar(double a, double b){ + System.out.println("Método para sumar double: "); + return a + b; + } +} diff --git a/JavaSCuatri/Clase10POO/test/TestOperaciones.java b/JavaSCuatri/Clase10POO/test/TestOperaciones.java new file mode 100644 index 00000000..c1b651a5 --- /dev/null +++ b/JavaSCuatri/Clase10POO/test/TestOperaciones.java @@ -0,0 +1,16 @@ +package Clase10POO.test; + +import Clase10POO.operaciones.operaciones; + +public class TestOperaciones { + public static void main(String[] args) { + var resultado = operaciones.sumar(7,9); //inf de tipos + System.out.println("resultado = " + resultado); + + var resultado2 = operaciones.sumar(5, 7); + System.out.println("resultado2 = " + resultado2); + + var resultado3 = operaciones.sumar(8, 6L); // muestra el double porq la var es long + System.out.println("resultado3 = " + resultado3); + } +} diff --git a/JavaSCuatri/Clase11Arreglos/Ejercicios/Ejercicio1.java b/JavaSCuatri/Clase11Arreglos/Ejercicios/Ejercicio1.java new file mode 100644 index 00000000..c10f8096 --- /dev/null +++ b/JavaSCuatri/Clase11Arreglos/Ejercicios/Ejercicio1.java @@ -0,0 +1,26 @@ +package Clase11Arreglos.Ejercicios; +import java.util.Scanner; + +public class Ejercicio1 { + // Leer 5 numeros. guardarlos en un arreglo y mostrarlos + // en el mismo orden introducidos + public static void main(String[] args) { + Scanner entrada = new Scanner(System.in); + float arreglos[] = new float[5]; // Tipo float de dimension 5 + + System.out.println("Cargando los datos en el arreglo"); + for(int i=0; i<5; i++){ + System.out.println((i+1) + " Escriba un número: "); + arreglos[i] = entrada.nextFloat(); + } + + // Mostramos los elementos tal cual lo ingresó + + System.out.println("\n Mostramos los elementos del arreglo: "); + for(float i:arreglos){ + System.out.println(i + " "); // mostramos con espacio y num del iterador + } + System.out.println("\n"); + } + +} diff --git a/JavaSCuatri/Clase11Arreglos/Ejercicios/Ejercicio2.java b/JavaSCuatri/Clase11Arreglos/Ejercicios/Ejercicio2.java new file mode 100644 index 00000000..49a1d461 --- /dev/null +++ b/JavaSCuatri/Clase11Arreglos/Ejercicios/Ejercicio2.java @@ -0,0 +1,27 @@ +package Clase11Arreglos.Ejercicios; + +import java.util.Scanner; + +// Leer 5 numeros. guardarlos en un arreglo y mostrarlos +// en el orden inverso + +public class Ejercicio2 { + public static void main(String[] args) { + Scanner entrada = new Scanner(System.in); + float numeros[] = new float[5]; // Tipo float de dimension 5 + + System.out.println("Cargando los datos en el arreglo"); + for(int i=0; i<5; i++){ + System.out.println((i+1) + " Escriba un número: "); + numeros[i] = entrada.nextFloat(); + } + + // Mostramos los elementos de manera inversa + + System.out.println("\n Mostramos los elementos del arreglo: "); + for(int i=4; i>=0; i--){ // recorre de atras hacia adelante.. + System.out.println(i + " " + numeros[i]); + } + System.out.println("\n"); + } +} diff --git a/JavaSCuatri/Clase11Arreglos/Ejercicios/Ejercicio3.java b/JavaSCuatri/Clase11Arreglos/Ejercicios/Ejercicio3.java new file mode 100644 index 00000000..e65166ca --- /dev/null +++ b/JavaSCuatri/Clase11Arreglos/Ejercicios/Ejercicio3.java @@ -0,0 +1,49 @@ +package Clase11Arreglos.Ejercicios; + +import java.util.Scanner; + +// Leer 5 numeros. guardarlos en un arreglo y realizar la media de num positivos +// negativos y contar el numero de ceros. + +public class Ejercicio3 { + public static void main(String[] args) { + Scanner entrada = new Scanner(System.in); + float numeros[] = new float[5]; // Tipo float de dimension 5 + float negativos = 0, positivos = 0, mediaNegativos = 0, mediaPos = 0; + int conteo0 = 0, contNeg = 0, contPos = 0; + + System.out.println("Cargamos numeros al arreglo: "); + for(int i=0; i<5; i++){ + System.out.println((i+1) + " Escriba un número: "); + numeros[i] = entrada.nextFloat(); + if(numeros[i]>0){ + positivos += numeros[i]; + contPos++; + } + else if(numeros[i]<0){ // si es menor a 0, va sumando negativos + negativos+= numeros[i]; + contNeg++; + } + else{ + conteo0++; + } + } + if(contPos==0){ // si pos quedó en 0.. + System.out.println("\n No se puede sacar la media de num pos"); + } + else{ + mediaPos = positivos / contPos; + System.out.println("La media de numeros positivos es: " + mediaPos); + } + + if(contNeg==0){ // si pos quedó en 0.. + System.out.println("\n No se puede sacar la media de num negativos"); + } + else{ + mediaNegativos = negativos / contNeg; + System.out.println("La media de numeros negativos es: " + mediaNegativos); + } + + System.out.println("La cantidad de ceros es: " + conteo0); + } +} diff --git a/JavaSCuatri/Clase11Arreglos/Test/TestArreglos.java b/JavaSCuatri/Clase11Arreglos/Test/TestArreglos.java new file mode 100644 index 00000000..0288b178 --- /dev/null +++ b/JavaSCuatri/Clase11Arreglos/Test/TestArreglos.java @@ -0,0 +1,21 @@ +package Clase11Arreglos.Test; + +public class TestArreglos { + public static void main(String[] args) { //lado derecho. instanciamos un objeto + int edades [] = new int[3]; // almacenará 3 elementos. Del lado izq declaramos la var + System.out.println("edades = " + edades); + + // Completamos el arreglo con valores + edades[0] = 17; + System.out.println("edades 0 = " + edades[0]); + edades[1] = 29; + System.out.println("edades 1 = " + edades[1]); + edades[2] = 34; + System.out.println("edades 2 = " + edades[2]); + + for(int i = 0; i < edades.length; i++){ + System.out.println("edades y sus elementos " + i + " : "+edades[i]); + } + + } +} \ No newline at end of file diff --git a/JavaSCuatri/Clase11Arreglos/Test/TestArreglosObject.java b/JavaSCuatri/Clase11Arreglos/Test/TestArreglosObject.java new file mode 100644 index 00000000..47c0148a --- /dev/null +++ b/JavaSCuatri/Clase11Arreglos/Test/TestArreglosObject.java @@ -0,0 +1,27 @@ +package Clase11Arreglos.Test; + +import Clase11Arreglos.domain.Persona; + +public class TestArreglosObject { + public static void main(String[] args) { + Persona personas[] = new Persona[2]; + // Agregamos nuevas referecnias + personas[0] = new Persona("Matias"); + personas[1] = new Persona("Jorge"); + + System.out.println("personas 0 = " + personas[0]); + System.out.println("personas 1 = " + personas[1]); + + // Iteracion + for(int i = 0; i < personas.length; i++){ + System.out.println("personas " + i + " = " + personas[i]); + } + + // Arrreglos de sintesis resumida + + String frutas[] = {"Banana", "Pera", "Tomate"}; + for(int i = 0; i < frutas.length; i++){ + System.out.println("Frutas = " + frutas[i]); + } + } +} \ No newline at end of file diff --git a/JavaSCuatri/Clase11Arreglos/domain/Persona.java b/JavaSCuatri/Clase11Arreglos/domain/Persona.java new file mode 100644 index 00000000..7789560a --- /dev/null +++ b/JavaSCuatri/Clase11Arreglos/domain/Persona.java @@ -0,0 +1,19 @@ +package Clase11Arreglos.domain; + +public class Persona { + // Arreglos de tipo object + private String nombre; + + public Persona(String nombre) { + this.nombre = nombre; + } + + public String getNombre() { + return nombre; + } + + public void setNombre(String nombre) { + this.nombre = nombre; + } + +} diff --git a/JavaSCuatri/Clase12Matrices/Test/EjerciciosMatrices/matriz3x3.java b/JavaSCuatri/Clase12Matrices/Test/EjerciciosMatrices/matriz3x3.java new file mode 100644 index 00000000..a8632135 --- /dev/null +++ b/JavaSCuatri/Clase12Matrices/Test/EjerciciosMatrices/matriz3x3.java @@ -0,0 +1,39 @@ +package Clase12Matrices.Test.EjerciciosMatrices; + +import java.util.Scanner; + +public class matriz3x3 { + public static void main(String[] args) { + Scanner entrada = new Scanner(System.in); + int matriz[][] = new int[3][3]; + + System.out.println("RELLENAR MATRIZ: "); + for(int i = 0; i < 3; i++){ + for(int j = 0; j < 3;j++){ + System.out.println("Matriz [" + i + " ] [" + j + " ] = "); + matriz[i][j] = entrada.nextInt(); + } + } + System.out.println(); + + System.out.println("Matriz original"); + for(int i = 0; i < 3; i++){ + for(int j = 0; j < 3;j++){ + System.out.println(matriz[i] [j] + " "); + } + System.out.println(); + } + System.out.println(); + + // Matriz transpuesta + System.out.println("Matriz transpuesta: "); + for(int i = 0; i < 3; i++){ + for(int j = 0; j < 3;j++){ + System.out.println(matriz[j][i] + " "); + } + System.out.println(); + } + System.out.println(); + + } +} diff --git a/JavaSCuatri/Clase12Matrices/Test/Test/EjerciciosMatrices/Matriznxm.java b/JavaSCuatri/Clase12Matrices/Test/Test/EjerciciosMatrices/Matriznxm.java new file mode 100644 index 00000000..b68894e0 --- /dev/null +++ b/JavaSCuatri/Clase12Matrices/Test/Test/EjerciciosMatrices/Matriznxm.java @@ -0,0 +1,64 @@ +package Clase12Matrices.Test.EjerciciosMatrices; + +import java.util.Scanner; + +import javax.swing.JOptionPane; + +public class Matriznxm { + /** + * @param args + */ + public static void main(String[] args) { + Scanner entrada = new Scanner(System.in); + int matriz[][], nFilas, nColum, sumaFilas, sumaCol; + int posFila, posCol; + nFilas = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero de filas: ")); + nColum = Integer.parseInt(JOptionPane.showInputDialog("Ingrese la cantidad de columnas: ")); + + matriz = new int [nFilas] [nColum]; //instanciamos + int filas[] = new int [nFilas]; + int columnas[] = new int [nColum]; + + System.out.println("Completamos matriz: "); + for(int i=0; i < nFilas; i++){ + for(int j=0; j < nColum; j++){ + System.out.println("Matriz [" + i + "] [" + j + "]"); + matriz[i][j] = entrada.nextInt(); + } + } + System.out.println("Matriz original: "); + for(int i=0; i < nFilas; i++){ + for(int j=0; j10UMLClass040300580UMLClass01014030Un dominio, direccion UMLClass1040210210<<Orden>> +- +-idOrden: +-producto[]: Producto +-ContOrdenes: int +MAXPRODUCTOS: int = 10 +-- ++Orden() ++agregarProd(producto): Producto ++calcularTotal(): double ++mostrarOrden(): void +-- +Responsibilities +-- Crear objetos Orden +-- Adm. lod productos UMLClass50040210180UMLClass5001010030Test ventasRelation1701032030lt=<<.10;10;300;10UMLClass10320210290<<Producto>> +- +-idProducto: int +-nombre: String +-precio: double +-contadorProductos: int +-- +-Producto() ++Producto(nombre: String, precio: double) ++getIdProducto(): int ++getNombre(): String ++setNombre(nombre: String): void ++getPrecio(): double ++setPrecio(precio: double): void ++toString(): String +-- +Responsibilities +-- Crear objetos dee tipo productos Relation110240240100lt=<. +<<Un producto se agrega a una orden>>10;10;10;80UMLClass52040210120<<VentasTest>> +-- ++main(args: String[]): void +-- +Responsibilidades +-- Ejecutar la prueba de + la aplicacion de ventas \ No newline at end of file diff --git a/JavaSCuatri/Clase2Ciclos/Ej1.java b/JavaSCuatri/Clase2Ciclos/Ej1.java new file mode 100644 index 00000000..32db6e17 --- /dev/null +++ b/JavaSCuatri/Clase2Ciclos/Ej1.java @@ -0,0 +1,23 @@ +/// CLASE NUMERO 2. Ejercicios con ciclos y Crear Clases + +/// Leer un numero y mostrar su cuadrado, hasta que ingrese un numero negativo + +package Clase2Ciclos; +import java.util.Scanner; + +public class Ej1 { + public static void main(String[] args) { + + Scanner entrada = new Scanner(System.in); + int numero, cuadrado; + System.out.println("Escriba un numero"); + numero = Integer.parseInt(entrada.nextLine()); + while(numero >=0){ + cuadrado = (int)Math.pow(numero, 2); + System.out.println("El numero "+numero+" elevado al cuadrado es: "+cuadrado); + System.out.println("Escriba otro numero: "); + numero = Integer.parseInt(entrada.nextLine()); + } + System.out.println("El programa ha finalizado"); + } +} \ No newline at end of file diff --git a/JavaSCuatri/Clase2Ciclos/Ej2.java b/JavaSCuatri/Clase2Ciclos/Ej2.java new file mode 100644 index 00000000..810f3802 --- /dev/null +++ b/JavaSCuatri/Clase2Ciclos/Ej2.java @@ -0,0 +1,22 @@ +package Clase2Ciclos; +// Ejercicio 1 de ciclos en Java sin la clase Scanner +// Leer un numero y mostrar su cuadrado, hasta que ingrese un numero negativo +import javax.swing.JOptionPane; + +public class Ej2 { + public static void main(String[] args) { + int numero, cuadrado; + // JOptionPane, ofrece una ventana emergente mostrando el texto + numero = Integer.parseInt(JOptionPane.showInputDialog("Escriba un numero: ")); + + while(numero >=0){ + cuadrado = (int)Math.pow(numero, 2); + System.out.println("El numero "+numero+" elevado al cuadrado es: "+cuadrado); + + numero = Integer.parseInt(JOptionPane.showInputDialog("Escriba otro numero: ")); + } + System.out.println("El programa ha finalizado por un numero negativo"); + + } + +} diff --git a/JavaSCuatri/Clase2Ciclos/Ej2JOption.java b/JavaSCuatri/Clase2Ciclos/Ej2JOption.java new file mode 100644 index 00000000..4a450fe8 --- /dev/null +++ b/JavaSCuatri/Clase2Ciclos/Ej2JOption.java @@ -0,0 +1,27 @@ +package Clase2Ciclos; + +import javax.swing.JOptionPane; + +// Ejercicio2= leer un numero e indicar si es pos o neg. +// se repite el proc hasta que ingrese 0 + + +public class Ej2JOption { + public static void main(String[] args) { + // con integer.parseInt nos ayuda a eliminar elproblema con el tipo de dato + // tipo string a entero + var num = Integer.parseInt(JOptionPane.showInputDialog("Escriba un num: ")); + while(num != 0){ + if(num > 0){ + JOptionPane.showMessageDialog(null, " El num " + num + " es positivo "); + } + else{ + JOptionPane.showMessageDialog(null, "El numero" + num + " es negativo "); + } + System.out.println(" Escriba un numero: "); + num = Integer.parseInt(JOptionPane.showInputDialog(" Escriba otro numero: ")); + } + JOptionPane.showMessageDialog(null, " El numero: "+ num +" finaliza el programa"); + } + +} diff --git a/JavaSCuatri/Clase2Ciclos/Ej2PosOneg.java b/JavaSCuatri/Clase2Ciclos/Ej2PosOneg.java new file mode 100644 index 00000000..2989c224 --- /dev/null +++ b/JavaSCuatri/Clase2Ciclos/Ej2PosOneg.java @@ -0,0 +1,26 @@ +package Clase2Ciclos; + +import java.util.Scanner; + +// Ejercicio2= leer un numero e indicar si es pos o neg. +// se repite el proc hasta que ingrese 0 + +public class Ej2PosOneg { + public static void main(String[] args) { + Scanner entrada = new Scanner(System.in); + System.out.println("Escriba un numero para ver si es + o - : "); + var num = Integer.parseInt(entrada.nextLine()); + while(num != 0){ + if(num > 0){ + System.out.println(" El numero "+num+" es positivo "); + } + else{ + System.out.println("El numero es negativo"); + } + System.out.println("Escriba un numero: "); + num = Integer.parseInt(entrada.nextLine()); + } + System.out.println("El numero: "+ num +" finaliza el programa"); + } + +} diff --git a/JavaSCuatri/Clase2Ciclos/Leccion3/persona.java b/JavaSCuatri/Clase2Ciclos/Leccion3/persona.java new file mode 100644 index 00000000..8681f5ea --- /dev/null +++ b/JavaSCuatri/Clase2Ciclos/Leccion3/persona.java @@ -0,0 +1,10 @@ +package Clase2Ciclos.Leccion3; + +// vamos a crear una clase(persona(valores)) pero vamos a trabajar +// en el objeto(nombre, apellido,etc), a partir de la clase + +public class persona { + public static void main(String[] args) { + + } +} diff --git a/JavaSCuatri/Clase3Completa/ClasesyObjetos.java b/JavaSCuatri/Clase3Completa/ClasesyObjetos.java new file mode 100644 index 00000000..27a477b6 --- /dev/null +++ b/JavaSCuatri/Clase3Completa/ClasesyObjetos.java @@ -0,0 +1,23 @@ +package Clase3Completa; + +// Objeto: percibiido por los cinco sentidos, tiene atributos(caract), +// necesita de la clase y en ella estan alojados los atributos. +// Clase: conjunto de objetos, es la plantilla, donde creamos el objeto. + +// Nombre de la clase: Persona +// Atributos: -nombre: string +// -genero: char +// -ocupacion: string +// Metodos: -obtenerNombre(): +// -obtenerGenero(): +// -obtenerOcupacion(): +// ........... + +public class ClasesyObjetos { + public static void main(String[] args) { + // Atributos de la clase + String nombre; + String apellido; + + } +} diff --git a/JavaSCuatri/Clase3Completa/EjCiclos03JOption.java b/JavaSCuatri/Clase3Completa/EjCiclos03JOption.java new file mode 100644 index 00000000..640d9a64 --- /dev/null +++ b/JavaSCuatri/Clase3Completa/EjCiclos03JOption.java @@ -0,0 +1,22 @@ +package Clase3Completa; + +import javax.swing.JOptionPane; + +public class EjCiclos03JOption { + public static void main(String[] args) { + int numero; + + numero = Integer.parseInt(JOptionPane.showInputDialog("Escriba un número")); + + while(numero != 0){ + if (numero % 2 == 0){ // mientras esto es T, el num es par + JOptionPane.showMessageDialog(null, "El numero inresado " + numero + " es par"); + } + else{ + JOptionPane.showMessageDialog(null, "El numero ingresado: " + numero + " es impar"); + } + numero = Integer.parseInt(JOptionPane.showInputDialog(" Escriba un numero")); + } + JOptionPane.showMessageDialog(null, "El numero 0 termina el programa"); + } +} diff --git a/JavaSCuatri/Clase3Completa/Ejercicio4Ciclos.java b/JavaSCuatri/Clase3Completa/Ejercicio4Ciclos.java new file mode 100644 index 00000000..ce0b754b --- /dev/null +++ b/JavaSCuatri/Clase3Completa/Ejercicio4Ciclos.java @@ -0,0 +1,25 @@ +package Clase3Completa; + +import java.util.Scanner; + +// Pedir numeros hasta que se teclee uno negativo y mostrar +// cuantos num se ingresaron + +public class Ejercicio4Ciclos { + public static void main(String[] args) { + Scanner entrada = new Scanner(System.in); + int numero, conteo = 0; + + System.out.println("Escriba un número: "); + numero = Integer.parseInt(entrada.nextLine()); + + while (numero >= 0){ + System.out.println("El numero: " + numero + " es positivo"); + conteo++; // realiza el conteo de cada num ingresado + System.out.println("Escriba otro numero: "); + numero = Integer.parseInt(entrada.nextLine()); // vuelve a pedir el num + } + // ingresa un negativo y sale del ciclo + System.out.println("A ingresado: " + conteo + " numeros que no son negativos"); + } +} diff --git a/JavaSCuatri/Clase3Completa/Ejercicio4JOption.java b/JavaSCuatri/Clase3Completa/Ejercicio4JOption.java new file mode 100644 index 00000000..822fb510 --- /dev/null +++ b/JavaSCuatri/Clase3Completa/Ejercicio4JOption.java @@ -0,0 +1,23 @@ +package Clase3Completa; +import javax.swing.JOptionPane; + +// Pedir numeros hasta que se teclee uno negativo y mostrar +// cuantos num se ingresaron + +public class Ejercicio4JOption { + public static void main(String[] args) { + int numero, conteo = 0; + + numero = Integer.parseInt(JOptionPane.showInputDialog("Escriba un numero: ")); + + while (numero >= 0){ + JOptionPane.showMessageDialog(null,"El numero: " + numero + " es positivo"); + conteo++; // realiza el conteo de cada num ingresado + + numero = Integer.parseInt(JOptionPane.showInputDialog("Escriba otro numero: ")); // vuelve a pedir el num + } + // ingresa un negativo y sale del ciclo + JOptionPane.showMessageDialog(null,"A ingresado: " + conteo + " numeros que no son negativos"); + } +} + \ No newline at end of file diff --git a/JavaSCuatri/Clase3Completa/Ejercicio5CS.java b/JavaSCuatri/Clase3Completa/Ejercicio5CS.java new file mode 100644 index 00000000..73e90e5a --- /dev/null +++ b/JavaSCuatri/Clase3Completa/Ejercicio5CS.java @@ -0,0 +1,34 @@ +package Clase3Completa; +import java.util.Scanner; + +// Realizar un juego para adivinar el numero, para ello +// generar un numero aleatorio entre 0-100 y luego ir pidiendo +// numeros indicando "es mayor" o "menor", segun sea mayor o menor +// con respecto a N. Termina cuando el usuario acierta y mostramos la cant de intentos + +public class Ejercicio5CS { + public static void main(String[] args) { + Scanner entrada = new Scanner(System.in); + int numero, aleator, cont = 0; + /// generar un num aleatorio + aleator = (int)(Math.random()*100); // conv a entero, genera un aleatorio + + do{ + System.out.println("Escriba un numero: "); + numero = Integer.parseInt(entrada.nextLine()); + /// una vez que ingresa el num: + + if(numero < aleator){ + System.out.println("Ingrese un numero mayor"); + } + else if(numero > aleator){ + System.out.println("Ingrese un numero menor"); + } + else{ // se nuestra una vez que acierta el num + System.out.println("¡FELICIDADES! Acertaste"); + } + cont++; + } while(numero != aleator); // repetir hasta q num sea distinto de aleatorio + System.out.println("Adivinaste el numero " + aleator + " en: " + cont + " intentos"); + } +} diff --git a/JavaSCuatri/Clase3Completa/Ejercicio5JOption.java b/JavaSCuatri/Clase3Completa/Ejercicio5JOption.java new file mode 100644 index 00000000..74d78fd9 --- /dev/null +++ b/JavaSCuatri/Clase3Completa/Ejercicio5JOption.java @@ -0,0 +1,33 @@ +package Clase3Completa; + +import javax.swing.JOptionPane; + +// Realizar un juego para adivinar el numero, para ello +// generar un numero aleatorio entre 0-100 y luego ir pidiendo +// numeros indicando "es mayor" o "menor", segun sea mayor o menor +// con respecto a N. Termina cuando el usuario acierta y mostramos la cant de intentos + +public class Ejercicio5JOption { + public static void main(String[] args) { + int numero, aleator, cont = 0; + /// generar un num aleatorio + aleator = (int)(Math.random()*100); // conv a entero, genera un aleatorio + + do{ + numero = Integer.parseInt(JOptionPane.showInputDialog("Escriba un numero: ")); + /// una vez que ingresa el num: + + if(numero < aleator){ + JOptionPane.showMessageDialog(null,"Ingrese un numero mayor"); + } + else if(numero > aleator){ + JOptionPane.showMessageDialog(null,"Ingrese un numero menor"); + } + else{ // se nuestra una vez que acierta el num + JOptionPane.showMessageDialog(null,"¡FELICIDADES! Acertaste"); + } + cont++; + } while(numero != aleator); // repetir hasta q num sea distinto de aleatorio + JOptionPane.showMessageDialog(null,"Adivinaste el numero " + aleator + " en: " + cont + " intentos"); + } +} diff --git a/JavaSCuatri/Clase3Completa/EjercicioCiclos3A.java b/JavaSCuatri/Clase3Completa/EjercicioCiclos3A.java new file mode 100644 index 00000000..55aa1536 --- /dev/null +++ b/JavaSCuatri/Clase3Completa/EjercicioCiclos3A.java @@ -0,0 +1,29 @@ +package Clase3Completa; + +import java.util.Scanner; + +// Leer numeros hasta que se introduzca el cero. Para cada num +// indicar si es par o no. Luego con JOptionPane + +public class EjercicioCiclos3A { + public static void main(String[] args) { + Scanner entrada = new Scanner(System.in); + + int numero; + System.out.println("Escriba un número: "); + numero = Integer.parseInt(entrada.nextLine()); + + while(numero != 0){ + if (numero % 2 == 0){ // mientras esto es T, el num es par + System.out.println("El numero inresado " + numero + " es par"); + } + else{ + System.out.println("El numero ingresado: " + numero + " es impar"); + } + System.out.println("Escriba un numero: "); + numero = Integer.parseInt(entrada.nextLine()); + } + + System.out.println("El numero 0 termina el programa"); + } +} diff --git a/JavaSCuatri/Clase4Completa/Ejercicio6CS.java b/JavaSCuatri/Clase4Completa/Ejercicio6CS.java new file mode 100644 index 00000000..1ba2bc22 --- /dev/null +++ b/JavaSCuatri/Clase4Completa/Ejercicio6CS.java @@ -0,0 +1,22 @@ +package Clase4Completa; + +import java.util.Scanner; + +// Pedir numeros hasta que se teclee 0, mostrar la suma +// de todos los mumeros introducidos + +public class Ejercicio6CS { + public static void main(String[] args) { + Scanner entrada = new Scanner(System.in); + + int numero, suma = 0; + do{ + System.out.println("Ingrese un numero: "); + numero = Integer.parseInt(entrada.nextLine()); + suma+= numero; // hacemos que se sumen los num ingresados + + }while(numero != 0); + System.out.println("La suma de todos los num ingresados es: " + suma); + + } +} diff --git a/JavaSCuatri/Clase4Completa/Ejercicio6OP.java b/JavaSCuatri/Clase4Completa/Ejercicio6OP.java new file mode 100644 index 00000000..5cb8f235 --- /dev/null +++ b/JavaSCuatri/Clase4Completa/Ejercicio6OP.java @@ -0,0 +1,16 @@ +package Clase4Completa; + +import javax.swing.JOptionPane; + +public class Ejercicio6OP { + public static void main(String[] args){ + int numero, suma = 0; + do{ + numero = Integer.parseInt(JOptionPane.showInputDialog("Escriba un numero: ")); + suma+= numero; // hacemos que se sumen los num ingresados + + }while(numero != 0); + JOptionPane.showMessageDialog(null,"La suma de todos los num ingresados es: " + suma); + + } +} diff --git a/JavaSCuatri/Clase4Completa/Leccion4/Aritmetica/OperacionPromedioJO.java b/JavaSCuatri/Clase4Completa/Leccion4/Aritmetica/OperacionPromedioJO.java new file mode 100644 index 00000000..d0c146e5 --- /dev/null +++ b/JavaSCuatri/Clase4Completa/Leccion4/Aritmetica/OperacionPromedioJO.java @@ -0,0 +1,30 @@ +package Clase4Completa.Leccion4.Aritmetica; + +import javax.swing.JOptionPane; + +// Ejercicios: pedir numeros hasta que se introduzca uno negativo y calcular la media + +public class OperacionPromedioJO { + public static void main(String[] args) { + + int numero, conteo = 0, suma = 0; + float promedio = 0; + + numero = Integer.parseInt(JOptionPane.showInputDialog("Digite un numero: ")); + + //mientras el num no sea neg + while(numero >=0){ + suma+= numero; // va sumando + conteo ++; // va sumando uno a conteo + + numero = Integer.parseInt(JOptionPane.showInputDialog("Escriba otro numero: ")); + } // Si ingresa neg no va a sumar, contar, nada. Por eso usamos if + if(conteo == 0){ + JOptionPane.showMessageDialog(null,"Eror, La division por 0 no existe"); + } + else{ + promedio = (float) suma/conteo; + JOptionPane.showMessageDialog(null,"El promedio es: " + promedio); + } + } +} diff --git a/JavaSCuatri/Clase4Completa/Leccion4/Aritmetica/Operaciones.java b/JavaSCuatri/Clase4Completa/Leccion4/Aritmetica/Operaciones.java new file mode 100644 index 00000000..2d3d2b97 --- /dev/null +++ b/JavaSCuatri/Clase4Completa/Leccion4/Aritmetica/Operaciones.java @@ -0,0 +1,14 @@ +package Clase4Completa.Leccion4.Aritmetica; + +public class Operaciones { // pascalcase para clases + // Atributos de la clase + int a; + int b; + + // Metodo + public void sumaNum(){ // camelcase para metodos/atributos + // cuerpo de la clase. Var locales + int resultado = a + b; + System.out.println("Resultado = " + resultado); + } +} diff --git a/JavaSCuatri/Clase4Completa/Leccion4/Aritmetica/Operaciones07.java b/JavaSCuatri/Clase4Completa/Leccion4/Aritmetica/Operaciones07.java new file mode 100644 index 00000000..f05deecb --- /dev/null +++ b/JavaSCuatri/Clase4Completa/Leccion4/Aritmetica/Operaciones07.java @@ -0,0 +1,29 @@ +package Clase4Completa.Leccion4.Aritmetica; + +// Ejercicios: pedir numeros hasta que se introduzca uno negativo y calcular la media +import java.util.Scanner; + +public class Operaciones07 { + public static void main(String[] args) { + Scanner entrada = new Scanner(System.in); + int numero, conteo = 0, suma = 0; + float promedio = 0; + System.out.println("Escriba un numero: "); + numero = Integer.parseInt(entrada.nextLine()); // conversion + + //mientras el num no sea neg + while(numero >=0){ + suma+= numero; // va sumando + conteo ++; // va sumando uno a conteo + System.out.println("Ingrese otro numero: "); + numero = Integer.parseInt(entrada.nextLine()); + } // Si ingresa neg no va a sumar, contar, nada. Por eso usamos if + if(conteo == 0){ + System.out.println("\nEror, La division por 0 no existe"); + } + else{ + promedio = (float) suma/conteo; + System.out.println("El promedio es: " + promedio); + } + } +} diff --git a/JavaSCuatri/Clase4Completa/Persona.java b/JavaSCuatri/Clase4Completa/Persona.java new file mode 100644 index 00000000..12a13e1d --- /dev/null +++ b/JavaSCuatri/Clase4Completa/Persona.java @@ -0,0 +1,22 @@ +// Clase 4 Clases y Objetos Parte 2 + +// Un metodo es una parte de codigo que vamos a poder +// reutilizar + +package Clase4Completa; + +public class Persona { + + // ((Las caract son los atributos)) Atributos de la clase + + String nombres; // puede recibir valores(argumento) o regresar (valor de retorno) + String apellidos; + + // Métodos de la clase (acciones) + + public void ObtenerInformacion() { // indicar que se puede usar por fuera de la clase y el void(no regresa info) + System.out.println("Nombre: " + nombres); // dentro de la clase podemos definir los atributos + System.out.println("Apellido: " + apellidos); + } + +} \ No newline at end of file diff --git a/JavaSCuatri/Clase4Completa/PruebaPersona.java b/JavaSCuatri/Clase4Completa/PruebaPersona.java new file mode 100644 index 00000000..d18267ce --- /dev/null +++ b/JavaSCuatri/Clase4Completa/PruebaPersona.java @@ -0,0 +1,32 @@ +package Clase4Completa; + +// 4.2 CREACION DE UN OBJETO, a partir de la persona (parte de arriba) + +public class PruebaPersona { + public static void main(String[] args) { // es una variable de tipo local que al terminar la ejecucion se destruye + Persona persona1; // :tipo de clase + persona1 = new Persona(); // llama al constructor Persona desde el objeto y permite asignar valor + persona1.nombres = "Matias"; // atributos. transformamos la clase a objeto + persona1.apellidos = "Ikaczijk"; + + // llamamos al metodo (recibe los valores y los imprime) con el objeto + + persona1.ObtenerInformacion(); // Muestra los valores del atributo en la clase + + // ------- + + // objetos --> Persona1 y Persona2 Son las instancias que crean al objeto + + Persona persona2 = new Persona(); // creamos otro obj + System.out.println("persona2 = " + persona2); + System.out.println("persona1 = " + persona1); + + persona2.ObtenerInformacion(); // da null porque ausenta de valor, no hay nada cargado y los obj no comparten info + + // cargamos los datos de persona2 + persona2.nombres = "Juan"; + persona2.apellidos = "Flores"; + persona2.ObtenerInformacion(); + + } +} diff --git a/JavaSCuatri/Clase5/ClaseAritmetica/CreamosUnMetodo.java b/JavaSCuatri/Clase5/ClaseAritmetica/CreamosUnMetodo.java new file mode 100644 index 00000000..5520f280 --- /dev/null +++ b/JavaSCuatri/Clase5/ClaseAritmetica/CreamosUnMetodo.java @@ -0,0 +1,7 @@ +package Clase5.ClaseAritmetica; + +public class CreamosUnMetodo { + public static void main(String[] args) { + + } +} diff --git a/JavaSCuatri/Clase5/ClaseAritmetica/CreamosUnObjeto.java b/JavaSCuatri/Clase5/ClaseAritmetica/CreamosUnObjeto.java new file mode 100644 index 00000000..72f064e0 --- /dev/null +++ b/JavaSCuatri/Clase5/ClaseAritmetica/CreamosUnObjeto.java @@ -0,0 +1,74 @@ +package Clase5.ClaseAritmetica; + +import Clase4Completa.Leccion4.Aritmetica.Operaciones; + +public class CreamosUnObjeto { + public static void main(String[] args) { + int a = 7; + int b = 3; // var local <-- memoria stack + miMetodo(); // llamamos el metodo nuevo + + Operaciones aritmetica1 = new Operaciones(); // llamamos al intructor + aritmetica1.a = 3; + aritmetica1.b = 7; + aritmetica1.sumaNum(); + + // Para almacenar un objeto u atributo, se utiliza memoria heap + + int resultado = aritmetica1.sumarConRetorno(); + System.out.println("Resultado: " + resultado); + + resultado = aritmetica1.sumarConArgumentos(12, 26); + System.out.println("Resultado usando argumentos: " + resultado); + + // Mod CLASE 6 + System.out.println("aritmetica1 a: " + aritmetica1.a); + System.out.println("aritmetica1 b: " + aritmetica1.b); + + Operaciones aritmetica2 = new Operaciones(5,8); + System.out.println("aritmetica2 = " + aritmetica2.a); + System.out.println("aritmetica2 = " + aritmetica2.b); + + // aritmetica1 = null, nunca usar esto + Persona persona = new Persona("Matias", "Ikaczijk"); + System.out.println("persona = " + persona); + System.out.println("Persona nombre = " + persona.nombre); + System.out.println("Persona apellido = " + persona.apellido); + } + + // MOD CLASE 6. MODULARIDAD + + public static void miMetodo(){ + // int a = 10; + System.out.println("Aquí hay otro metodo"); + } + +} +// creamos una clase dentro de otra.. No podrá ser publica +// default o package. NUEVA CLASE: + +class Persona{ + // pondremos atributos.. + String nombre; + String apellido; + + Persona(String nombre, String apellido){ + super(); // metodo constructor de la clase Padre object + new Imprimir().imprimir(this); + this.nombre = nombre; + this.apellido = apellido; // constructor q apunta a los atributos + System.out.println("Objeto persona usando this: " + this); //muestra ek num de referencia de la memoria + } +} +class Imprimir{ + public Imprimir(){ + super(); // constructor de la clase padre, para reservar memoria + } + + // metodo dentro de la clase.. + + public void imprimir(Persona persona){ + System.out.println("Persona desde la clase imprimir: " + persona); + System.out.println("Impresion del objeto actual (this) : " + this); + } +} diff --git a/JavaSCuatri/Clase5/EjerciciosJava/Ej8JOption.java b/JavaSCuatri/Clase5/EjerciciosJava/Ej8JOption.java new file mode 100644 index 00000000..b4d6b17f --- /dev/null +++ b/JavaSCuatri/Clase5/EjerciciosJava/Ej8JOption.java @@ -0,0 +1,17 @@ +package Clase5.EjerciciosJava; +// Pedir un numero N y mostrar los numeros que se encuentran hasta N + +import javax.swing.JOptionPane; + +public class Ej8JOption { + public static void main(String[] args) { + + int numero = Integer.parseInt(JOptionPane.showInputDialog("Escriba un numero: ")); + int i = 1; + + while(i <= numero){ // mientras sea menor al numero ingresado, va mostrando + JOptionPane.showMessageDialog(null,i); + i++; + } + } +} diff --git a/JavaSCuatri/Clase5/EjerciciosJava/Ejercicio8PedirNum.java b/JavaSCuatri/Clase5/EjerciciosJava/Ejercicio8PedirNum.java new file mode 100644 index 00000000..e3a2cfa8 --- /dev/null +++ b/JavaSCuatri/Clase5/EjerciciosJava/Ejercicio8PedirNum.java @@ -0,0 +1,19 @@ +package Clase5.EjerciciosJava; +// Pedir un numero N y mostrar los numeros que le anteceden + +import java.util.Scanner; + +public class Ejercicio8PedirNum { + public static void main(String[] args) { + Scanner entrada = new Scanner(System.in); + System.out.println("Escriba un número: "); + int numero = Integer.parseInt(entrada.nextLine()); + int i = 1; + + while(i <= numero){ // mientras sea menor al numero ingresado, va mostrando + System.out.println(i); + i++; + } + entrada.close(); + } +} diff --git a/JavaSCuatri/Clase5/EjerciciosJava/Ejercicio9Ciclos.java b/JavaSCuatri/Clase5/EjerciciosJava/Ejercicio9Ciclos.java new file mode 100644 index 00000000..9decbd70 --- /dev/null +++ b/JavaSCuatri/Clase5/EjerciciosJava/Ejercicio9Ciclos.java @@ -0,0 +1,36 @@ +package Clase5.EjerciciosJava; + +import java.util.Scanner; + + +// Pedir el dia, mes y año de una fecha e indicar si es correcta. +// Suponiendo que todos los meses tienen 30 dias + +public class Ejercicio9Ciclos { + public static void main(String[] args) { + Scanner entrada = new Scanner(System.in); + + System.out.println("Escriba el dia: "); + int dia = Integer.parseInt(entrada.nextLine()); + + System.out.println("Escriba el mes: "); + int mes = Integer.parseInt(entrada.nextLine()); + + System.out.println("Escriba el año: "); + int anio = Integer.parseInt(entrada.nextLine()); + + if((dia != 0) && (dia <= 30)){ + if((mes != 0) && (anio <= 2023)){ + System.out.println("La fecha ingresada es: " + dia + "/" + mes + "/" + anio); + } + else{ + System.out.println("Fecha incorrecta, año incorrecto"); + } + } + else{ + System.out.println("Fecha incorrecta, dia incorrecto"); + } + entrada.close(); + } +} + diff --git a/JavaSCuatri/Clase5/EjerciciosJava/Ejercicio9JOption.java b/JavaSCuatri/Clase5/EjerciciosJava/Ejercicio9JOption.java new file mode 100644 index 00000000..f9833d06 --- /dev/null +++ b/JavaSCuatri/Clase5/EjerciciosJava/Ejercicio9JOption.java @@ -0,0 +1,34 @@ +package Clase5.EjerciciosJava; + +import javax.swing.JOptionPane; + +// Pedir el dia, mes y año de una fecha e indicar si es correcta. +// Suponiendo que todos los meses tienen 30 dias + +public class Ejercicio9JOption { + public static void main(String[] args) { + + int dia = Integer.parseInt(JOptionPane.showInputDialog("Escriba el dia")); + + int mes = Integer.parseInt(JOptionPane.showInputDialog("Escriba el mes: ")); + + int anio = Integer.parseInt(JOptionPane.showInputDialog("Escriba el año: ")); + + if((dia != 0) && (dia <= 30)){ + if((mes != 0) && (mes <= 12)){ + if((mes != 0) && (anio <= 2023)){ + JOptionPane.showMessageDialog(null,"La fecha ingresada es: " + dia + "/" + mes + "/" + anio); + } + else{ + JOptionPane.showMessageDialog(null,"Fecha incorrecta, año incorrecto"); + } + } + else{ + JOptionPane.showMessageDialog(null,"Fecha incorrecta, dia incorrecto"); + } + } + else{ + JOptionPane.showMessageDialog(null, "Fecha incorrecta, dia incorrecto"); + } + } +} diff --git a/JavaSCuatri/Clase6POO/Ejercicios/ProyectoCaja/Caja/Caja.java b/JavaSCuatri/Clase6POO/Ejercicios/ProyectoCaja/Caja/Caja.java new file mode 100644 index 00000000..be840714 --- /dev/null +++ b/JavaSCuatri/Clase6POO/Ejercicios/ProyectoCaja/Caja/Caja.java @@ -0,0 +1,28 @@ +package Clase6POO.Ejercicios.ProyectoCaja.Caja; + +// Ejercicio1: Crear un proyecto según las especificaciones +// mostradas a continuacion +// --- La formula es: volumen = ancho * alto * profundida + +public class Caja { // Clase publica caja + // atributos, caract + int ancho; + int alto; + int profundidad; + + // metodos y construcciones(acciones) + public Caja() { // const 1 vacio + } + + // Constructor 2 con parametros + public Caja(int ancho, int alto, int profundidad) { + this.ancho = ancho; // this apunta al espacio de memoria + this.alto = alto; + this.profundidad = profundidad; + } + + public int calcularVolumen(){ // metodo para calcular + return ancho * alto * profundidad; + } + +} diff --git a/JavaSCuatri/Clase6POO/Ejercicios/ProyectoCaja/Caja/PruebaCaja.java b/JavaSCuatri/Clase6POO/Ejercicios/ProyectoCaja/Caja/PruebaCaja.java new file mode 100644 index 00000000..3ae71ec7 --- /dev/null +++ b/JavaSCuatri/Clase6POO/Ejercicios/ProyectoCaja/Caja/PruebaCaja.java @@ -0,0 +1,26 @@ +package Clase6POO.Ejercicios.ProyectoCaja.Caja; + +public class PruebaCaja { + public static void main(String args[]) { // metodo main + // Variables locales + int medidaAncho = 3; // valores ingresados en codigo duro + int medidaAlto = 2; + int medidaProf = 6; + + Caja caja1 = new Caja(); // Instanciamos el obj, constructor vacio + caja1.ancho = medidaAncho; // pasamos los valores al obj + caja1.alto = medidaAlto; + caja1.profundidad = medidaProf; + + int resultado = caja1.calcularVolumen(); // Llamamos al metodo + + // Primer resultado + System.out.println("resultado de volumen de caja 1: " + resultado); + + Caja caja2 = new Caja(2,4,6); // llamamos al constructor 2 con nuevos argumentos + + // llamamos con el nuevo objeto al método para un nuevo calculo + + System.out.println("resultado volumen de caja 2: " + caja2.calcularVolumen()); + } +} \ No newline at end of file diff --git a/JavaSCuatri/Clase6POO/PasoXReferencia.java b/JavaSCuatri/Clase6POO/PasoXReferencia.java new file mode 100644 index 00000000..e6c9127e --- /dev/null +++ b/JavaSCuatri/Clase6POO/PasoXReferencia.java @@ -0,0 +1,42 @@ +package Clase6POO; + +import Clase2Ciclos.Leccion3.persona; +import Clase4Completa.Persona; + +public class PasoXReferencia { + public static void main(String[] args) { + // instanciar un objeto + Persona persona1 = new Persona(); // llamamos al const de la otra clase + persona1.nombres = "Juan"; + System.out.println("persona1 nombre = " + persona1.nombres); + + CambioValor(persona1); + + System.out.println("El cambio que hicimos en el nombre es: " + persona1.nombres); + persona1 = cambiarElvalor(persona1); + + // Persona persona2 = null; + + Persona persona2 = new Persona(); + persona2 = cambiarElvalor(persona2); + System.out.println("El nuevo valor del obj es: " + persona2.nombres); + } + // para acceder al obj y clase: // PASO X REF + public static void CambioValor(Persona persona){ + persona.nombres = "Esteban"; + } + // otro metodo + public static Persona cambiarElvalor(Persona persona){ + // debemos retornar algo + // -- en caso que necesitemos incorporar el return varias veces: + if(persona == null){ + System.out.println("Valor de persona invalido, Null"); + return null; + } + else{ + persona.nombres = "Monica"; + return persona; // finalizacion de un metodo + } + + } +} diff --git a/JavaSCuatri/Clase6POO/PasoXvalor.java b/JavaSCuatri/Clase6POO/PasoXvalor.java new file mode 100644 index 00000000..b33c69e4 --- /dev/null +++ b/JavaSCuatri/Clase6POO/PasoXvalor.java @@ -0,0 +1,14 @@ +package Clase6POO; + +public class PasoXvalor { + public static void main(String[] args) { + var valorX = 20; + System.out.println("valorX = " + valorX); + CambioValor(valorX); // Solo lo enviamos una copia + System.out.println("valorX = " + valorX); + } + public static void CambioValor(int arg1){ // parametro por valor + System.out.println(" arg1 = " + arg1); + arg1 = 15; + } +} diff --git a/JavaSCuatri/Clase6POO/SobrecargadeConstructor.java b/JavaSCuatri/Clase6POO/SobrecargadeConstructor.java new file mode 100644 index 00000000..47dcd8a8 --- /dev/null +++ b/JavaSCuatri/Clase6POO/SobrecargadeConstructor.java @@ -0,0 +1,21 @@ +package Clase6POO; + +public class SobrecargadeConstructor { + // atributos de la clase + int a; + int b; + + // El constructor es un metodo especial. 3 objetivos: + // contruye un objeto, reserva espacio de memo, inicia los atrib de la clase + + public SobrecargadeConstructor(){ + System.out.println("Se está ejecutando el constructor 1.."); + } + + public SobrecargadeConstructor(int a, int b){ + this.a = a; + this.b = b; + System.out.println("Se está ejecutando el constructor 2"); + } + +} diff --git a/JavaSCuatri/Clase6POO/ciclo10JOP.java b/JavaSCuatri/Clase6POO/ciclo10JOP.java new file mode 100644 index 00000000..4568b6c8 --- /dev/null +++ b/JavaSCuatri/Clase6POO/ciclo10JOP.java @@ -0,0 +1,16 @@ +package Clase6POO; +import javax.swing.JOptionPane; + +// Ejercicio 10 : Pedir 10 números y escribir la suma total + +public class ciclo10JOP { + public static void main(String[] args) { + int numero, suma = 0; + for(int i = 1; i <= 10; i ++){ + + numero = Integer.parseInt(JOptionPane.showInputDialog("Escriba un numero: ")); + suma += numero; + } + JOptionPane.showMessageDialog(null,"La suma de todos los numeros es: "+ suma); + } +} diff --git a/JavaSCuatri/Clase6POO/ciclos10.java b/JavaSCuatri/Clase6POO/ciclos10.java new file mode 100644 index 00000000..0d12c4b5 --- /dev/null +++ b/JavaSCuatri/Clase6POO/ciclos10.java @@ -0,0 +1,20 @@ +package Clase6POO; + +import java.util.Scanner; + +// Ejercicio 10 : Pedir 10 números y escribir la suma total + +public class ciclos10 { + public static void main(String[] args) { + Scanner entrada = new Scanner(System.in); + int numero, suma = 0; + for(int i = 1; i <= 10; i ++){ + System.out.println("Escriba un numero: "); + numero = Integer.parseInt(entrada.nextLine()); + suma += numero; + } + System.out.println("La suma de todos los numeros es: "+ suma); + + entrada.close(); + } +} diff --git a/JavaSCuatri/Clase7POO/Ejercicios/Ejercicio11JOP.java b/JavaSCuatri/Clase7POO/Ejercicios/Ejercicio11JOP.java new file mode 100644 index 00000000..1494f158 --- /dev/null +++ b/JavaSCuatri/Clase7POO/Ejercicios/Ejercicio11JOP.java @@ -0,0 +1,16 @@ +package Clase7POO.Ejercicios; + +import javax.swing.JOptionPane; + +// Diseñar un programa que muestre el prod de los 10 primeros num impares + +public class Ejercicio11JOP { + public static void main(String[] args) { + long producto = 1; // var local + for (int i = 1; i<20; i +=2){ + // comienza en uno, suma 2 = 3, 3 +2 5 y asi suce.. hasta llegar al ultimo + producto *= i; // va calculando el prod de los numeros sumados + } + JOptionPane.showMessageDialog(null,"El producto de los numeros impares es: " + producto); + } +} diff --git a/JavaSCuatri/Clase7POO/Ejercicios/Ejercicio12Ciclos.java b/JavaSCuatri/Clase7POO/Ejercicios/Ejercicio12Ciclos.java new file mode 100644 index 00000000..58bbfd14 --- /dev/null +++ b/JavaSCuatri/Clase7POO/Ejercicios/Ejercicio12Ciclos.java @@ -0,0 +1,23 @@ +package Clase7POO.Ejercicios; + +// Pedir un numero y calcular su factorial. +// Hacerlo en Scanner y JOPtion + +// import java.util.Scanner; +import javax.swing.JOptionPane; + +public class Ejercicio12Ciclos { + public static void main(String[] args) { + // Scanner entrada = new Scanner(System.in); + long factorial = 1; + // System.out.println("Escriba un numero: "); + int numero = Integer.parseInt(JOptionPane.showInputDialog("Escriba un número: ")); + for(int i = 1; i <= numero; i++){ + factorial *= i; // calculo del factorial + } + + // System.out.println("\n El factorial del numero ingresado es: " + factorial); + JOptionPane.showMessageDialog(null, "El factorial del numero ingresado es: " + factorial); + } + // entrada.close(); +} diff --git a/JavaSCuatri/Clase7POO/Encapsulamiento/Persona.java b/JavaSCuatri/Clase7POO/Encapsulamiento/Persona.java new file mode 100644 index 00000000..6a299ce5 --- /dev/null +++ b/JavaSCuatri/Clase7POO/Encapsulamiento/Persona.java @@ -0,0 +1,50 @@ +package Encapsulamiento; +// dominio + +// PARTE 1 ENCAPSULAMIENTO +public class Persona { + // Atributos: + private String nombre; + private double sueldo; + private boolean eliminado; + + // Constructor de la clase: + public Persona(String nombre, double sueldo, boolean eliminado){ + this.nombre = nombre; + this.sueldo = sueldo; // atributo primero y var despues + this.eliminado = eliminado; + } + + // Definir metodos, set y get + + public String getNombre(){ + return nombre; // retorna el valor del atributo + } + + public void setNombre(String nombre){ + this.nombre = nombre; // necesita un parametro y modifica + } + + public double getSueldo(){ + return sueldo; // retorna el valor guardado en el atributo + } + + public void setSueldo(double sueldo){ + this.sueldo = sueldo; + } + + // no se usa el get para recuperar info, se usa is + public boolean isEliminado(){ + return eliminado; + } + + public void setEliminado(boolean eliminado){ + this.eliminado = eliminado; + } + + public String toString(){ // convierte en una cadena cada atributo + return "Persona [ nombre: "+ this.nombre + ", Sueldo: " + this.sueldo + + " Eliminado: " + this.eliminado + " ]"; + } + +} diff --git a/JavaSCuatri/Clase7POO/Encapsulamiento/TestPersonaClase8/PersonaPrueba.java b/JavaSCuatri/Clase7POO/Encapsulamiento/TestPersonaClase8/PersonaPrueba.java new file mode 100644 index 00000000..54cc78eb --- /dev/null +++ b/JavaSCuatri/Clase7POO/Encapsulamiento/TestPersonaClase8/PersonaPrueba.java @@ -0,0 +1,29 @@ +package Encapsulamiento.TestPersonaClase8; + +import Encapsulamiento.Persona; +public class PersonaPrueba { + public static void main(String[] args) { + Persona Persona1 = new Persona("Nicolas", 57000, false); + System.out.println("Persona1 su nombre es: " + Persona1.getNombre()); + System.out.println("Persona1: " + Persona1.toString()); + // Modificar a traves de set + Persona1.setNombre("Juan Ignacio"); + System.out.println("Persona1 con su nombre modificado es: " + Persona1.getNombre()); + System.out.println("Persona1, su sueldo es: " + Persona1.getSueldo()); + System.out.println("Persona1 para obtener el bolleano es: " + Persona1.isEliminado()); + + // TAREA: Crear otro objeto de tipo Persona, asignar valores de manera inical, imprimir, modificar valores y volver a imprimir + + Persona Persona2 = new Persona("Azucena", 58000, false); + System.out.println("Persona2 su nombre es: " + Persona2.getNombre()); + // Modificar a traves de set + Persona2.setNombre("Anastacia"); + System.out.println("Persona2 con su nombre modificado es: " + Persona2.getNombre()); + System.out.println("Persona2, su sueldo es: " + Persona2.getSueldo()); + System.out.println("Persona2 para obtener el bolleano es: " + Persona2.isEliminado()); + + // Metodo toString --> permite imprimir el estado del objeto qe estemos creando, en cualq momento.. + System.out.println("Persona1: " + Persona1.toString()); + + } +} diff --git a/JavaSCuatri/Clase7POO/PalabraThis.java b/JavaSCuatri/Clase7POO/PalabraThis.java new file mode 100644 index 00000000..72e53f91 --- /dev/null +++ b/JavaSCuatri/Clase7POO/PalabraThis.java @@ -0,0 +1 @@ +// Apunta hacia una referencia (atributo), traducido como "esto" \ No newline at end of file diff --git a/JavaSCuatri/Clase8/ContextoEstatico.txt b/JavaSCuatri/Clase8/ContextoEstatico.txt new file mode 100644 index 00000000..21fc5e22 --- /dev/null +++ b/JavaSCuatri/Clase8/ContextoEstatico.txt @@ -0,0 +1,11 @@ +* Contexto estático. Es el contexto en el cual trabajamos, no pude acceder al dinamico porque se necesitan que las clases ya esten cargadas + +* cuando ya está cargadada la clase en memoria, empezamos a crear objetos de la clase, conocidos como contexto dinamico. +El dinamico, si puede acceder al contexto estático.. +----- + +La palabra STATIC, se asocia a la clase estático, se asocian las clases +La informacion que modifiquemos en la clase, la van a ver los objetos + +USO: NombreClase.atributoEstatico + diff --git a/JavaSCuatri/Clase8/domain/Persona.java b/JavaSCuatri/Clase8/domain/Persona.java new file mode 100644 index 00000000..47bef5b0 --- /dev/null +++ b/JavaSCuatri/Clase8/domain/Persona.java @@ -0,0 +1,52 @@ +package Clase8.domain; +// CONTEXTO ESTÁTICO + +public class Persona { + + // Cargamos Atributos encapsulados + private int idPersona; + private static int contadorPersona; // Con mod de acceso. se incrementa por cada var creada en el constructor + private String nombre; + + // constructor + public Persona(String nombre){ + this.nombre = nombre; + // atributo estático, incrementar el contador para cada objeto nuevo + Persona.contadorPersona++; // ref a traves de la clase + + // Asignar un nuevo valor a la persona + this.idPersona = Persona.contadorPersona; // hace el incremento en el constructor + + } + + public static int getContadorPersona(){ + return contadorPersona; + } + + public static void setContadorPersona(int aContadorPersona){ + contadorPersona = aContadorPersona; + } + + public int getIdPersona(){ + return this.idPersona; + } + + public void setIdPersona(int idPersona){ + this.idPersona = idPersona; + } + + public String getNombre(){ + return this.nombre; + } + + public void setNombre(String nombre){ + this.nombre = nombre; + } + + // Metodo toString, lo sobreescribiremos, asi hereda el metodo de la clase object + + public String toString(){ + return "Persona{" + " idPersona = " + idPersona + ", nombre = " + nombre + "}"; + } + +} diff --git a/JavaSCuatri/Clase8/domain/PersonaPrueba.java b/JavaSCuatri/Clase8/domain/PersonaPrueba.java new file mode 100644 index 00000000..992f3851 --- /dev/null +++ b/JavaSCuatri/Clase8/domain/PersonaPrueba.java @@ -0,0 +1,33 @@ +package Clase8.domain; + +public class PersonaPrueba { + // podemos crear un atributo.. + private int contador; + public static void main(String[] args) { + // poder acceder al metodo solo poniendo el nombre + Persona Persona1 = new Persona("Anabel"); + System.out.println(" Persona1 = " + Persona1); + + // creamos otro obj + Persona Persona2 = new Persona("Jesus"); + System.out.println("Persona2 = " + Persona2); + + // imprimir(Persona1); + // imprimir(Persona2); + + // this.contador = 10; // no se puede referenciar desde un cont estático + PersonaPrueba personaP1 = new PersonaPrueba(); // lo traemos de forma dinamica + System.out.println(personaP1.getContador()); // y lo llamamos para mostrar el resultado + } + // CREAMOS OTRO METODO + public void imprimir(Persona persona){// no regresa nada, es dinamico + System.out.println("persona = " + persona); + } + + // creamos un metodo (obj) a traves del getContador, en forma dinamica + public int getContador(){ + imprimir(new Persona("Liliana")); + return this.contador; + } + +} diff --git a/JavaSCuatri/Clase8/herencia.uxf b/JavaSCuatri/Clase8/herencia.uxf new file mode 100644 index 00000000..e69de29b diff --git a/JavaSCuatri/Clase9Herencia/Clase9Herencia/Domain/Cliente.java b/JavaSCuatri/Clase9Herencia/Clase9Herencia/Domain/Cliente.java new file mode 100644 index 00000000..568bb669 --- /dev/null +++ b/JavaSCuatri/Clase9Herencia/Clase9Herencia/Domain/Cliente.java @@ -0,0 +1,53 @@ +package Clase9Herencia.Domain; + +import java.util.Date; + +public class Cliente extends Persona { + // Atributos: + private int idCliente; + private Date fechaRegistro; + private boolean vip; + private static int contadorCliente; // tipo estático + + // constructores + public Cliente(Date fechaRegistro, boolean vip, String nombre, String string, int edad, String direccion){ + super(nombre, genero, edad, direccion); + this.idCliente = ++contadorCliente; + this.fechaRegistro = fechaRegistro; + this.vip = vip; + } + + public int getIdCliente() { + return this.idCliente; + } + + + public Date getFechaRegistro() { + return this.fechaRegistro; + } + + public void setFechaRegistro(Date fechaRegistro) { + this.fechaRegistro = fechaRegistro; + } + + public boolean isVip() { + return vip; + } + + public void setVip(boolean vip) { + this.vip = vip; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); // clase + sb.append("Cliente (idCliente=").append(idCliente); //llama y agrega atributos + sb.append(", fechaRegistro=").append(fechaRegistro); + sb.append(", vip=").append(vip); + sb.append(", ").append(super.toString()); + sb.append("}"); + return sb.toString(); + } + + +} diff --git a/JavaSCuatri/Clase9Herencia/Clase9Herencia/Domain/Empleado.java b/JavaSCuatri/Clase9Herencia/Clase9Herencia/Domain/Empleado.java new file mode 100644 index 00000000..d0544c02 --- /dev/null +++ b/JavaSCuatri/Clase9Herencia/Clase9Herencia/Domain/Empleado.java @@ -0,0 +1,38 @@ +package Clase9Herencia.Domain; + +public class Empleado extends Persona { // empleado es herencia de la class persona + private int idEmpleado; + private double sueldo; + private static int contadorEmpleados; + + // constructor + public Empleado(String nombre, double sueldo){ + super(nombre); + this.idEmpleado = ++Empleado.contadorEmpleados; + this.sueldo = sueldo; + } + + public int getIdEmpleado() { + return this.idEmpleado; + } + + public double getSueldo() { + return this.sueldo; + } + + public void setSueldo(double sueldo) { + this.sueldo = sueldo; + } + + @Override + public String toString(){ + StringBuilder sb = new StringBuilder(); // clase + sb.append("Empleado (idEmpleado=").append(idEmpleado); //llama y agrega atributos + sb.append(", sueldo=").append(sueldo); + sb.append(", ").append(super.toString()); //mostraria todos los datos + sb.append(")"); + return sb.toString(); + } + +} + diff --git a/JavaSCuatri/Clase9Herencia/Clase9Herencia/Domain/Persona.java b/JavaSCuatri/Clase9Herencia/Clase9Herencia/Domain/Persona.java new file mode 100644 index 00000000..bf699e37 --- /dev/null +++ b/JavaSCuatri/Clase9Herencia/Clase9Herencia/Domain/Persona.java @@ -0,0 +1,65 @@ +package Clase9Herencia.Domain; + +public class Persona { + // atributos de herencia + protected String nombre; // pensado para el concepto de herencia + protected static char genero; + protected int edad; // por default es 0 + protected String direccion; //null porq no tiene un valor asignado + + // Cosntructor vacio: es para crear objetos sin necesidad de inicializar los atributos de la clase + public Persona(){ // constructor 1 + + } + public Persona (String nombre){ // constructor 2 + this.nombre = nombre; + } + // cada costructor que agregamos sirve para crear distintos tipos + // de objetos, con valores iniciales de distintas formas.. + + // Constructor 3 completo, con todos los atributos.. + + public Persona(String nombre, char genero, int edad, String direccion){ + this.nombre = nombre; + this.genero = genero; + this.edad = edad; + this.direccion = direccion; + } + public String getNombre() { + return this.nombre; + } + public void setNombre(String nombre) { + this.nombre = nombre; + } + public char getGenero() { + return this.genero; + } + public void setGenero(char genero) { + this.genero = genero; + } + public int getEdad() { + return this.edad; + } + public void setEdad(int edad) { + this.edad = edad; + } + public String getDireccion() { + return this.direccion; + } + public void setDireccion(String direccion) { + this.direccion = direccion; + } + + // Metodo toString + @Override + public String toString(){ + StringBuilder sb = new StringBuilder(); // clase + sb.append("Persona (nombre=").append(nombre); //llama y agrega atributos + sb.append(", genero=").append(genero); + sb.append(", edad=").append(edad); //mostraria todos los datos + sb.append(", direccion=").append(direccion); + sb.append(", ").append(super.toString()); //muestra espacio en memoria + sb.append(")"); + return sb.toString(); + } +} diff --git a/JavaSCuatri/Clase9Herencia/Clase9Herencia/Domain/herencia.uxf b/JavaSCuatri/Clase9Herencia/Clase9Herencia/Domain/herencia.uxf new file mode 100644 index 00000000..e570cf03 --- /dev/null +++ b/JavaSCuatri/Clase9Herencia/Clase9Herencia/Domain/herencia.uxf @@ -0,0 +1,38 @@ +10extenseUMLClass11020210250<<Persona>> +Package::Clase9Herencia.Domain + +-- +-nombre: String +-genero: char +-edad: int +-direccion: String +-- ++getNombre():Str ++setNombre(String): void ++getGenero(): char ++setGenero(char): void ++getEdad(): int ++setEdad(int): void ++getDireccion(): String ++setDireccion(String): voidRelation1902703070lt=<<.10;10;10;50Relation1031047030lt=<<-10;10;450;10Relation4503103090lt=<<-10;70;10;10Relation103103090lt=<<-10;70;10;10UMLClass460380210190<<Cliente>> +Package::Clase9Herencia.Domain + +-- +-idCliente: int +-fechaRegistro: Date +-vip: boolean +-- ++getIdCliente(): int ++getFecgaRegistro(): date ++setFechaRegistro(): void ++idVip(): boolean ++setVip(): voidUMLClass0380210150<<Empleado>> +Package::Clase9Herencia.Domain + +-- +-idEmpleado: int +-sueldo: double +-- ++getIdEmpleado(): int ++setIdEmpleado(): double ++setSueldo(): void \ No newline at end of file diff --git a/JavaSCuatri/Clase9Herencia/Clase9Herencia/Test/TestHerencia.java b/JavaSCuatri/Clase9Herencia/Clase9Herencia/Test/TestHerencia.java new file mode 100644 index 00000000..22ef2d6b --- /dev/null +++ b/JavaSCuatri/Clase9Herencia/Clase9Herencia/Test/TestHerencia.java @@ -0,0 +1,23 @@ +package Clase9Herencia.Test; + +import java.util.Date; + +import Clase9Herencia.Domain.Cliente; +import Clase9Herencia.Domain.Empleado; + +public class TestHerencia { + // lo que sucede cuando se llama a la class empleado, ve que está vacia + // pero al ser hija de la class Persona, va y muestra los atributos vacios.. del toString + + public static void main(String[] args) { + Empleado empleado1 = new Empleado("Matias", 58000.0); + System.out.println("Empleado1 = " + empleado1); + + Date fecha1 = new Date(); + + // por cada nuevo atributo, hay un nuevo valor + + Cliente cliente1 = new Cliente(new Date(), true, "Jose Flores", "Masc", 33, "Av Alvear O"); + System.out.println("Cliente1= " + cliente1); + } +} diff --git a/JavaSCuatri/Clase9Herencia/Domain/Empleado.java b/JavaSCuatri/Clase9Herencia/Domain/Empleado.java new file mode 100644 index 00000000..d0544c02 --- /dev/null +++ b/JavaSCuatri/Clase9Herencia/Domain/Empleado.java @@ -0,0 +1,38 @@ +package Clase9Herencia.Domain; + +public class Empleado extends Persona { // empleado es herencia de la class persona + private int idEmpleado; + private double sueldo; + private static int contadorEmpleados; + + // constructor + public Empleado(String nombre, double sueldo){ + super(nombre); + this.idEmpleado = ++Empleado.contadorEmpleados; + this.sueldo = sueldo; + } + + public int getIdEmpleado() { + return this.idEmpleado; + } + + public double getSueldo() { + return this.sueldo; + } + + public void setSueldo(double sueldo) { + this.sueldo = sueldo; + } + + @Override + public String toString(){ + StringBuilder sb = new StringBuilder(); // clase + sb.append("Empleado (idEmpleado=").append(idEmpleado); //llama y agrega atributos + sb.append(", sueldo=").append(sueldo); + sb.append(", ").append(super.toString()); //mostraria todos los datos + sb.append(")"); + return sb.toString(); + } + +} + diff --git a/JavaSCuatri/Clase9Herencia/Domain/Persona.java b/JavaSCuatri/Clase9Herencia/Domain/Persona.java new file mode 100644 index 00000000..d512069e --- /dev/null +++ b/JavaSCuatri/Clase9Herencia/Domain/Persona.java @@ -0,0 +1,58 @@ +package Clase9Herencia.Domain; + +public class Persona { + // atributos de herencia + protected String nombre; // pensado para el concepto de herencia + protected char genero; + protected int edad; + protected String direccion; + + // Cosntructor vacio: es para crear objetos sin necesidad de inicializar los atributos de la clase + public Persona(){ // constructor 1 + + } + public Persona (String nombre){ // constructor 2 + this.nombre = nombre; + } + // cada costructor que agregamos sirve para crear distintos tipos + // de objetos, con valores iniciales de distintas formas.. + + // Constructor 3 completo, con todos los atributos.. + + public Persona(String nombre, char genero, int edad, String direccion){ + this.nombre = nombre; + this.genero = genero; + this.edad = edad; + this.direccion = direccion; + } + public String getNombre() { + return this.nombre; + } + public void setNombre(String nombre) { + this.nombre = nombre; + } + public char getGenero() { + return this.genero; + } + public void setGenero(char genero) { + this.genero = genero; + } + public int getEdad() { + return this.edad; + } + public void setEdad(int edad) { + this.edad = edad; + } + public String getDireccion() { + return this.direccion; + } + public void setDireccion(String direccion) { + this.direccion = direccion; + } + + // Metodo toString + @Override // sobreescribimos el metodo toString + public String toString(){ // CLase padre + return "Persona {" + "nombre= " + nombre + ", genero=" + genero + ", edad= " + edad + " }"; + } +} diff --git a/JavaSCuatri/Clase9Herencia/Domain/herencia.uxf b/JavaSCuatri/Clase9Herencia/Domain/herencia.uxf new file mode 100644 index 00000000..e570cf03 --- /dev/null +++ b/JavaSCuatri/Clase9Herencia/Domain/herencia.uxf @@ -0,0 +1,38 @@ +10extenseUMLClass11020210250<<Persona>> +Package::Clase9Herencia.Domain + +-- +-nombre: String +-genero: char +-edad: int +-direccion: String +-- ++getNombre():Str ++setNombre(String): void ++getGenero(): char ++setGenero(char): void ++getEdad(): int ++setEdad(int): void ++getDireccion(): String ++setDireccion(String): voidRelation1902703070lt=<<.10;10;10;50Relation1031047030lt=<<-10;10;450;10Relation4503103090lt=<<-10;70;10;10Relation103103090lt=<<-10;70;10;10UMLClass460380210190<<Cliente>> +Package::Clase9Herencia.Domain + +-- +-idCliente: int +-fechaRegistro: Date +-vip: boolean +-- ++getIdCliente(): int ++getFecgaRegistro(): date ++setFechaRegistro(): void ++idVip(): boolean ++setVip(): voidUMLClass0380210150<<Empleado>> +Package::Clase9Herencia.Domain + +-- +-idEmpleado: int +-sueldo: double +-- ++getIdEmpleado(): int ++setIdEmpleado(): double ++setSueldo(): void \ No newline at end of file diff --git a/JavaSCuatri/Clase9Herencia/Test/TestHerencia.java b/JavaSCuatri/Clase9Herencia/Test/TestHerencia.java new file mode 100644 index 00000000..43d6dd98 --- /dev/null +++ b/JavaSCuatri/Clase9Herencia/Test/TestHerencia.java @@ -0,0 +1,13 @@ +package Clase9Herencia.Test; + +import Clase9Herencia.Domain.Empleado; + +public class TestHerencia { + // lo que sucede cuando se llama a la class empleado, ve que está vacia + // pero al ser hija de la class Persona, va y muestra los atributos vacios.. del toString + + public static void main(String[] args) { + Empleado empleado1 = new Empleado("Matias", 58000.0); + System.out.println("Empleado1 = " + empleado1); + } +} diff --git a/JavaSCuatri/Leccion2/Clase1.java b/JavaSCuatri/Leccion2/Clase1.java new file mode 100644 index 00000000..1e8784df --- /dev/null +++ b/JavaSCuatri/Leccion2/Clase1.java @@ -0,0 +1,57 @@ +package Leccion2; +public class Clase1{ + public static void main(String[] args) { + var conteo = 0; // inf de tipo + // CICLO WHILE + while (conteo < 7) { // si esta condicion no se cumple, no podremos ver el codigo del prog + System.out.println("Conteo = " + conteo); + conteo++; // va incrementando uno + + // ciclo Do WHILE: Por lo menos una vez se ejecuta el ciclo + var contador = 0; + do{ + System.out.println("contador = " + contador); + contador++; + }while (contador <= 7); + + // 1er espacio se declara la variable, 2do condicion a cumplir, 3ro: incremento o decremento de la var(recorrido) + for( var cont = 0 ; cont < 7 ; cont++) { + System.out.println(" cont = " + cont); + } + // Palabra break + for( var cont = 0 ; cont < 7 ; cont++){ + if(cont % 2 == 0){ + System.out.println(" cont = " + cont); + break; + } + } + + // para saltar numeros impares.. + + for( var cont = 0 ; cont < 7 ; cont++){ + if(cont % 2 != 0){ + continue; // pasa a la siguiente iteracion, cuando encuentra un numero impar e imprime el par + } + System.out.println(" cont = " + cont); + } + + // uso de etiquetas (LABELS). Nos sirve para indicar a las palabras continue y break ir hacia un punto + // especifico del programa. + + // Uso de la palabra break y continue junto a las etiquetas + inicio: + for (var cont1 = 0 ; cont1 < 7 ; cont1++){ + if (cont1 % 2 != 0) { + continue inicio; // pasa a la sgte iteracion + } + System.out.println(" cont1 = " + cont1); + } + + + + + + + } + } +} \ No newline at end of file diff --git a/JavaScriptSCuatri/Clase 4 Tipos de Datos Parte 2/ReutilizarVariables.js b/JavaScriptSCuatri/Clase 4 Tipos de Datos Parte 2/ReutilizarVariables.js new file mode 100644 index 00000000..7c33dd83 --- /dev/null +++ b/JavaScriptSCuatri/Clase 4 Tipos de Datos Parte 2/ReutilizarVariables.js @@ -0,0 +1,59 @@ +// Las variables son dinamicas.. +var nombre = "Matias"; +console.log(typeof nombre); + +nombre = 7; +console.log(typeof nombre) + +// tipo numerico +var num = 3000; +console.log(num); + +// tipo object +var objeto = { + // dentro de la asignacion, ponemos el nombre + nombre : "Matias", + apellido : "Ikaczijk", + tel : "262587111" +} +console.log(objeto); + +// ----- 4.4 Definir un tipo clase + +// Tipo de dato boolean(bandera) +var bandera = true; +console.log(bandera); + +// funcion--> permiten realizar tareas, se reutilizan lineas de codigo +function mifuntion(){} +console.log(typeof mifuntion) + +// dato symbol +var simbolo = Symbol("Mi simbolo: ") +console.log(simbolo) + +// Clases: +class persona{ + // nos premite crear un obj + constructor(nombre,apellido){ + this.nombre = nombre; + this.apellido = apellido; + } +} +console.log(typeof persona); + +//Tipo de dato undefined +var x; +console.log(x); + +//null: significa ausencia de un valor +var y = null; // null no es un tipo de dato pero su origen es de type object +console.log(y); + +// Tipo de dato array y Empty String +var autos = ["Citroen", "Chevrolet", "BMW", "Ford"]; +console.log(autos); +console.log(typeof autos); // Preguntamos que tipo de dato es.. + +var z = " "; +console.log(z); // cadena vacia diff --git a/JavaScriptSCuatri/Clase 4 Tipos de Datos Parte 2/idex.html b/JavaScriptSCuatri/Clase 4 Tipos de Datos Parte 2/idex.html new file mode 100644 index 00000000..010c3aa3 --- /dev/null +++ b/JavaScriptSCuatri/Clase 4 Tipos de Datos Parte 2/idex.html @@ -0,0 +1,12 @@ + + + + + + JavaScript + + + + + + \ No newline at end of file diff --git a/JavaScriptSCuatri/Clase 9/Ejercicios.js b/JavaScriptSCuatri/Clase 9/Ejercicios.js new file mode 100644 index 00000000..a24c7d2e --- /dev/null +++ b/JavaScriptSCuatri/Clase 9/Ejercicios.js @@ -0,0 +1,38 @@ +// OPERADOR OR +// Ejercicio puede ir o no al partido de futbol + +let vacaciones = false, diaDescanso = false; // creamos var y damos el valor +if(vacaciones || diaDescanso){ + console.log("El padre puede asistir al juego de su hijo") +} +else{ + console.log("El padre no podrá asistir al juego") +} + +// 9.2 Operador ternario: Ejercicio Par Impar + +let resultado = 3 > 2 ? "Verdadero" : "Falso"; +console.log(resultado) +let numero = 12; +resultado = numero % 2 == 0 ? "Es un numero par" : "Es un numero impar"; +console.log(resultado) + +// Convertir String a Number +let miNum = "19"; +console.log(typeof miNum); +let edad = Number(miNum); // funcion de convercion +console.log(typeof edad); + +//Funcion isNan --> verificar el valor de una variable numerica + +if(isNaN(edad)){ + console.log("La var no contiene solo números") +} +else{ + if(edad >= 18){ + console.log("Usted puede votar"); + } + else{ + console.log("Aún no puede ejercer el voto") + } +} diff --git a/JavaScriptSCuatri/Clase 9/index.html b/JavaScriptSCuatri/Clase 9/index.html new file mode 100644 index 00000000..faf3f166 --- /dev/null +++ b/JavaScriptSCuatri/Clase 9/index.html @@ -0,0 +1,12 @@ + + + + + + JavaScript + + + + + + \ No newline at end of file diff --git a/JavaScriptSCuatri/Clase10Ejercicios/Ejercicios.js b/JavaScriptSCuatri/Clase10Ejercicios/Ejercicios.js new file mode 100644 index 00000000..9e4f4300 --- /dev/null +++ b/JavaScriptSCuatri/Clase10Ejercicios/Ejercicios.js @@ -0,0 +1,72 @@ +// Ejercicio 1. Calcular estacion del año: +let mes = 1; // ingresamos el numero nos +let estacion; + +// pondresmos condicionales anidados.. + +if(mes == 1 || mes == 2 || mes == 12){ + estacion = "Estamos en verano"; +} +else if( mes == 3 || mes == 4 || mes == 5){ + estacion = "Estamos en otoño" +} +else if(mes == 6 || mes == 7 || mes == 8){ + estacion = "Estamos en invierno" +} +else if(mes == 9 || mes == 10 || mes == 11){ + estacion = "Estamos en primavera" +} +else{ + estacion = "Estacion incorrecta" +} + +console.log("Para el valor ingresado: " + estacion); + + +// Ejercicio num 2: + +let hora = 3; +let mensaje; + +// Dependiendo la hora del dia, es la act que estemos realizando +// Era otra alternativa a la propuesta por el prof, lo hice antes de escuchar jeje +if(hora >= 0 && hora <= 7){ + mensaje = "Estoy denscansando" +} +else if(hora >= 8 && hora <= 13){ + mensaje = "Estoy en jornada laboral" +} +else if(hora >= 14 && hora <= 15){ + mensaje = "Estoy de sobre mesa / lavando platos" +} +else if(hora >= 16 && hora <= 18){ + mensaje = "Me encuentro en el gym, generalmente.." +} +else if(hora >= 19 && hora <= 23){ + mensaje = "Me encuentro capacitandome y aprendiendo" +} +else{ + "Valor incorrecto, fuera de rango" +} + +console.log("Para la hora ingresada, " + mensaje) + +// Estructura switch, optimizamos el proceso + +switch(mes){ // traemos la variable con el num + case 1: case 2: case 12: + estacion = "Verano"; + break; + case 3: case 4: case 5: + estacion = "Otoño"; + break; + case 6: case 7: case 8: + estacion = "Invierno"; + break; + case 9: case 10: case 11: + estacion = "Primavera"; + break; + default: + estacion = "Valor fuera de rango"; +} +console.log("Bienvedidos a la estacion: " + estacion) \ No newline at end of file diff --git a/JavaScriptSCuatri/Clase10Ejercicios/index.html b/JavaScriptSCuatri/Clase10Ejercicios/index.html new file mode 100644 index 00000000..343d71ef --- /dev/null +++ b/JavaScriptSCuatri/Clase10Ejercicios/index.html @@ -0,0 +1,11 @@ + + + + + + JavaScript + + + + + \ No newline at end of file diff --git a/JavaScriptSCuatri/Clase11/04-01-Ejercicios.js b/JavaScriptSCuatri/Clase11/04-01-Ejercicios.js new file mode 100644 index 00000000..cdf31594 --- /dev/null +++ b/JavaScriptSCuatri/Clase11/04-01-Ejercicios.js @@ -0,0 +1,106 @@ +/* +const se utiliza para valores constantes que no pueden reasignarse +*/ +const fechaNac = 2001; +console.log(fechaNac); + +// fechaNac = 2005. Claramente nos da error +// console.log(fechaNac) + +// Para evitar repetir un codigo: + +let days = "Lunes"; + +// let days = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"]; +switch(days){ // lea el dato ingresado + case "Lunes": + console.log("Hoy es: " + days); + break; + case "Martes": + console.log("Hoy es: " + days); + break; + case "Miercoles": + console.log("Hoy es: " + days); + break; + case "Jueves": + console.log("Hoy es: " + days); + break; + case "Viernes": + console.log("Hoy es: " + days); + break; + case "Sabado": + console.log("Hoy es: " + days); + break; + case "Domingo": + console.log("Hoy es: " + days) + default: + break; +} +// Version mejorada + +let days2 = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"]; +function getDay(n){ // necesita parametro + if(n <1 || n > 7){ + throw new Error("out of range"); + } + return days2[n-1]; // retorna lo guardado +} +console.log(getDay(5)); // llamamos y muestra el dia + +// Ej meses del año + +// Hacer un ej similar al anterior pero ahora con los meses del año, +// debemos hacerlo con la estructura switch y luego la opc mejorada + +let month = 11; +switch(month){ + case 1: + console.log("Estamos en Enero"); + break; + case 2: + console.log("Estamos en Febrero, el mejor(? "); + break; + case 3: + console.log("Estamos en Marzo"); + break; + case 4: + console.log("Estamos en Abril"); + break; + case 5: + console.log("Estamos en Mayo"); + break; + case 6: + console.log("Estamos en Junio"); + break; + case 7: + console.log("Estamos en Julio") + + case 8: + console.log("Estamos en Agosto"); + break; + case 9: + console.log("Estamos en Septiembre") + + case 10: + console.log("Estamos en Octubre") + + case 11: + console.log("Estamos en Noviembre"); + break; + case 12: + console.log("Estamos en Diciembre") + default: + console.log("El mes ingresado es incorrecto") + break; +} + +// VERSION PRO + +let mes = ["Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "julio", "Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre"] +function getmes(n){ + if(n <1 || n > 12){ + throw new Error("out of range"); + } + return mes[n-1]; // retorna lo guardado +} +console.log(getmes(7)); \ No newline at end of file diff --git a/JavaScriptSCuatri/Clase11/index.html b/JavaScriptSCuatri/Clase11/index.html new file mode 100644 index 00000000..d5f0193d --- /dev/null +++ b/JavaScriptSCuatri/Clase11/index.html @@ -0,0 +1,11 @@ + + + + + + JavaScript + + + + + \ No newline at end of file diff --git a/JavaScriptSCuatri/Clase3TiposDeDatos/02-01-TipoDeDatos.js b/JavaScriptSCuatri/Clase3TiposDeDatos/02-01-TipoDeDatos.js new file mode 100644 index 00000000..e5ec957c --- /dev/null +++ b/JavaScriptSCuatri/Clase3TiposDeDatos/02-01-TipoDeDatos.js @@ -0,0 +1,24 @@ +// Tipos de datos en JavaScript + +/* +La sintaxis es similar a lo que es Java +en cuanto a comentarios +*/ + +// comenzamos con datos STRING +var nombre = "Matias"; +console.log(nombre); + +// tipo numerico +var num = 3000; +console.log(num); + +// tipo object +var objeto = { + // dentro de la asignacion, ponemos el nombre + nombre : "Matias", + apellido : "Ikaczijk", + tel : "262587111" +} +console.log(objeto); + diff --git a/JavaScriptSCuatri/Clase3TiposDeDatos/index.html b/JavaScriptSCuatri/Clase3TiposDeDatos/index.html new file mode 100644 index 00000000..e42efdb8 --- /dev/null +++ b/JavaScriptSCuatri/Clase3TiposDeDatos/index.html @@ -0,0 +1,11 @@ + + + + + + JavaScript + + + + + \ No newline at end of file diff --git a/JavaScriptSCuatri/Clase5DatosP3/Sintaxis Ja y JS.txt b/JavaScriptSCuatri/Clase5DatosP3/Sintaxis Ja y JS.txt new file mode 100644 index 00000000..a6e86c81 --- /dev/null +++ b/JavaScriptSCuatri/Clase5DatosP3/Sintaxis Ja y JS.txt @@ -0,0 +1,41 @@ +sintaxis similares entre java y JavaScript +Operadores: +-- Simplificados: ++= +-= +*= +/= + +-- Aritmeticos: ++ +- +* +/ + +-- de asignacion: += +-- de Comparacion: +== + +Documentar: +// una linea de comentario +/* */ multiples lineas + +Secuencias de escape: +\' Mostrar una comilla simple dentro de una cadena en la salida de informacion + +\" Mostrar foble comilla dentro de una cadena en la salida de informacion + +\\ Barra invertida, diagonal inversa, para mostrar un bash lash + +\n = salto de linea +\r = retorno +\t = tabulacion +\b = retroceso +\f = salto de pag + +Operador de aumento: +++ --> uno en uno + +Operador de decremento: +-- diff --git a/JavaScriptSCuatri/Clase6 ConcatenarCadenas/02-01-ConcatenacionDeCadenas.js b/JavaScriptSCuatri/Clase6 ConcatenarCadenas/02-01-ConcatenacionDeCadenas.js new file mode 100644 index 00000000..24904c87 --- /dev/null +++ b/JavaScriptSCuatri/Clase6 ConcatenarCadenas/02-01-ConcatenacionDeCadenas.js @@ -0,0 +1,20 @@ +var nombre = "Esteban"; +var apellido = " Pollito"; +var nombreComp = nombre + " " + apellido; +console.log(nombreComp); // primera concatenacion + +var nombreComp2 = "Matias" + " " + " Ikaczijk"; // segunda concatenacion +console.log(nombreComp2); + +var juntos = nombre + 219; +console.log(juntos); + +juntos = nombre + 78 + 17; +console.log(juntos); + +juntos = 78 + 17 + nombre; +console.log(juntos); // de esta manera, concatena pero primero suma los numeros + +// CONCATENACION PARTE 2: +nombre += apellido; // usando el operador simplificado +console.log(nombre); diff --git a/JavaScriptSCuatri/Clase6 ConcatenarCadenas/index.html b/JavaScriptSCuatri/Clase6 ConcatenarCadenas/index.html new file mode 100644 index 00000000..297de50c --- /dev/null +++ b/JavaScriptSCuatri/Clase6 ConcatenarCadenas/index.html @@ -0,0 +1,11 @@ + + + + + + JavaScript + + + + + \ No newline at end of file diff --git a/JavaScriptSCuatri/Clase7Similitudes/02-01-Similitudes.js b/JavaScriptSCuatri/Clase7Similitudes/02-01-Similitudes.js new file mode 100644 index 00000000..58974f57 --- /dev/null +++ b/JavaScriptSCuatri/Clase7Similitudes/02-01-Similitudes.js @@ -0,0 +1,4 @@ +let x, y; // podemos declarar varias variables en una linea.. +x = 17, y = 21; +let z = x + y; +console.log(z) diff --git a/JavaScriptSCuatri/Clase7Similitudes/Ejercicio1/02-01-Operadores.js b/JavaScriptSCuatri/Clase7Similitudes/Ejercicio1/02-01-Operadores.js new file mode 100644 index 00000000..8a897379 --- /dev/null +++ b/JavaScriptSCuatri/Clase7Similitudes/Ejercicio1/02-01-Operadores.js @@ -0,0 +1,18 @@ +// Ejercicio para encontrar pares e impares .. +let parImpar = 7; +if(parImpar % 2 ==0){ + console.log("Es un numero par") +} +else{ + console.log("Es un número impar:") +} + +// Ejercicio es mayor de edad.. + +let edad = 14, adulto = 18; +if(edad >= adulto){ + console.log("Usted es mayor de edad..") +} +else{ + console.log("Usted es menor de edad..") +} \ No newline at end of file diff --git a/JavaScriptSCuatri/Clase7Similitudes/Ejercicio1/index.html b/JavaScriptSCuatri/Clase7Similitudes/Ejercicio1/index.html new file mode 100644 index 00000000..2a2c4ff6 --- /dev/null +++ b/JavaScriptSCuatri/Clase7Similitudes/Ejercicio1/index.html @@ -0,0 +1,12 @@ + + + + + + JavaScript + + + + + + \ No newline at end of file diff --git a/JavaScriptSCuatri/Clase7Similitudes/index.html b/JavaScriptSCuatri/Clase7Similitudes/index.html new file mode 100644 index 00000000..6558332a --- /dev/null +++ b/JavaScriptSCuatri/Clase7Similitudes/index.html @@ -0,0 +1,11 @@ + + + + + + JavaScript + + + + + \ No newline at end of file diff --git a/JavaScriptSCuatri/Clase8JS/Clase8JS/Ejercicio.js b/JavaScriptSCuatri/Clase8JS/Clase8JS/Ejercicio.js new file mode 100644 index 00000000..4b3907ad --- /dev/null +++ b/JavaScriptSCuatri/Clase8JS/Clase8JS/Ejercicio.js @@ -0,0 +1,62 @@ +// 8.1 Ejercicio: dentro de un rango: Operador and +// operador and -> && Doble aspersan + +let dentroDeRango = -10; +let valMinimo = 0, valMax = 10; + +if(dentroDeRango >= valMinimo && dentroDeRango <= valMax){ + console.log("El numero está dentro del rango") +} +else{ + console.log("El número ingresado está fuera del rango") +} + +// 8.3 + +let nombre = "Pepe"; +console.log(nombre); +const apellido = "Lopez"; +// apellido = "Perez"; una costante no se puede modificar +console.log(apellido); + +// 8.4 Aclaración con var, let y const + +// con var -> se puede reasignar en cualquier momento +var nombre2 = "Estefan"; +nombre2 = "Jesus"; +console.log(nombre2) + +function saludar(){ + var nombre2 = "Nazarena"; + console.log(nombre2); +} +console.log(nombre2); // no lee el dato en la funcion + +if(true){ + var edad = 32; + console.log(edad); +} +console.log(edad); + +/* Let: puede ser reasignada en cualquier momento, la diferencia + es que su ambito es de bloque, solo disponible dentro de un bloque de + llaves o dentro de una funcion +*/ + +function saludar2(){ + let nombre3 = "Osvaldo"; + console.log(nombre3); +} +// console.log(nombre3); // no lee el dato en la funcion + +if(true){ + let edad3 = 82; + console.log(edad3); +} +console.log(edad3); // en la estructura if falla la var + +// const se usa para valores que no pueden ser reasignados +const fechaNac = 2006; +console.log(fechaNac); +// fechaNac = 2001; +// console.log(fechaNac); \ No newline at end of file diff --git a/JavaScriptSCuatri/Clase8JS/Clase8JS/index.html b/JavaScriptSCuatri/Clase8JS/Clase8JS/index.html new file mode 100644 index 00000000..f6b218a0 --- /dev/null +++ b/JavaScriptSCuatri/Clase8JS/Clase8JS/index.html @@ -0,0 +1,12 @@ + + + + + + JavaScript + + + + + + \ No newline at end of file diff --git a/JavaScriptSCuatri/Clase8JS/Ejercicio.js b/JavaScriptSCuatri/Clase8JS/Ejercicio.js new file mode 100644 index 00000000..925fd1a4 --- /dev/null +++ b/JavaScriptSCuatri/Clase8JS/Ejercicio.js @@ -0,0 +1,62 @@ +// 8.1 Ejercicio: dentro de un rango: Operador and +// operador and -> && Doble aspersan + +let dentroDeRango = -10; +let valMinimo = 0, valMax = 10; + +if(dentroDeRango >= valMinimo && dentroDeRango <= valMax){ + console.log("El numero está dentro del rango") +} +else{ + console.log("El número ingresado está fuera del rango") +} + +// 8.3 + +let nombre = "Pepe"; +console.log(nombre); +const apellido = "Lopez"; +// apellido = "Perez"; una costante no se puede modificar +console.log(apellido); + +// 8.4 Aclaración con var, let y const + +// con var -> se puede reasignar en cualquier momento +var nombre2 = "Estefan"; +nombre2 = "Jesus"; +console.log(nombre2) + +function saludar(){ + var nombre2 = "Nazarena"; + console.log(nombre2); +} +console.log(nombre2); // no lee el dato en la funcion + +if(true){ + var edad = 32; + console.log(edad); +} +console.log(edad); + +/* Let: puede ser reasignada en cualquier momento, la diferencia + es que su ambito es de bloque, solo disponible dentro de un bloque de + llaves o dentro de una funcion +*/ + +function saludar2(){ + var nombre3 = "Osvaldo"; + console.log(nombre3); +} +// console.log(nombre3); // no lee el dato en la funcion + +if(true){ + var edad3 = 82; + console.log(edad3); +} +console.log(edad3); // en la estructura if falla la var + +// const se usa para valores que no pueden ser reasignados +const fechaNac = 2006; +console.log(fechaNac); +fechaNac = 2001; +console.log(fechaNac); \ No newline at end of file diff --git a/JavaScriptSCuatri/Clase8JS/index.html b/JavaScriptSCuatri/Clase8JS/index.html new file mode 100644 index 00000000..f6b218a0 --- /dev/null +++ b/JavaScriptSCuatri/Clase8JS/index.html @@ -0,0 +1,12 @@ + + + + + + JavaScript + + + + + + \ No newline at end of file diff --git a/JavaScriptSCuatri/Leccion1/01-01-holamundo.js b/JavaScriptSCuatri/Leccion1/01-01-holamundo.js new file mode 100644 index 00000000..c2a6d606 --- /dev/null +++ b/JavaScriptSCuatri/Leccion1/01-01-holamundo.js @@ -0,0 +1,13 @@ +var nombre = " Matias "; // nombre es el identificador, de tipo dinamico +nombre = " Matias Nicolas "; // reasignacion +var apellido = " Ikaczijk "; +console.log(nombre); +console.log(apellido); + +// concatenamos +console.log(nombre + apellido); + +// para mostrarlo en 3 lineas distintas +nombre = " Matias \n Nicolas \n "; +apellido = " Ikaczijk "; +console.log(nombre + apellido) diff --git a/JavaScriptSCuatri/Leccion1/Holamundo.js b/JavaScriptSCuatri/Leccion1/Holamundo.js new file mode 100644 index 00000000..c5cc7c4f --- /dev/null +++ b/JavaScriptSCuatri/Leccion1/Holamundo.js @@ -0,0 +1,3 @@ +var nombre = "Matias"; +nombre = " Hola mundo desde JavaScript"; +console.log(nombre) \ No newline at end of file diff --git a/JavaScriptSCuatri/Leccion1/index.html b/JavaScriptSCuatri/Leccion1/index.html new file mode 100644 index 00000000..22abfa7a --- /dev/null +++ b/JavaScriptSCuatri/Leccion1/index.html @@ -0,0 +1,11 @@ +< + + + + + JavaScript + + + + + \ No newline at end of file diff --git a/PythonSCuatri/Clase 10/Persona.py b/PythonSCuatri/Clase 10/Persona.py new file mode 100644 index 00000000..57626d39 --- /dev/null +++ b/PythonSCuatri/Clase 10/Persona.py @@ -0,0 +1,78 @@ +class Persona2: + def __init__(self, nombre, apellido, edad): + self._nombre = nombre # encapsulamos con el _ + self._apellido = apellido + self._edad = edad + def mostrar_detalle(self): + print(f" Los datos a mostrar son los siguientes: {self._nombre} {self._apellido} {self._edad}") + + + # para cada atributo necesitamos un metodo getter and setter + + @property #decorador + + def nombre(self): # Método getter + print("Utlizamos el metodo GET") + return self._nombre + + @nombre.setter # setter + def nombre(self, nombre): #Método setter + print("Utilizamos el método set") + self._nombre = nombre + + # TAREA. Crear el método get y set para el apellido y edad + + @property + def apellido(self): + return self._apellido + @apellido.setter + + def apellido(self, apellido): + self._apellido = apellido + + @property + def edad(self): + return self._edad + @edad.setter # modifica lo de adentro del atributo + def edad(self, edad): + self._edad = edad + + def __del___(self): # destructor + print(f"Persona2: {self._nombre} {self._apellido} {self._edad} ") + +if __name__ == "__main__": + persona1 = Persona2("Matias " , "Ikaczijk ", 22) + print(persona1.nombre) # llamamos al metodo get + print(persona1.mostrar_detalle()) + # CREAR tres objetos mas, utilizando los metodos getter and setter + # # para modificar y mostrar los cambios con el metodo mostrar_detalle + # # dif entre getter y setter. El setter, necesita el self y otro parametro, porque modifica el valor del atributo. + persona2 = Persona2("Juan Carlos ", "Lopez ", 49) + persona2.nombre = "Juan Andres " + persona2.apellido = "Araujo" + persona2.edad = 33 + + print(persona2.nombre) + print(persona2.apellido) + print(persona2.edad) + print(persona2.mostrar_detalle()) + + persona3 = Persona2("Estela ", "De La Hoz ", 65) + persona3.nombre = "Julian " + persona3.apellido = "Arao" + persona3.edad = 19 + + print(persona3.nombre) + print(persona3.apellido) + print(persona3.edad) + print(persona3.mostrar_detalle()) + + persona4 = Persona2("Florencia ", "Mosano ", 46) + persona4.nombre = "Jazmin " + persona4.apellido = "Ocla" + persona4.edad = 41 + + print(persona4.nombre) + print(persona4.apellido) + print(persona4.edad) + print(persona4.mostrar_detalle()) \ No newline at end of file diff --git a/PythonSCuatri/Clase 10/PruebaPersona2.py b/PythonSCuatri/Clase 10/PruebaPersona2.py new file mode 100644 index 00000000..ae91e8b7 --- /dev/null +++ b/PythonSCuatri/Clase 10/PruebaPersona2.py @@ -0,0 +1,13 @@ +from Persona import Persona2 + +print("Creamos objetos".center(50, "-")) + +if __name__ == "__main__": + persona5 = Persona2("José ", "Flores ", 39) + persona5.mostrar_detalle() + + print(__name__) + +print("Eliminamos objetos".center(50, "-")) + +del persona5 \ No newline at end of file diff --git a/PythonSCuatri/Clase 10/__pycache__/Persona.cpython-311.pyc b/PythonSCuatri/Clase 10/__pycache__/Persona.cpython-311.pyc new file mode 100644 index 00000000..32265179 Binary files /dev/null and b/PythonSCuatri/Clase 10/__pycache__/Persona.cpython-311.pyc differ diff --git a/PythonSCuatri/Clase 11/ClientePersona.py b/PythonSCuatri/Clase 11/ClientePersona.py new file mode 100644 index 00000000..5a92deba --- /dev/null +++ b/PythonSCuatri/Clase 11/ClientePersona.py @@ -0,0 +1,8 @@ +from Persona import * # se importan todas las clases del modulo persona + +# Creamos obj +Persona1 = Persona("Matias", 42) +print(Persona1) + +Empleado3 = Empleado("Romina", 19, 290896) +print(Empleado3) \ No newline at end of file diff --git a/PythonSCuatri/Clase 11/EjVehiculo.py b/PythonSCuatri/Clase 11/EjVehiculo.py new file mode 100644 index 00000000..023bae5a --- /dev/null +++ b/PythonSCuatri/Clase 11/EjVehiculo.py @@ -0,0 +1,50 @@ +class Vehiculo: + """ + Definir una clase padre llamada Vehiculo y dos hijas llamada Auto y Bicicleta + las cuales heredan de la clase padre Vehiculo. La clase padre debe tener los sgtes atributos y met: + Vehiculo(clase padre) + - atributos(color, ruedas) + - metodos(__init__(color, ruedas) y __str__()) + + Auto(hija de vehiculo) + - atributos(velocidad (km/h)) + - metodos(__init__(color, ruedas, velocidad) y __str__()) + + Bicicleta(clase hija de vehiculo) + - atributos(tipo(urbana/montaña/etc.)) + - metodos(__init__(color, ruedas,tipo) y __str__()) + + crear un obj para cada clase + """ + def __init__(self, color, ruedas): + self.color = color + self. ruedas = ruedas + def __str__(self): + return "color: " + self.color + " ruedas: " + str(self.ruedas) + +class Auto(Vehiculo): + #met dunter y str + def __init__(self, color, ruedas,velocidad): + super().__init__(color, ruedas) + self.velocidad = velocidad + def __str__(self): + return super().__str__() + ", velocidad(km/h): " + str(self.velocidad) + +class Bicicleta(Vehiculo): + #met dunter y str + def __init__(self, color, ruedas, tipo): + super().__init__(color, ruedas) + self.tipo = tipo + def __str__(self): + return super().__str__() + ", tipo de bicicleta: " + self.tipo + +# creamos el primer obj +vehiculo = Vehiculo(" Negro mate , ", 4) +print(vehiculo) + +# Creamos el segundo obj +auto = Auto(" Rojo , ", 4, 120) +print(auto) + +# tercer obj +bici = Bicicleta("Celeste ", 2, " Mountanbike") \ No newline at end of file diff --git a/PythonSCuatri/Clase 11/Leccion8/EjVehiculo.py b/PythonSCuatri/Clase 11/Leccion8/EjVehiculo.py new file mode 100644 index 00000000..e69de29b diff --git a/PythonSCuatri/Clase 11/Leccion8/herencia.uxf b/PythonSCuatri/Clase 11/Leccion8/herencia.uxf new file mode 100644 index 00000000..b0568b49 --- /dev/null +++ b/PythonSCuatri/Clase 11/Leccion8/herencia.uxf @@ -0,0 +1,22 @@ +10UMLClass24030210100<<Vehiculo>> +-- +- color: str +- ruedas: int +-- +__init__(color,ruedas) +__str__() +UMLClass50200210100<<Auto>> +-- +- velocidad: int +-- +__init__(color,ruedas, velocidad) +__str__() +UMLClass420200210100<<Bicicleta>> +-- +- tipo: str +-- +__init__(color,ruedas,tipo) +__str__() +Relation13017023050lt=.> +<<extends>>210;10;10;30Relation32016024050lt=.> +<<extends>>10;20;220;30Relation3201303070lt=<<.10;10;10;50 \ No newline at end of file diff --git a/PythonSCuatri/Clase 11/Persona.py b/PythonSCuatri/Clase 11/Persona.py new file mode 100644 index 00000000..301ab4bc --- /dev/null +++ b/PythonSCuatri/Clase 11/Persona.py @@ -0,0 +1,55 @@ +class Persona: + def __init__(self, nombre, edad): + self.nombre = nombre + self.edad = edad + + @property + def nombre(self): + return self._nombre + @nombre.setter + def nombre(self, nombre): + self._nombre = nombre + + @property + def edad(self): + return self._edad + @edad.setter + def edad(self, edad): + self._edad = edad + + def __str__(self): # sobre escribir los atributos encapsulados + return f"Persona: [ Nombre: {self._nombre} , Edad: {self._edad}]" + +class Empleado(Persona): # clase hija de la clase persona + def __init__(self, nombre, edad, sueldo): + super().__init__(nombre, edad) # usamos las caract del padre + self.sueldo = sueldo + + @property + def sueldo(self): + return self._sueldo + + @sueldo.setter + def sueldo(self, sueldo): + self._sueldo = sueldo + + def __str__(self): + return f" Empleado: [ Sueldo: {self._sueldo}] {super().__str__()}" # sobre escribimos el str de la clase padre + +Empleado1 = Empleado("Arturo", 40, 78900) +print(Empleado1.nombre) +print(Empleado1.edad) +print(Empleado1.sueldo) + +# Crear otro obj, pasar los datos y mostrarlos (encapsulamiento, getter and setter) +# Modificarlos y volverlos a mostrar + +Empleado2 = Empleado("Mariela", 20, 456890) +print(Empleado2.nombre) +print(Empleado2.edad) +print(Empleado2.sueldo) + +#Modificamos +Empleado2.nombre = "Manuela" +Empleado2.edad = 38 +Empleado2._sueldo = 259800 \ No newline at end of file diff --git a/PythonSCuatri/Clase 11/__pycache__/Persona.cpython-311.pyc b/PythonSCuatri/Clase 11/__pycache__/Persona.cpython-311.pyc new file mode 100644 index 00000000..4ca123ff Binary files /dev/null and b/PythonSCuatri/Clase 11/__pycache__/Persona.cpython-311.pyc differ diff --git a/PythonSCuatri/Clase 11/herencia.uxf b/PythonSCuatri/Clase 11/herencia.uxf new file mode 100644 index 00000000..e69de29b diff --git a/PythonSCuatri/Clase 3/3EjDiccYtarea.py b/PythonSCuatri/Clase 3/3EjDiccYtarea.py new file mode 100644 index 00000000..84ec5162 --- /dev/null +++ b/PythonSCuatri/Clase 3/3EjDiccYtarea.py @@ -0,0 +1,33 @@ +# ingresar elementos al diccionario llamado seleccionArgentina, +# lo elementos a ingresar deben ser como mínimo 4, +# estos elementos son los jugadores con su número de camiseta, +# nombre, apellido, edad, altura, precio y +# posición de juego, por supuesto ver el video anterior + +SeleccionArg = { + 10 : {"Nombre": "Lionel Messi", "Edad" : 36, "Alto" : 1.7, "Precio" : "280.8 M de euros", "Posicion" : "Delantero"}, + 9 : {"Nombre" : "Julian Alvarez", "Edad" : 23, "Alto" : 1.7, "Precio" : "21.48 M de euros", "Posicion" : "Delantero"}, + 24 : {"Nombre" : "Leandro Paredes" , "Edad" : 29, "Alto" : 1.83, "Precio" : "27.8 M de euros", "Posicion" : "Centrocampista"}, + 1 : {"Nombre" : "Franco Armani" , "Edad" : 36, "Alto" : 1.88, "Precio" : "3 M de euros", "Posicion" : "Arquero"}, + 23 : {"Nombre" : "Emiliano Martinez" , "Edad" : 31, "Alto" : 1.95, "Precio" : "28 M de euros", "Posicion" : "Arquero"}, + 3 : {"Nombre" : "Nicolas Tagliafico" , "Edad" : 31, "Alto" : 1.72, "Precio" : "15 M de euros", "Posicion" : "Defensa"} +} +print(SeleccionArg) + +# para ver uno en particular: +print(SeleccionArg[1]) + +# para ver solo valores: +print(SeleccionArg.values()) + +# para recorrer el arreglo, hacemos lo siguiente: +## para ver SOLO num de jugadores: +for llave in SeleccionArg: + print(llave) + +# para ver todos los datos +for llave, valor in SeleccionArg.items(): + print(llave, valor) + +# para ver tamaño y cant de elementos +print(len(SeleccionArg)) diff --git a/PythonSCuatri/Clase 3/3MetodoCola.py b/PythonSCuatri/Clase 3/3MetodoCola.py new file mode 100644 index 00000000..57bcf967 --- /dev/null +++ b/PythonSCuatri/Clase 3/3MetodoCola.py @@ -0,0 +1,33 @@ +# 3.5 Método con listas llamado COLA + +# Escritura de datos de tipo fifo (first input / first output). Primero q entra, primero q sale + +cola = ["Ariel", "Lorena" , "Luis" , "Oscar"] +cola.append("Josefina") +cola.append("Estefan") +print(cola) + +# sacamos elementos +Retira = cola.pop(0) # Ariel atendido +print(f"Atendido {Retira}") +print(cola) + +Retira = cola.pop(0) # Lorena atendida +print(f"Atendida {Retira}") +print(cola) + +Retira = cola.pop(0) # Luis atendido +print(f"Atendido {Retira}") +print(cola) + +Retira = cola.pop(0) # Oscar atendido +print(f"Atendido {Retira}") +print(cola) + +Retira = cola.pop(0) # Josefina atendido +print(f"Atendida {Retira}") +print(cola) + +Retira = cola.pop(0) # Estefan atendido +print(f"Atendido {Retira}") +print(cola) diff --git a/PythonSCuatri/Clase 3/3MetodoPila.py b/PythonSCuatri/Clase 3/3MetodoPila.py new file mode 100644 index 00000000..b095a4e0 --- /dev/null +++ b/PythonSCuatri/Clase 3/3MetodoPila.py @@ -0,0 +1,14 @@ +# Pilas (lista). Se trabaja con el ult numero y se va agreegando +pila = [1,2,3] +print(pila) + +pila.append(4) +pila.append(5) +print(pila) + +#quita el ultimo elemento y lo guarda en otra var +elementoBorrado = pila.pop() +print(f"Elemento borrado = {elementoBorrado}") + +#sacar elementos por el final. Saca y retorna +print(f"La pila quedó asi: {pila}") diff --git a/PythonSCuatri/Clase 3/3Repaso1SetOconjunto.py b/PythonSCuatri/Clase 3/3Repaso1SetOconjunto.py new file mode 100644 index 00000000..6f10bb06 --- /dev/null +++ b/PythonSCuatri/Clase 3/3Repaso1SetOconjunto.py @@ -0,0 +1,69 @@ + +tupla = (4,"Hola mundi", 7.30, [2,3,9], "hola", 4) +print(tupla) + +print(4 in tupla) # Accion booleana, su resp es de tipo booleana +# Lo que podemos usar dentro de tuplas es: index, count, len + +# En tuplas, podemos convertir de tupla a lista y viseversa + +# -------- + +# Lunes 4 sep, repaso + +# Definimos un conjunto: (dentro de ello, hay valores unicos) +conjunto = set() +conjunto1 = {"Hola" ,} # Si lo inicializamos con llaves, debemos agregar un elemento inicialmente, sino dará error + +conjunto.add("Hola") +conjunto.add("9") + +conjunto1.add("Buenas noches") + +print(conjunto1) +print(conjunto) + +# para consultar por un elemento: +print(9 not in conjunto1) +print(7 in conjunto) + +# Como igualar dos conjuntos +print(conjunto1 == conjunto) + +# Para operar entre conjuntos +# Unir conjuntos +conjunto3 = conjunto | conjunto1 +print(conjunto3) + +# para ver si tienen algun elemento en comun +conjunto3 = conjunto1 & conjunto +print(conjunto3) + +# visualizar los elementos de un conjunto que no esta el otro +conjunto3 = conjunto1 - conjunto +print(conjunto3) +conjunto3 = conjunto - conjunto1 +print(conjunto3) + +# mostrar elementos que estan en los dos conjuntos pero no compartidos +conjunto3 = conjunto1 ^ conjunto +print(conjunto3) + +# como determinar si un conjunto está dentro de otro +conjunto3 = conjunto1 | conjunto +print(conjunto1.issubset(conjunto3)) #dentro del conj 3 se guardan dos conjuntos +print(conjunto.issubset(conjunto3)) +print(conjunto3.issubset(conjunto1)) + +# para saber si estos conjuntos no comparten ni un elemento (disconexos) +print(conjunto3.issuperset(conjunto1)) # consultamos si los elementos del conjunto1 estan dentro del conjunto3 +print(conjunto3.issuperset(conjunto)) # si es v nos dice q el conjunto3 es un superconjunto +print(conjunto1.issuperset(conjunto3)) # caso inverso, consultamos si el conjunto3 está dentro del 1 + +# como saber si ambos conjuntos son disconexos +print(conjunto.isdisjoint(conjunto1)) + +# LOS CONJUNTOS NO SON TOTALMENTE MUTABLES NI INMUTABLES.. no se pueden modificar + +# para volverlos totalmente inmutables, hacemos esto: +conjunto1 = frozenset # no se puede ni eliminar, ni agregar, ni modificar diff --git a/PythonSCuatri/Clase 3/Repaso2Diccionario.py b/PythonSCuatri/Clase 3/Repaso2Diccionario.py new file mode 100644 index 00000000..1c96d6b5 --- /dev/null +++ b/PythonSCuatri/Clase 3/Repaso2Diccionario.py @@ -0,0 +1,11 @@ +# REPASO DICCIONARIOS +diccionarioNuevo = {"Azul":"Blue", "Rojo" : "Red", "Verde": "Green"} +print(diccionarioNuevo) + +# eliminar elemento +del(diccionarioNuevo["Azul"]) +print(diccionarioNuevo) + +# agregar al dicc otros datoss. Diccionario dentro de otro +diccionario2 = {"Matias" : {"edad" : 22, "altura" : 1.90}, "Osvaldo" : [45, 1.85], "Esteban" : [39, 1.75]} +print(diccionario2) diff --git a/PythonSCuatri/Clase 4/Ej6Llenarlista.py b/PythonSCuatri/Clase 4/Ej6Llenarlista.py new file mode 100644 index 00000000..8b5e7e1f --- /dev/null +++ b/PythonSCuatri/Clase 4/Ej6Llenarlista.py @@ -0,0 +1,11 @@ +# Llenar una lista con numero del 1 al 50, luego mostrar +# la lista con el ciclo for, los elementos deben verse asi: 1-2-3..-50 + +lista = [] +i = 1 +while i <= 50: + lista.append(i) + i += 1 # va sumando 1 al iterador + # para que sea mas eficaz: hacemos lista = list(range(1,51)) +for i in lista: + print(i,end= " - ") # va dejando un - entre num diff --git a/PythonSCuatri/Clase 4/Ejercicio1Math.py b/PythonSCuatri/Clase 4/Ejercicio1Math.py new file mode 100644 index 00000000..97c115c5 --- /dev/null +++ b/PythonSCuatri/Clase 4/Ejercicio1Math.py @@ -0,0 +1,22 @@ +import math + +# dada la sgte tupla: +tupla = (13,1,8,3,2,5,8) +# crear una lista que solo incluya num menores a 5 + +lista = [] +#filtramos los elementos menores a 5 de la tupla +for elemento in tupla: + if elemento < 5: + lista.append(elemento) +print(lista) + +# 4.4 Ejercicio 1 con Matemáticas y la clase math + +# Sacar la raíz cuadrada de un número positivo + +numero = int(input("Escriba un numero positivo: ")) +while numero < 0: + print("Error, debe ingresar un numero positivo..") + numero = int(input("Ingrese un numero POSITIVO: ")) +print(f"\nSu raiz cuadrada es: {math.sqrt(numero): .2f}") # sqrt, funcion raiz cuadraada.. 2f nos muestra solo 2 num, desp de la coma diff --git a/PythonSCuatri/Clase 4/EjercicioColecciones1.py b/PythonSCuatri/Clase 4/EjercicioColecciones1.py new file mode 100644 index 00000000..973c5c48 --- /dev/null +++ b/PythonSCuatri/Clase 4/EjercicioColecciones1.py @@ -0,0 +1,18 @@ +# Ejercicio 1: Eliminar duplicados de una lista +# Escribir un programa donde tenga una lista y que luego elimine +# los elementos repetidos, por ultimo, mostrar la lista + +#.. Creamos la lista .. +lista = [1,2,3,"Mati", "Buenas Tardes", 3.3, 1, "Mati", 2, 1, 1, "Hola"] +print(lista) + +# para eliminar elementos repetidos, debemos crear un conjunto o set.. +conjunto = set(lista) # de esta manera, convertimos la lista en conjunto +print(conjunto) + +lista = list(conjunto) # conv conjunto a lista +print(lista) + +# ahora, hacemos lo mismo pero en una sola linea +lista = list(set(lista)) +print(lista) \ No newline at end of file diff --git a/PythonSCuatri/Clase 4/EjercicioColecciones3.py b/PythonSCuatri/Clase 4/EjercicioColecciones3.py new file mode 100644 index 00000000..c5f994fc --- /dev/null +++ b/PythonSCuatri/Clase 4/EjercicioColecciones3.py @@ -0,0 +1,25 @@ +# Ejercicio 3: +# Agregar personajes de la saga "El señor de los anillos" a una lista + +personajes = [] # creamos lista vacia + +# creamos diccionario +P1 = {"Nombre" :"Aragon", "Clase" : "Guerrero", "Raza" : "Dúnadan del norte"} + +# agregamos al personaje a nuestra lista +personajes.append(P1) + +P2 = {"Nombre" :"Gandalf", "Clase" : "Mago", "Raza" : "Istar"} +personajes.append(P2) + +P3 = {"Nombre" :"Legolas", "Clase" : "Arquero", "Raza" : "Elfo Sindar"} +personajes.append(P3) + +P4 = {"Nombre" :"Sauron", "Clase" : "maiar", "Raza" : "ainur"} +personajes.append(P4) + +P5 = {"Nombre" :"Gollum", "Clase" : "-", "Raza" : "seres antropomorfos"} +personajes.append(P5) + + +print(f"Mostramos la lista con los personajes: {personajes}") diff --git a/PythonSCuatri/Clase 4/EjerciciosColeccion2.py b/PythonSCuatri/Clase 4/EjerciciosColeccion2.py new file mode 100644 index 00000000..af146d54 --- /dev/null +++ b/PythonSCuatri/Clase 4/EjerciciosColeccion2.py @@ -0,0 +1,42 @@ +#.. Ejercicio 2: Operaciones de conjuntos con listas .. + +# Escriba un programa que tenga dos listas y que a continuacion +# cree las siguientes listas (no debe haber repeticiones): + +# -- 1 lista de palabras que aparecen en las listas +# -- 2 lista de palabras que aparecen en la primera lista, pero no en la segunda (-) +# -- 3 listas de palabras que aparecen en la segunda, pero no en la primera +# -- 4 lista de palabras que aparecen en ambas listas + +lista1 = ["Hola","Buenas tardes", "apio", "remolacha", "Hola mundo", "apio","camotin", "Hola mundo"] +lista2 = ["Buenas tardes", "soy Mati", "tengo 22 años", "soy estudiante", "soy Mati", "Buenas tardes"] +print(lista1) +print(lista2) + +# Eliminar elementos repetidos: +print(" Después de eliminar elementos repetidos: ") +conjunto1 = set(lista1) +conjunto2 = set(lista2) +print(conjunto1) +print(conjunto2) + + +print("Palabras que aparecen en ambas listas:") +union = list(conjunto1 | conjunto2) # 1 .. unimos conjuntos +print(union) + +# 2 . palabras que aparecen en el conjunto 2 pero no en 1 +print("Mostramos solo elementos que aparecen en el conjunto 2") +solo2 = list(conjunto2 - conjunto1) +print(solo2) + +# 3. palabras que aparece en la 1 pero no en la dos +print("Mostramos solo elementos que aparecen en el conjunto 1") +solo1 = list(conjunto1 - conjunto2) +print(solo1) + +# 4. Palabras de ambas listas(en comun) +interseccion = list(conjunto1 & conjunto2) +print(interseccion) + + diff --git a/PythonSCuatri/Clase 4/ModElementosEj7.py b/PythonSCuatri/Clase 4/ModElementosEj7.py new file mode 100644 index 00000000..3e38838f --- /dev/null +++ b/PythonSCuatri/Clase 4/ModElementosEj7.py @@ -0,0 +1,19 @@ +# Modificar los elementos de una lista +# Llenar una lista con numeros del 1 al 10, luego modificar los elementos +# de la lista multiplicandolos por un valor ingresado por el usuario + +lista = (range(1,11)) +print("Lista original") + +for i in lista: + print(i, end="-") + +valor = int(input("\nEscriba un valor para multiplicarlo: ")) + +# Para multiplicar los elementos de la lista: +for indice, i in enumerate(lista): # funcion para modificar indices de la lista + lista[indice] *= valor # el iterador solo recorre indices.. + +print(f"Lista con los elementos multiplicados por {valor}..:") +for i in lista: + print(i, end="-") diff --git a/PythonSCuatri/Clase 4/RecorrerDiccSeleccion.py b/PythonSCuatri/Clase 4/RecorrerDiccSeleccion.py new file mode 100644 index 00000000..24744f83 --- /dev/null +++ b/PythonSCuatri/Clase 4/RecorrerDiccSeleccion.py @@ -0,0 +1,15 @@ +# Otra forma de recorrer el diccionario +SeleccionArg = { + 10 : {"Nombre": "Lionel Messi", "Edad" : 36, "Alto" : 1.7, "Precio" : "280.8 M de euros", "Posicion" : "Delantero"}, + 9 : {"Nombre" : "Julian Alvarez", "Edad" : 23, "Alto" : 1.7, "Precio" : "21.48 M de euros", "Posicion" : "Delantero"}, + 24 : {"Nombre" : "Leandro Paredes" , "Edad" : 29, "Alto" : 1.83, "Precio" : "27.8 M de euros", "Posicion" : "Centrocampista"}, + 1 : {"Nombre" : "Franco Armani" , "Edad" : 36, "Alto" : 1.88, "Precio" : "3 M de euros", "Posicion" : "Arquero"}, + 23 : {"Nombre" : "Emiliano Martinez" , "Edad" : 31, "Alto" : 1.95, "Precio" : "28 M de euros", "Posicion" : "Arquero"}, + 3 : {"Nombre" : "Nicolas Tagliafico" , "Edad" : 31, "Alto" : 1.72, "Precio" : "15 M de euros", "Posicion" : "Defensa"} +} +print(SeleccionArg) + +# Nos muestra el numero --> luego la info + +for i in SeleccionArg: + print(f"{i} --> {SeleccionArg[i]}") \ No newline at end of file diff --git a/PythonSCuatri/Clase 4/ej8Insertarelementos.py b/PythonSCuatri/Clase 4/ej8Insertarelementos.py new file mode 100644 index 00000000..0c5f40f4 --- /dev/null +++ b/PythonSCuatri/Clase 4/ej8Insertarelementos.py @@ -0,0 +1,17 @@ +# --- Ejercicio: Insertar numeros y ordenarlos ---- + +# Pedir numeros y meterlos en una lista, cuando el usuario +# introduzca un numero 0, el programa dejaria de insertar.. +# Por ultimo, mostrar los numeros ordenados de mayor a menor + +lista = [] +salir = False +while not salir: # mientras salir sea False, lo cambiamos a V + numero = int(input("Escriba un numero: ")) + if numero == 0: # cuando pone 0, salir pasa a ser True + salir = True + else: # mientras no sea 0.. se agrega ek num a la lista + lista.append(numero) +# Funcion para ordenar: +lista.sort() +print(f" Lista ordenada: \n{lista}") \ No newline at end of file diff --git a/PythonSCuatri/Clase 5/CEjercicio8.py b/PythonSCuatri/Clase 5/CEjercicio8.py new file mode 100644 index 00000000..a0c281f3 --- /dev/null +++ b/PythonSCuatri/Clase 5/CEjercicio8.py @@ -0,0 +1,38 @@ +# Ejercicio 8: Menú interactivo - Cajero Automatico +# Hacer un programa que simule un cajero, con un salddo inicial de 1000 pesos +# y tendrá las siguientes opciones: +# - Ingresar dinero a cuenta: +# - Retirar dinero de cuenta: +# - Mostrar dinero disponible +# - Salir + +saldo = 1000 +while True: + print("\t. :Menú: ") + print("1 - Ingresar dinero a cuenta: ") + print("2 - Retirar dinero de la cuenta: ") + print("3 - Mostrar dinero disponible: ") + print(" 4 - Salir ") + + opcion = int(input("Ingrese una opcion de menu: ")) + print() + + if opcion == 1: + extra = float(input("¿Cuanto dinero deseea ingresar? : $ ")) # acá se guarda el dinero a ingresar + saldo += extra + print(F" Dinero en cuenta: $ {saldo}") + elif opcion == 2: + retirar = float(input("¿cuanto dinero necesita retirar? --> ")) + if retirar > saldo: + print("No tiene suficiente fondos..") + else: + saldo-= retirar + print(f"Dinero en cuenta: $ {saldo} --> ") + elif opcion == 3: + print(f"Dinero en cuenta hasta el momento: $ {saldo} ") + elif opcion == 4: + print("Gracias por usar nuestro servicio..") + break + else: + print("Ingrese una opcion válida..") + print( ) \ No newline at end of file diff --git a/PythonSCuatri/Clase 5/Ejercicio4.py b/PythonSCuatri/Clase 5/Ejercicio4.py new file mode 100644 index 00000000..82d10a01 --- /dev/null +++ b/PythonSCuatri/Clase 5/Ejercicio4.py @@ -0,0 +1,13 @@ +# Ejercicio sumar pares dentro de un rango +# Hacer un programa para sumar numeros pares dentro de un rango: +# suma de pares en el rango 2 - 30 +# suma = 240 + +a = int(input("¿Desde qué numero empezará a sumar?: ")) +b = int(input("¿En qué numero para la suma?: ")) + +suma = 0 +for i in range(a, b +1): + if i%2 == 0: # para saber si es par + suma += i +print(f"\n La suma dentro de rango es: {suma}") \ No newline at end of file diff --git a/PythonSCuatri/Clase 5/Ejercicio5.py b/PythonSCuatri/Clase 5/Ejercicio5.py new file mode 100644 index 00000000..14ef4883 --- /dev/null +++ b/PythonSCuatri/Clase 5/Ejercicio5.py @@ -0,0 +1,11 @@ +# Ejercicio 5: Factorial de número positivo +# Hacer un programa para calcular el factorial de un numero positivo + +numero = int(input("Ingrese un numero positivo: ")) +while numero < 0: # mientras sea negativo: + print("Error, el número es negativo") + numero = int(input("Ingrese un numero POSITIVO: ")) +factorial = 1 # var para calcular el factorial +for i in range(1, numero + 1): + factorial *= i +print(f"\n El factorial del numero {numero} ingresado es: {factorial}") diff --git a/PythonSCuatri/Clase 5/Ejercicio6.py b/PythonSCuatri/Clase 5/Ejercicio6.py new file mode 100644 index 00000000..a5bbeb5b --- /dev/null +++ b/PythonSCuatri/Clase 5/Ejercicio6.py @@ -0,0 +1,17 @@ +# Ejercicio 6: Tabla de multiplicaar + +# Hacer un programa que pida un numero por teclado, guarde +# en una lista su tabla de multiplicar hasta el 10. + # Por ejemplo: si se digita el 5, la lista tendrá 5,10,15,20,25,30.. + +numero = int(input("Ingrese un número para realizar su tabla de multiplicacion.. ")) +lista = [] +for i in range(0,10): + lista.append(i * numero) +print(f"\n La tabla de multiplicar del número ingresado es: \n {lista}") + +# para mostrarlo en forma de tabla: + +for indice, i in enumerate(lista): + # deberia agregar una variable que vaya recorriendo 1 en 1 + print(f"{numero} x {i} = {lista[indice]}") \ No newline at end of file diff --git a/PythonSCuatri/Clase 5/Ejercicio7.py b/PythonSCuatri/Clase 5/Ejercicio7.py new file mode 100644 index 00000000..2057d512 --- /dev/null +++ b/PythonSCuatri/Clase 5/Ejercicio7.py @@ -0,0 +1,23 @@ +import random +# Adivinar el numero: + +# Realizar un juego para adivinar el numero. Para ello se debe generar +# un numero aleat entre 1 - 100 y luego ir pidiendo numero indicando +# si es mayor o menor segun N. El proceso termina +# cuando el usuario acierta y se muestra la cantidad de intentos + +aleatorio = random.randint(0,100) # toma de 0 a 100 aleatorio +cont = 0 +print(" ... JUEGO: ADIVINA EL NÚMERO ...") +while True: + numero = int(input("Escriba un numero: ")) + cont += 1 + if numero > aleatorio: + print("\t No es el numero, ingrese un numero menor..") + elif numero < aleatorio: + print("\t No es el número, escriba uno mayor..") + else: # Cuando adivina el num: + print(f"El número ha sido acertado: {aleatorio}, ¡felicidades!") + break # para el ciclo +# Mostramos la cantidad de intentos: +print(f"La cantidad de intentos fue: {cont}") \ No newline at end of file diff --git a/PythonSCuatri/Clase 5/Ejercicio9.py b/PythonSCuatri/Clase 5/Ejercicio9.py new file mode 100644 index 00000000..2ae27c63 --- /dev/null +++ b/PythonSCuatri/Clase 5/Ejercicio9.py @@ -0,0 +1,16 @@ +# Mostrar una frase sin espacios y contar su longitud +# Se debe devolver la misma frase pero sin espacios en blanco, ademas +# un contador de cuantos caract tiene la frase( sin contar los espacios blancos) + +# Ejemplo: frase = vivir por siempre en paz +# frase final = vivirporsiempreenpaz +# num caract = 20 + +frase = input(" Escriba una fraase: ") +frase2 = " " +for i in frase: + if i != " ": + frase2 += i +frase = frase2 +print(f"\n Frase final: {frase}") +print(f"N° Caracteres: {len(frase)} ") \ No newline at end of file diff --git a/PythonSCuatri/Clase 5/Funciones.py b/PythonSCuatri/Clase 5/Funciones.py new file mode 100644 index 00000000..a706cc5b --- /dev/null +++ b/PythonSCuatri/Clase 5/Funciones.py @@ -0,0 +1,8 @@ +# Funciones en python: Bloque de code que podemos llamar N veces +# Necesita ser llamada para que se ejecute + +def mi_funcion(): #Se define la funcion + print("Saludos") + print("¿Cómo estan hoy?") + +mi_funcion() #Llamamos a la funcion \ No newline at end of file diff --git a/PythonSCuatri/Clase 7 FuncionesR/Ejercicios/Ejercicio2.py b/PythonSCuatri/Clase 7 FuncionesR/Ejercicios/Ejercicio2.py new file mode 100644 index 00000000..812839e2 --- /dev/null +++ b/PythonSCuatri/Clase 7 FuncionesR/Ejercicios/Ejercicio2.py @@ -0,0 +1,16 @@ +# Ejercicio2: Funcion con *args para multiplicar + +# Crear una funcion para multiplicar los valores recibidos de tipo num, +# utilizando argumentos variables * args como parametro de la funcion y +# regresar como result la multiplicacion de todos los valores pasados como argumento + +# DEFINIMOS LA FUNCION PARA MULTIPLICAR + +def mult_valores(*numeros): + resultado = 1 # ponemos 1 para q nos sirva a la hora de multip + for numero in numeros: + resultado *= numero + return resultado + +# Llamamos la funcion +print(mult_valores(3,5,15)) #le pasamos argumentos \ No newline at end of file diff --git a/PythonSCuatri/Clase 7 FuncionesR/Ejercicios/Ejercicio3.py b/PythonSCuatri/Clase 7 FuncionesR/Ejercicios/Ejercicio3.py new file mode 100644 index 00000000..acb98b63 --- /dev/null +++ b/PythonSCuatri/Clase 7 FuncionesR/Ejercicios/Ejercicio3.py @@ -0,0 +1,18 @@ +# Ejercicio Funcion Recursiva: + +# Imprimir numeros de 5 a 1 de manera descentente usando funciones recursivas +# Puede ser cualquier valor positivo.. + +# EJEMPLO: Si ponemos 5, deberia salir esto.. +# 5, 4, 3, 2 , 1 + +def imprimirNumerosRecursivos(numero): #llega el parametro + if numero >= 1: # entra el numero, revisa si es mayor o = + print(numero) # entra y muestra + imprimirNumerosRecursivos(numero - 1) # lo llama y entra un numero menos, asi va entrando y mostrando.. + elif numero == 0: + return + elif numero <= 0: + print("Valor incorrecto..") +NumRecursivo = int(input("Ingrese un numero para ver su recursividad.. ")) +imprimirNumerosRecursivos(NumRecursivo) \ No newline at end of file diff --git a/PythonSCuatri/Clase 7 FuncionesR/Ejercicios/Ejercicio4Calculadora.py b/PythonSCuatri/Clase 7 FuncionesR/Ejercicios/Ejercicio4Calculadora.py new file mode 100644 index 00000000..f31eeec9 --- /dev/null +++ b/PythonSCuatri/Clase 7 FuncionesR/Ejercicios/Ejercicio4Calculadora.py @@ -0,0 +1,20 @@ +# EJERCICIO 4: Calculadora de impuestos.. + +# Crear una funcion que calcule el total de un pago incluyendo.. +# - IVA +# Formula: pago_total = pagoSinImpuesto + pagoSinImpuesto * (impuesto /100) + +# Proporcione el pago sin impuesto: 1000 +# Proporcione el monto del impuesto: 21% +# Pago con impuesto: xxxxx + +def TotalConImp(pagoSinImpuesto, impuesto): + pagoTotal = pagoSinImpuesto + pagoSinImpuesto * (impuesto/100) + return pagoTotal + +#Ejecutamos la funcion, pidiendo los datos + +pagoSinImpuesto = float(input("Ingrese el monto sin impuesto: ")) +impuesto = float(input("Ingrese el impuesto a aplicar: ")) +pagoConImp = TotalConImp(pagoSinImpuesto,impuesto) +print(f"El pago con impuesto es: {pagoConImp}") #pasamos la var \ No newline at end of file diff --git a/PythonSCuatri/Clase 7 FuncionesR/Ejercicios/Ejercicio5Grados.py b/PythonSCuatri/Clase 7 FuncionesR/Ejercicios/Ejercicio5Grados.py new file mode 100644 index 00000000..b59ebb12 --- /dev/null +++ b/PythonSCuatri/Clase 7 FuncionesR/Ejercicios/Ejercicio5Grados.py @@ -0,0 +1,19 @@ +# EJERCICIO 5: Convertir temp + +# Realizar funciones para convertir de grados celsius a fahrenheit y viseversa.. +# Formulas: ºF = ºC x 1.8 + 32 // ºC = (ºF-32) ÷ 1.8 + +# funcion Convertir grados de celsius a f: +def CaFahrenheit(celsius): + return celsius * 1.8 + 32 + +def FaCelsius(Fahrenheit): # grados f a c + return (Fahrenheit - 32) / 1.8 + +celsius = float(input("Escriba los grados Celsius: ")) +resultado = CaFahrenheit(celsius) +print(f"{celsius} C a F --> {resultado} ") + +Fahrenheit = float(input("Ingrese los grados Fahrenheit: ")) +resultado = FaCelsius(Fahrenheit) +print(f"{Fahrenheit} F a C --> {resultado}") \ No newline at end of file diff --git a/PythonSCuatri/Clase 7 FuncionesR/FuncionesRecursivas.py b/PythonSCuatri/Clase 7 FuncionesR/FuncionesRecursivas.py new file mode 100644 index 00000000..566a15f8 --- /dev/null +++ b/PythonSCuatri/Clase 7 FuncionesR/FuncionesRecursivas.py @@ -0,0 +1,13 @@ +# FUNCION RECURSIVA: .. Se manda a llamar a si misma para completar una tarea.. +# Tiene dos fases: caso base y caso recursivo + +def factorial(numero): # recibimos num, envia arg, recibimos como parametro y nuestra funcion encuentra el resul + if numero == 1: + return 1 # caso base + else: + return numero * factorial(numero - 1) # caso recursivo +numFactorial = int(input("Escriba un numero para calcular su factorial: ")) +resultado = factorial(numFactorial) # codigo duro +print(f" El factorial del número {numFactorial} es: {resultado}") + +# Para hacer la tarea q nos pide. Haria una entrada de info con un input, solicitando q ingrese un numero diff --git a/PythonSCuatri/Clase 7 FuncionesR/ManejarListaTerminos.py b/PythonSCuatri/Clase 7 FuncionesR/ManejarListaTerminos.py new file mode 100644 index 00000000..39336ee9 --- /dev/null +++ b/PythonSCuatri/Clase 7 FuncionesR/ManejarListaTerminos.py @@ -0,0 +1,25 @@ +def ListaTerminos(**terminos): # kwards -->llaves, paramentros y argumentos + for llave, valor in terminos.items(): # --> items para recorrer diccionario + print(f"{llave} : {valor}") +ListaTerminos(IDE = "Integrated Develoment Enviroment", PK = "Primary Key") # pasamos terminos +ListaTerminos(Nombre = "Leo Messi") + +# Funcionamiento: +# 1: Recibe arg +# 2: Convierte en paramentros +# 3: Hace la operacion y muestra el diccionario + + +# Distintos tipos de datos, como argumento: +# funcion que recibe lista con elementos: + +def MostrarNombres(nombres): + for nombre in nombres: + print(nombre) +nombres2 = ["Juan", "Coscu", "Oscar"] # entra, asigna nombre = Juan, vuelve a entrar nombre = Coscu... +MostrarNombres(nombres2) +MostrarNombres("Jaz") + +# MostrarNombres(10,11) No es iterable... pero si ponemos: +# MostrarNombres((10,11)) se convierte en tupla, es decir iterable y puede recorrerlo +# MostrarNombres ([10,11]) lo convertimos a lista \ No newline at end of file diff --git a/PythonSCuatri/Clase 8 POO P1/Clase 8 POO P1/Persona.py b/PythonSCuatri/Clase 8 POO P1/Clase 8 POO P1/Persona.py new file mode 100644 index 00000000..a2d368dc --- /dev/null +++ b/PythonSCuatri/Clase 8 POO P1/Clase 8 POO P1/Persona.py @@ -0,0 +1,78 @@ +class Persona: +# Atributos o características --> metodo init(permite inicializar metodos) + # metodo INIT dunder + def __init__(self, nombre, dni, apellido,edad, *args, **kwargs): # self: Llama a traves de este y el init, uno mismo, al objeto hace referencia + self.nombre = nombre + # encapsulamiento abajo, para q no sea modificado + self._dni = dni + self.apellido = apellido + self.edad = edad # atributos + self.args = args + self.kwargs = kwargs + + def mostrar_detalle(self): + print(f"La clase Persona tiene los siguientes datos: {self.nombre}{self.apellido} {self._dni} {self.edad}, la direccion es: {self.args}, los datos importantes son: {self.kwargs}") + +persona1 = Persona("Matias", "Ikz", 45687120 , 22) #constructor, instancia + +print(persona1.apellido) +print(persona1.nombre) +print(persona1.edad) + +# Creación de objetos con argumentos +class Persona2: + def __init__(self, nombre,apellido, dni, edad): # self: Llama a traves de este y el init, uno mismo, al objeto hace referencia + self.nombre = nombre + self.apellido = apellido # variables + self.edad = edad + self._dni = dni +# Objeto: +persona = Persona2("Arturo", "Lope", 34578140, 33) # enviamos argumetos + +print(persona.apellido) # llamamos a traves del obj persona al atributo(con los valores) +print(persona.nombre) +print(persona.edad) + +print(f"El objeto2 de la clase persona es: {persona.nombre} {persona.apellido} Su edad es: {persona.edad}") + +class Persona3: + def __init__(self, nombre,apellido, dni, edad): # self: Llama a traves de este y el init, uno mismo, al objeto hace referencia + self.nombre = nombre # evita ser modificado + self.apellido = apellido + self._dni = dni # variables + self.edad = edad + def mostrar_detalle(self): #self = this + print(f" Persona: {self.nombre}{self.apellido} {self.edad}") + +persona3 = Persona3("Jose", "Casti", 48579214 , 45) +print(f"El objeto3 de la clase persona es: {persona3.nombre} {persona3.apellido} {persona3._dni} Su edad es: {persona3.edad}") + +# SI BIEN, EL PROFE LO HACE DENTRO DE UNA MISMA CLASS PERSONA, EL PROGRAMA FUNCIONA.. + +# Modificar atributos de un objeto +persona3.nombre = "Juancito " +persona3.apellido = " Costra " +persona3.edad = 39 +persona3._dni = 45698784 + +print(f"El objeto3 de la clase persona, modificado es: {persona3.nombre} {persona3.apellido} {persona3._dni} , Su edad es: {persona3.edad}") + +# METODOS DE INSTANCIA: + # METODO (asociado a una clase) = FUNCION (depende de si misma) +persona1.mostrar_detalle() # la ref se pasa de manera automatica +persona3.mostrar_detalle() + +# Persona.mostrar_detalle(persona3) # pasamos de manera manual la referencia + + +# Clase 9 part 2.2 + +# Podemos agregar atributos a los objetos, es un atributo superficial +persona1.telefono = "45688945" +print(f"El celular de {persona1.nombre} es = {persona1.telefono} ") + +# Pasamos mas datos: tupla + datos para el diccionario.. +persona4 = Persona("Roberto", " Funes", 34, "Teléfono", 26548787, "Calle j", 345, "Manzana", "B", "Casa 45", Altura = 1.89, Peso = 75, ColorF = "Azul", Movilidad ="Bicicleta - moto") +persona4.mostrar_detalle() +# print(persona4._dni) no se debe hacer +# Clases y obj -- > diff --git a/PythonSCuatri/Clase 8 POO P1/Clase 8 POO P1/diagramaUml.uxf b/PythonSCuatri/Clase 8 POO P1/Clase 8 POO P1/diagramaUml.uxf new file mode 100644 index 00000000..a880373a --- /dev/null +++ b/PythonSCuatri/Clase 8 POO P1/Clase 8 POO P1/diagramaUml.uxf @@ -0,0 +1 @@ +10 \ No newline at end of file diff --git a/PythonSCuatri/Clase 8 POO P1/Persona.py b/PythonSCuatri/Clase 8 POO P1/Persona.py new file mode 100644 index 00000000..70e611ef --- /dev/null +++ b/PythonSCuatri/Clase 8 POO P1/Persona.py @@ -0,0 +1,55 @@ +class Persona: +# Atributos o características --> metodo init(permite inicializar metodos) + + def __init__(self): # self: Llama a traves de este y el init, uno mismo, al objeto hace referencia + self.nombre = "Matias" + self.apellido = "Ikz" # atributos + self.edad = 22 + def mostrar_detalle(self): + print(f" Persona: {self.nombre}{self.apellido} {self.edad}") + +persona1 = Persona() #constructor, instancia + +print(persona1.apellido) +print(persona1.nombre) +print(persona1.edad) + +# Creación de objetos con argumentos +class Persona2: + def __init__(self, nombre,apellido, edad): # self: Llama a traves de este y el init, uno mismo, al objeto hace referencia + self.nombre = nombre + self.apellido = apellido # variables + self.edad = edad +# Objeto: +persona = Persona2("Arturo", "Lope", "33") # enviamos argumetos + +print(persona.apellido) # llamamos a traves del obj persona al atributo(con los valores) +print(persona.nombre) +print(persona.edad) + +print(f"El objeto2 de la clase persona es: {persona.nombre} {persona.apellido} Su edad es: {persona.edad}") + +class Persona3: + def __init__(self, nombre,apellido, edad): # self: Llama a traves de este y el init, uno mismo, al objeto hace referencia + self.nombre = nombre + self.apellido = apellido # variables + self.edad = edad + def mostrar_detalle(self): + print(f" Persona: {self.nombre}{self.apellido} {self.edad}") + +persona3 = Persona3("Jose", "Casti", "45") +print(f"El objeto3 de la clase persona es: {persona3.nombre} {persona3.apellido} Su edad es: {persona3.edad}") + +# SI BIEN, EL PROFE LO HACE DENTRO DE UNA MISMA CLASS PERSONA, EL PROGRAMA FUNCIONA.. + +# Modificar atributos de un objeto +persona3.nombre = "Juancito " +persona3.apellido = " Costra " +persona3.edad = 39 + +print(f"El objeto3 de la clase persona, modificado es: {persona3.nombre} {persona3.apellido} , Su edad es: {persona3.edad}") + +# METODOS DE INSTANCIA: + # METODO (asociado a una clase) = FUNCION (depende de si misma) +persona1.mostrar_detalle() +persona3.mostrar_detalle() \ No newline at end of file diff --git a/PythonSCuatri/Clase 8 POO P1/diagramaUml.uxf b/PythonSCuatri/Clase 8 POO P1/diagramaUml.uxf new file mode 100644 index 00000000..a880373a --- /dev/null +++ b/PythonSCuatri/Clase 8 POO P1/diagramaUml.uxf @@ -0,0 +1 @@ +10 \ No newline at end of file diff --git a/PythonSCuatri/Clase 9/EjerciciosAritmetica/Aritmetica1.py b/PythonSCuatri/Clase 9/EjerciciosAritmetica/Aritmetica1.py new file mode 100644 index 00000000..e96e9b47 --- /dev/null +++ b/PythonSCuatri/Clase 9/EjerciciosAritmetica/Aritmetica1.py @@ -0,0 +1,26 @@ +class Aritmetica: + """ + el nombre de este tipo de comentario es: DocString + En esta clase veremos algunas operaciones como suma, resta, multiplicacion y mas.. + """ + def __init__(self, operandoA, operandoB): + self.operandoA = operandoA + self.operandoB = operandoB + + # Metodos para sumar, restar, mult, div + + def sumar(self): + return self.operandoA + self.operandoB + def resta(self): + return self.operandoA - self.operandoB + def mult(self): + return self.operandoB * self.operandoA + def div(self): + return self.operandoA / self.operandoB + +# CREAMOS UNA INSTANCIA DE LA CLASE ARITMETICA +aritmetica1 = Aritmetica(7,9) +print(f"La suma es igual a = {aritmetica1.sumar()}") +print(f"La resta de los dos numeros es: {aritmetica1.resta()}") +print(f"La multiplicacion de los dos numeros es: {aritmetica1.mult()}") +print(f"La division de los dos numeros es: {aritmetica1.div():.2f}") \ No newline at end of file diff --git a/PythonSCuatri/Clase 9/EjerciciosAritmetica/ClassCubo.py b/PythonSCuatri/Clase 9/EjerciciosAritmetica/ClassCubo.py new file mode 100644 index 00000000..b5821509 --- /dev/null +++ b/PythonSCuatri/Clase 9/EjerciciosAritmetica/ClassCubo.py @@ -0,0 +1,22 @@ +class Cubo: + """ + Crear la clase cubo con los atributos ancho, alto y profundidad + con unmetodo calcular volumen: + volumen = ancho * alto * profundidad + el usuario debe ingresar los valores + + """ + def __init__(self, ancho, alto, profundidad): #recibe los parametros + self.ancho = ancho + self.alto = alto + self.profundidad = profundidad + + def Volumen(self): + return self.ancho * self.alto * self.profundidad + +ancho = int(input("Escriba el numero que corresponde al ancho del cubo: ")) +alto = int(input("Escriba el numero para la altura del cubo: ")) +profundidad = int(input("Escriba el numero que corresponde a la profundidad: ")) + +cubo1 = Cubo(ancho, alto, profundidad) # conv a atributos +print(f"El volumen del cubo es: {cubo1.Volumen()}") diff --git a/PythonSCuatri/Clase 9/EjerciciosAritmetica/ClassRectangulo.py b/PythonSCuatri/Clase 9/EjerciciosAritmetica/ClassRectangulo.py new file mode 100644 index 00000000..58f1b121 --- /dev/null +++ b/PythonSCuatri/Clase 9/EjerciciosAritmetica/ClassRectangulo.py @@ -0,0 +1,16 @@ +#Debe tener do atributos. Altura y base +# el nombre del metodo será calcilar el area utilizando la formula: +# area = base * altura . Pero los datos lo debe ingresar el usuario y +# los objetos deben ser 3.. + +class Rectangulo: + def __init__(self, altura, base): + self.altura = altura + self.base = base + def calcularArea(self): + return self.altura * self.base +base = int(input("Escriba el numero que corresponde a la base del rectangulo: ")) +altura = int(input("Escriba el numero para la altura del rectángulo: ")) + +Rectangulo1 = Rectangulo(base,altura) +print(f"El resultado de esta multiplicacion es: {Rectangulo1.calcularArea()}") diff --git a/PythonSCuatri/Clase1.py b/PythonSCuatri/Clase1.py new file mode 100644 index 00000000..cfc39082 --- /dev/null +++ b/PythonSCuatri/Clase1.py @@ -0,0 +1,86 @@ +# Colecciones Parte 1 +nombres = ["Matias" , "Carlos" , "Josefina" , "Ariel"] +print(nombres) + +print(nombres[1]) +print(nombres[3]) + +# en caso que la lista sea larga: +print(nombres[-1]) +print(nombres[-2]) + +# recuerar un rango de la lista +print(nombres[0:2]) # muestra las primeras pos del indice + +# ir del inicio de la lista al indice +print(nombres[ :3]) #muestra el 0,1,2 + +# para que ejecute desde el num indicado hasta el final +print(nombres[1: ]) + +# para modificar un valor +nombres[3] = "Liliana" +print(nombres) + +# iterar la lista +for nombre in nombres: + print(nombre) +else: + print("Se acabaron los nombres de la lista") + +# listas, parte 3. Preguntamos cuantos elementos tiene una lista +print(len(nombres)) #funcion que regresa la cant de elementos que contiene +nombres.append("Marcela") #ingresa un elemento a la lista, wn ultimo lugar +print(nombres) + +#incertamos un elemento en la posicion q queremos +#1ro va el indice(entero), donde queremos agregar el nombre +nombres.insert(1, "Albert") +print(nombres) +nombres.insert(3,"Debora") +print(nombres) + +# ¿cómo eliminamos un elemento? +nombres.remove("Albert") +print(nombres) + +# para eliminar el ultimo elemento +nombres.pop() +print(nombres) + +#eliminar un indice especifico +del nombres[2] +print(nombres) + +#eliminar o borrar elementos +nombres.clear() +print(nombres) + +#eliminar lista +del nombres +# print(nombres) - nos da error en el ej de abajo, x eso comentamos + +# TUPLAS, sigue el orden de las listas pero estas no se pueden modificar, INMUTABLES +cocina = ("cuchara", "cuchillo", "tenedor") +print(cocina) +print(len(cocina)) + +# acceder a un elemento de la tupla + +print(cocina[2]) +print(cocina[-2]) + +# como acceder a un rango +print(cocina[0:1]) + +# TUPLAS ´P2 + +# recorrer los elementos de la tupla +for cocinar in cocina: + print(cocinar, end= " ") # (\n) cada vez que muestra un elemento hace un salto de linea +# con el end = " ", hacemos que se muestre en un mismo renglon + +CocinaLista = list(cocina) # tupla a lista +CocinaLista[0] = "Plato" #mod de la lista +cocina = tuple(CocinaLista) #volvemos a convertirla en tuple +print("\n", cocina) \ No newline at end of file diff --git a/PythonSCuatri/Clase2Colecciones2/2.1TiposetOconjunto.py b/PythonSCuatri/Clase2Colecciones2/2.1TiposetOconjunto.py new file mode 100644 index 00000000..211b7a77 --- /dev/null +++ b/PythonSCuatri/Clase2Colecciones2/2.1TiposetOconjunto.py @@ -0,0 +1,34 @@ +# set no tiene orden y no deja almacenar elementos duplicados. +# cuando mandamos a imprimir, el orden es aleatorio + +# TIPO SET o conjunto +planetas = {"Marte", "Jupiter", "Venus"} +print(planetas) + +# funcion len: largo o cantidad de elementos +print(len(planetas)) + +# Revisar si existe un elemento dentro del set. Se debe escribir identico +print("Marte" in planetas) +print("saturno" in planetas) + +# agregar un elemento +planetas.add("Tierra") +planetas.add("Saturno") +print(planetas) + +# eliminar elementos +planetas.remove("Saturno") #si esta bien escrito, no da error al print +print(planetas) + +#si introducimos mal el nombre de la palabra a remover, esta palabra la pasa por alto +planetas.discard("marte") +print(planetas) + +# Limpiar el set +planetas.clear() +print(planetas) + +# Eliminar set o conjunto +del planetas +print(planetas) \ No newline at end of file diff --git a/PythonSCuatri/Clase2Colecciones2/2.2Diccionario.py b/PythonSCuatri/Clase2Colecciones2/2.2Diccionario.py new file mode 100644 index 00000000..2f28eb49 --- /dev/null +++ b/PythonSCuatri/Clase2Colecciones2/2.2Diccionario.py @@ -0,0 +1,61 @@ +# ¿Qué es un diccionario? coleccion de datos ordenados de manera particular + +# "Maradona" : 10 --> el conjunto de datos es un diccionario + +# UNA LLAVE Y UN VALOR +# dict(key,value) + +diccionario = { + "IDE" : "Integrated Development Environment", + "POO" : "Programacion Orientada a Objetos", + "SABD" : "Sistema de Administracion de Base de Base de Datos" +} +# mostramos el diccionario con tres elementos +print(diccionario) + +#verificar cant de elementos +print(len(diccionario)) + +# como acceder al diccionario con la llave (key) +print(diccionario["IDE"]) + +# otra forma de recuperar un elemento +print(diccionario.get("POO")) +print(diccionario.get("SABD")) + +# modificar un elemento +diccionario["IDE"] = " Entorno de Desarrollo Integrado" +print(diccionario) + +# ¿cómo recorrer los elementos? +for termino in diccionario: + print(termino) +# necesitamos una funcionpara recorrer un diccionario +for termino, valor in diccionario.items(): + print(termino, valor) + +# otra manera de acceder al diccionario. +for termino in diccionario.keys(): + print(termino) # muestra solo las llaves + +for valor in diccionario.values(): # muestra los valores sin las llaves + print(valor) + +# comprobar si una llave está o no está en el diccionario +print("IDE" in diccionario) #devuelve un booleano (v o f) + +# agregar un elemento +diccionario["PK"] = "Primary key" +print(diccionario) + +# eliminar elementos +diccionario.pop("SABD") +print(diccionario) + +# vaciar un diccionario +diccionario.clear() +print(diccionario) + +# eliminar diccionario +del diccionario +print(diccionario) \ No newline at end of file diff --git a/PythonSCuatri/Clase2Colecciones2/2.3Repaso.py b/PythonSCuatri/Clase2Colecciones2/2.3Repaso.py new file mode 100644 index 00000000..1ee65a47 --- /dev/null +++ b/PythonSCuatri/Clase2Colecciones2/2.3Repaso.py @@ -0,0 +1,51 @@ +# las listas son arreglos o vectores, dentro de las colecciones de Python +nombres = ["Matias" , "Carlos" , "Josefina" , "Ariel"] +print(nombres) + +# Agregar elemento, puede tener distintos tipos de datos +nombres.append("Gustavo") +nombres.append([1,2,3]) # agregamos una lista de 3 elementos +nombres.append(True) # booleano +nombres.append(10.45) # float +nombres.append([3,7,0]) #listas +nombres.append("No soy un nombre, solo soy un dato mas") + +print(nombres) + +# concatenar listas + +lista1 = [1 , 2 , 3] +lista2 = [5 , 6 , 7] +lista3 = lista1 + lista2 +print(lista3) + +# para agregar varios elementos a la lista + +lista3.extend([9,1,11]) # agregamos otro 1 y ejecutamos la funcion count +print(lista3) + +# para saber en que indice está un elemento +print(lista3.index(6)) + +# con esta funcion podemos ver si hay uno o mas numeros iguales +print(lista3.count(1)) # al imprimir nos dice que solo hay un 1 + +# para mostrar una lista en reversa +lista3.reverse() +print(lista3) + +# para multiplicar una lista repitiendo sus elementos: +lista = [3,4,5] * 2 +print(lista3) + +# metodos de ordenamiento +lista3.sort() # por default de manera ascendente los ordena +print(list) + +lista3.sort(reverse=True)#para invertirla y mostrarlos de manera descendente +print(lista3) + +tupla = (4,"Hola mundi", 7.30, [2,3,9], "hola", 4) +print(tupla) + +print(4 in tupla) \ No newline at end of file diff --git a/PythonSCuatri/EjerciciosClase1.py b/PythonSCuatri/EjerciciosClase1.py new file mode 100644 index 00000000..196b50c6 --- /dev/null +++ b/PythonSCuatri/EjerciciosClase1.py @@ -0,0 +1,28 @@ +#Ej 1: Iterar un rango de 0 a 10 e imprimir num divisible entre 3 + +print("Rango de 0 a 10 con numeros divisibles entre 3") +for i in range(11): + if i % 3 == 0: + print(i) + +# Ej 2: Crear un rango de numeros de 2 a 6 e imprimirlos +print(" Rango con valores de inicio 2 y fin 6") +rango = range(2,7) +for i in rango: + print(i) + +# Ej 3: Crear un rango de 3 a 10 pero con incremento 2 en 2 +print(" Num que se encuentran entre 3 y 10 pero con icremento 2") +#1rro el rango (3 a 11), luego el incremento +for i in range(3,11,2): + print(i) + +# 1.3 ejercicios de tuplas y listas +tupla = (13, 1, 8, 3, 2, 5, 8) # definimos la tupla +# creamos una lista que solo incluya los numeros menores a 5 e imprima por consola [1,3,2] +lista = [ ] +# filtramos los elementos menores de cinco +for elemento in tupla: + if elemento < 5: + lista.append(elemento) +print(lista) diff --git a/README.md b/README.md index e701386a..3fab9ce0 100644 --- a/README.md +++ b/README.md @@ -1 +1,7 @@ -# DevGroup_Segundo_Semestre \ No newline at end of file +# DevGroup_Segundo_Semestre +En este repositorio y rama llamada "Matias Ikaczijk" trabajaré todo el segundo cuatrimestre y probablemente los consecuentes. En este repo, yo y demas compañeros, iremos cargando nuestras actividades y progreso en la Tecnicatura. + +😎 En mi perfil podes ver mas informacion sobre mi.. En el repositorio SegCuatri, están los commits y tag que no se pudieron copiar en este repo, ya que de manera local se trabajó con otro + +

Languages and Tools:

+

git html5 java javascript python