Leer Datos

import java.io.*;
import java.util.*;
import javax.swing.*;

public class LeerDatos{

public static String dato(){

BufferedReader leerCad=new BufferedReader( new InputStreamReader ( System.in ) );
String num="";
try{
   num=leerCad.readLine();
   }
catch( IOException e ){
System.err.println( "Error"+e.getMessage());
}
return num;
}

//Metodo para convertir la cadena leida en entero ( int )

public static int numInt(){

try{
   return Integer.parseInt( dato());
   }
catch( NumberFormatException e ){
return 0;
}
}

//Metodo para convertir la cadena a Double

public static double numDouble(){

try{
   return Double.parseDouble( dato());
   }
catch( NumberFormatException e ){
return 0;
}
}

//Metodo para convertir la cadena a Short

public static short numShort(){

try{
   return Short.parseShort( dato());
   }
catch( NumberFormatException e ){
return 0;
}
}

//Metodo para convertir la cadena a Long

public static long numLong(){

try{
   return Long.parseLong( dato());
   }
catch( NumberFormatException e ){
return 0;
}
}

//Metodo para convertir la cadena a Byte

public static byte numByte(){

try{
   return Byte.parseByte( dato());
   }
catch( NumberFormatException e ){
return 0;
}
}

//Metodo para convertir la cadena a Float

public static float numFloat(){

try{
   return Float.parseFloat( dato());
   }
catch( NumberFormatException e ){
return 0;
}
}

//Scanner

public static String datoSc(){

Scanner leerCad= new Scanner( System.in );
String tipo="";

try{
   return leerCad.nextLine();
   }
catch( InputMismatchException e ){
   return tipo;
   }
   }

//Metodo para leer un numero Int con Scanner

public static int tipoInt(){

Scanner leer=new Scanner( System.in );
try{
   return leer.nextInt();
   }
catch( InputMismatchException e ){
   return 0;
   }
   }
 

//Metodo para leer un numero Byte con Scanner

public static byte tipoByte(){

Scanner leer=new Scanner( System.in );
try{
   return leer.nextByte();
   }
catch( InputMismatchException e ){
   return 0;
   }
   }

//Metodo para leer un numero Short con Scanner

public static short tipoShort(){

Scanner leer=new Scanner( System.in );
try{
   return leer.nextShort();
   }
catch( InputMismatchException e ){
   return 0;
   }
   }

//Metodo para leer un numero Long con Scanner

public static long tipoLong(){

Scanner leer=new Scanner( System.in );
try{
   return leer.nextLong();
   }
catch( InputMismatchException e ){
   return 0;
   }
   }

//Metodo para leer un numero Float con Scanner

public static float tipoFloat(){

Scanner leer=new Scanner( System.in );
try{
   return leer.nextFloat();
   }
catch( InputMismatchException e ){
   return 0;
   }
   }

//Metodo para leer un numero de tipo double con Scanner

public static double tipoDouble()
{
Scanner leer=new Scanner( System.in );
try{
   return leer.nextDouble();
   }
catch(InputMismatchException e ){
   return 0;
   }
   }

//JOptionPane
public static String datoOp(){
JOptionPane.showMessageDialog(null,"Otro metodo", null, JOptionPane.INFORMATION_MESSAGE);
String op="";

try{
   return JOptionPane.showInputDialog(null,"","", JOptionPane.QUESTION_MESSAGE);
   }
catch(NumberFormatException e ){
   return op;
   }
   }


//Metodo para convertir la cadena a real ( double )

public static double opDouble( String mensaje ){
try{
   return Double.parseDouble( JOptionPane.showInputDialog(null,mensaje));
   }
catch(NumberFormatException e ){
   return 0;
   }
   }

//Metodo para convertir la cadena a byte ( byte )

public static byte opByte( String mensaje ){
try{
   return Byte.parseByte( JOptionPane.showInputDialog(null,mensaje));
   }
catch(NumberFormatException e ){
   return 0;
   }
   }

//Metodo para convertir la cadena a long ( long )

public static long opLong( String mensaje ){
try{
   return Long.parseLong( JOptionPane.showInputDialog(null,mensaje));
   }
catch(NumberFormatException e ){
   return 0;
   }
   }

//Metodo para convertir la cadena a float ( float )

public static float opFloat( String mensaje ){
try{
   return Float.parseFloat( JOptionPane.showInputDialog(null,mensaje));
   }
catch(NumberFormatException e ){
   return 0;
   }
   }

//Metodo para convertir la cadena a short ( short )

public static short opShort( String mensaje ){
try{
   return Short.parseShort( JOptionPane.showInputDialog(null,mensaje));
   }
catch(NumberFormatException e ){
   return 0;
   }
   }

//Metodo para convertir la cadena a entero ( int )

public static int opInt( String mensaje ){
try{
   return Integer.parseInt( JOptionPane.showInputDialog(null,mensaje));
   }
catch(NumberFormatException e ){
   return 0;
   }
   }
   }

