Implementa Funciones en Java

//yo tuve que declarar antes las variables que pasan por argumento //para la función ya que marcaba error fue algo asi:

      double quantity;
        String  currency;
        System.out.println("pesos a dolares: " + convertToDolar(quantity=200, currency="MXN"));

Los metodos son declarados como static ya que el metodo main es static.
Los métodos declarados como static tienen varias restricciones, una de ellas es que pueden llamar directamente solo a otros métodos estáticos en su clase.

Recuerden que también pueden usar operadores de asignación para el switch de currency.

quantity *= 0.052; 
//es igual que decir
quantity = quantity * 0.052;

¡Hola!
Experimente un poco con el código, cambia Switch por la sentencia If, aquí les dejo mi código 😃

public class Functions {
    public static void main(String[] args) {

        System.out.println("Pesos a dolares: " + converToDolar(200,"MXN"));

    }

    public static double converToDolar(double quantity, String currency){

        //Switch case and default
        /*switch (currency){
            case "MXN" :
                quantity = quantity * 0.042;
                break;
            case "COL" :
                quantity = quantity * 0.00026;
                break;
            case "BOL" :
                quantity = quantity * 0.15;
                break;
            default:
                quantity = 0.0;
                break;
        }
        return quantity;
}*/
        //If, else if and else
        if (currency == "MXN"){
            quantity = quantity * 0.042;
        }else if (currency == "COP"){
            quantity = quantity * 0.00026;
        }else if (currency == "BOL"){
            quantity = quantity * 0.15;
        }else {
            quantity = 0.0;
        }
        return quantity;
}
}

Cualquier corrección sera bienvenida…

Ricardo Arango…
La palabra reservada static hace que un método (en este caso) pase a formar parte de la clase Funciones…
La clase Math tiene muchos métodos static ya que con solo escribir el nombre de la clase Math seguido del punto ya muestra todos los métodos static sin necesidad de instanciar la clase ó crear objetos de ésta…
En la clase Funciones de ejemplo… la profesora accede a los métodos directamente con solo escribir el nombre circleArea(), sphereArea(), sphereVolume() porque estos pueden ser accedidos directamente a a traves de la misma clase…

Me agrado bastante dividir los procesos en varias funciones y me llamo mucho la atención como IntelliJ reconoce que se está llamando una función y al colocar los parámetros nos indica exactamente a cual variable de la función corresponderá.

Notes

Hice mi version del conversor de monedas para que pueda recibir inpur del usuario 😃

Code:

import java.lang.*;
import java.util.Scanner;

/**
 * CurrencyConverter
 */
public class CurrencyConverter {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.printf("💸----Currency-Converter----💸\n");

        System.out.printf("\nCurrent currency type: ");
        String uCurrencyType = scanner.next();
        System.out.printf("\nQuantity: ");
        double uCurrencyAmount = scanner.nextDouble();

        //out
        System.out.printf("%.2f %s >> USD = %.4f USD\n", uCurrencyAmount, uCurrencyType, toUSD(uCurrencyAmount, uCurrencyType));
    }

    public static double toUSD(double quantity, String fromCurrency) {
        switch (fromCurrency.toUpperCase()) { //MXN|COP|BOL
            case "MXN":
                quantity *= 0.046;
                break;
            case "COP":
                quantity *= 0.00026;
                break;
            case "BRL":
                quantity *= 0.18;
                break;
            default:
                System.err.printf("ERROR: this program only supports MXN|COP|BRL >> USD\ntry again with the aforementioned currencies\n");
                System.exit(1);
                break;
        }
        return quantity;
    }
}

Output:

💸----Currency-Converter----💸

Current currency type: BRL

Quantity: 800
800.00 BRL >> USD = 144.0000 USD

😎

Static Method
Static methods are the methods in Java that can be called without creating an object of class. They are referenced by the class name itself or reference to the Object of that class

La verdad he visto vario cursos de Java, y a pesar de ser algo tan básico, la forma en que lo explica la profe es muy clara y entendible para cualquier persona en cualquier nivel. Excelente por Anahí.

Conversion COP a Dólar, 19/08/2021 (Actualizado)
😞

Tenía entendido que en Java no existían funciones ya que recibían el nombre de métodos, ¿es eso cierto?, ¿son los métodos y las funciones lo mismo? y de no ser así ¿Cuál es la diferencia entre método y función?

para los que tengan problemas al compilarlo cuando ella va a imprimir el converToDolar();
ella lo que copia es esto:
System.out.println("PESOS A DOLARES: "+ converToDolar(200, “MXN”));

no esto:
System.out.println("PESOS A DOLARES: "+ converToDolar(quantity: 200, currency: “MXN”));

al poner el segundo caso les da error porque las variables quantity y currency non existen en el metodo main y tienen que declararlas.

la funciones en el caso del main, usan static, porque no son objetos a los cuales se crean instancias.

A ella se le autocompleta el sout de pesos a dolares dentro de main porque primero escribe 200 y luego
"MXN", si no ponen quantity y currency y antes de esto siguieron todo a la perfeccion, debe completarse solo en automatico. al menos a si lo sulicione yo. Bajenle la speed al video y compruebenlo.

