Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.

Mensajes - Mario R. Rancel

Páginas: 1 [2] 3 4 5 6 7 ... 32

C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / ¿Es TreeSet un tipo List? Conocer subtipos de interface y supertipos clase Java

« en: 07 de Febrero 2022, 18:45 »

Trataremos de responder aquí a la pregunta planteada ¿Es TreeSet o HashSet un tipo de List en Java?

Para saber las clases que son de supertipo List puedes escribir en google "List api java 11" (suponiendo que estás usando versión de java 11) y acceder a la documentación del api de Java https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html

Ahí al principio verás las clases que tienen supertipo List

All Known Implementing Classes: AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector

Estas son las clases de tipo List, por tanto ni TreeSet ni HashSet son de tipo List.

Si quieres saber cuál es el supertipo de TreeSet puedes escribir en google "treeset api java 11" y acceder a https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/TreeSet.html

Ahí te indica la herencia de TreeSet y los supertipos a los que pertenece TreeSet

All Implemented Interfaces: Serializable, Cloneable, Iterable<E>, Collection<E>, NavigableSet<E>, Set<E>, SortedSet<E>

En este caso, con el enfoque con el que estamos trabajando, lo que interesa aquí es que TreeSet es un tipo de Set (conjunto). No aparece que implemente la interface List, por lo tanto no es un tipo de List.

Esta forma de conocer los supertipos, tanto desde "arriba hacia abajo" (buscando List y viendo qué clases la implementan) o desde "abajo hacia arriba" (buscando una clase como TreeSet y viendo qué interfaces implementa) puede ser muy útil para la programación Java.

Nota: obviamente, si un método nos pide un tipo List, no podemos pasarle un TreeSet porque un TreeSet no es un tipo de List.

C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / Re: programar agenda telefónica en Java añadir consultar eliminar contactos validar

« en: 31 de Enero 2022, 20:44 »

Kabuto: Las expresiones regulares son un dolor de cabeza...

, pero las muy malditas son muy útiles y potentes.

Prueba con esta expresión, yo la he probado y parece funcionar bien:

Código: [Seleccionar]

[\\d]{9}
\d es un carácter especial que significa cualquier digito, es lo mismo que poner el rango 0-9

Pero en Java y otros lenguajes, hay que usar doble barra invertida \\d
La primera barra lo que hace es "escapar" a la segunda, es decir, para indicar que esa segunda barra, forma parte de un carácter especial, el carácter \d
Si no la "escapamos", el compilador piensa que es una barra invertida y una letra d (dos caracteres individuales). Pero nosotros lo que queremos es indicar un único carácter "especial" (que se compone de dos símbolos, pero es un único carácter en verdad)

El {9} indica la cantidad de caracteres que ha de tener la cadena para coincidir con la expresión. Ahí le decimos que queremos 9, ni más ni menos.

C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / Re: programar agenda telefónica en Java añadir consultar eliminar contactos validar

« en: 31 de Enero 2022, 20:43 »

LordFer: Siento molestarte otra vez Kabuto, he conseguido hacer que puedas buscar el contacto por el nombre o por el correo, pero a la hora de poner el teléfono, quería poner una expresion regular para que el número de teléfono tenga que tener si o si 9 digitos, pero no consigo que funcione, he probado este.

\\+[0-9]

Pero no funciona, ¿Sabes a qué se debe esto?

C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / Re: programar agenda telefónica en Java añadir consultar eliminar contactos validar

« en: 31 de Enero 2022, 20:43 »

Kabuto: Sí, las tildes por lo general es mejor no ponerlas porque pueden dar errores, o bien no darlos pero luego salir caracteres raros en pantalla según el ordenador donde se ejecute el código.
Mea culpa.

Usando isEmpty() será suficiente.
El método isBlank() es relativamente "nuevo", se añadió a la clase String en la versión 11 de Java. Si estás compilando con una versión anterior no te lo reconocerá.
Pero esto no es importante ahora mismo, de momento centra tus preocupaciones en entender y desarrollar la lógica del programa.

Por si tienes curiosidad, la diferencia entre esos métodos es que isEmpty() devuelve true si la cadena está completamente vacía, es decir, cero caracteres.

En cambio, isBlank() devuelve true si la cadena está completamente vacía o también si los caracteres que contiene son únicamente espacios en blanco.

Así que la diferencia entre tu programa y el mío, es que el tuyo aceptaría cadenas de espacios en blanco para modificar los nombres, apellidos y teléfonos.
El mío no los aceptaría, solo se podrían modificar tecleando algo, letras, símbolos o lo que sea, pero nada de espacios en blanco.

Pero insisto, son detalles sin importancia, no pierdas tiempos con esto.

Saludos.

C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / Re: programar agenda telefónica en Java añadir consultar eliminar contactos validar

« en: 31 de Enero 2022, 20:42 »

LordFer: Buenos días Kabuto, antes de nada muchas gracias por ayudarme con el código la verdad, te explico los dos cambios que he tenido que realizar:

1. He tenido que quitar todas las tildes, ya que el compilador de java, da error al compilar.
2. Tuve cambiar por los .isBlank por is.Empty, me quedo así esa parte del código:

Código: [Seleccionar]

