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

Buenas Alex, gracias, si aún no me hago idea de las implicaciones en la parte gráfica pero por otros lenguajes entiendo el ahorro de control de tipologias.

Mil gracias por el comentario.

Buenas tardes, ahi va mi respuesta

Intenta compilar el siguiente código:

public class Test {
    int atributo1;
    Test (int atrib) {atributo1 = 0;}
    public static void main (String[ ] Args) {
        System.out.println ("Mensaje 1");
        System.out.println ("Atributo 1 vale" + this.getAtrib1());
    } //Cierre del main

    public int getAtrib1() {return atributo1;}
} //Cierre de la clase

¿Qué mensaje de error se obtiene?

non static variable this cannot be referenced from a static context

¿Por qué se obtiene este mensaje de error?

Bueno el metodo main al ser static, solo puede acceder a variables y metodos de su clase si son static también, sino se entiende que son variables y metodos de instancia y no de clase.

En concreto el error en el this, aunque ponga en static la variable y el metodo sigue persistiendo.

    System.out.println ("Atributo 1 vale" + this.getAtrib1()); 
Al quitarlo compila y hace lo que queremos, deduzco que tiene que ver con que "this." hace referencia a la variable de instancia y no de Clase, aunque buscando no lo he podido confirmar cien por cien seguro.

Encontré esto para asegurarme de que no decía una barbaridad.

this

Al acceder a variables de instancia de una clase, la palabra clave this hace referencia a los miembros de la propia clase en el objeto actual; es decir, this se refiere al objeto actual sobre el que está actuando un método determinado y se utiliza siempre que se quiera hace referencia al objetoactual de la clase.

¿Cómo podemos solucionarlo para que se ejecute lo que pretendemos?


/**
 * Write a description of class Test here.
 *
 * @author (your name)
 * @version (a version number or a date)
 */
public class Test {
    static int atributo1;
   
    Test(int atrib) { atributo1 = 0; }

    public static void main (String [] args) {
        System.out.println ("Mensaje 1");
        System.out.println ("Atributo 1 vale" + getAtrib1() );
       
    } //cierre main

     static public int getAtrib1() { return atributo1; }
} //cierre clase

También me funciona añadiendo Test.getAtrib1() pero no con el this.getAtrib1 lo que me dio la idea de pensar que this se referia al metodo o variable de instancia y no de clase.
System.out.println ("Atributo 1 vale" + Test.getAtrib1() );

P.D. por lo que veo no acierto con mi deducción del this.getAtrib1, si se refiere a la clase no a instancia, pero aun así me da error y no comprendo porque, poniendo todo static, en cambio Test.getAtrib1 no da error, aunque deberian ser lo mismo. Si alguien puede ilustrarme lo agradeceré porque no lo veo.

Buenas tardes, aquí dejo mi ejercicio resuelto

Clase Enum TipoPiedra


/**
 * Enumeration class Piedras - Esta clase contiene los tipos de piedra y sus pesos especificos.
 *
 * @author Lorenzo31
 * @version 09-04-2015
 */

public enum TipoPiedra {

    CALIZA (1200f),

    MARMOL (1423.55f),

    PIZARRA (1325f),

    CUARZITA (1466.22f);

    private final float peso;

    TipoPiedra(float valorPeso) { peso = valorPeso; }

    public float getPeso() { return peso; }
   
    /**
     * Funcion que @return un float y calcula el peso de un palet fijandose en el peso unitario
     * y multiplicandolo por 2.27 que se daba por supuesto en el ejercicio anterior, era un palet
     */
    public float getPesoPalet() { return 2.27f * peso; }

}

Clase Main GestorPiedra

/**
 * Clase Main que recorre los tipos de Enumerados declarados en Enum TipoPiedra
 * @Author Lorenzo31
 */

public class GestorPiedra {
   
    public static void main (String [] args){
       
        System.out.println("Iniciamos el programa ");
       
       System.out.println(" TIPO PIEDRA \t PESO M3 \t PESO TOTAL PALET");
       
        for(TipoPiedra tmp: TipoPiedra.values()){
        System.out.println(tmp.toString()  + "\t \t" + tmp.getPeso() + "kg \t \t" + tmp.getPesoPalet() + "kg" );
    }
    }
}


Buenas, aquí dejo mi solución al ejercicio. Un poco laborioso lo de averiguar como recoger enum del usuario, supongo que despues compensa que ya queda todo controlado en los valores que tu deseas se entre.

Sin más ahí va.

Clase Enum MarcaDeVehiculo


/**
 * Enumeration class MarcaDeVehiculo - Tipos de Vehiculos que podran recogerse
 *
 * @author Lorenzo31
 * @version 09-04-2015
 */