Con else if:

    public static double toDollar(String coin, double quantity){
        if (coin == "mxn"){
            return quantity/20.35;
        }
        else if (coin == "co"){
            return quantity/3837.33;
        }
        else if (coin == "cl"){
            return quantity/802.70;
        }
        else {
            System.out.println("Type a correct coin");
            return 0.0;
        }

Si tienen algún error para imprimir la función converToDolar; deben solamente poner los valores sin declarar la variable.
ej:

System.out.println("PESOS A DOLARES: " + convertToDollar(200, "ARS")); 

Static solo aplica para el main

🔮 Si estamos copiando y pegando código, debemos crear una función que sea reutilizable.

Este es mi aporte usando entrada y salida de datos

import java.util.Scanner;

public class Convertidor {
    public static void main(String[] args) {
        float precioEuro = 5001.82F;
        
        Scanner entrada = new Scanner(System.in);
        int pesosAconvertir;

        System.out.println("Digite la cantidad de pesos colombianos que desea convertir a euros: ");
        pesosAconvertir = entrada.nextInt();

        eurosApesos(pesosAconvertir, precioEuro);
        System.out.println("COP $" + pesosAconvertir + " es igual a €"+eurosApesos(pesosAconvertir, precioEuro));
    }

    public static double eurosApesos(int pesos, double euro){
        return pesos/euro;
    }
}
 

aqui probando con otras cosas en java para que el usuario interactue

import java.util.Scanner;
public class mierda {

	public static void main(String[] args) {
		Scanner respuesta = new Scanner(System.in);
		print("Indica donde quieres comprarlo, si en VNZLA, MXC, o COP");
		String resquest = respuesta.nextLine();
		print("indica la cantidad de dolares a comprar");
		double cantidad = respuesta.nextDouble();
		System.out.println(CalcularMonedas(cantidad, resquest));
	}
	public static String print(String message) {
		System.out.println(message);
		return message;
	}
	public static double CalcularMonedas(double Dolar, String currency) {
		
	switch(currency) {
	case "VZLA":
		Dolar = Dolar * 9.51;
		break;
	case "MXN":
		Dolar = Dolar * 21;
		break;
	case "COP":
		Dolar = Dolar * 4988.83 ;
		break;
	}
	return Dolar;
	}
}

COP actual 0.00022 😦

<public class Funciones {
    public static void main(String[] args) {
        double y = 3;
        //Area de un circulo
        //pi * r2

        circleArea(y);
        System.out.println(circleArea(y));

        //Area de una esfera
        //4*PI*r2
        sphereArea(y);
        System.out.println(sphereArea(y));

        //Volumen de una esfera
        //(4/3)*pi * r3
        sphereVolumen(y);
        System.out.println(sphereVolumen(y));

        System.out.println("Pesos a dolares: " + convertToDolar(1000, "COP"));
    }

    public static double circleArea(double r){
        return Math.PI * Math.pow(r,2);
    }

    public static double sphereArea(double r){
        return 4 * Math.PI * Math.pow(r,2);
    }

    public static double sphereVolumen(double r){
        return (4/3) * Math.PI * Math.pow(r,3);
    }

    public static double convertToDolar(double quantity, String currency){
        switch (currency){
            case "MXN":
                quantity = quantity * 0.049;
                break;
            case "COP":
                quantity = quantity * 0.00023;
                break;
        }

        return quantity;
    }
}> 

En las ultimas versiones de java se le envían parámetros así:

Las funciones a diferencia de c++, se declaran una sola vez y al mismo tiempo se le indica qué debe hacer, en c++, primero se declara la función y posteriormente se debe rellenar lo que realiza la función perse.

Un programa fácil usando funciones y condicionales para determinar si un número es par o impar.

package practica;

public class Practica {

public static void main(String[] args) {
    String tipo = tipoNumero(11);
    System.out.println(tipo);
}

public static String tipoNumero (int a) {
    
    //El programa dirá si el numero es par o impar
    
    if (a%2==0){
        return ("Número par");
    }
    else {
        return ("Número impar");
    }
}

}

Muy interesantes todos estos detalles de la sintaxis de Java.

yo me confundía porque uso el IDE eclipse, Anahi, la tutora, en el momento de hacer la salida con System.println en el main solo escribe los valores de “quantity” y MXN. En su caso intelliJ escribe quantity y currency en gris, pero como referencia, pero la tutora solo ingresa los valores de la función, en el orden en el que se han declarado en la función.
Así sí funciona, en caso les haya sucedido lo que me sucedió a mí.

Mis apuntes de la area de la esfera:

import java.util.Scanner;

public class _011_Funciones {
    public static void main(String [] Args){
        Scanner entrada = new Scanner(System.in);
        //Area de una esfera a=4*pi*radio^2
        System.out.print("Ingrese el radio de la esfera..: ");
        double radio = entrada.nextDouble();
        double area = areaEsfera(radio);
        System.out.println("Radio = "+radio+" unidades. \nArea Esfera = "+area+" unidades cuadradas.");
    }

    public static double areaEsfera(double rad){
        return 4*Math.PI*Math.pow(rad,2);
    }
}

Con las clases anteriores y esta hice un programa con funciones, espero lo haya hecho bien. 😅

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

public class TipoCambio {
    private static final double PESO_MXN_DOLAR = 0.059;
    private static final double PESO_ARG_DOLAR = 0.0039;
    private static final double PESO_COL_DOLAR = 0.00024;
    private static final double PESO_CHI_DOLAR = 0.0013;
    private static final double PESO_URU_DOLAR = 0.027;
    private static final double SOL_PE_DOLAR = 0.27;
    private static final double QUETZAL_DOLAR = 0.13;
    private static final double REAL_BRA_DOLAR = 0.21;

    public static void main(String[] args) {
        boolean menu = false;
        String op;
        while(!menu){
            System.out.println("---BIENVENIDO A LA TASA DE CAMBIO----");
            System.out.println("--Que moneda quiere cambiar a dolar--");
            System.out.println("MXN.- PESO MEXICANO  ");
            System.out.println("ARG.- PESO ARGENTINO ");
            System.out.println("COP.- PESO COLOMBIANO");
            System.out.println("CLP.- PESO CHILENO   ");
            System.out.println("UYU.- PESO URUGUAYO  ");
            System.out.println("PEN.- SOL PERUANO ");
            System.out.println("GTQ.- QUETZAL GUATEMALTECO ");
            System.out.println("BRL.- REAL BRASILEÑO ");
            System.out.println("Salir.- Salir ");
            System.out.print("Eliga una opcion: ");
            op = Opcion();

            if(op.equals("SALIR") || op.equals("salir") ||op.equals("Salir") ){
                menu = true;
                System.out.println("Saliste del sistema");
            }else{
                Conversion(op);
            }

        }



    }

    private static void Conversion(String op){
        double m;
        System.out.print("Ingresa el precio a convertir ");
        m = pedirP();


        switch (op.toUpperCase()){
            case "MXN"-> System.out.println("La conversión de " + m + " pesos MXN son de " + pesoMXN(m) + " dólares");
            case "ARG" -> System.out.println("La conversión de " + m + " pesos ARG son de " + pesoARG(m) + " dólares");
            case "COP" -> System.out.println("La conversión de " + m + " pesos COP son de " + pesoCOL(m) + " dólares");
            case "CLP" -> System.out.println("La conversión de " + m + " pesos CLP son de " + pesoCHI(m) + " dólares");
            case "UYU" -> System.out.println("La conversión de " + m + " pesos UYU son de " + pesoURU(m) + " dólares");
            case "PEN"-> System.out.println("La conversión de " + m + " soles PEN son de " + solPE(m) + " dólares");
            case "GTQ" -> System.out.println("La conversión de " + m + " quetzales GTQ son de " + quetzal(m) + " dólares");
            case "BRL" -> System.out.println("La conversión de " + m + " reales BRL son de " + realBRA(m) + " dólares");
            default -> System.out.println("ELEGINA UNA OPCION CORRECTA");


        }
    }
    private static String Opcion(){
        Scanner leer = new Scanner(System.in);
        try {
            return leer.next();
        } catch (InputMismatchException e) {
            System.out.println("Error: Debes ingresar un valor de texto.");
             return "";// Otra acción apropiada en caso de error
        }
    }

    private static double pedirP() {
        Scanner leer = new Scanner(System.in);
        try {
            return leer.nextDouble();
        } catch (InputMismatchException e) {
            System.out.println("Error: Debes ingresar un valor numérico.");
            return 0.0; // Otra acción apropiada en caso de error
        }
    }
    private static double pesoMXN(double m) {
        return PESO_MXN_DOLAR * m;
    }

    private static double pesoARG(double m) {
        return PESO_ARG_DOLAR * m;
    }

    private static double pesoCOL(double m) {
        return PESO_COL_DOLAR * m;
    }

    private static double pesoCHI(double m) {
        return PESO_CHI_DOLAR * m;
    }

    private static double pesoURU(double m) {
        return PESO_URU_DOLAR * m;
    }

    private static double solPE(double m) {
        return SOL_PE_DOLAR * m;
    }

    private static double quetzal(double m) {
        return QUETZAL_DOLAR * m;
    }

    private static double realBRA(double m) {
        return REAL_BRA_DOLAR * m;
    }


}
> 

import java.util.Scanner;

public class Funciones {
    public static double circleArea(double r){
        return Math.PI * Math.pow(r,2);
    }

    public static double surfaceAreaSphere(double r){
        return Math.PI * Math.pow(r,2) * 4;
    }

    public static double volumeSphere(double r){
        return Math.PI * Math.pow(r,3) * (4.0/3.0);
    }

    public static double convertToDollar(double quantity, String currency){
        //Actualizado el 19/06/23 02:12 AM
        // ARS Oficial Tipo Vendedor
        switch (currency){
            case "ARS" -> quantity = quantity *  259;
            case "EUR" -> quantity = quantity *  0.91;
            case "GBP" -> quantity = quantity *  0.78;
            case "AUD" -> quantity = quantity *  1.46;
            default -> quantity = -1;
        }
        return quantity;
    }

    public static void main(String[] args) {
        double r = 3;
        System.out.println("Area del círculo       : " + circleArea(r));
        System.out.println("Superficie del círculo : " + surfaceAreaSphere(r));
        System.out.println("Volumen del círculo    : " + volumeSphere(r));

        System.out.println();
        
        Scanner entrada = new Scanner(System.in);
        double dolares;
        String moneda;

        System.out.print("Ingrese cantidad de dólares: ");
        dolares = entrada.nextDouble();

        System.out.println("Ingrese la otra moneda: ");
        System.out.print("  ARS, EUR, GBP, AUD : ");
        moneda = entrada.next();
        moneda = moneda.toUpperCase();

        System.out.println(dolares + " dolares equivale a " + convertToDollar(dolares,moneda) + " " + moneda);
    }
}

yo hace poco ya pude entender el tema, espero esto les sirva

public class Funciones2 {
    public static void main(String[] args) {
        int a = 10;
        int b = 11;

                sumadenumero (a,b);

        System.out.println(sumadenumero (a,b));
    }
// ésta es la funcion, lo que ocurre es que la parte de arriba es la que llama la funcion. recuerden 
//que  la funcion tiene que estar al mismo nivel de la clase por eso esta fuera de las llaves
    public static int sumadenumero (int a, int b){

       return a + b;
    }

}

espero no ser solo yo. pero no le entiendo muy bien que digamos.

Yo resolví el siguiente problema utilizando funciones😎

Crear un sistema que ayude a Felipe calcular la prima correspondiente, respecto al salario de sus trabajadores teniendo en cuenta los siguientes aspectos:

*Si gana entre 250USD y 499USD darle el 90% del salario de adición

*Si gana entre 500USD y 1.999USD darle el 80% del salario de adición

*Si gana entre 2.000USD y 3.099USD darle el 70% del salario de adición

*Si gana entre 3.099USD o mas darle el 60% del salario de adición

Solucion:

//conversion de peso a dolar
	public static double convertToDollar(double cantidad, String moneda) {
		double  valorActual; 
		switch (moneda) {
		case "MXN":
			valorActual = 18.58;
			break;
		case "COP":
			valorActual = 0.00021;
			break;
		default:
			throw new IllegalArgumentException("la moneda no ha sido registrada");
		}
		cantidad = cantidad / valorActual;
		return cantidad;
	}
	

Una lectura corta que habla mas sobre funciones en Java
Link

Mi código de esta clase (NetBeans 16, Java 19):

Jugando con la consola!

public static void main(String[] args) {
        double inputQuantity;
        String inputCurrency;
        Scanner input = new Scanner(System.in);

        System.out.println("Enter the currency type (MXN,COP,CUP,BOB) supported");
        inputCurrency = input.next();

        System.out.println("Now enter the amount to convert to USD");
        inputQuantity = input.nextDouble();

        double resultUSD = convertToUSD(inputQuantity, inputCurrency);
        System.out.println(resultUSD + " USD Dolaritos");
    }

    public static double convertToUSD(double quantity, String currency) {
        switch (currency) {
            case "MXN":
                quantity *= 0.052;
                break;
            case "COP":
                quantity *= 0.00031;
                break;
            case "CUP":
                quantity *= 0.042;
                break;
            case "BOB":
                quantity *= 0.14;
                break;
            default:
                System.out.println("Invalid currency type entered:" + currency);
                quantity = 0.0;
                break;
        }

        return quantity;
    }

//Class import for request user data
import java.util.Scanner;
public class FunctionCalculator {

public static void main(String[] args) {
    //Option menu
    System.out.println("Welcome Aplication Calcultor \n" +
            "1. Add\n" +
            "2. Subtraction\n" +
            "3. Multiplication\n" +
            "4. Division");
    //Create object for request data
    Scanner entrada = new Scanner((System.in));
    //Request data
    System.out.println("Type the option: ");
    int operation = entrada.nextInt();
    float operatingA = entrada.nextInt();
    float operatingB = entrada.nextInt();
    System.out.println(operation);
    System.out.println(operatingA);
    System.out.println(operatingB);


    //Called to the function
    calculator(operatingA,operatingB,operation);
}
//Calculator function
public static float calculator( float operatingA, float operatingB, int operation){
    switch (operation){
        case 1:
            operatingA = operatingA +  operatingB;
            System.out.println("This is the result the add: " + operatingA);
            break;
        case 2:
            operatingA = operatingA - operatingB;
            System.out.println("This is the result: "+ operatingA);
            break;
        case 3:
            operatingA = operatingA * operatingB;
            System.out.println("This is the result: " + operatingA);
            break;
        case 4:
            operatingA = operatingA / operatingB;
            System.out.println("This is the result: " + operatingA);
            break;
        default:
            System.out.println("select other option");

    }
    return operatingA;
}

}

codigo de la funcion con if:

public static double converterDollar(double quantity, String currency){
if(currency == “COL”){
quantity = quantity * 0.00020;
} else if (currency == “MXM”) {
quantity = quantity * 0.052;
}else{
System.out.println(“moneda no encontrada”);
}
return quantity;
}

0.050 pesos mexicanos a dolares.

Para reciclar más se puede hacer la función usando void

public static void circleArea(double r){
        System.out.println("Función void: " + (Math.PI*Math.pow(r,2)));
    }

Así en el main solo se debe llamar a la función y pasarle el parámetro sin tener que agregar Systema.out.println(…); en cada vez que sea desees sacar el área de un circulo.

circleArea(y);

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        System.out.println("Conversion de dinero \nMXM a Dollar $ , Yen ¥ and Euro € \nQue tipo de conversion quieres hacer ?");
        System.out.println("Ingresa el Monto en Pesos ");
        double MXN = teclado.nextDouble();
        teclado.nextLine();
        System.out.println("Ingresa al tipo de cambio al que  sera convertido");
        String currency = teclado.nextLine();
        //llamamos a la funcion y le damos un mensaje
        double Money = converToMoney(MXN, currency);
        if (currency.equals("Dollar")){
            if (MXN <= 1){
                System.out.println(MXN + " Peso convertido a Dollar equivale a " + (float) Money + " Dollar ");
            }else{
                System.out.println(MXN + " Pesos convertidos a Dollars equivale a " + (float) Money + " Dollars ");
            }
        }else if(currency.equals("Yen")){
            if (MXN <= 1){
                System.out.println(MXN + " Peso convertido a Yen equivale a " + (float) Money + " Yen ");
            }else{
                System.out.println(MXN + " Pesos convertidos a Yenes equivale a " + (float) Money + " Yenes ");
            }
        }else if(currency.equals("Euro")){
            if (MXN <= 1){
                System.out.println(MXN + " Peso convertido a Euro equivale a " + (float) Money + " Euro ");
            }else{
                System.out.println(MXN + " Pesos convertidos a Euros equivale a " + (float) Money + " Euros ");
            }
        }
    }
    public static double converToMoney (double MXN, String currency) {
        double quantity = 0;
        switch (currency) {
            case "Dollar":
                quantity = MXN * 0.049;
                break;
            case "Yen":
                quantity = MXN * 7.09;
                break;
            case "Euro":
                quantity = MXN * 0.051;
                break;
        }
        return quantity;
    }
}

