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

Después de muchas pruebas y de decidir investigar un poco.. aquí el ejercicio, favor verificar!.

VerificadoDeEntradas:

//importacion de API's
import java.lang.String; //no es necesario pero aqui esta!
import java.util.Scanner;

//clase
public class VerificadoDeEntradas {
    //sin variables y sin constructor

    //metodo Main
    public static void main (String[]args) {
        System.out.println ("Escriba la palabra que sera verificada:");

        //variables locales
        Scanner entradaPorTeclado = new Scanner (System.in);
        String palabraIntroducida = entradaPorTeclado.nextLine ();
        int contadorDeLetras = palabraIntroducida.length ();
        String verificadorPrimeraLetra = palabraIntroducida.substring (0,1);

        //if y else con los System.out.println
        if (contadorDeLetras > 5 && contadorDeLetras < 15 && verificadorPrimeraLetra.equals("a") || contadorDeLetras > 5 && contadorDeLetras < 15 && verificadorPrimeraLetra.equals("A")) {
            System.out.println ("La cadena "+ palabraIntroducida +" tiene entre 5 y 15 caracteres y comienza por \"a\" o por \"A\".");
        } else {

            if (contadorDeLetras > 5 && contadorDeLetras < 15 && verificadorPrimeraLetra != "0") {
                System.out.println ("La cadena "+ palabraIntroducida +" tiene entre 5 y 15 caracteres y no comienza por \"a\".");
            } else {

                if (contadorDeLetras < 5 || contadorDeLetras > 15) {

                    //abriendo in if dentro de otro if
                    if (verificadorPrimeraLetra.equals("a") || verificadorPrimeraLetra.equals("A")) {
                        System.out.println ("La cadena "+ palabraIntroducida +" no tiene entre 5 y 15 caracteres y comienza por \"a\" o por \"A\".");
                    } else {                 
                        System.out.println ("La cadena "+ palabraIntroducida +" no tiene entre 5 y 15 caracteres y no comienza por \"a\" o por \"A\".");
                    }
                } else {}
            }
        }
    }//cierre de main
}//cierre de clase

Esta muy largo el código, pero asi fue como pude hacerlo y ademas cumple con lo que dice el mandato (creo).

Crea una clase con un método main que pida una entrada de teclado y usando condicionales, el método length de la clase String y el método substring de la clase String, muestre un mensaje indicando:

a) Si la cadena introducida tiene menos de 5 caracteres, entre 5 y 15 caracteres o más de 15 caracteres.

b) Si la cadena introducida comienza por la letra a.

Ejemplo: se pide la entrada y el usuario introduce “vereda”. Por pantalla se debe mostrar: “La cadena introducida tiene entre 5 y 15 caracteres y no comienza por a”.

Reflexiona y responde a las siguientes preguntas:

a) ¿Es posible llamar a un método externo de un objeto que ha sido declarado pero no creado?

No, no creo que sea posible llamar un método externo, sin crear el objeto.

b) ¿Es posible llamar a un método externo de un objeto “A” que ha sido declarado y creado pero cuyo constructor está vacío?

Si, ya que el constructor define un valor por defecto de las variables de la clase pero no impide que el método sea llamado.

c) Una llamada al método pow de la clase Math que hacemos dentro de un método definido en una clase ¿Es una llamada a un método interno o a un método externo? ¿La llamada al método pow se hace sobre un objeto declarado y creado o no declarado y no creado?

Aunque sea de un API, es de un método externo ya que esa clase no la creamos nosotros y tenemos que importarla.

Me imagino que al momento de importar la clase Math, pues se crea y se declara para poder usar dichos metodos (pow, sqrt, ect).

Si por casualidad aun tengo un mal concepto favor de aclarar....

Mi duda radica en los public, private, proteted y vacios...

yo pensé que era obligatorio decir si un método era publico para usarlo en otra clase o privado solo para darle uso en esta clase.. el protected no se a que va, pero me imagino que lo sabre mientras avance....

La question es que vi un ejemplo en el CU00649B, donde el metodo no tenia public ni private, y aun así funciono de lujo..... entonces cuando no se le pone nada a un método por defecto es privado o publico?..

(Aquí cito el ejemplo que vi):

//Combina las tres primeras letras de dos textos recibidos como parámetro en una sola cadena separada por un espacio
 public class Combinador {
    //Campos de la clase
    private String texto1;
    private String texto2;
 
    //Constructor de la clase
    public Combinador () {
        texto1 = "";
        texto2 = "";
    } //Cierre del constructor
 
    //Método que combina las tres primeras letras de cada cadena
    String combinacion (String valor_texto1, String valor_texto2) {
        String combinacion = valor_texto1.substring (0,3) + " " + valor_texto2.substring (0,3);
        return combinacion; //combinacion es tanto el nombre del método como el de una variable local
    } //Cierre del método
 } //Cierre de la clase