public enum MarcaDeVehiculo { FORD, TOYOTA, SUZUKI, RENAULT, SEAT}

Clase Vehiculo


/**
 * Write a description of class Vehiculo here.
 *
 * @author Lorenzo31
 * @version 09-04-2015
 */
public class Vehiculo {
   
    private String matricula;
    private MarcaDeVehiculo marcaCoche;
   
    public Vehiculo(){ matricula = ""; }
   
    /**
     * Método que establece el valor de matricula
     */
   
    public void setMatricula(String valorMatricula){ matricula = valorMatricula; }
   
     /**
     * Método que establece el valor de marcaCoche
     */
    public void setMarcaCoche(MarcaDeVehiculo valorMarcaCoche){ marcaCoche = valorMarcaCoche; }
   
    /**
     * Metodo que devuelve el valor de @return matricula
     */
   
    public String getMatricula (){ return matricula; }
   
   
    /**
     * Metodo que devuelve el valor de @return marcaCoche
     */
    public MarcaDeVehiculo getMarcaCoche (){ return marcaCoche; }
}

Clase GestorVehiculo

import java.util.Scanner;
import java.lang.IllegalArgumentException;

/**
 * @Author Lorenzo31
 * Esta clase recoge datos de matricula y modelo de un Vehiculo y muestra los resultados
 */

public class GestorVehiculo{
   
    public static void main (String [] args){
        Vehiculo coche = new Vehiculo();
        boolean modeloValido = false;

        System.out.println("Iniciamos el programa ");
       
        //Recoge matricula
        System.out.println("Introduce una matricula (String)");
        Scanner entrada = new Scanner(System.in);
        coche.setMatricula(entrada.nextLine() );
       
        //Recoge modelo
        System.out.println("Introduce un nuevo modelo ");
        do{
            try{
                coche.setMarcaCoche(MarcaDeVehiculo.valueOf(entrada.nextLine().toUpperCase()));
                modeloValido = true;
            }catch(IllegalArgumentException e){ System.out.println("Introduce un modelo válido: FORD, TOYOTA, SUZUKI, RENAULT, SEAT"); }
        }while (modeloValido == false);
       
        //Muestra matricula y modelo por pantalla
        System.out.println("Matricula: " + coche.getMatricula() + " Modelo " + coche.getMarcaCoche() );
       
        System.out.println("Final del programa");
    }

}


Buenas tardes, dejo mi solución para este ejercicio.

Clase EscanerDatos

import java.util.Scanner;
import java.util.InputMismatchException;

/**
 * Esta clase guarda los valores introducidos por el usuario a partir del teclado
 *
 * @author Lorenzo31
 * @version 08-04-2015
 */
public class EscanerDatos
{
    /**
     * Constructor vacio sin necesidad de parametros
     */
   
    public EscanerDatos(){ /*vacio*/ }

    /**
     * Método que recoge datos por consola y devuelve un double
     * @return devuelve un valor double introducido por el usuario
     */
    public double getDouble(){

        double valor = 0;
         System.out.println("Introduce un valor ");
          do{
           try{
                Scanner escaner = new Scanner(System.in);
                valor = escaner.nextDouble();
            }catch (InputMismatchException e){ System.out.println("Debes introducir un valor double");
            }
          } while (valor == 0);

        return valor;
    }
   
    /**
     * Método que recoge datos por consola y devuelve un entero
     * @return devuelve un valor int introducido por el usuario entre 1 y 4
     */
    public int getEntero(){
       int valor = 0;
       do{
           try{
                Scanner escaner = new Scanner(System.in);
                valor = escaner.nextInt();
            }catch (InputMismatchException e){ System.out.println("Debes introducir un valor entero");
            }
          } while (valor < 1 || valor > 4);
   
       return valor;   
    }
   
   
}


Clase MiniCalculadoraEjemplo

import java.lang.Math;

/**
 * Esta clase define operaciones matemáticas realizadas a partir
 * de unos valores por que determina el usuario previamente.
 * @author Lorenzo31
 * @version 08-04-2015
 */

public class MiniCalculadoraEjemplo{
   
    /**
     * Constructor sin parámetros ni inicializaciones
     */
   
    public MiniCalculadoraEjemplo(){ /*vacio*/ }
   
    /**
     * Método que calcula el valor absoluto de un número.
     * @param numero : el valor sobre el que se desea ejecutar la operación
     * @return valor absoluto resultante del cálculo
     */
   
    public double getValorAbsoluto(double numero){ return Math.abs(numero); }
   
    /**
     * Método que calcula la raiz cuadrada de un número.
     * @param numero : el valor sobre el que se desea ejecutar la operación
     * @return valor resultante del cálculo de la raiz cuadrada
     */
   
