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

Gracias Alex, voy a instalarlo por curiosidad, aunque a mi todo lo que sea microsoft me echa para atrás....jajajaja

A jigsaw decirle bueno que estoy con Alex, es mejor separar los temas, así hay mas orden y es mas fácil hacer referencias a los temas ante alguna duda similar.

Y bueno lo de como compartir el proyecto tienes mil formas, desde google drive, pasando por dropbox, mega, etc etc,

Intenta ser mas claro en tus dudas, nos escribes:

Adjunto el proyecto abajo, espero lo revisen y me ayuden como puedo mostrar los datos de las 3 tablas distintas que tengo en la base de datos (empleados,asignaciones,deducciones).

¿pero a ver como se relacionan estas 3 tablas? ¿que SGBD estas usando? ¿ que columnas tienes esas tablas?..... y sobre todo como dice Alex, si vas a adjuntar un proyecto debes decir claramente en que punto se encuentra el problema.

Bueno un saludo y espero que nos aclares el tema para poder ayudarte mejor y mas rápidamente. Un saludo!

jeje Hola buenos días, bueno veamos, el ejercicio original es el siguiente:

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

Como tu bien comentas en el primer post el error viene dado en esta linea:

System.out.println ("Atributo 1 vale" + this.getAtrib1());

Donde se intenta llamar al método getAtrib1() en un contexto estático (método main es estático) cuando el método resulta que no es estático, la clave esta en la palabra reservada this, digamos que de alguna manera this se sustituye en este caso por la palabra Test, con lo cual, la linea que nos esta generando el error es equivalente a la siguiente:

System.out.println ("Atributo 1 vale" + Test.getAtrib1());

Si ahondamos el la teoría, nombre_de_clase.nombre_metodo() --> Es la forma de llamar a un método que es estático dentro de la clase, pero en este caso resulta que getAtrib1() no es un método estático y por tanto el compilador como tu bien dices:

Non-static variable this cannot be referenced from a static context

Así que te comentaba que había dos soluciones, una ya la sabemos que es convertir tanto el método getAtrib1() como la propiedad atributo1 a estáticos.

La otra solución que te comentaba es crear un objeto, Pues simplemente es añadir una linea nueva dentro del main con la creación de un objeto de tipo Test y cambiar la palabra reservada this por el nombre que le hemos dado al objeto, con lo que el código quedaría de la siguiente forma:

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

Si te fijas lo que hago es crear e inicializar un objeto llamado t y después en lugar de llamar al método directamente

this.getAtrib1()
Lo llamaríamos a través del objeto t que acabamos de crear de la siguiente forma:

 t.getAtrib1()
Con lo cual la llamada al método ya no se hace de forma estática (Test.getAtrib1())
sino que lo hacemos a través de un objeto inicializado llamado t (t.getAtrib1())

No te preocupes si no entiendes muy bien cuando hacer una cosa o cuando hacer otra, con la practica te irás dando cuenta poco a poco.

Para ponerte un ejemplo, la clase java.lang.Math es una clase donde todos sus métodos no estáticos.

http://docs.oracle.com/javase/7/docs/api/java/lang/Math.html

Resumiendo un poco:
Yo me quedaría con lo siguiente, en un método estático no es posible llamar a  métodos no estáticos de la misma clase ni a propiedades que tampoco sean estáticas dentro de la misma clase.

Pero ya te digo, no te preocupes porque poco a poco te irás dando cuenta de como actuar según lo que se te presente.

 Un saludo y siento estas extensiones de post...

Sobre VB 6 no te puedo ayudar mucho, pero hablas de reportes y mostrar datos de varias tablas, bueno, todo lenguaje de programación provee de mecanismo para el acceso a bases de datos, si quieres mostrar datos de varias tablas pues lo que debes hacer es o una consulta sql con los datos que necesitas de las tres tablas si estas están relacionadas entre si, o una consulta por cada tabla. Pero como te comento sobre VB no tengo mucha idea.

Sobre tu segunda duda, bueno dices de un sistema de venta de productos, pues en mi opinión, lo mínimo que necesitaras será: 

• Un catalogo --> Para mostrar los productos. Esto dependerá de si son muchos productos, o es solo un producto concreto.
• Un mecanismo para agregar y eliminar productos fácilmente. Esto es si existe un catálogo
• Un carro de la compra --> Para almacenar los productos que desea comprar el usuario
• Un mecanismo para registrar los pedidos
• Un mecanismo para realizar el pago
• Algún mecanismo para encriptar las transferencias de datos para realizar el pago seguro(Normalmente algún certificado de alguna entidad oficial)
• Y sobre todo un manual de como realizar un pedido, como se realizara el envio, costes, etc