Son geniales las funciones!

Excelentes ejemplos para las funciones

Increible como uno no olvida los paortes que hacen los compañeros! Por mas Aporteeees!

siempre veo esta clase en lo otro lenguajes de programación y nunca me aprendo las formulas. esa si me las aprendo de memoria.

“static” aplica a los métodos que comparten el métoido main.

Comparto mi codigo de esta clase

public class Funciones
{
    public static void main(String[] args)
    {
        double y = 3;
        double x = 6;
        double area = circleArea(y);
        double areaSphere = sphereArea(y);
        double volumenSphere = sphereVolumen(y);
        double quality = 500;
        System.out.println(area);

        //Area de un circulo
        //pi*r2 // pow eleva un numero a una potencia x, primer numero y el segundo es la potencia.
        System.out.println("Area Circulo");
        System.out.println(circleArea(y));

        //Area de una esfera
        //4*PI*r2
        System.out.println("Area Sphere");
        System.out.println(sphereArea(y));

        //Volumen de una esfera
        // (4/3)*PI*r3
        System.out.println("Volumen sphere");
        System.out.println(sphereVolumen(y));

        System.out.println("PESOS A DOLARES " + convertToDollar(quality, "MXN") + " MXN");
        System.out.println("PESOS A DOLARES " + convertToDollar(quality, "COP") + " COP");
    }