Principal Proyectil

import java.io.*;
import java.util.*;
import javax.swing.*;

public class Principal{
public static void main (String args[]){
Scanner leer = new Scanner (System.in);
double r,t,h,vo,a,ra;
double G=9.81, Pi=3.1416;
Proyectil fin = new Proyectil();
Double.parseDouble(JOptionPane.showInputDialog(null,"Ingresa la velocidad inicial."));{
vo=leer.nextDouble();}
Double.parseDouble(JOptionPane.showInputDialog(null,"Ingresa el angulo."));{
a=leer.nextDouble();}
ra=fin.radian(a,Pi);
r = fin.distancia(vo, ra, G);
System.out.println("La distancia recorrida es:"+r);
t=fin.tiempo(vo, ra, G);
System.out.println("El tiempo es:"+t);
h=fin.altura(vo, ra, G);
System.out.println("La altura es:"+h);
}
}

Metodo Proyectil

import java.io.*;
import java.util.*;
public class Proyectil{

double G=9.81, Pi=3.1416;
double vo,ra,a,r,t,h;
//Metodo para combertir angulos a radianes
public double radian (double a, double Pi){
ra=(Pi*a)/180;
return ((Pi*a)/180);}
public double radian (int a, int Pi){
ra=(Pi*a)/180;
return (ra);}

//Metodo para la distancia
public double distancia (double vo, double ra, double G){
r=(vo*Math.sin(2*ra))/G;
return (r);}
public double distancia (int vo, int ra, int G){
r=(vo*Math.sin(2*ra))/G;
return (r);}

//Metodo para el tiempo
public double tiempo (double vo, double ra, double G){
t=(2*vo*Math.sin(ra))/G;
return (t);}
public double tiempo (int vo, int ra, int G){
t=(2*vo*Math.sin(ra))/G;
return (t);}

//Metodo para altura
public double altura (double vo, double ra, double G){
h=((vo*vo)*Math.sin(ra))/G;
return (h);}
public double altura (int vo, int ra, int G){
h=((vo*vo)*Math.sin(ra))/G;
return (h);}

}

Principal Operaciones y Figuras

Metodo principal para Operaciones y Figuras:

