Mensajes

Vale ya lo pillo. Ya se como va gracias.

Si, pero esperaba alguna explicación tipo es que hace menos evaluaciones en el código mejorando su rapidez, o puede dar problemas si se usa x cosas también o algo, no un simple es mejor usar while(cond1 y cond2parasalir) porque si :/ .

Hola a todos de nuevo, xD.
Quería saber porque no es bueno utilizar return o break dentro de un bucle para salir de estos si ya has encontrado la letra, palabra dentro de una cadena por ejemplo, yo si lo encontraba devolvía el índice donde se había encontrado, de lo contrario devolvía -1 ya fuera del bucle y al corregirlo nos dicen que es una mala práctica de programación sin más explicación. ¿ Alguien sabe el por que ?. ¿ Es que antes no existían los return o break y por eso quieren que lo hagamos de otra forma ?.

Estimado:

Te dejo un ejemplo sencillo.

Código [Seleccionar] Expandir


import java.util.*;
class Promedio{
       public static void main(String[] args){
               Scanner in=new Scanner(System.in);
               int[] nota=new int[7];//nota va a ser la "variable instacia" del arreglo de enteros de 0 a 7
               int suma=0;
               int promedio=0;
               for(int i=0;i<7;i++){//vuelta 7 veces de 0 a 6
                       System.out.println("Ingresar nota:"+i);
                       nota[i]=in.nextInt();//Llenamos tu arreglo
                       //Almacenamos valor en pos i del arreglo nota.
                       suma=suma+nota[i];
               }
               promedio=suma/7;
               System.out.println("El promedio de enteros es:"+promedio);

       }
}


Atento a tus comentarios.

Saluda Atte.

Ese ejemplo lo entiendo, sin embargo lo entiendo porque hace la instancia sin mas y usa el nombre de la instancia para acceder al array recorrerlo llenarlo y hacer la media.
Sin embargo en el ejemplo anterior de Libros primero se crea el array de 10 elementos con el nombre libro. Y después hace librería[0] = new Libreria(); cuando yo habría hecho como tu en el ejemplo, habría usado libro[0] = new librería(), sin embargo el usa todo el rato libro y es lo que me confunde.  :/

Es decir: ¿ en el primero metes en la posición 0 del array catalogo un constructor de la clase Precio vacío de forma temporal y para acceder a algún método de Precio valdría con poner por ejemplo catalogo[0].dameSalario(); ?

Y el segundo simplemente es una instancia cPrecio de la clase Precio ? con el que puedo hacer perfectamente cPrecio.dameSalario();