        //Funciones A
    //"static" solo se usa cuando se comparte el metodo main
    public static double circleArea (double r)
        {
            return Math.PI * Math.pow(r,2);
        }
    public static double sphereArea (double r)
        {
            return Math.PI * 4 * Math.pow(r,2);
        }
    public static double sphereVolumen (double r)
        {
            return   Math.PI * (4/3) * Math.pow(r,3);
        }

        //Funciones B
    public static double convertToDollar (double quantity, String currency)
        {
        //MXN COP
        switch (currency) {
            case "MXN":
                quantity = quantity * 0.052;
                break;
            case "COP":
                quantity = quantity * 0.00031;
                break;

        }
            return quantity;
        }


}

Yo le agregue la opción default, para cuando se declara un valor que no se encuentra en el switch

public static double convertToDollar(double quantity, String currency){
    //MXN COP
    switch (currency){
        case "MXN":
            quantity = quantity * 0.052;
            break;
        case "COP":
            quantity = quantity * 0.00031;
            break;
        default:
            quantity = 0;
            out.println("Opcion no valida");
    }
    return quantity;
}

la verdad era mejor no reutilizar codigo

Static es lo que este a nivel de main, que bella definicion

import java.util.Scanner;

public class EjercicioFunciones {
    public static void main(String[] args) {
        
        double radio = 3;
        double area = areaCirculo(radio);
        System.out.println(area);

        double radioEsfera = 10;
        double AreaEsfera = areaEsfera(radioEsfera);
        System.out.println(AreaEsfera);

        double VolumenEsfera = volumenEsfera(radio);
        System.out.println(VolumenEsfera);

        Scanner sc = new Scanner(System.in);

        System.out.print("Ingresa tu moneda: ");
        String moneda;
        moneda = sc.nextLine();

        System.out.print("Ingresa la cantidad: ");
        double cantidad;
        cantidad = sc.nextInt();

        double resultado = convertirMoneda(moneda, cantidad);
        System.out.println(resultado);

        sc.close();
    }