Favor verificar.... se que el "import" esta de sobra pero es por el ejercicio.

MiniCalculadoraEjemplo:

//API necesario aunque es un API que se carga automaticamente.
import java.lang.Math;

//clase
public class MiniCalculadoraEjemplo {

    //constructor
    public MiniCalculadoraEjemplo () {
        //nada que declarar
    }

    //metodo de valor absoluto 
    public double valorAbsoluto (double numeroAbsoluto) {
        return Math.abs (numeroAbsoluto);
    }

    //raiz cuadrada
    public double raizCuadrada (double numeroRaizcuadrada) {
        return Math.sqrt (numeroRaizcuadrada);
    }
}

Muy bueno este tema de los API's, simplifica muchas cosas....

Si una clase define varios constructores, el constructor invocado por la sentencia new es el que coincide en número y tipo de parámetros con los utilizados en la sentencia new. Por ejemplo: taxi1 = new Taxi(); invoca al constructor general, mientras que taxi1 = new Taxi (“BFG-7432”) invoca al constructor que requiere un String como parámetro. new Taxi (“BFG-7432”, “Oeste”) invocaría al constructor que requiere dos String como parámetros. new Taxi (“BFG-7432”, “Oeste”, 2) invocaría al constructor que requiere dos String y un entero como parámetros, etc. No puede haber dos constructores que requieran el mismo número y tipo de parámetros (por ejemplo dos constructores que requieran un String) porque eso generaría una ambigüedad que daría lugar a un error de compilación.

Eso lo entiendo perfectamente, pero si en la clase Taxi tengo dos constructores, uno con valores por defecto y uno con varios parámetros (dos int y uno String), entonces taxi1 = new Taxi(2,50) me dará error de compilación por que necesita 3 parámetros para poder invocar ese constructor? "En este caso falta el String".....

Entrega del ejercicio #41, favor verificar si cumple con el mandato....

SalonCasa:
//clase
public class SalonCasa {
    private int numeroDeTelevisores;
    private String tipoSalon;
   
    //constructor
    public SalonCasa () {
        numeroDeTelevisores = 0;
        tipoSalon = "Desconocido";
    }
   
    //setters
    public void setNumeroDeTelevisores (int valorNumeroDeTelevisores) {
        numeroDeTelevisores = valorNumeroDeTelevisores;
    }
   
    public void setTipoSalon (String valorTipoSalon) {
        tipoSalon = valorTipoSalon;
    }
   
    //getters
    public int getNumeroDeTelevisores () {return numeroDeTelevisores;}
   
    public String getTipoSalon () {return tipoSalon;}
}


CocinaCasa:
//clase
public class CocinaCasa {
    private boolean esIndependiente;
    private int numeroDeFuegos;
   
    //constructor
    public CocinaCasa () {
        esIndependiente = false;
        numeroDeFuegos = 0;
    }
   
    //setters
    public void setEsIndependiente (boolean valorEsIndependiente) {
        esIndependiente = valorEsIndependiente;
    }
   
    public void setNumeroDeFuegos (int valorNumeroDeFuegos) {
        numeroDeFuegos = valorNumeroDeFuegos;
    }
   
    //gettes
    public boolean getEsIndependente () {return esIndependiente;}
   
    public int getNumeroDeFuegos () {return numeroDeFuegos;}
}


Casa:
//clase con otras clases
public class Casa {
    private double superficie;
    private String direccion;
    private SalonCasa salonCasa;
    private CocinaCasa cocina;
   
    //constructor
    public Casa () {
        superficie = 0.0;
        direccion = "";
        salonCasa = new SalonCasa ();
        cocina = new CocinaCasa ();
    }
   
    //setters de esta clase
    public void setSuperficie (double valorSuperficie) {
        superficie = valorSuperficie;
    }
   
    public void setDireccion (String valorDireccion) {
        direccion = valorDireccion;
    }
   
    //setters de las otras clases
   
    public void setNumeroDeTelevisores (int valorNumeroDeTelevisores) {salonCasa.setNumeroDeTelevisores(valorNumeroDeTelevisores);}
   
    public void setTipoSalon (String valorTipoSalon) {salonCasa.setTipoSalon(valorTipoSalon);}
   
    public void setEsIndependiente (boolean valorEsIndependiente) {cocina.setEsIndependiente(valorEsIndependiente);}
   
    public void setNumeroDeFuegos (int valorNumeroDeFuegos) {cocina.setNumeroDeFuegos(valorNumeroDeFuegos);}
   