Muchas gracias a todos, por ahora estoy con 2 libros y 1 manual ( el de como programar Java 7ªedición que lo llevo ya por la página 120, el resto de libros son para complementar a este último que me sirven para comparar ambos y practicar ejercicios.

Mmm... he realizado una prueba y me ha dado resultados diferentes a los que se indican :/. Al parecer funciona según donde estén apuntando la última vez las instancias.
Dejo el ejemplo que he realizado por curiosidad y ha resultado ser diferente del esperado. Ya he entendido como funciona y no se si es que realmente no he entendido tu explicación o te has equivocado.

Código (java) [Seleccionar] Expandir

package PrimeraClase;
public class Constructores {
boolean valiente = false;
int edad;
String colorPelo;
double altura;

public Constructores(boolean valiente, int edad, String colorPelo, double altura ){
this.valiente = valiente;
this.edad = edad;
this.colorPelo = colorPelo;
this.altura = altura;
}

public Constructores(){
this.valiente = false;
this.edad = 0;
this.colorPelo = null;
this.altura = 0;
}

public static void main (String[] arg)
{
/*
new Persona().getNombre(); y
Persona p = new Persona();
p.getNombre();
Es que en el primero creas una referencia temporal para el objeto que esta creando new e invocas el metodo
y la variable es destruida temporal es destruida despues de esa linea mientras que en la segunda se genera
el objeto en el heap y se guarda esa direccion para que pueda ser usada posteriormente.
la variable p existira hasta que se salga del metodo donde se declaro o del bloque ({..}) donde se creo.
*/
// System.out.println(new Constructores().colorPelo = "marron");
Constructores pj = new Constructores(true, 30, "moreno", 1.9f);
Constructores pj1 = new Constructores(false,15,"rubio",1.4f);
Constructores pj2;


System.out.println("Datos de PJ");
System.out.println("El pj es valiente: "+pj.valiente);
System.out.println("El pj tiene: "+pj.edad+" años");
System.out.println("El pj es: "+pj.colorPelo);
System.out.println("El pj mide: "+pj.altura+" cm");
System.out.println("******************************************************************");
System.out.println("Datos de PJ1");
System.out.println("El pj1 es valiente: "+ pj1.valiente);
System.out.println("El pj1 tiene: "+pj1.edad+" años");
System.out.println("El pj1 es: "+pj1.colorPelo);
System.out.println("El pj1 mide: "+pj1.altura+" cm");
System.out.println("******************************************************************");
System.out.println("******************************************************************");
System.out.println("Ahora en pj1 apunta a pj por lo que debería salir lo mismo que pj");
pj1 = pj;
System.out.println("El pj1 es valiente: "+ pj1.valiente);
System.out.println("El pj1 tiene: "+pj1.edad+" años");
System.out.println("El pj1 es: "+pj1.colorPelo);
System.out.println("El pj1 mide: "+pj1.altura+" cm");
System.out.println("******************************************************************");
System.out.println("******************************************************************");
pj2 = pj1;
System.out.println("Ahora pj2 apunta a pj1 que a su vez pj1 ya estaba apuntando a pj por lo que debería salir lo mismo que pj");
System.out.println("El pj2 es valiente: "+ pj2.valiente);
System.out.println("El pj2 tiene: "+pj2.edad+" años");
System.out.println("El pj2 es: "+pj2.colorPelo);
System.out.println("El pj2 mide: "+pj2.altura+" cm");
}
}

Código [Seleccionar] Expandir

RESULTADOS
Datos de PJ
El pj es valiente: true
El pj tiene: 30 años
El pj es: moreno
El pj mide: 1.899999976158142 cm
******************************************************************
Datos de PJ1
El pj1 es valiente: false
El pj1 tiene: 15 años
El pj1 es: rubio
El pj1 mide: 1.399999976158142 cm
******************************************************************
******************************************************************
Ahora en pj1 apunta a pj por lo que debería salir lo mismo que pj
El pj1 es valiente: true
El pj1 tiene: 30 años
El pj1 es: moreno
El pj1 mide: 1.899999976158142 cm
******************************************************************
******************************************************************
Ahora pj2 apunta a pj1 que a su vez pj1 ya estaba apuntando a pj por lo que debería salir lo mismo que pj
El pj2 es valiente: true
El pj2 tiene: 30 años
El pj2 es: moreno
El pj2 mide: 1.899999976158142 cm


Ok, es mas fácil que los puntero de c++. No se quedan direcciones de memoria guardadas. Al final A apuntab al sitio de siempre, B apunta a A y C a B.
Ok gracias !! 

Muy buenas tengo una duda un poco rara en el paso de valores por referencia, por ejemplo en el siguiente ejemplo:
Button A = new Button();
Button B = new Button();
Button C = B

Hasta aquí tengo 3 espacios de memoria verdad ? A, B y C solo que A apunto a un sitio, B a otro y C apunta al de B verdad?.
Ahora viene mi duda.
¿ Si ahora digo que B = A ?
Estaría haciendo paso por paso que A apunte a su sitio de siempre, B que tenía su espacio de memoria ahora apunte a A, pero en C que está mi duda apuntaba a B, pero al haber cambiado el apuntador de B se supone que ahora esta apunta a A, es decir todos apuntan a A ?. O por el contrario es más simple y seguiría C apuntando a B.

Pues me has convencido con lo de dejarme los ojos en una pantalla. Lástima que no hayan inventado algún portátil tipo ibook con pantalla que no refleje la luz ni canse la vista, no te deje los ojos llorando.