    public static double areaCirculo(double r){
        // PI * r2
        return Math.PI * Math.pow(r, 2);
    }

    public static double areaEsfera(double radio) {
        // Formula 4 * PI * r2
        return (4 * Math.PI * Math.pow(radio, 2));
    }

    public static double volumenEsfera(double radio) {
        // Formula (4/3) * PI * r3
        return (4/3) * Math.PI * Math.pow(radio, 3);
    }

    public static double convertirMoneda(String moneda, double cantidad) {
        switch (moneda) {
            case "MXN":
                cantidad = cantidad * 0.052;
                break;
            case "COL":
                cantidad = cantidad * 0.00031;
                break;        
            default:
                System.out.println("Ingresa una moneda correcta");
        }

        return cantidad;
    }
}

Funciones:

import java.io.IOException;
import java.util.Scanner;

public class Functions {
    public static void main(String[] args) throws IOException {
        System.out.println("Calculadora para figuras geometricas planas.\n\n");
        System.out.println("Escoja una de las opciones:\n");
        System.out.println(
                "A. Area del Circulo\nB. Area de una Esfera\nC. Area de un Triangulo\nD. Area de un Rectangulo\nE. Area de un Cuadrado\n");
        String option;
        Scanner s = new Scanner(System.in);
        option = s.next();
        double area = 0.0;
        double radius = 0.0;
        double height = 0.0;
        double base = 0.0;

        switch (option) {
            case "A":
                System.out.println("\nIngrese el radio del Ciruclo\n");
                radius = s.nextDouble();
                area = circleArea(radius);
                System.out.println("\nEl area es:\t" + area + "\n");
                break;

            case "B":
                System.out.println("\nIngrese el radio de la Esfera\n");
                radius = s.nextDouble();
                area = esphereArea(radius);
                System.out.println("\nEl area es:\t" + area + "\n");
                break;

            case "C":
                System.out.println("\nIngrese la altura del triangulo\n");
                height = s.nextDouble();
                System.out.println("\nIngrese la base del triangulo\n");
                base = s.nextDouble();
                area = triangleArea(base, height);
                System.out.println("\nEl area es:\t" + area + "\n");
                break;

            case "D":
                System.out.println("\nIngrese la altura del rectangulo\n");
                height = s.nextDouble();
                System.out.println("\nIngrese la base del rectangulo\n");
                base = s.nextDouble();
                area = rectangleArea(base, height);
                System.out.println("\nEl area es:\t" + area + "\n");
                break;

            case "E":
                System.out.println("\nIngrese la longitud del lado\n");
                height = s.nextDouble();
                area = rectangleArea(height, height);
                System.out.println("\nEl area es:\t" + area + "\n");
                break;

            default:
                System.out.println("\nPor favor seleccione una de las opciones\n");
                break;
        }
    }