    public double getRaizCuadrada(double numero){ return Math.sqrt(numero); }
}

Clase GestorCalculo


/**
 * Esta clase contiene el main necesario para la ejecución de los calculos
 *
 * @author Lorenzo31
 * @version 08-04-2015
 */
public class GestorCalculo
{
    /**
     * Metodo main que ejecuta las opciones de calculo y pide valor al usuario
     * Con menu para elegir opciones
     * @see <a href = "https://www.aprenderaprogramar.es/index.php?option=com_content&view=article&id=646:documentar-proyectos-java-con-javadoc-comentarios-simbolos-tags-deprecated-param-etc-cu00680b&catid=68:curso-aprender-programacion-java-desde-cero&Itemid=188" /> aprenderaprogramar.com – Didáctica en programación </a>
     */
    public static void main (String [] args){
        double numero;
        int valor;
       
        System.out.println("Iniciamos el programa \n ");
       
        MiniCalculadoraEjemplo operar = new MiniCalculadoraEjemplo();
       
        EscanerDatos entrada = new EscanerDatos();
        numero = entrada.getDouble();

       
        do{
            System.out.println(" 1.- Introducir nuevo número \n 2.- Calcular valor absoluto \n 3.- Calcular raiz cuadrada \n 4.-Salir \n");

            valor = entrada.getEntero();

            switch(valor){
                case 1: numero = entrada.getDouble(); break;
                case 2: System.out.println(operar.getValorAbsoluto(numero) ); break;
                case 3: System.out.println(operar.getRaizCuadrada(numero) ); break;
            }
        }while (valor != 4);
   
        System.out.println("Final del programa "); 
    } //final main

}//final clase


Bueno muchas gracias por tu respuesta lo primero Mario.

Sí tengo clara la diferencia entre Set y List que las dos vienen de Collection. Tendré en cuenta lo de los nombres, ya lo hago pero es obvio que a veces resulta dificil poner uno que explique la clase sintetizada y de forma correcta.

Sí la resolución del GestorIterador es genial, pero no es mía, la cogí a posteriori de otro compañero del foro, el doble Iterador, la mía era solo con uno, aunque al menos sabía que algo me faltaba.

La parte en la que dices has añadido un salto de linea creo se podria resolver simplemente cambiando
 
     while(iterObjetos.hasNext()){
                  System.out.print(iterObjetos.next() + ", "); }

por un System.out.println. en ese caso con coma al final.

También adjunto tu petición de eliminar la coma final con tu println("") y el cambio de la clase ConjuntoSet por ListaSet.

import java.util.Iterator;
import java.util.Set;

public class GestorIterador {
    public static void main (String [] args){
        ListaSet prueba = new ListaSet();
        for( Iterator <Set> iterConjunto = prueba.getLista().iterator(); iterConjunto.hasNext();){
       
            for( Iterator iterObjetos = iterConjunto.next().iterator(); iterObjetos.hasNext();)
            {
                System.out.print(iterObjetos.next());
                // añado esta condición que en el caso de ser falsas las dos no imprime la ultima coma
                if (iterConjunto.hasNext() || iterObjetos.hasNext()){System.out.print(", "); }
                System.out.println("");
             }
             
        }

    }
}



Buenas tardes, dejo la solución de mi ejercicio aunque no estoy nada satisfecho.

No se si es la vuelta de Semana Santa pero he encontrado especialmente complicado el ejercicio ( lo cual no es malo ) la razón de que no me convenza es que saco por pantalla los contenidos de los objetos en conjunto y no la información concreta que alberga cada uno. El resultado es el mismo pero en conjunto [ 2, 8,5 ] [ sol, luna,saturno ].

Clase Estrellas

import java.util.HashSet;

public class Estrellas{
   
    private HashSet <String> stars = new HashSet <String>();
   
    public Estrellas(){  //constructor inicializado por defecto
        stars.add("sol");
        stars.add("luna");
        stars.add("saturno");
    }//cierre contructor
   
    public HashSet <String> getEstrellas() { return stars; }
} //cierre clase

Clase Numeros

import java.util.TreeSet;

public class Numeros {
   
    private TreeSet <Integer> numbers = new TreeSet <Integer>();
   
    public Numeros(){  //contructor crea por defecto los objetos
        numbers.add(2);
        numbers.add(8);
        numbers.add(5);
    }
   
    public TreeSet<Integer> getNumeros(){ return numbers; }
}

Clase ConjuntoSet

import java.util.ArrayList;
import java.util.Set;

public class ConjuntoSet {

    private ArrayList <Set> conjuntoObjetos = new ArrayList <Set>();