//Pedimos datos nuevos, si deja campos vacios, entonces no modificaremos esos datos
			System.out.print("Nombre: ");
			String nombre = teclado.nextLine();
			if (!nombre.isEmpty())
				modificar.setNombre(nombre);
			System.out.print("Apellidos: ");
			String apellidos = teclado.nextLine();
			if (!apellidos.isEmpty())
				modificar.setApellidos(apellidos);
			System.out.print("Telefono: ");
			String telefono = teclado.nextLine();
			if (!telefono.isEmpty())
				modificar.setTelefono(telefono);
			
			/*

A continuación voy a intentar añadir que también se pueda buscar el contacto por su nombre o por su numero de teléfono. De nuevo muchísimas gracias por tu ayuda!

C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / Re: programar agenda telefónica en Java añadir consultar eliminar contactos validar

« en: 31 de Enero 2022, 20:41 »

Kabuto: Clase Agenda

Será un ArrayList de objetos Contacto

He programado las opciones básicas:

- Añadir contacto.
Recibe un objeto Contacto y lo registra. A no ser que ya exista otro con el mismo correo, en cuyo caso rechazará el nuevo Contacto.
El ArrayList se vale de manera interna (no lo vemos en el código) del método equals() que escribimos en la clase Contacto para poder comprobar esto.

- Eliminar contacto
Recibe un String con el correo del contacto a eliminar.
Si lo encuentra, lo elimina. Si no, informa de que no existe.

- Buscar contacto
Recibe un String con el correo del contacto a buscar.
Si lo encuentra, lo retorna. Si no, informa que no existe y retorna un valor null
Este método será útil después para mostrar un contacto en concreto y también para modificarlo.

- Mostrar una lista de contactos registrados.
Si la lista no está vacía, recorrerá todos los contactos del ArrayList y los mostrará.
Aquí entra en juego el método toString() que escribimos anteriormente. Gracias a él, cada objeto Contacto sabe cómo ha de mostrarse en pantalla, no es necesario pedir datos a los getters para mostrarlos.

No tiene mayor misterio la verdad, pregunta lo que no te quede claro.

Código: [Seleccionar]

import java.util.ArrayList;

public class Agenda {

	private ArrayList<Contacto> agenda;

	public Agenda() {
		agenda = new ArrayList<Contacto>();
	}

	public void anadirContacto(Contacto contacto) {

		if (agenda.contains(contacto)) { //Ya hay un contacto equivalente(con el mismo correo)
			System.out.println("Ya existe un Contacto con el correo: " + contacto.getCorreo());
			System.out.println("Registro rechazado");
		}
		else {
			agenda.add(contacto); //Lo aceptamos
			System.out.println("Registro aceptado");
		}
	}

	public void eliminarContacto(String correo) {
		//Referencia para el contacto que vamos a buscar
		Contacto buscar = null;

		//Buscamos el contacto
		for (Contacto cont: agenda)
			if (cont.getCorreo().equals(correo)) {//Encontrado
				buscar = cont; //Lo referenciamos
				break; //Ponemos fin a la búsqueda
			}

		//Comprobamos si se ha encontrado, en cuyo caso será eliminado
		if (buscar == null)
			System.out.println("No existe ningún Contacto con el correo: " + correo);
		else {
			agenda.remove(buscar); //Eliminamos el contacto buscado
			System.out.println("Contacto eliminado.");
		}
	}

	public Contacto obtenerContacto(String correo) {
		//Buscamos el contacto
		for (Contacto cont: agenda)
			if (cont.getCorreo().equals(correo)) {//Encontrado
				return cont; //Lo retornamos, aquí finalizaría este método
			}

		//Si el bucle for ha finalizado sin retornar nada, es que no existe contacto con ese correo
		System.out.println("No existe ningún Contacto con el correo: " + correo);
		return null;
	}

	public void listarContactos() {

		System.out.println("\n\t\tAGENDA DE CONTACTOS");
		System.out.println("\t\t------ -- ---------\n");

		if (agenda.isEmpty())
			System.out.println("No hay contactos registrados.");
		else {
			//Antes de listar, ordenamos por apellidos
			agenda.sort(null);//Pasamos valor null porque los Contactos ya saben como han de ordenarse

			for (Contacto cont: agenda) {
				System.out.println("\t\t******");
				System.out.println(cont); //Grácias al método toString(), con esto basta para mostrar los datos
				System.out.println("\t\t******\n");
			}
		}
	}

}

Y por último la clase Main

Para facilitar las cosas declaramos un objeto Agenda y un Scanner como variables de "ámbito global", es decir, fuera del método main().
De esta manera, estos objetos son visibles en TODA la clase principal, así los distintos métodos "secundarios" que harán tareas específicas, podrán acceder directamente a la "agenda" y al Scanner.

El método main() consistirá en un bucle que muestra el menú de opciones, pide opción al usuario y mediante un switch decide a qué método secundario hay que llamar.

Los método secundarios son los que hacen todo el trabajo: piden datos, registran contactos, eliminan, modifican y validan que el correo electrónico cumpla con el formato adecuado.

Por cierto, la expresión regular de tu código es incorrecta, en algunos rangos de a y z minúsculas, pone la Z mayúscula, invalidando esos rangos.
Es decir, las letras que marco en rojo, deberían ser z minúsculas, no mayúsculas

Citar

"^[_A-Za-Z0-9-\\+]+(\\.[_A-Za-Z0-9-]+)*@"
+ "[A-Za-z0-9-]+(\\.[A-Za-Z0-9]+)*(\\.[A-Za-z]{2,})$"

Verás que la validación del correo la hago un poco distinto. No uso un objeto Pattern. Se podría usar, pero la clase String ya tiene un método llamado matches() al que directamente le podemos pasar la expresión regular sin tener que compilarla en un Pattern

Te dejo el código, comprueba su funcionamiento y pregunta lo que no entiendas.
Cuando lo tengas claro, intenta añadir nuevas funcionalidades a la agenda. Si te atascas, comparte por aquí tu código y te seguimos ayudando.
Un saludo.

Código: [Seleccionar]

import java.util.Scanner;

public class Main {
	
	//Variables/objetos de ámbito global 
	private static Agenda agenda = new Agenda();
	private static Scanner teclado = new Scanner(System.in);

	//Método principal
	public static void main(String[] args) {
		char opcion = ' ';
		
		while (opcion != '9') {
			mostrarMenu();
			opcion = teclado.nextLine().charAt(0);
			
			switch(opcion) {
			case '1':
				registrarContacto();
				break;
			case '2':
				eliminarContacto();
				break;
			case '3':
				modificarContacto();
				break;
			case '4':
				buscarContacto();
				break;
			case '5':
				agenda.listarContactos();
				break;
			case '9':
				System.out.println("\n\n\t\tFIN DE PROGRAMA");
				break;
			default:
				System.out.println("Opción inválida");
			}
		}

	}
	
	//Métodos secundarios
	private static void mostrarMenu() {
		System.out.println("\n\t\tMENU AGENDA");
		System.out.println("\t\t---- ------\n");
		System.out.println("[1] -- Registrar Contacto");
		System.out.println("[2] -- Eliminar Contacto");
		System.out.println("[3] -- Modificar Contacto");
		System.out.println("[4] -- Buscar Contacto");
		System.out.println("[5] -- Listar Agenda");
		System.out.println("[9] -- TERMINAR PROGRAMA");
		System.out.print("Elija opción: ");
	}
	
	private static void registrarContacto() {
		//Pedimos datos
		System.out.println("\n\tNUEVO CONTACTO\n");
		System.out.print("Nombre: ");
		String nombre = teclado.nextLine();
		System.out.print("Apellidos: ");
		String apellidos = teclado.nextLine();
		System.out.print("Teléfono: ");
		String telefono = teclado.nextLine();
		System.out.print("Correo: ");
		String correo = pedirCorreo();
		//Intentamos registrarlo
		agenda.anadirContacto(new Contacto(nombre, apellidos, telefono, correo));
	}
	
	private static void eliminarContacto() {
		System.out.println("Indique correo del contacto a eliminar.");
		System.out.print("Correo: ");
		String correo = pedirCorreo();
		agenda.eliminarContacto(correo);
	}
	
	private static void modificarContacto() {
		System.out.println("Indique correo del contacto a modificar.");
		System.out.print("Correo: ");
		String correo = pedirCorreo();
		//Buscamos el contacto
		Contacto modificar = agenda.obtenerContacto(correo);
		if (modificar != null) {
			System.out.println("Datos actuales del Contacto:\n");
			System.out.println(modificar);
			System.out.println("\nA continuación introduzca los nuevos datos que quiera modificar.");
			System.out.println("Si algún dato no quiere modificarlo, pulse ENTER dejando el campo vacío.");
			
			//Pedimos datos nuevos, si deja campos vacios, entonces no modificaremos esos datos
			System.out.print("Nombre: ");
			String nombre = teclado.nextLine();
			if (!nombre.isBlank())
				modificar.setNombre(nombre);
			System.out.print("Apellidos: ");
			String apellidos = teclado.nextLine();
			if (!apellidos.isBlank())
				modificar.setApellidos(apellidos);
			System.out.print("Teléfono: ");
			String telefono = teclado.nextLine();
			if (!telefono.isBlank())
				modificar.setTelefono(telefono);
			
			/*
			 * Modificar el correo es un poco más difícil
			 * porque ha de cumplir un patrón determinado, 
			 * pero en este caso, podemos aceptar un campo vacío.
			 * El campo vacío no cumple el patrón, pero se acepta
			 * porque significa que el usuario no quiere modificar
			 * el correo ya existente.
			 */
			boolean aceptado = false;
			while(!aceptado) {
				System.out.print("Correo: ");
				correo = teclado.nextLine();
				if (correo.isBlank()) //No quiere modificar
					aceptado = true;
				else { //Quiere modificar, pero ha de ser un correo validado
					if (validarCorreo(correo)) {
						modificar.setCorreo(correo);
						aceptado = true;
					}
					else
						System.out.println("Correo no válido. Intente de nuevo.");
				}
			}
			
			System.out.println("\nModificación completada");
		}
	}
	
	private static void buscarContacto() {
		System.out.println("Indique correo del contacto a buscar.");
		System.out.print("Correo: ");
		String correo = pedirCorreo();
		//Buscamos el contacto
		Contacto buscar = agenda.obtenerContacto(correo);
		
		if (buscar != null) {
			System.out.println("Datos del Contacto:\n");
			System.out.println(buscar);
		}
	}
	
	private static String pedirCorreo() {
		String correo = "";
		
		while (!validarCorreo(correo)) {
			correo = teclado.nextLine();
			if (!validarCorreo(correo))
				System.out.print("Correo no es válido. Intente de nuevo: ");
		}
		
		return correo;
	}
	
	private static boolean validarCorreo(String correo) {
		
		String expresionRegular = "^[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*@"
                + "[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$";
		
		return correo.matches(expresionRegular);
	}

}