En mi opinión, creo que eso es lo mínimo que debe tener un sistema de venta por internet ya depende también mucho del producto o productos que se vendan, sistemas de envíos, formas de pago, etc etc, la verdad que es un tema bastante extenso, jeje

Yo te recomendaría que cogieras algún gestor de contenidos como drupal o joomla y le pusieras un modulo de venta por internet o alguno mas especifico como el CMS prestashop, y les echaras un ojo a como funcionan, que características tienen, etc

No siempre se trata de coger un documento en blanco y liarse a picar código, también hay que aprender de cosas que ya están echas, sumergirse en el código de otra persona  y analizar como lo ha echo, por eso te recomiendo lo de investigar algún CMS.

Y nada un saludo.

jajaja El chino echándole carbón y mi vecino de barbacoa... XDDD

Bueno mientras se dan esta serie de echos, seguiremos aquí echando una mano, que quien te dice que no estemos ayudando a  un bill gates en potencia dentro del foro.... jajaja

Bueno a mi de momento me basta con la satisfacción de aprender cada día cositas nuevas y sobre todo compartirlas con los demás! Hasta mas ver.





 

Voy a intentar explicarte el porque de esas razones que según tu están ocultas, jeje.

Método estático

A ver normalmente un método estático es un método, el cual no requiere de la creación de un objeto para poder invocarlo, a grosso modo, son métodos que recibirán una serie de datos y devolverán un resultado, pero como hemos comentado no es necesario crear un objeto para invocar a dicho método, por tanto al no crear ningún objeto, los atributos no están inicializados.

Lo mismo ocurre con los métodos que no son estáticos, estos métodos solo existen cuando se crea un objeto y es a través de ese objeto sobre el que llamamos a los métodos. Cuando llamamos a un método estático, no es necesario crear un objeto, y por tanto esos métodos no estáticos no existen, con lo cual no pueden ser llamados, que es lo que ocurre en este ejercicio.

Cuando llamamos a un método estático de una clase, solo existirán los atributos y métodos que sean estáticos. Con lo cual este ejercicio podría tener dos posible soluciones:

Una, la que tu has echo, que es declarar los elementos que se usan dentro de un método estático como estáticos lo cual genera una cadena, ya que al convertir el método  getAtrib1() a estático, este hace una llamada al atributo1 el cual para poder usarlo dentro de un método estatico( el que acabamos de convertir ), el atributo también debe ser estático, por lo cual también es necesario realizar ese cambio y convertir el atributo1 a estático.

Bien, esta bien echo y dado que el objetivo del ejercicio es aprender el uso de la palabra reservada static es la forma correcta de actuar.

Otra posible solución podría haber sido simplemente crear un objeto de la clase Test y sustituir la palabra reservada this por el nombre que le hubieras dado al objeto. Aunque claro de este modo no verías como se produce un método estático que hace uso de atributos estáticos dentro de la misma clase.

Resumiendo lo que debes saber es que para poder usar un atributo o un método de una clase dentro de un método estático de la misma clase, dos posibilidades:

• Establecer los atributos y métodos también como estáticos
• O crear un objeto de esa clase y a través de este ya puedes llamar a los métodos y atributos

   

Bueno espero no haberte liado mucho y haberte aclarado alguna que otra cosilla, de todas formas es lo de siempre práctica, práctica y mas práctica... Un saludo!

       
 

Hola, bueno, creo que te puedo aportar alguna cosilla mas:

A ver lo de concatenar unos métodos con otros, es muy común, claro esta que siempre se puede hacer lo que tu dices:

porque se supone que al  usar el metodo
 substring  no deberias de declarar una Variable que contuviera "entradaTeclado.substring(0,1)" y ya despues si hacer el "equals".

Pero ten en cuenta que al hacer eso estas creando una variable nueva, lo que conlleva a la necesidad de asignar una nueva posición de memoria, lo que hace que el programa deba ejecutar mas instrucciones y lo que lleva a un mayor tiempo de ejecución.

Mientras que si lo haces con métodos encadenados el programa ganará en eficiencia además de que te ahorrarás bastante código.

Cuando encadenar y cuando crear variables intermedias.

Bueno, imagínate que la cadena que nos devuelve  "entradaTeclado.substring(0,1)"  vamos a necesitarla 1000 veces, entonces si te convendría crear una variable intermedia, pero si te fijas en este programita solo hacemos uso de ella 2 veces con lo cual es mas ligero los métodos concatenados asi: "entradaTeclado.substring(0,1).equals("a");"

Poco a poco te iras acostumbrando a esto de concatenar métodos, te darás cuenta que si tienes un método A que devuelve una cadena y un método B que se invoca con un objeto de tipo cadena, podrás concatenarlos de esta forma A().B()