    public static double circleArea(double radius) {
        return Math.PI * Math.pow(radius, 2);
    }

    public static double esphereArea(double radius) {
        return 4 * Math.PI * Math.pow(radius, 2);
    }

    public static double triangleArea(double base, double height) {
        return (base * height) / 2;
    }

    public static double rectangleArea(double base, double height) {
        return (base * height);
    }
}

Hola este es mi aporte jeje.

Esta es mi versión del conversor de monedas a dólares:

import java.util.Scanner;
public class ConversiónMonedaSwitch {
    public static Scanner teclado=new Scanner(System.in);
    public static String currency="";
    public static double dineros;
    public static int saludo(){
        int opcion;
        System.out.print("*******Bienvenido al Conversor de Monedas*******\n");
        System.out.println("1. Pesos Mexicanos a Dólares");
        System.out.println("2. Pesos Colombianos a Dólares");
        System.out.println("3. Lempiras Hondureños a Dólares");
        System.out.print("\nIngresa una opción: ");
        opcion = teclado.nextInt();
        return opcion;
    }

    public static double conversion(int opcion){
        double tazaCambio=1.00;
        switch(opcion){
            case 1:
                tazaCambio=0.049;
                currency="Pesos Mexicanos";
                break;
            case 2:
                tazaCambio=0.00026;
                currency="Pesos Colombianos";
                break;
            case 3:
                tazaCambio=0.041;
                currency="Lempiras Hondureños";
                break;
        }
        System.out.print("Ingresa la cantidad en "+currency+": ");
        dineros=teclado.nextDouble();
        return (double)Math.round((dineros*tazaCambio*100))/100;
    }

    public static void main(String[] args) {
        double dolares=conversion(saludo());
        System.out.println("Tus "+dineros+" "+currency+" equivalen a "+dolares+" Dólares.");
    }
}

“Yo trate de hacer algo para que el usuario pueda elegir si quiere cambiar pesos col a dolares o a pesos mexicanos”

import java.util.Scanner;

public class FucionesConversorMonedas {

public static void main(String[] args) {
    Scanner teclado = new Scanner(System.in);
    System.out.println("Digite la moneda que desea convertir: ");
    String moneda = teclado.nextLine();
    System.out.println("Digite el valor que desea convertir: ");
    double valor = teclado.nextDouble();

    System.out.println(conversorMonedas(moneda,valor));

}
public static double conversorMonedas(String moneda, double valor) {
    switch (moneda) {
        case "COP":
            String conversion1;
            Scanner conversion = new Scanner(System.in);
            System.out.println("Pesos colombianos a USD o MXN: ");
            conversion1 = conversion.nextLine();
                if (conversion1.equals("USD")){
                    valor = valor/3880;
                    System.out.println("El valor en dolares USD es: ");
                }else{
                    valor = valor*0.0052;
                    System.out.println("El valor en pesos MXN es: ");
                }
            break;
        case "MXN":
            String conversion2;
            Scanner conver = new Scanner(System.in);
            System.out.println("Pesos mexicanos a USD o COP: ");
            conversion2 = conver.nextLine();
            if (conversion2.equals("USD")){
                valor = valor*0.05;
                System.out.println("El valor en dolares USD es: ");
            }else{
                valor = valor*193.93;
                System.out.println("El valor en pesos COP es: ");
            }
    }
    return valor;
}

}

Aquí dejo el ejercicio de conversión de pesos a dólares con valores actualizados 😄 2021

<System.out.println("PESOS A DOLARES: " + convertirdolares(200,"COP" ));

public static double convertirdolares(double cantidad, String moneda){
        //MXN COP
        switch (moneda){
            case "COP":
                cantidad = cantidad * 0.050;
                break;
            case "MXN":
                cantidad = cantidad * 0.00026;
                break;

        }

        return  cantidad;
    }
}> 

Crear una función en java static solo se usa cuando la funcion comparte el metodo main

No se si sirva de algo pero en pythom declaramos las funciones antes del main por buenas practicas

    public static double converToDolar(double quantyti, String currency){
        //MXN COP
        switch (currency){
            case "MXN":
                quantyti = quantyti * 0.052;
                break;
            case "COP":
                quantyti = quantyti * 0.00031;
                break;
        }
        return quantyti;
    }