C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / Re: programar agenda telefónica en Java añadir consultar eliminar contactos validar

« en: 31 de Enero 2022, 20:38 »

Kabuto: Hola. Muchos errores se deben a nombre de variables mal escritos, pero también a llamadas a métodos y clases que en realidad no has escrito, y claro,

Java no los encuentra.

¿Qué tal si comenzamos desde el principio?

He reescrito la clase Contacto haciendo algunos cambios.

- He cambiado el nombre de los atributos para que se ajuste más a las "convenciones" de Java. En este lenguaje no se estila hacer que nombres de

variables/atributos comiencen con una línea de subrayado.
Aunque por supuesto, eres libre de ponérsela. No afecta al funcionamiento del programa.
Pero no es costumbre hacerlo así.

- El atributo teléfono he preferido usar un String en lugar de un int.
Aunque sea un atributo compuesto de cifras numéricas, si no vamos a hacer operaciones matemáticas con él(sumas, restas, divisiones,...), por lo

general vamos a preferir tratar ese atributo como una cadena alfanumérica (String).
Aunque, de nuevo, eres libre de escoger el tipo de dato que quieras.

- Puesto que parece que quieres que los contactos se ordenen por "apellido", esto se puede facilitar haciendo que la clase implemente la interfaz

Comparable.
Al implementar esta interfaz, podemos sobreescribir (override) un método llamado compareTo() donde decidimos cómo se han de comparar los

objetos Contacto para decidir cual es el "mayor o menor", es decir, cuál va delante y cuál va detrás.
En este caso, el orden dependerá de comparar los apellidos, que como son datos String, esta clase ya sabe por sí misma como deben compararse.
Así que solo hay que retornar el resultado de comparar los apellidos.

- Además creo que quieres que el atributo "correo" funcione como una especia de clave única identificadora.
Es decir, no pueden haber dos contactos con un mismo correo, ya que va a ser un identificador único.
Esto también podemos facilitarlo si sobreescribimos el método equals().
Este método lo tienen TODAS las clases escritas en Java y sirve para decidir si dos objetos son iguales/equivalentes.
Pero aunque todas las clases lo incorporan, para que realmente funcione tenemos que sobreescribirlo y añadir el código necesario para decidir nosotros

cuándo se deben considerar "iguales" dos objetos de esta clase.

En este caso, vamos a querer que dos objetos se consideren "iguales/equivalentes" si ambos son de la clase Contacto y además tienen el mismo

valor para el atributo "correo".

Estos dos métodos, el compareTo() y el equals(), luego veremos que el ArrayList donde almacenaremos los objetos Contacto, sabrá

usarlos automáticamente para pedirle que ordene los contactos o para impedir que se almacenen dos contactos con el mismo correo.

- Por último, le vamos a sobreescribir también el método toString().
Este método se usa para construir una cadena donde se muestren todos los datos de los atributos, o al menos, los que consideremos más relevantes.
Esto facilita luego mostrar un listado de Contactos en pantalla, porque gracias a este método, cada objeto Contacto es capaz de

proporcionar una única cadena con los datos que queremos mostrar

El código podría quedar así:

Código: [Seleccionar]

public class Contacto implements Comparable<Contacto>{
	
	private String nombre;
	private String apellidos;
	private String telefono; //Puesto que no haremos operaciones matemáticas, mejor String que int
	private String correo;
	
	public Contacto(String nombre, String apellidos, String telefono, String correo) {
		this.nombre = nombre;
		this.apellidos = apellidos;
		this.telefono = telefono;
		this.correo = correo;
	}

	public String getNombre() {
		return nombre;
	}

	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	public String getApellidos() {
		return apellidos;
	}

	public void setApellidos(String apellidos) {
		this.apellidos = apellidos;
	}

	public String getTelefono() {
		return telefono;
	}

	public void setTelefono(String telefono) {
		this.telefono = telefono;
	}

	public String getCorreo() {
		return correo;
	}

	public void setCorreo(String correo) {
		this.correo = correo;
	}

	@Override
	public int compareTo(Contacto otroContacto) {
		//Los contactos se comparan mediante los apellidos para ordenarse
		return apellidos.compareTo(otroContacto.getApellidos());
	}
	
	@Override
	public boolean equals(Object obj) {
		
		if (obj instanceof Contacto) {
			//El objeto recibido es un Contacto, hay que hacer "casting" para tratarlo como tal
			Contacto otroContacto = (Contacto) obj;//Casting
			//Dos contactos se consideran iguales, si coinciden su correo
			return correo.equals(otroContacto.getCorreo());//Esto devuelve true o false, según si los correos coinciden o no
		}
		else
			return false; //El objeto con el que se compara, no es un Contacto
	}

	@Override
	public String toString() {
		//Construimos una cadena con los datos del contacto
		String cadena = "Nombre: " + nombre + " " + apellidos;
		cadena += "\nTeléfono: " + telefono + "\tCorreo: " + correo;
		//La retornamos
		return cadena;
	}
	
}

Revísalo y comenta si hay algo que no entiendes.

A ver si luego rasco algo más de tiempo y revisamos la clase Agenda. Un saludo.

C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / programar agenda telefónica en Java añadir consultar eliminar contactos validar

« en: 31 de Enero 2022, 20:37 »

Hola a todos, reproduzco a continuación un tema que fue creado por LordFer y por Kabuto para que pueda ser consultado y servir de ayuda, gracias a ambos.

LordFer: Buenas tardes programadores, escribo en este foro ya que no encuentro solución para terminar mi código. Se trata de crear una agenda de contactos que contenga las siguientes opciones: añadir contacto, eliminarlos, lista de todos los contactos, y buscar contactos, según su apellido, nombre o correo.