    //getters de esta clase
    public double getSuperficie () {return superficie;}
   
    public String getDireccion () {return direccion;}
   
    //getters de las otras clases
    public SalonCasa getSalonCasa () {return salonCasa;}
   
    public CocinaCasa getCocina () {return cocina;}
}

Todavía tengo mis lagunas sobre este tema, espero rellenar en el transcurso del curso!!.

entiendo la practica a la perfección pero tengo una duda que explicare al final del codigo,

//clase
public class Motor {
    private int tipoBomba;
    private String tipoFluido;
    private String combustible;

    //constructor
    public Motor () {
        tipoBomba = 0;
        tipoFluido = "";
        combustible = "";
    }

    //setters
    public void setBomba (int valorBomba) {
        tipoBomba = valorBomba;
    }

    public void setFluido (String valorFluido) {
        tipoFluido = valorFluido;
    }

    public void setCombustible (String valorCombustible) {
        combustible = valorCombustible;
    }

    //getters
    public int getBomba () {return tipoBomba;}

    public String getFluido () {return tipoFluido;}

    public String getCombustible () {return combustible;}

    //practica de Variable Local
    public boolean dimeSiMotorEsParaAgua () {
        boolean motorEsParaAgua = false;
        if (tipoBomba == 1) {
            motorEsParaAgua = true;
        }
        return motorEsParaAgua;
    }
}

Mi duda en esta practica es: las variables locales se desaparecen después de que se termine el método, pero no el resultado según leí... ese resultado se refiere a algún proceso que salga después de la eliminación de es variable local?. creo que necesito un ejemplo para ver como se podría salvar el valor de la variable local en esta practica...

creo que no me explique bien, pero es que no se como se podría salvar el resultado de "motorEsParaAgua = true", si no se puede usar ese resultado directamente en otro método... digo directamente por que si existe forma de hacerlo indirectamente.. por ejemplo: podría crear una variable de campo que se vea afectada cuando este método ejecute y modifique la variable local, y afecte la variable de campo con dicha modificación y así salvar el resultado, pero existe forma de usar ese resultado de "motorEsParaAgua = true" en otro metodo directamente?

favor indicar si cometi alguna falla en el codigo:

Considera estás desarrollando un programa Java donde necesitas trabajar con objetos de tipo Rueda (que representa a una rueda de un vehículo). Define una clase Rueda considerando los siguientes atributos de clase: tipo (String), grosor (double), diametro (double), marca (String). Define un constructor asignando unos valores de defecto a los atributos y los métodos para poder establecer y obtener los valores de los atributos. Crea un método denominado comprobarDimensiones donde a través de condicionales if realices las siguientes comprobaciones:

a) Si el diámetro es superior a 1.4 debe mostrarse por consola el mensaje “La rueda es para un vehículo grande”. Si es menor o igual a 1.4 pero mayor que 0.8 debe mostrarse por consola el mensaje “La rueda es para un vehículo mediano”. Si no se cumplen ninguna de las condiciones anteriores debe mostrarse por pantalla el mensaje “La rueda es para un vehículo pequeño”.

b) Si el diámetro es superior a 1.4 con un grosor inferior a 0.4, ó si el diámetro es menor o igual a 1.4 pero mayor que 0.8, con un grosor inferior a 0.25, deberá mostrarse por consola el mensaje “El grosor para esta rueda es inferior al recomendado”.


//rueda
public class rueda {
    String tipo;
    double grosor;
    double diametro;
    String marca;

    public rueda () {
        tipo="";
        grosor=0;
        diametro=0;
        marca="";
    }

    //Setters
    public void set_tipo (String valor_tipo) {
        tipo=valor_tipo;
    }

    public void set_grosor (double valor_grosor) {
        grosor=valor_grosor;
    }

    public void set_diametro (double valor_diametro) {
        diametro=valor_diametro;
    }

    public void set_marca (String valor_marca) {
        marca=valor_marca;
    }

    //Getters
    public String get_tipo () {return tipo;}

    public double get_grosor () {return grosor;}

    public double get_diamtro () {return diametro;}

    public String get_marca () {return marca;}

    //aqui se agregan los If y Else en la practica.
    public void comprobarDimensiones () {
        if (diametro>1.4){
            System.out.println ("La rueda es para un vehículo grande");
        }
        else if (diametro<=1.4 && diametro>0.8) {
            System.out.println ("La rueda es para un vehículo mediano");
        }
        else {
            System.out.println ("La rueda es para un vehículo pequeño");
        }

        if (diametro>1.4 && grosor<0.4 || diametro<=1.4 && diametro>0.8 && grosor<0.25){
            System.out.println ("El grosor para esta rueda es inferior al recomendado");
        }
        else{}
    }
}