y después el la imbocamos:

        // CONVERTIDOR DE MONEDA DE PESOS O MXN A DOLARES
        System.out.println("Pesos a dolares: "+ converToDolar(5000,"COP"));```

Se deben tener claros los parametros y que implican cada uno dentro de la funcinón, de lo contrario no va a ser optima.

public class Funcion {
    public static void main(String[] args) {
        System.out.println("Guaraníes a dolar: " + converToDolar(100, "GS"));
        System.out.println("Pesos colombianos a dolar: " + converToDolar(100, "COP"));
    }
    
    public static double converToDolar(double quantity, String currency){
        switch(currency){
            case "GS":
                quantity = quantity * 0.00015;
                break;
            case "COP":
                quantity = quantity * 0.00028;
                break;
        }
        
        return quantity;
    }
    
}```

No me quedo claro lo de static.

Super!!

public class Funciones {
    public static void main(String[] args) {
        double y = 54;
        double area = areaCirculo(y);
        double volumen = sphereArea(y);
        System.out.println("El área de un cículo con radio " + y + " es: " + area);
        System.out.println("El volumen de una esfera de radio " + y + " es: " +volumen);

    }
    public static double areaCirculo(double radio ){
        return Math.PI * Math.pow(radio, 2);
    }
    public  static double sphereArea(double r){
        return 4*Math.PI*Math.pow(r, 2);
    }
}

public class Factorial {
    public static void main(String[] args) {
        int numero = 10;
        System.out.println("El factorial del numero " + numero + " es: " + factorial(numero));
    }
    public static int factorial (int numero) {
        if (numero==0){
            return 1;
        } else{
            return numero * factorial(numero - 1);
        }
    }
}

Si queremos utilizar una función directamente sin tener que instanciarlo podemos utilizar la palabra reservada “static” y de esa forma solo tenes que llamar a la funcion misma.

repasando!

public class funciones {

public static void main(String[] args) {
    // TIENEN UNA ENTRADA Y UNA SALIDA: SE RECIBEN COMO PARAMETROS EN LA FUNCION
    /*
    -- AYUDAN A MODULARIZAR EL CODIGO
    -- AYUDAN A REUTILIZAR EL CODIGO
    -- EVITAR EL CODIGO REPETIDO
            public int suma (int a, int b){
                return a+b; // el valor de regreso, especificar el valor de regreso
             }
       LLAMAR  FUNCION:
       int c = suma (5,7);
       // retorna el resultado en la variable c
     */

    // IMPLEMENTAR FUNCIONES
    double x = 2.134;
    double y = 3;
    // Calculo del area de un Circulo
    // llamamos a la funcion y almacenamos el resultado en la variable area
   circleArea(y);
   roundNumber(x);
   roundFlorNumber(x);
   powNumbers(x,y);
   maxNumber(x,y);
   mathSqrt(x);
   spheraArea(y);
   spheraVolumen(y);
   double quantity = 5000;
   String currency = "COP";
   convertToDolar(quantity,currency);
}

    // LAS FUNCIONES VIVEN AL NIVEL DE LA CLASE, SALIMOS DEL METODO MAIN.
    // STATIC: PARA METODOS QUE COMPARTEN EL METODO MAIN
    public static double circleArea (double y){
        double area= 0;
        area = Math.PI*Math.pow(y,2);
        System.out.println("EL AREA ES "+area);
        return area;
    }

    public  static double roundNumber (double x){
        double r;
        r = Math.ceil(x);
        System.out.println("EL NUMERO REDONDEADO ES "+r+" EL NUMERO ORIGINAL ERA: "+x );
        return r ;
    }

    public  static double roundFlorNumber (double x){
        double r;
        r = Math.floor(x);
        System.out.println("EL NUMERO REDONDEADO AL MENOR ES "+r+" EL NUMERO ORIGINAL ERA: "+x );
        return r ;
    }

    public static double powNumbers(double x , double y){
    double r =0;
    r = Math.pow(x,y);
    System.out.println("LA BASE ES "+x + " ELEVADO AL EXPONENTE "+ y + " EL RESULTADO ES "+ r);
    return r;
    }

public  static double maxNumber (double x, double y){
    double r;
    r = Math.max(x,y);
    System.out.println("EL NUMERO MAYOR ES "+r);
    return r ;
}

public  static double mathSqrt (double x){
    double r;
    r = Math.sqrt(x);
    System.out.println("LA RAIZ CUADRADA DE  "+x + " ES "+ r );
    return r ;
}

public static double spheraArea (double y){

    double r=0;
    r = Math.PI*4*Math.pow(y,2);
    System.out.println("EL AREA DE LA ESFERA ES "+r);
    return r;
}

public static double spheraVolumen(double y){
    double r = 0;
    r = (Math.PI*(4/3)*Math.pow(y,3));
    System.out.println("EL VOLUMEN DE LA ESFERA ES "+r);
    return r;
}

public static  double convertToDolar(double quantity, String currency){

    switch (currency){
        case "MXN": quantity = quantity * 0.052;
            System.out.println("LA CANTIDAD DE PESOS MEXICANOS ES "+ quantity );
        break;
        case "COP": quantity = quantity * 0.00029;
            System.out.println("LA CANTIDAD DE PESOS COLOMBIANOS ES "+ quantity );
            break;
        default:
            System.out.println("SELECCIONE UNA OPCION VALIDA");
            break;
    }
return quantity;
}

}

package Sumas;


    public class Operacion {






    public int sumar(int numero1, int numero2){

    int sum= numero1+numero2;
    return sum;


    }
    public int resta (int numero1,int numero2){

        int resta = numero1-numero2;
        return resta;
    }


    public int multiplicacion(int numero1, int numero2){

        int mult= numero1*numero2;
        return mult;



    }

    public int division (int numero1, int numero2){
    int div= numero1/numero2;
    return div;


    }

    public void mostrar (int suma, int resta, int multiplicaion,int division){
        System.out.println("la suma es "+ suma);
        System.out.println("la resta es "+ resta);
        System.out.println("la multipliacion es "+ multiplicaion);
        System.out.println("la division es "+ division);





    }


    }