//Una pequeña clase prinsipal que sirve para elejir el metodo que deseas usar
import java.util.*;
class OperacionesDos{

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

double a, b, x=0;
int op=0;

OperacionesYFiguras OYF = new OperacionesYFiguras();


//En la clase OperacionesYFiguras tiene mas metodos ingrese los que crea nesesario para el menu
//MENU
System.out.println( "1. Suma" );
System.out.println( "2. Resta" );
System.out.println( "3. Multiplicacion" );
System.out.println( "4. Division" );
System.out.println( "5. Modulo" );
System.out.print( "Seleccione una operacion:" );
op=leer.nextInt();

//Pide los datos para realisar la operacion
System.out.print( "Ingrese el primer numero:" );
a=leer.nextDouble();
System.out.print( "Ingrese el segundo numero:" );
b=leer.nextDouble();

//Dependiendo el menu es dependiendo cuantos "case()" se nesesitaran
switch(op){

   case(1):x = OYF.suma( a,b );
   break;
 
   case(2):x = OYF.resta( a,b );
   break;
 
   case(3):x = OYF.multiplicacion( a,b );
   break;
     
   case(4):x = OYF.division( a,b );
   break;
 
   case(5):x = OYF.modulo( a,b );
   break;
     
   }
 
System.out.print( "El resultado de la operacion es:"+x );
}

}
 

Metodo Operaciones y Figuras

Metodos:

public class OperacionesYFiguras{

/*Suma*/
public double suma( double a,double b ){
return( a+b );}
public int suma( int a,int b ){
return( a+b );}

/*Resta*/
public double resta( double a,double b ){
return( a-b );}
public int resta( int a,int b ){
return( a-b );}

/*Multiplicacion*/
public double multiplicacion( double a,double b ){
return( a*b );}
public int multiplicacion( int a,int b ){
return( a*b );}

/*Divicion*/
public double division( double a,double b ){
double c;
c=( b!=0 )?a/b:0;
return ( c );}
public int division( int a,int b ){
int c;
c=( b!=0 )?a/b:0;
return ( c );}

/*Modulo*/
public double modulo( double a,double b ){
double c;
c=( b!=0 )?a%b:0;
return( c );}
public int modulo( int a,int b ){
int c;
c=( b!=0 )?a%b:0;
return( c );}

/*Potencia*/
public double Potenciacion( double x,int n ){
return( Math.pow( x,n ));}
public double Potenciacion( int x,int n ){
return( Math.pow( x,n ));}

/*Potencia 2*/
public double potenciacion2( double x,int n ){
return( 1/Math.pow( x,n ));}
public double potenciacion2( int x,int n ){
return( 1/Math.pow( x,n ));}

/*Factorial*/
public double factorial( double n ){
if( n==0 )
return 1;
else
return n*factorial(n-1);}
public int factorial( int n ){
if( n==0 )
return 1;
else
return n*factorial(n-1);}

/*Cubo*/
//Volumen del cbno
public double volumenCubo( double l ){
return( l*l*l );}
public int volumenCubo( int l ){
return( l*l*l );}

//Area Base del cobo
public double areaBaseCubo( double l ){
return( l*l );}
public int areaBaseCubo( int l ){
return( l*l );}

//Area Lado del cobo
public double areaLadoCubo( double l ){
return( 4*Math.pow(l,2) );}
public double areaLadoCubo( int l ){
return( 4*Math.pow(l,2) );}

//Area Superior del cobo
public double areaSupCubo( double l ){
return( 6*Math.pow(l,2) );}
public double areaSupCubo( int l ){
return( 6*Math.pow(l,2) );}

/*Paralilepipedo*/
//Volumen Paralilepipedo
public double volumenParalilepipedo( double a, double b, double c ){
return( a*b*c );}
public int volumenParalilepipedo( int a, int b, int c ){
return( a*b*c );}

//Area Base Paralilepipedo
public double areaBaseParalilepipedo( double a, double b ){
return( a*b );}
public int areaBaseParalilepipedo( int a, int b ){
return( a*b );}

//Area Superior Paralilepipedo
public double areaSupParalilepipedo( double a, double b, double c ){
return( 2*( a*b+a*c+b*c ) );}
public double areaSupParalilepipedo( int a, int b, int c ){
return( 2*( a*b+a*c+b*c ) );}

/*Cilindro*/
//Volumen Cilindro
public double volumenCilindro( double r, double h ){
return( Math.PI*((r*r)*h) );}
public double volumenCilindro( int r, int h ){
return( Math.PI*((r*r)*h) );}

//Area Base Cilindro
public double areaBaseCilindro( double r ){
return( Math.PI*Math.pow(r,2) );}
public double areaBaseCilindro( int r ){
return( Math.PI*Math.pow(r,2) );}

//Area Superior Cilindro
public double areaSupCilindro( double r, double h ){
return( 2*Math.PI*(r*h) );}
public double areaSupCilindro( int r, int h ){
return( 2*Math.PI*(r*h));}

/*Esfera*/
//Volumen Esfera
public double volumenEsfera( double r ){
return( 4/3*(Math.PI*Math.pow(r,3)) );}
public double volumenCilindro( int r ){
return( 4/3*(Math.PI*Math.pow(r,3)) );}

//Area Superior Esfera
public double areaSupEsfera( double r, double h ){
return( 4*(Math.PI*Math.pow(r,2)));}
public double areaSupEsfera( int r, int h ){
return( 4*(Math.PI*Math.pow(r,2)));}

/*Cono*/
//Volumen Cono
public double volumenCono( double r, double h ){
return( (Math.PI*(Math.pow( r,2 )*h) )/3 );}
public double volumenCono( int r, int h ){
return( (Math.PI*(Math.pow( r,2 )*h) )/3 );}

//Area Lado Cono
public double areaLadoCono( double r, double h ){
return( ((Math.PI*r)*Math.sqrt(Math.pow(r,2)+Math.pow(h,2)))/2);}
public double areaLadoCono( int r, int h ){
return( ((Math.PI*r)*Math.sqrt(Math.pow(r,2)+Math.pow(h,2)))/2);}

//Area Superior Cono
public double areaSupCono( double r, double h ){
return((Math.PI*r)*Math.sqrt((Math.pow(r,2)+Math.pow(h,2))+Math.PI*Math.pow(r,2)));}
public double areaSupCono( int r, int h ){
return((Math.PI*r)*Math.sqrt((Math.pow(r,2)+Math.pow(h,2))+Math.PI*Math.pow(r,2)));}


}