Veamos con un ejemplo simple:

public class Prueba {
    public static void main (String[ ] Args) {
        String s1="pepe";
        String s2="PePe";
        System.out.println(s1.substring(0, 2).toLowerCase().equals(s2.substring(0, 2).toLowerCase()));
    }
}
 

Simplemente tenemos dos cadenas y se imprime por pantalla el resultado de esta instrucción: " s1.substring(0, 2).toLowerCase().equals(s2.substring(0, 2).toLowerCase()) "

donde s1 es "pepe" y s2 es "PePe"

Esa instrucción se ejecuta de izquierda a derecha y es el punto el que delimita cada instrucción, veamoslo paso a paso:

Instrucción 1: s1 --> Simplemente es el valor de la cadena s1 es decir "pepe"
Instrucción 2: substring(0,2) --> Pues nos devolverá la cadena "pe"
Instrucción 3: toLowerCase() --> Este método nos convierte a minúsculas lo que tenga a su izquierda, que en este caso es "pe"
Instrucción 4: equals(s2.substring(0, 2).toLowerCase()) --> En este caso compararía el "pe" que teníamos a la izquierda con lo que está entre paréntesis.

En este punto, java mantendría la cadena "pe" almacenada y empezaría a evaluar lo que esta dentro del paréntesis: " s2.substring(0, 2).toLowerCase() " que si empezamos a leer de izquierda:

s2 --> tiene la cadena "PePe"
substring(0, 2) --> sería "Pe"
toLowerCase() --> seria "pe"

Por tanto se mostraría en pantalla el valor: true

Ahora veamos como sería si lo hiciéramos almacenando en variables intermedias los valores de cada instrucción:

public class Prueba {
    public static void main (String[ ] Args) {
        String s1="pepe";
        String s2="PePe";
        String subS1=s1.substring(0, 2);
        String lowerSubS1=subS1.toLowerCase();
        String subS2=s2.substring(0,2);
        String lowerSubS2=subS2.toLowerCase();
       
        System.out.println(lowerSubS1.equals(lowerSubS2));
    }
}

 Si te fijas hemos tenido que crear 4 variables auxiliares lo que podíamos realizar en una sola linea. Y esta es de las simples, jeje hay veces que hay que concatenar 6 o 7 métodos en cadena. Que claro esta que siempre podemos hacerlo por pasos pero como ves es mas rápido y eficiente de esta manera.

La clave esta en que lo que devuelve el método de la izquierda, debe ser lo que invoca al método de la derecha.

Bueno espero al menos haberte podido aclarar alguna cosilla, aunque es lo de siempre con la practica y el tiempo te irás a costumbrando a realizar este tipo de sentencias.

Un saludo!


 

Este También esta bien, pero los comentarios deben ser acordes al código XDD

for(int i=0;i<(palabraTeclado.length());i++) {//el uso de for y del metodo length nos sive para decirno que tan larga es la cadena que introducimos es un valor tipo int
         
           String letra=palabraTeclado.substring(i,i+1);//usamos el metodo substring para obtener las letras de la cadena inroducida pero
                                                        // le ponesmos como sus index (i,i+1) que empiece desde i hasta i+para que cada ves sea la siguiente letra
                                                        //lo que hace es irse recorriendo un lugar
            System.out.println("letra:"+""+i+" "+letra);}//cierre if

Ese cierre if del final se te ha colado.... Un saludo!

Hola me llamo la atención este post, mira un par de recomendaciones, la primera para mas claridad, y la segunda para ampliar un poco la librería:

System.out.println("Por favor introduzca el nombre de un cantante"); EntradaDeTeclado entrada1 = new EntradaDeTeclado();
Intenta poner una instrucción por linea así ganarás en claridad, jeje me costo encontrar donde creabas el objeto "EntradaTeclado entrada1". Simplemente por claridad, para ti y para los demás.

Mi segunda recomendación es sobre la siguiente condición:

if(respuesta.equals("s")== true || respuesta.equals("S")== true){
Existe un método igual que equals que se llama equalsIgnoreCase( String ) que compara las dos cadenas ignorando las mayúsculas y minúsculas. Con lo cual con este método las cadenas "COCHE"  , "coche", "Coche" , "CocHE" todas devolverian true si las compararamos con la cadena "coche".

En tu caso, la condición podría ser de la siguiente manera:

if(respuesta.equalsIgnoreCase("s")){
No es que el tuyo este mal, pero si te fijas con este método nos olvidamos de tener que realizar condiciones redundantes para mayúsculas y minúsculas.

Por otro lado fíjate lo que te comentan, cuando un método devuelve un valor booleano, no es necesario usar operadores.

Y nada, un saludo y espero que te sea util el metodo equalsIgnoreCase( String ).