Esta ultima parte es la que no se realizar, por eso les pido ayuda, ya que no tengo mucha experiencia en programación.

Les adjunto lo que llevo de código.

No se que escribir en else if (opciones equals("4"))

Main.java -->

Código: [Seleccionar]

import AgendaDef.Contacto;
import AgendaDef.Agenda;
//import AgendaDef.OrdenApellidos;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/* Autores:  */

public class Main{
    
    public static void main(String [] args)
    {
        Pattern pattern = Pattern
               .compile("^[_A-Za-Z0-9-\\+]+(\\.[_A-Za-Z0-9-]+)*@"
                        + "[A-Za-z0-9-]+(\\.[A-Za-Z0-9]+)*(\\.[A-Za-z]{2,})$"); 
                        
        /*Esto sirve para poder comprobar el correo mas adelante. Lo sacamos desde este foro
        /es.stackoverflow.com/questions/46067/expresiones-regulares-para-correo-electronico-en-java*/                
        
        imprimirOpciones();
        ControladorContactos agenda = new ControladorContactos();
        
        Scanner usuario = new Scanner(System.in);
        String opciones = usuario.next();
        
        while (opciones.equals("6"))
        {
            
            if (opciones.equals("1"))
            {
            //Aqui es donde se crea el contacto
                System.out.println("********************************");
                System.out.println("Ha seleccionado crear un contacto ");
                System.out.println("");
                System.out.print("\tIntroduce el nombre del contacto: ");
                String nombreContacto = usuario.next();
                System.out.print("\tIntroduce los apellidos del contacto: ");
                String apellidos = usuario.next();
                System.out.print("\tIntroduce el numero de telefono del contacto: ");
                String telefono = usuario.next();
                System.out.print("\tIntroduce el correo electronico de la persona: ");
                String correo = usuario.next();
                
                //Con el codigo de la linea 14 se comprueba el correo//
                Matcher mather = pattern.matcher(correo);
                if (mather.find() == true) 
                {
                
                if (agenda.comprobarContacto(correo))
                {
                    Contacto contactoCorrecto = new Contacto (nombreContacto, apellidos, telefono, correo);
                    agenda.anadirContacto(contactoCorrecto);
                    System.out.println("El contacto se ha guardado correctamente. ");
                }
                else
                {
                    System.out.println("No se puede guardar el correo, ya existe uno igual.");
                }
                
                }
            }  
            
            else if (opciones.equals("2"))
            {
                //Eliminar un contacto
                System.out.println("******************************");
                System.out.println("Ha seleccionado eliminar un conctacto");
                System.out.println("");
                System.out.println("\tIntroduce el correo del contacto que quieres borrar: ");
                String correo = usuario.next();
                
                if (agenda.eliminarContacto(correo))
                {
                    System.out.println("El contacto ha sido eliminado.");
                }
                
                else
                {
                    System.out.println("No existe ningun contacto con ese correo");
                }
                
                volverMenu();
            }
             
            else if (opciones.equals("3"))
            {
                //Editar un contacto
                System.out.println("********************************");
                System.out.println("Ha seleccionado editar un contacto");
                System.out.println("");
                System.out.println("\tIntroduzca el correo del contacto que desea editar");
                String correo = usuario.next();
                
                if (agenda.comprobarContacto(correo))
                {
                    System.out.println("Elija que valor desea editar: ");
                    System.out.println("\t a. Cambiar nombre");
                    System.out.println("\t b. Cambiar los apellidos");
                    System.out.println("\t c. Cambiar el telefono");
                    System.out.println("\t d. Cambiar el correo electronico");
                    
                    String opcion = usuario.next();
                    System.out.print("Introduzca de el nuevo valor: ");
                    String valor = usuario.next();
                    agenda.editarContacto(correo, opcion, valor);
                    System.out.println("Se ha actualizado el contacto con exito.");
                }
                else
                {
                    System.out.println("No existe ningun contacto con ese correo");
                }
                
                volverMenu();
            }   
            
            else if (opciones.equals("4"))
            {
                //Buscar un contacto
                System.out.println("********************************");
                System.out.println("Ha seleccionado buscar un contacto");
                System.out.println("");
                System.out.println("\tElija cual es su criterio de busqueda: ");
                
            }
            
            
            else if (opciones.equals ("5"))
            {
                System.out.println("Esta es tu agenda de contactos: ");
                for (Item _Agenda : _Agenda) 
                {
                String nombreContacto = _Agenda.getNombreContacto();
                String telefono = _Agenda.getTelefono();
                String apellidos = _Agenda.getApellidos();
                String correo = _Agenda.getCorreo();
                
                System.out.println("Nombre: " + nombreContacto + apellidos + "\tTelefono: " + telefono + "\tCorreo electronico: " + correo);
                }
                System.out.println("---------------");
                
                volverMenu();
            }
            }
        }
    }

Agenda.java -->

Código: [Seleccionar]

package AgendaDef;

import java.util.ArrayList;
//import java.IOException;
import java.util.Comparator;

public final class Agenda{
    ArrayList <Contacto> _Agenda = new ArrayList <>();
    String  Contactos = "agenda.dat";
    
    public Agenda()
    {
    //Aqui es donde se inicia el array list, cuando se anada un contacto
        this._Agenda = new ArrayList <Contacto>();
    }
    
    public void anadirContacto (Contacto contacto_actual)
    {
        this._Agenda.add(contacto_actual);
    }
    
    public boolean eliminarContacto (String correo)
    {
        boolean isRemove = false;
        
        for (int i=0; i < this._Agenda.size(); i++)
        {
            Contacto actual = (Contacto) this._Agenda.get(i);
            
            if (actual.getCorreo().toLowerCase().equals(correo.toLowerCase()))
            {
                System.out.println("\tHemos eliminado: " + actual.getNombreContacto() + " " + actual.getApellidos());
                this._Agenda.remove(i);
                isRemove = true;
            }
        }
    }
    
    public ArrayList<Contacto> consultarContactoPorNombre(String nombreContacto)
    {
        ArrayList<Contacto> contactosConEseNombre = new ArrayList<Contacto> ();
        for (Contacto contactos : Contactos.getNombreContacto) 
        {
            if (contactos.getNombreContacto().toLowerCase().equals(nombreContacto.toLowerCase())) 
            {
                contactosConEseNombre.add(contactos);
            }
        }
        return contactosConEseNombre;     
    }
    
    public ArrayList<Contacto> consultarContactoPorApellido(String apellidos)
    {
        ArrayList<Contacto> contactosConEseApellido = new ArrayList<Contacto> ();
        for (Contacto contactos : Contactos.getApellidos) 
        {
            if (contactos.getApellidos().equals(apellidos)) 
            {
                contactosConEseApellido.add(contactos);
            } 
        }
        return contactosConEseApellido;     
    }
    
    public ArrayList<Contacto> consultarContactoPorEmail(String correo)
    {
        ArrayList<Contacto> contactosConEseEmail= new ArrayList<Contacto> ();
        
        for (Contacto contactos : Contactos.getCorreo) 
        {
                if ( correo.getCorreo().equals(correo)) 
                {
                    contactosConEseEmail.add(contactos);
                }
            
        }
        return contactosConEseEmail;     
    }
    