Principal Vectores

Metodo principal para vector:

import java.io.*;
import java.util.*;

public class Vector{
public static void main (String args[]){
Scanner leer = new Scanner (System.in);
int n;
Metodos met = new Metodos();

System.out.print("Ingresa el numero de renglones del vector");
n=leer.nextInt();
int a[] = met.leerVector(n);
int b[] = met.leerVector(n);
//Dependiendo el metodo es el nombre que le pondran por ejemplo "met.sumaVector, met.restaVector, met.multiplicacionVector
int c[] = met.sumaVector(a,b);
met.escribeVector(c);
}
}

Metodo Vectores

Metodos

import java.util.*;
public class Metodos{
Scanner leer = new Scanner (System.in);

//Leer vectores.
public int[] leerVector (int n){
int i;
int x[] = new int [n];
System.out.println("Leer elementos del vector");
for (i=0 ; i<x.length ; i++){
x[i] = leer.nextInt();}
return (x);
}

//Suma vectores.
public int[] sumaVector (int a[], int b[]){
int i, n=a.length;
int c[] = new int [n];
for (i=0 ; i<c.length ; i++){
c[i] = a[i] + b[i];}
return (c);
}

//Resta vectores.
public int[] restaVector (int a[], int b[]){
int i, n=a.length;
int c[] = new int [n];
for (i=0 ; i<c.length ; i++){
c[i] = a[i] - b[i];}
return (c);
}

//Multiplicacion vectores.
public int[] multiplicacionVector (int a[], int b[]){
int i, n=a.length;
int c[] = new int [n];
for (i=0 ; i<c.length ; i++){
c[i] = a[i] * b[i];}
return (c);
}


//Escribe vectores.
public void escribeVector (int c[]){
int i;
for (i=0 ; i<c.length ; i++){
System.out.println(c[i]);}
}

}