    public ConjuntoSet(){
        //Creo objeto Estrellas y lo añado al conjuntoObjetos
        Estrellas estrella1 = new Estrellas();
        conjuntoObjetos.add(estrella1.getEstrellas());
        //Creo objeto Numeros y lo añado al conjuntoObjetos
        Numeros numero1 = new Numeros();
        conjuntoObjetos.add(numero1.getNumeros());
    }

    public ArrayList<Set> getConjunto(){return conjuntoObjetos; }
}

Clase GestorIterador

import java.util.Iterator;


public class GestorIterador {

    public static void main (String [] args){

        ConjuntoSet prueba = new ConjuntoSet();

        Iterator iter = prueba.getConjunto().iterator();

        while(iter.hasNext()){
            System.out.print(iter.next());}

    }
}

Quizás si en la clase ConjuntoSet, creara fuera del contructor los new Estrellas y Numeros, podria llamarlos en el main con un get que los devolviera y hacer un Iterador independiente de cada uno, pero no me convence demasiado tampoco.

Después de mirar un poco algun ejercicio de compañeros añado la clase GestorIterador con lo que creo soluciona mi problema, que imprimia en conjunto y no por separado los elementos.

Clase GestorIterador (Mejorada creo)

import java.util.Iterator;
import java.util.Set;


public class GestorIterador {

    public static void main (String [] args){

        ConjuntoSet prueba = new ConjuntoSet();

        Iterator <Set> iterConjunto = prueba.getConjunto().iterator();

        while(iterConjunto.hasNext()){
            Iterator iterObjetos = iterConjunto.next().iterator();
                 
              while(iterObjetos.hasNext()){
                  System.out.print(iterObjetos.next() + ", "); }
               
        }

    }
}

Veo no es lo mismo Iterador iter, que Iterador <Set> iter, le avisas que dentro del iter habra nuevos Objetos de tipo Set que puedes volver a iterar, eso creo, este ejercicio es algo lío

Buenas, adjunto ejercicio usando fill con indices inicial y final (exclusivo), era solo una práctica pero ahi va igual por si a alguien le aporta.


import java.util.Arrays;

//uso metodo copyOf clase Arrays
public class FillConIndices{
    public static void main (String [] args){
        int [] miArray1 = { 2, -4, 3, -7};

        for ( int miNumero : miArray1 ) {System.out.println("miArray1 " + miNumero ); }

        System.out.println("");

        int [] otroArray = {1, 2, 4, 8};

        for ( int miNumero : otroArray ) { System.out.println("otroArray " + miNumero ); }

        System.out.println("Son mismo objeto?   " + (miArray1 == otroArray) );
        System.out.println("Tienen mismo contenido?   " + Arrays.equals(miArray1, otroArray) );

        //Copiamos el array utilizando copyOf de la clase Arrays

        otroArray = Arrays.copyOf(miArray1, miArray1.length + 2);

        for(int i = 0; i < otroArray.length; i++){
            if( otroArray[i] < 0 ){ Arrays.fill (otroArray, i, i + 1, 33);}
        }

        for ( int miNumero : otroArray ) { System.out.println ("otroArray " + miNumero ); }
        System.out.println("Son mismo objeto?   " + (miArray1 == otroArray) );
        System.out.println("Tienen mismo contenido?   " + Arrays.equals(miArray1, otroArray) );
    }
}




Buenas aquí va mi solucion al ejercicio.

Crea un programa Java donde declares un array de enteros tipo int miArray1 cuyo contenido inicial sea {2, -4, 3, -7}. Muestra su contenido por pantalla. Copia el contenido de este array a un ArrayList denominado lista1 y muestra su contenido por pantalla. ¿Qué tipo de datos almacena el array? ¿Qué tipo de datos almacena el ArrayList?

¿Qué tipo de datos almacena el array? Puede almacenar tanto primitivos como Objetos, el array siempre será una colección de elementos con índice, sea de primitivos o de objetos. En este ejercicio los datos almacenados en el array son tipos primitivos (números simples)

¿Qué tipo de datos almacena el ArrayList? Solo almacena Objetos, para numeros usa Integer, Double, Float...  En este ejercicio el ArrayList almacena objetos Integer.

Clase TestArrayList, muy sencilla solo era de verificación.

import java.util.ArrayList;

public class TestArrayList{

    public static void main (String[] args){
        int [] miArray1 = {2, -4, 3, -7};

        for(int numArray : miArray1){ System.out.println("miArray1 " + numArray); }

        ArrayList<Integer> lista1 = new ArrayList<Integer>();

        for(int i = 0; i < miArray1.length ; i++){
            lista1.add(miArray1[i]);}

        for (int numArray : lista1){ System.out.println("lista1 " + numArray); }
    }
}


Muchas gracias Ogramar, y por los apoyos recibidos que hacen falta, el curso es duro. Pero tremendamente útil,