    public void eliminarContacto(Contacto contactos)
    {
        for (Contacto contactos : Contacto.getNombreContacto) 
        {
            if(Contactos.getNombreContacto().contains(contactos))
            {
                contacto.excluirContactoDeGrupo(contactos);
            }
        }
        contactos.remove(Contactos);
    }
    
    
    
}

Contacto.java -->

Código: [Seleccionar]

package AgendaDef;

public class Contacto{
    public String _nombreContacto;
    public String _apellidos;
    public String _telefono;
    public String _correo;
    
    
    public Contacto(String nombreContacto, String apellidos, String correo,  String telefono)
    {
        this._nombreContacto = nomnbreContacto;
        this._apellidos      = apellidos;
        this._telefono       = telefono;
        this._correo         = correo;
    }
    
    //Metodos GET
    
    public String getNombreContacto()
    {
        return this._nombreContacto;
    }
    
    public String getApellidos()
    {
        return this._apellidos;    
    }
    
    public String getTelefono()
    {
        return this._telefono;
    }
    
    public String getCorreo()
    {
        return this._correo;    
    }
    
    //Metodos SET
    
    public void setNombreContacto(String nombreContacto)
    {
        this._nombreContacto = nombreContacto;
    }
    
    public void setApellidos(String apellidos)
    {
        this._apellidos = apellidos;
    }
    
    public void setCorreo(String correo)
    {
        this._correo = correo;
    }
    
    public void setTelefono(String telefono)
    {
        this._telefono = telefono;
    }
}

Errores -->

Código: [Seleccionar]

./Root/AgendaDef/Agenda.java:42: error: cannot find symbol
        for (Contacto contactos : Contactos.getNombreContacto) 
                                           ^
  symbol:   variable getNombreContacto
  location: variable Contactos of type String
./Root/AgendaDef/Agenda.java:55: error: cannot find symbol
        for (Contacto contactos : Contactos.getApellidos) 
                                           ^
  symbol:   variable getApellidos
  location: variable Contactos of type String
./Root/AgendaDef/Agenda.java:69: error: cannot find symbol
        for (Contacto contactos : Contactos.getCorreo) 
                                           ^
  symbol:   variable getCorreo
  location: variable Contactos of type String
./Root/AgendaDef/Agenda.java:71: error: cannot find symbol
                if ( correo.getCorreo().equals(correo)) 
                           ^
  symbol:   method getCorreo()
  location: variable correo of type String
./Root/AgendaDef/Agenda.java:82: error: cannot find symbol
        for (Contacto contactos : Contacto.getNombreContacto) 
                                          ^
  symbol:   variable getNombreContacto
  location: class Contacto
./Root/AgendaDef/Agenda.java:82: error: variable contactos is already defined in method eliminarContacto(Contacto)
        for (Contacto contactos : Contacto.getNombreContacto) 
                      ^
./Root/AgendaDef/Agenda.java:84: error: cannot find symbol
            if(Contactos.getNombreContacto().contains(contactos))
                        ^
  symbol:   method getNombreContacto()
  location: variable Contactos of type String
./Root/AgendaDef/Agenda.java:86: error: cannot find symbol
                contacto.excluirContactoDeGrupo(contactos);
                ^
  symbol:   variable contacto
  location: class Agenda
./Root/AgendaDef/Agenda.java:89: error: cannot find symbol
        contactos.remove(Contactos);
                 ^
  symbol:   method remove(String)
  location: variable contactos of type Contacto
./Root/AgendaDef/Contacto.java:12: error: cannot find symbol
        this._nombreContacto = nomnbreContacto;
                               ^
  symbol:   variable nomnbreContacto
  location: class Contacto
./Root/Main.java:21: error: cannot find symbol
        imprimirOpciones();
        ^
  symbol:   method imprimirOpciones()
  location: class Main
./Root/Main.java:22: error: cannot find symbol
        ControladorContactos agenda = new ControladorContactos();
        ^
  symbol:   class ControladorContactos
  location: class Main
./Root/Main.java:22: error: cannot find symbol
        ControladorContactos agenda = new ControladorContactos();
                                          ^
  symbol:   class ControladorContactos
  location: class Main
./Root/Main.java:83: error: cannot find symbol
                volverMenu();
                ^
  symbol:   method volverMenu()
  location: class Main
./Root/Main.java:114: error: cannot find symbol
                volverMenu();
                ^
  symbol:   method volverMenu()
  location: class Main
./Root/Main.java:131: error: cannot find symbol
                for (Item _Agenda : _Agenda) 
                                    ^
  symbol:   variable _Agenda
  location: class Main
./Root/Main.java:131: error: cannot find symbol
                for (Item _Agenda : _Agenda) 
                     ^
  symbol:   class Item
  location: class Main
./Root/Main.java:142: error: cannot find symbol
                volverMenu();
                ^
  symbol:   method volverMenu()
  location: class Main
18 errors

Comunidad / Felices fiestas y próspero año nuevo para todos

« en: 24 de Diciembre 2021, 15:25 »

Un año más desde aprenderaprogramar.com les transmitimos nuestros deseos para que todos tengan una

Feliz Navidad y Próspero Año Nuevo.

Gracias a todos los que colaboran o han colaborado con aprenderaprogramar.com

Aprender a programar desde cero / Re: Lenguaje en c

« en: 24 de Octubre 2021, 11:22 »

Hola Kabuto, yo el código lo veo correcto. Para messi22, en https://aprenderaprogramar.com/foros/index.php?topic=1460.0 tienes las indicaciones sobre cómo escribir en los foros, cómo poner título a los hilos, etc. Si te queda alguna duda escribe una consulta en el foro "Comunidad". Es importante que aportes código para poder partir de él (ver cómo pegar código en el hilo citado). Si necesitas una base de lenguaje C mira el curso disponible en la web https://aprenderaprogramar.com/index.php?option=com_content&view=category&id=82&Itemid=210
Un saludo,

Aprender a programar desde cero / Re: Java agrupar objetos de distintos tipos en una colección polimorfismo CU00688B#

« en: 06 de Octubre 2021, 19:58 »

Hola Diego, efectivamente es como indicas. Declarando el objeto de tipo Producto fuera del bucle, evitamos el consumo de recursos que supone estar creando el objeto en cada iteración del bucle.

Por tanto tu planteamiento supone una mejora en la eficiencia del código. En ocasiones estos detalles no tienen importancia, pero en otras ocasiones sí que lo tienen. Además ser capaz de valorar estas cuestiones es interesante pues demuestra que se están entendiendo bien los conceptos de programación.

Gracias por la aportación. Saludos cordiales,

Comunidad / Re: Presentación

« en: 31 de Mayo 2021, 21:04 »

Hola Daniel y bienvenido. Aparte de lo ya comentado aporto algún comentario. Si realmente tienes muy escasa base de programación puede venirte bien leer este hilo https://aprenderaprogramar.com/foros/index.php?topic=1313.0 y posiblemente no sea mala opción que empieces con un curso básico antes de empezar con Java. Leer algún artículo como ¿Es Java el mejor lenguaje para aprender a programar desde cero? en https://aprenderaprogramar.com/index.php?option=com_content&view=category&layout=blog&id=84&Itemid=18 quizás te sirva de orientación.