package Sumas;
import java.util.Scanner;

public class main {

public static void main(String[] args) {
    Scanner type = new Scanner(System.in);
  
    Operacion sc = new Operacion ();
   
    System.out.println("Ingrese un numero ");
    int numero1 = type.nextInt();
    System.out.println("Ingrese un segundo numero ");
    int numero2= type.nextInt();
   
int suma = sc.sumar(numero1, numero2);
int resta = sc.resta(numero1, numero2);
int multipli=sc.multiplicacion(numero1, numero2);
int divi=sc.division(numero1, numero2);

sc.mostrar(suma, resta, multipli, divi);

Comparto el código funcionando para que comparen por si se les presenta alguna falla.

public class Funciones {
public static void main(String[] args) {
double y = 3;
//Area de un círculo
//pi * r2
circleArea(y);

    //Area de una esfera
    //4 * PI * r2
    sphereArea(y);

    //Volumen de una esfera
    //(4/3) * PI * r3
    sphereVolume(y);

    System.out.println("PESOS A DOLARES: " + converToDolar(1000,"COP"));
}

public static double circleArea(double r){
    return Math.PI * Math.pow(r,2);
}

public static double sphereArea(double r){
    return 4 * Math.PI * Math.pow(r,3);
}

public static double sphereVolume(double r){
    return (4/3) * Math.PI * Math.pow(r,3);
}
public static double converToDolar(double quantity, String currency){
    //MXN COP
    switch (currency){
        case "MXN":
            quantity = quantity * 0.052;
            break;
        case "COP":
            quantity = quantity * 0.00031;
            break;
    }

    return quantity;
}

}

Optimiza el código.

static aplica para métodos que comparten el método main

        //convertidor
        double quantity;
        String currency;
        System.out.println("Pesos a dolares: " + converToDolar(quantity=200, currency="MXN"));```

¿Se tienen que declarar las variables en el main antes de mandar llamar una funcion?

Todo ok.

public class Funciones {
    public static void main(String[] args) {
        double y = 3;
        //Area de un circulo pi*r^2
        double area = circleArea(y);
        System.out.println(circleArea(y));

        //Area de una esfera 4*pi+r^2
        double areaE = sphereArea(y);
        System.out.println(sphereArea(y));

        //Volumen de una esfera (4/3)*pi*r^3
        double Volumen = sphereVolumen(y);
        System.out.println(sphereVolumen(y));

        System.out.println("PESOS A DOLARES: "+ converToDolar(1000,"COP"));
    }

    public static double circleArea(double r){
        return Math.PI*Math.pow(r,2);
    }
    public static double sphereArea(double r){
        return 4*Math.PI*Math.pow(r,2);
    }
    public static double sphereVolumen(double r){
        return (4/3)*Math.PI*Math.pow(r,3);
    }
    public static  double converToDolar(double quantity, String currency){
        //MXN COP
        switch (currency){
            case "MXN":
                quantity = quantity*0.052;
                break;
            case "COP":
                quantity = quantity*0.00031;
                break;
        }
        return quantity;


    }
}```

Repasando 😃

public class FuncionName {
//declaración de la funcion Suma
public static int Suma(int a, int b){
return a + b;
}
//declaración de la función Mensaje --void no retorna valor
public static void Mensaje(){
System.out.println(“Ejecución Exitosa!!” );
}

//Metodo MAIN
public static void main(String[] args) {
    int c = Suma(5,7);   //llamado a la función Suma
    System.out.println(c);

    Mensaje();                 //llamado a la función Mensaje
}

}

Resultado;
12
Ejecución Exitosa!!

Son muy buenas las pautas dadas para crear los metodos.

public class Funtions {
	public static void main(String[] args) {
		
		int dollar=100;
		String name=sayMyName();
		String lastName=sayMyLastName();
		
		
		System.out.println(
		"My name Is:"+name+"\n"+
		"My last name is: "+ lastName+"\n"+
		dollar+"$="+dollarConvertToRD(100)+"RD");
		
		/*Result:
		 *My name Is:Ramon Antonio
		 *My last name is: Melo olivero
-		 *100$=5710.0RD		
		 */
		
	}
	
	public static String sayMyName() {
		
		return "Ramon Antonio";
	}
	
	public static String sayMyLastName() {
		
		return "Melo olivero";
		
	}
	
	public static double dollarConvertToRD(double a) {
		
		return a*57.10;
		
		
		
	}
}```

Agregando la moneda de mi país

System.out.println("PESOS A DOLARES: " + convertToDolar(2100, "BOB"));
//MXN COP BOB
        switch (currency){
            case "MXN":
                quantity = quantity * 0.052;
                break;
            case "COP":
                quantity = quantity * 0.00031;
                break;
            case "BOB":
                quantity = quantity * 0.14;
        }

Vamos platzi

public class holamundo {
    public static void main(String[] args) {

        System.out.println("PESOS A DOLARES: " + convertir("COP", 1000));

    }
    public static double convertir(String tipo, double cantidad){

        switch (tipo){
            case "CLP":
                cantidad = cantidad * 0.0012;
                break;
            case "COP":
                cantidad = cantidad = 0.00031;
                break;
        }
        return cantidad;
    }
}

Se va poniendo bueno esto…

Nota mental: funciones y métodos son la misma cosa 😆😂