Comunidad / Re: Oportunidades laborales área de programación de computadores para trabajadores

« en: 13 de Mayo 2021, 20:57 »

Gracias como siempre Kabuto por las aportaciones. Sólo matizar una cuestión: el curso "Bases de la programación nivel I" no es un curso <<donde no se pone en práctica lo que se explica de forma que se puedan visualizar resultados en un ordenador>>. El curso combina aspectos teóricos con aspectos prácticos, y se programa delante de ordenador para ver cómo se aplica la lógica. Es decir, es un curso donde quien lo realiza ya puede realizar sus primeros programas delante de ordenador y hacer sus pinitos para ver cómo se aplica la teoría a la práctica. De resto comparto todo lo indicado: "El inicio desde cero puede ser duro..., pero luego va siendo más asequible e incluso apasionante."

Comunidad / Oportunidades laborales área de programación de computadores para trabajadores

« en: 12 de Mayo 2021, 19:47 »

Hola, hemos recibido y respondido una consulta relativa a las posibilidades y salidas laborales de la programación para trabajadores, que extracto a continuación porque pienso puede ser de interés general.

EXTRACTO CONSULTA

Quiero generar una oportunidad laboral nueva, y estoy pensando en la programación. No sé nada de programación, y me interesa aprender por 2 razones:

La primera es poder trabajar idealmente de forma remota con alguna empresa que me contrate, que pueda manejar mis horarios, ideal sería un trabajo por objetivos, que pueda administrar mi tiempo, para poder seguir haciendo otras cosas.

La segunda es que para mi actividad laboral uso software que permite la programación a cierto nivel.

Entonces si puedo combinar mis 2 objetivos aprender a programar para tener una salida laboral alternativa y que además pueda si lo deseo programar para mi actividad laboral sería lo ideal.

Les consulto cual sería el camino, primero realmente tengo que probar si la programación es para mí y puedo abordarlo económicamente.

Tengo bastante experiencia laboral, pero de programación nada.

Espero puedan orientarme, si mis objetivos son viables, estaba pensando en un horizonte de tiempo de 2 años. Y viendo la web de ustedes entiendo que podría empezar por el curso : CURSO "FUNDAMENTOS DE PROGRAMACIÓN NIVEL I" con eso ver si realmente la programación es para mi y luego si es así, avanzar con más cursos.

Mi duda es pricipalmente si para poder llegar a uno de los objetivos que es que una empresa me pueda contratar para programar como trabajo remoto, lo que no sé, es si estas empresas que contratan programadores, se fijan y buscan más en la educación formal, me refiero a una carrera universitaria de programación o se puede estudiar por ejemplo con los cursos de ustedes y conseguir igualmente ese tipo de trabajos de programador contratado por empresas? Porque no me interesa ser programador freelancer, entonces entiendo que debo orientarme a lo que la industria está contratando.

EXTRACTO RESPUESTA

La cuestión que planteas es interesante pero a la vez más complicada de responder de lo que puede parecer a primera vista. Hay muchos factores implicados. Creo que para esta consulta vas a encontrar tantas respuestas como personas a las que preguntes. No obstante, a partir de diferentes respuestas quizás puedas llegar a tus propias conclusiones.

La primera cuestión que te comento es que para llegar a un grado de conocimiento de la programación suficiente para que esta se convierta en salida laboral, a la mayoría de las personas les lleva cuatro, cinco ó más años. Es un área de conocimiento muy extensa y adquirir dominio requiere tiempo.

No obstante, adquirir conocimientos de programación tiene otro aliciente: por un lado, comprender mejor cómo funcionan las máquinas y la inteligencia artificial. Por otro lado, la programación se está convirtiendo cada vez más en un conocimiento transversal. Para quienes trabajan en economía, saber programar puede ayudarles a resolver problemas económicos. Para quienes trabajan en medicina, puede ayudarles a resolver problemas médicos. Y así sucesivamente, porque cada vez más todo está apoyado en tecnología y la tecnología tiene detrás software a distintos niveles, pero cada vez es más común que todo tipo de herramientas faciliten entornos de programación para que los usuarios puedan sacarle un mayor partido.

Aprender programación es un camino no sencillo. No a todo el mundo se le da bien la programación. Podríamos decir que es algo similar al dibujo, no a todo el mundo se le da bien. La forma de saber si se te da bien posiblemente sea intentándolo.

Respecto a la educación formal, ciertamente es necesaria si se quiere conseguir un "trabajo de oficina en una empresa", que es el 90% del trabajo que hay. Realizar cursos por libre puede ser útil para aprender, hacer cosas por libre, y como trampolín para luego hacer más cosas, pero no es lo más frecuente que lleve a poder trabajar profesionalmente en el área.

Luego tenemos los casos "excepcionales", que son de personas con altas capacidades que son capaces de resolver en horas o días lo que a las personas normales les lleva días o meses. Esas personas suelen ser captadas por empresas importantes y ganar buenos sueldos, pero que una persona resulte de este tipo es tan probable como que te toque la lotería: es bastante improbable.

Respecto al curso Bases de la programación nivel I de aprenderaprogramar.com, puede ser un buen curso para tomar un primer contacto con la programación. Pero es solo eso, un primer contacto. Para realizar este curso se recomienda tener un nivel de matemáticas igual o superior al de enseñanzas medidas.

Recomendamos leer artículos:

Hilo de los foros sobre fundamentos de programación: https://aprenderaprogramar.com/foros/index.php?topic=1313.0
Artículos de la sección cómo empezar: https://www.aprenderaprogramar.com/index.php?option=com_content&view=category&layout=blog&id=84&Itemid=18

Y con estas y otras opiniones, que cada persona se forme su opinión para su situación personal y profesional

Saludos,

C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / Re: Java método equals Cómo se puede diferenciar entre igualdad e identidad CU00662B

« en: 06 de Mayo 2021, 21:10 »

Hola Felipe, ahora tu diseño es orientado a objetos. Has creado objetos que interaccionan entre sí, y es el main quien dirige la dinámica de la interacción. Se puede decir que "vas por buen camino". Hay cuestiones que deberás ir perfilando. Por ejemplo, una cuestión importante en el diseño orientado a objetos es definir bien las responsabilidades de cada objeto. Por ejemplo, un objeto CapturaTeclado es poco lógico que tenga entre sus funciones mostrar por pantalla "Inicio de programa", eso no sería un buen diseño. ¿Por qué? Porque un objeto de este tipo debe tener bien delimitadas sus funciones y estas ser acordes con el nombre del objeto. Una CapturaTeclado debería limitarse a representar y facilitar métodos de una captura de teclado, no a mostrar mensajes por pantalla ni otras cosas. Pero no te preocupes ahora de estas cuestiones, pues es algo que se debe ir asimilando poco a poco. A través de lectura, participación en foros, práctica, realización de ejercicios, etc. irás mejorando poco a poco.

Saludos

C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / Re: Java método equals Cómo se puede diferenciar entre igualdad e identidad CU00662B

« en: 30 de Abril 2021, 21:47 »

Se me había pasado eso... Otro detalle para que te apuntes Felipe, ya que muchas veces quedan fragmentos de código "muerto" dentro de nuestro código y esto se debe tratar de evitar.

C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / Re: Java método equals Cómo se puede diferenciar entre igualdad e identidad CU00662B

« en: 29 de Abril 2021, 20:19 »

Hola Felipe, tu código funciona correctamente. Te hago algunas sugerencias de mejora:

- Una cosa es los índices que usemos nosotros como programadores (0, 1, 2, 3 ...) y otra la forma de contar habitual en la vida normal o día a día (1, 2, 3, ...) por ello en el resultado que ofrece el programa al usuario parece que sería más fácil para el usuario si en lugar de mostrando ¿La letra 0 igual en las 2 palabras? empezaras mostrando ¿La letra 0 igual en las 2 palabras? Esto no te obliga a cambiar índices, se puede resolver de forma fácil sumando 1 en el momento de mostrar la salida por pantalla.

- En tu código se ve un cierto grado de repetición de instrucciones. La repetición no es deseable en programación porque resulta ineficiente y a la larga genera problemas para mantener los programas. Consulta otras soluciones en los foros (por ejemplo https://aprenderaprogramar.com/foros/index.php?topic=2089.0) que muestran soluciones más compactas, con menos código y menos repeticiones, e inténtalo por tí mismo.

Respecto a lo que comentas sobre <<No sé la verdad si se debía desarrollar como el ejemplo del tema Pensar en objetos. Una entrada de teclado o consola en Java como objeto con campos y métodos.>> te puedo decir lo siguiente: en Java en general siempre debes pensar en objetos y trabajar utilizando diferentes clases que representen los elementos de tu modelo. En este ejercicio no se decía nada al respecto y es un ejercicio sencillo, por tanto crear alguna clase auxiliar no es obligatorio para este ejercicio, aunque si se quiere se puede hacer para practicar. En programas reales o en ejercicios más complicados sí se hace necesario utilizar diferentes clases.

Saludos

C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más / Re: practica y ejercicio Sockets

« en: 08 de Marzo 2021, 20:41 »

Hola jordy96, en el código que has pasado falta código para que compile. No está el código de la clase formu1, que parece representar a un formulario. También falta el código de la clase Sockets4_servidor.

¿No tienes el resto del código?

Este ejercicio parece referirse a una máquina que actúa como servidor que recibe peticiones de clientes. Por tanto vas a necesitar un código para la máquina que actúe como servidor y otro código para la máquina que actúe como cliente. Ambas máquinas tienen que estar "arrancadas" (en ejecución) para que pueda materializarse el intercambio de datagramas.

Por otro lado, indicas que el servidor tiene que responder con números octales (0,1,2,3,4,5,6,7) pero, ¿responde aleatoriamente a cualquier petición, o tiene que responder determinado número según cuál sea el contenido de la petición? ¿Cuál es exactamente el enunciado o rúbrica del ejercicio?

Este es un ejemplo de implementación para una máquina cliente que envía datagramas UDP:

Código: [Seleccionar]

import java.io.IOException; 
import java.net.DatagramPacket; 
import java.net.DatagramSocket; 
import java.net.InetAddress; 
import java.util.Scanner; 

public class Cliente_usa_udp 
{ 
	public static void main(String args[]) throws IOException 
	{ 
		Scanner sc = new Scanner(System.in); 

		// Paso 1: crear el socket
		DatagramSocket ds = new DatagramSocket(); 

		InetAddress ip = InetAddress.getLocalHost(); 
		byte buf[] = null; 

		// iterar mientras el usuario no introduzca "adios" 
		while (true) 		{ 
			String inp = sc.nextLine(); 

			// convertir la entrada en un array de bytes. 
			buf = inp.getBytes(); 

			// Paso 2: crear el datagramPacket para enviar los datos 
			DatagramPacket DpSend = new DatagramPacket(buf, buf.length, ip, 1234); 

			// Paso 3: invocar send para enviar los datos 
			ds.send(DpSend); 

			// El bucle termina si el usuario introduce <<adios>> 
			if (inp.equals("adios")) 
				break; 
		} 
	} 
}

Y este para una máquina servidor que recibe datagramas y muestra lo que recibe, en este caso no emite respuesta y se cierra si recibe <<adios>> del cliente:

Código: [Seleccionar]

import java.io.IOException; 
import java.net.DatagramPacket; 
import java.net.DatagramSocket; 
import java.net.InetAddress; 
import java.net.SocketException; 

public class Servidor_usa_udp 
{ 
	public static void main(String[] args) throws IOException { 
		// Paso 1: crear un puerto para escuchar, en este ejemplo el puerto es el 1234 
		DatagramSocket ds = new DatagramSocket(1234); 
		byte[] receive = new byte[65535]; 

		DatagramPacket DpReceive = null; 
		while (true) { 

			// Paso 2: crear un DatgramPacket para recibir los datos 
			DpReceive = new DatagramPacket(receive, receive.length); 

			// Paso 3: recibir los datos en un buffer de bytes 
			ds.receive(DpReceive); 

			System.out.println("Cliente:-" + data(receive)); 

			// Cerrar el servidor si el cliente envía "adios" 
			if (data(receive).toString().equals("adios")) { 
				System.out.println("El cliente envió adios.....SALIENDO"); 
				break; 
			} 

			// Limpiar el buffer después de cada mensaje. 
			receive = new byte[65535]; 
		} 
	} 

	// Método auxiliar para convertir el array de bytes en un string 
	public static StringBuilder data(byte[] a) 	{ 
		if (a == null) 
			return null; 
		StringBuilder ret = new StringBuilder(); 
		int i = 0; 
		while (a[i] != 0) 
		{ 
			ret.append((char) a[i]); 
			i++; 
		} 
		return ret; 
	} 
}

Aprender a programar desde cero / Similitudes y diferencias entre bucle y programa con botón Visual Basic eventos

« en: 26 de Febrero 2021, 20:02 »

En los cursos de fundamentos (bases) de programación generalmente usamos el pseudocódigo y diagramas de flujo para aprender a plantear la solución a problemas. El pseudocódigo no es un lenguaje propiamente dicho, por lo que no se puede ejecutar sobre un computador. No obstante, sí podemos ejecutarlo mentalmente para valorar su corrección y ver si un programa planteado con esa lógica daría los resultados adecuados.

Normalmente se usa un lenguaje para hacer prácticas y ver cómo trasladar a resultados prácticos sobre un computador los planteamientos lógicos. El lenguaje que se usa depende del curso, pero grosso modo podemos pensar en dos tipos de lenguajes:

- "Tradicionales de consola" como C o Pascal tradicional etc.
- "Gráficos con ventanas y botones" como Visual Basic

Hay lenguajes que pueden trabajarse tanto en modo consola como en modo gráfico, pero no vamos a detenernos en esto.

Usar uno u otro tipo de lenguaje tiene ventajas e inconvenientes. Si se trabaja mediante consola, los resultados visualmente son más pobres. Sin embargo, son buenos para empezar porque permiten trasladar el pseudocódigo muy fácilmente a código. No obstante, la pobreza visual en general desmotiva a los alumnos porque les parece que no obtienen resultados "profesionales".

Si se trabaja en un entorno de tipo Visual Basic, los resultados son visualmente más atractivos al usarse ventanas y botones. Esto es motivador y alienta a los alumnos a continuar. Como desventaja podemos indicar que la lógica de estos entornos no es tan lineal, y trasladar el pseudocódigo a código a veces puede no ser tan fácil.

Supongamos que se nos plantea este ejercicio:

1. Crear el pseudocódigo que pida al usuario la base y la altura de un rectángulo, y que a partir de esos datos proporcione el área del rectángulo. Una vez mostrado al usuario, se le debe preguntar al usuario si quiere repetir y realizar otro cálculo (en cuyo caso se le pedirán de nuevo los datos y se realizará y mostrará de nuevo el cálculo) o no (en cuyo caso el algoritmo termina).

Una solución posible para este ejercicio es este pseudocódigo:

1-Inicio
2-Respuesta= ”s”
3-Mientras Respuesta= “s” ó Respuesta= “S” Hacer
3.1-Mostrar "Introduzca la base": Pedir a: Mostrar "Introduzca la altura": Pedir b
3.2-Area = a*b
3.3-Mostrar “El área del rectángulo es”, Area
3.4-Mostrar “Quiere continuar (S/N)”
3.5-Pedir Respuesta
Repetr
4-Fin

Este ejercicio usa un bucle do while para permitir tantas repeticiones como el usuario desee.

Un programa en Visual Basic para implementar lo anterior podría ser este código 1:

Código: [Seleccionar]

Option Explicit
Dim i As Integer
Dim respuesta As Boolean
Dim pregunta As Integer
Dim a%, b As Integer
Dim resultado As Integer

Private Sub Form_Load()
Show
Label1 = "Introduzca base y altura" & vbCrLf
End Sub

Private Sub Command1_Click()
respuesta = False
Label1 = Label1
Do While respuesta = False
	a = Val(Text1)
	b = Val(Text2)
	resultado = a * b
	Label1 = Label1 & "El área del rectángulo es" & Space(1) & resultado & vbCrLf
	pregunta = MsgBox("¿Desea continuar?", vbQuestion + vbYesNo, "Pregunta")
	If pregunta = vbYes Then
		respuesta = True
	Else
		Unload Form1
		End
	End If
Loop
End Sub

Este programa utiliza un do while con msgbox. Esta forma de escritura se asemeja a la del pseudocódigo, aunque la forma más “natural” de generar un programa de este tipo en Visual Basic sería usar textboxes y un botón para repetir y otro para finalizar. Ambas opciones, dentro de un curso de fundamentos, las consideraríamos correctas para este ejercicio, aunque podemos extendernos en explicar esto un poco si queremos.

La solución planteada anterior en Visual Basic es un poco "farragosa" desde la perspectiva de la forma de programación propia de este entorno, que podemos llamar "programación orientada a eventos". Si nos fijamos en el código 1, se usa un msgBox para preguntar si se quiere continuar o no, y si no se quiere continuar se termina el programa descargando el formulario. Esto es una forma de hacer las cosas poco natural para Visual Basic. Pensemos en cocinar algo: para hacer un potaje de verduras es más natural hacerlo en un caldero (olla) porque su altura nos permite llenarlo de agua y que no se derrame. Pero también podemos hacerlo en una sartén aunque no sea tan natural, y nos puede quedar bien también.

En Visual Basic, lo más natural sería un programa de este tipo, código 2:

Código: [Seleccionar]

Option Explicit
Dim i As Integer
Dim respuesta As Boolean
Dim pregunta As Integer
Dim a%, b As Integer
Dim resultado As Integer

Private Sub Form_Load()
Show
Label1 = "Introduzca base y altura" & vbCrLf
Command1.Text = "Calcular área"
End Sub

Private Sub Command1_Click()
respuesta = False
Label1 = Label1
	a = Val(Text1)
	b = Val(Text2)
	resultado = a * b
	Label2 = "El área del rectángulo es" & Space(1) & resultado & vbCrLf
End Sub

¿Qué ha cambiado? El bucle do while ha desaparecido, y ya no se pregunta directamente al usuario si quiere repetir o no.

¿Este programa responde al objetivo que se plantea en el pseudocódigo?

La respuesta es que sí, lo que pasa es que lo hace con otra lógica propia de aplicaciones visuales.

Esto quizás no es tan propio de explicarlo en un curso básico, pero podemos intentarlo.

En las aplicaciones tradicionales de consola, no hay bucle si no se escribe el bucle en el código. En cambio en entornos como Visual Basic hay un "bucle continuo" en segundo plano, que no está escrito en código, sino que se ejecuta por defecto cuando se ejecuta un programa. Este bucle al que me refiero es un bucle de "Captura de eventos". Estos entornos están preparados para detectar lo que hace el usuario con el ratón o con el teclado, y ejecutar algo en respuesta a eso que ha hecho el usuario, lo que llamamos un evento. Por ejemplo si el usuario pulsa un botón se produce un evento. Si pulsa sobre el formulario es otro evento. Si escribe en un textbox es otro evento, etc. Así, se pueden producir muchos eventos en muy poco tiempo.

En este programa, el bucle sería el bucle de segundo plano de captura de eventos al que nos hemos referido, y la ejecución del código ante el evento click sobre el botón de cálculo sería el código que calcula el área y muestra el resultado.

Cada vez que se pulsa el botón, se hace el cálculo y se muestra el resultado. Entre dos pulsaciones de botón el usuario puede cambiar los datos de base y altura. El usuario puede repetir tantas veces como desee.

Sería una lógica como esta:

Inicio
Mientras [Aspa de cierre pulsada == false] hacer
Mostrar el formulario y contenidos
Si usuario pulsa botón
Hacer cálculos y mostrar resultados
FinSi
Repetir
Fin

Aquí vemos que el programa está en un "bucle infinito" esperando a que el usuario pulse el botón. Si no pulsa el botón, el programa espera. Si pulsa el botón, calcula. Si pulsa el aspa de cierre, se cierra.

Nos encontramos así que tanto el pseudocódigo como el código 1 como el código 2 cumplen los objetivos planteados que eran:
- Que el usuario pueda introducir datos de base y altura y calcular el área de rectángulo tantas veces como quiera
- Que cuando el usuario lo decida, el programa termine

Usar textboxes y un botón es la forma de programar más habitual para hacer algo de este tipo en Visual Basic. Es más natural que usar un msgBox y unload. Pero para un curso de fundamentos nos vale tanto plantearlo de una manera como de otra, porque ambas son formas válidas de implementar la lógica.

Este tipo de cuestiones pueden resultar un tanto complicadas de comprender, por lo que en los cursos de fundamentos no nos detenemos en este tipo de cuestiones normalmente, es preferible dejarlo para un poco más adelante.

Aprender a programar desde cero / Re: Ayuda, programar una batalla pokemon en JAVA NETBEANS POO

« en: 15 de Febrero 2021, 19:47 »

Hola Weirdo, no sé el punto de partida en el que te encuentras. Cuando se trata de empezar desde cero recomendamos leer https://aprenderaprogramar.com/foros/index.php?topic=1313.0 y artículos de la sección Cómo Empezar (https://aprenderaprogramar.com/index.php?option=com_content&view=category&layout=blog&id=84&Itemid=18)

Y si se trata de empezar desde cero pero con Java, recomendamos seguir este curso paso a paso: https://aprenderaprogramar.com/index.php?option=com_content&view=category&id=68&Itemid=188

Páginas: 1 [2] 3 4 5 6 7 ... 32

Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

Noticias: