Regla de Java

Byte : Representa un tipo de dato de 8 bits con signo.
De tal manera que puede

almacenar los valores numéricos de -128 a 127 (ambos inclusive).
Short :Representa un tipo de dato de 16 bits con signo. De esta manera almacena
valores numéricos de -32.768 a 32.767.
Int: Es un tipo de dato de 32 bits con signo para almacenar valores numéricos. Cuyo
valor mínimo es -231 y el valor máximo 231-1.
Long : Es un tipo de dato de 64 bits con signo que almacena valores numéricos
entre -263 a 263-1Float: Es un tipo dato para almacenar números en coma flotante
con precisión simple de 32 bits.
Double:Es un tipo de dato para almacenar números en coma flotante con doble
precisión de 64 bits.
Boolean: Sirve para definir tipos de datos booleanos. Es decir, aquellos que tienen
un valor de true o false. Ocupa 1 bit de información.
Char:Es un tipo de datos que representa a un carácter Unicode sencillo de 16 bits.
***********************************************************************************
******************
Pedir un número N, y mostrar todos los números del 1 al N. ( Usar while)
public class Numero_Entero {

public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n;
System.out.print("Poner un número entero: ");
n = sc.nextInt();
System.out.println("Numeros del 1 al " + n + ": ");
int i = 1;while (i <= n) {
System.out.println(i);i++;
}
}
}
***********************************************************************************
*******************
Crea un arreglo de números de 100 posiciones, que contendrá los números del 1 al
100.
Obtén la suma de todos ellos y la media. ( usar el bucle preferido)
public class Pregunta3 {

int[] numeros = new int[100];
int suma = 0;double media;
for (int i = 0; i < numeros.length; i++) {
numeros[i] = i + 1;suma += numeros[i];
}
System.out.println("La suma: " + suma);
media = (double) suma / numeros.length;
System.out.println("La media: " + media);
}
}
***********************************************************************************
********************
Escribir un programa que calcule el factorial de un numero N. (usar for)
package Pregunta2;
import java.util.Scanner;
public class Pregunta2 {
int n,factorial=1;
System.out.println("Ingrese un valor: ");
n = sc.nextInt();for(int i=1;i<=n;i++)
{
factorial = factorial * i;}
System.out.println("El factorial de" + " " + n + " " + "es: " + factorial);
}
}
***********************************************************************************
**********************
1- Realizar la carga de dos números enteros por teclado e imprimir su suma y su

producto.
package sumaproducto;
public class SumaProducto {
Scanner obj = new Scanner(System.in);
int n1;
int n2;
int suma;
int producto;
System.out.println("Ingrese el primer numero:");

n1= obj.nextInt();
System.out.println("Ingrese el segundo numero:");
n2= obj.nextInt();
suma=n1+n2;
producto=n1*n2;
System.out.print("La suma de los dos numeros es:");

System.out.println(suma);
System.out.print("El producto de los dos numeros es:");
System.out.println(producto);
}
}
}
***********************************************************************************
***************************
2. Escribe una aplicación con un String que contenga una contraseña cualquiera.
( usar la clase scanner)
Después se te pedirá que introduzcas la contraseña, con 3 intentos.
Cuando aciertes ya no pedirá mas la contraseña y mostrara un mensaje diciendo
“Enhorabuena”.
(3 intentos o si acierta sale, aunque le queden intentos).
/*Declaración Variables*/
Scanner teclado = new Scanner(System.in);
String clave = "Fabiola";
final int intentos = 3;
boolean correcto = false;
String contraseña;
/*PROCESO - Ingreso de Datos y Salida*/
for (int i = 0; i < intentos && !correcto; i++) {
System.out.print("Ingrese contraseña: ");
contraseña = teclado.next();
if (contraseña.equals(clave)) {
System.out.println("EnArturo");
correcto = true;
} else {
System.out.println("Equivocacion de Contraseña");
}
}
}
***********************************************************************************
*************************
ejerccio
Hacer un programa que pida una entrada de teclado y usando condicionales,

que use el método length de la clase String y el método substring de la clase
String, (investigar)
para lo siguiente
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. ( un mensaje para cada caso)
b) Si la cadena introducida comienza por la letra "a" ó "A", (mensaje)
Ejemplo 1: 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”.
ejemplo 2: se pide la entrada y el usuario introduce “ahora vamos a salir a

divertirnos”.
Por pantalla se debe mostrar: “La cadena introducida tiene mas de 15 caracteres y
comienza por a”.
package practica.pkg21;
public class Practica21 {
public static void main(String[] args)
{
String numero, numero_2;
int Conclusion_caracteres;
System.out.print("Ingrese la cadena :");
numero= teclado.nextLine();
Conclusion_caracteres = numero.length();
numero_2 = numero.substring(0, 1);
if (Conclusion_caracteres >= 5) {
if (Conclusion_caracteres <= 15) {
System.out.print("la cadena ingresada tiene entre 5 a 15 caracteres");
} else {
System.out.print("la cadena ingresada supera los 15 caracteres");
}
} else {
System.out.print("la cadena ingresada es menor a 5 caracteres");
if (numero_2.equals("a") || numero_2.equals("A")) {
System.out.println(" y comienza con A");
} else {
System.out.println(" y no comienza con A");
}
}
Ejercicio 2
Dada una cadena cad, y un caracter car, ( ambos se deben ingresar por teclado)
verificar cuántas veces se repite el carácter car en la cadena cad
por ejemplo:
Entrada: cad = "casa blanca", car = 'a'
Salida: El caracter 'a' se repite 4 veces
// hints :usar for (para recorrer la cadena ingresada),

nextLine(),
next().charAt(0)
length :::
package arturo1;
public class Arturo1 {

System.out.println("Ingrese la cadena:");
String cadena = sc.nextLine(); //leemos la cadena
System.out.println("Ingrese el caracter a buscar:");
String caracter = sc.next(); //ya que no contamos con un metodo especifico para
//los caracteres entonces leemos como cadena, luego obtenemos el primer
//caracter para almacenarlo en un char, que seria el char que debemos buscar en
//la primera cadena ingresada
char car = caracter.charAt(0);
int cantidadRepeticiones = 0;
//iteramos hasta que el indice sea menor al tamanio de la cadena
for (int i = 0 ; i < cadena.length() ; i++) {
char aux = cadena.charAt(i); //obtenemos el caracter en la posicion i
if (aux == car) {
cantidadRepeticiones++;
}
}
//mostramos por pantalla la cantidad de repeticiones
System.out.println("La cantidad de repeticiones es: " + cantidadRepeticiones);
}
}
}
***********************************************************************************
************
1. Hacer un programa que muestre las tablas de multiplicar del 1 al 12.
public class JavaApplication9 {

System.out.print("ingrese rango inicial: ");
int n = teclado.nextInt();
System.out.print("ingrese rango final: ");

int m = teclado.nextInt();
for(int i = n; i <= m; i++ ) {

System.out.println("----Multiplicar por " + i + "-----");
for(int j = 1; j <= 9; j++ ) {
System.out.println( i + " x " + j + " = " + (i*j) ) ;
}
System.out.println();
}
}
}
***********************************************************************************
****************
2. Muestra los números del 1 al 100 (ambos incluidos) divisibles entre 2 y 3.
package javaapplication10;
System.out.println("del 1 al 100 divisibles a 2 y 3");

for (int i = 1; i <= 100; i++) {
if ((i % 2 == 0 && i % 3 == 0) || (i == 1 || i == 100)) {
System.out.print(i + "\t");
}
}
System.out.print("\n");
}
***********************************************************************************
******************************
1. hacer un programa que llene un arreglo con los "n" primeros números primos.
luego los muestre por
pantalla con su respectiva posición dentro del arreglo.
static Scanner entrada = new Scanner(System.in);
boolean band, a;
int numero , j = 0, s = 2, m;
System.out.print("cuantos primos desea generar ? : ");
numero = entrada.nextInt();
for (int x = 1; x <= numero; x++){

a = false;
while(!a){
m = 2;
band = true;
while ((band) && (m < s)){
if (s % m == 0)
band =false ;
else
m = m + 1;
}
if (band){
j = j + 1;
System.out.print("El primo numero " + j + " es " + s );
a = true;
}
s = s + 1;
}
}
}
}
***********************************************************************************
*
2. Ordena este arreglo de números .
num[0] = 4;
num[1] = 12;
num[2] = 9;
num[3] = 10;
num[4] = 1;
public class Trabajo {
int num[] = new int[5];

int aux1;
num[0] = 4;
num[1] = 12;
num[2] = 9;
num[3] = 10;
num[4] = 1;
for (int i = 0; i < num.length; i++) {
for (int j = 0; j < num.length; j++) {
if (num[i] <= num[j]) {
aux1 = num[i];
num[i] = num[j];
num[j] = aux1;
} else {
for (int i = 0; i < num.length; i++) {
System.out.println(num[i]);
}
}
***********************************************************************************
***************
Matrices
public class ejercicio1 {

Crear un array bidimensional de tamaño 7x7 y rellénalo de forma que los elementos
de la diagonal
principal sean 1 y el resto 0. Muéstra el array por pantalla en forma de cuadrado.
public static void main(String[] arg) {
int matriz[][] = new int[7][7];
matriz[0][0] = 1;
matriz[1][1] = 1;
matriz[2][2] = 1;
matriz[3][3] = 1;
matriz[4][4] = 1;
matriz[5][5] = 1;
matriz[6][6] = 1;
for (int i = 0; i < matriz.length; i++) {

for (int j = 0; j < matriz.length; j++) {
System.out.print(matriz[i][j] + "\t");
}
}
}
***********************************************************************************
************************
ejerccio 2
Dada una matriz Z almacenar en un vector A la suma por sus columnas y en un vector
B la suma por sus filas
int fila = 3;
int columna = 3;
int a[][] = new int[fila][columna], b[] = new int[20];
int c[] = new int[a.length];
int contador = 1;
for (int i = 0; i < fila; i++) {
for (int j = 0; j < columna; j++) {
a[i][j] = contador;
System.out.print(a[i][j] + "\t");
contador++;
b[i] = b[i] + a[i][j];
}
System.out.print("==>" + b[i] + "\t");
}
for (int i = 0; i < fila; i++) {
for (int j = 0; j < columna; j++) {
c[j] = c[j] + a[i][j];

}
}
for (int i = 0; i < a.length; i++) {
System.out.print(c[i] + "\t");
}
***********************************************************************************
********************
public class ejercicio 3 {
public static void main(String[] arg) {

int [] [] miMatriz = { {1,2,3},{4,5,6},{7,8,9} };
int [] [] miMatrizTraspuesta = new int [3][3];
System.out.print(" la matriz original es: ");

for (int i = 0;i < miMatriz.length;i++)
{
for (int j = 0;j < miMatriz.length;j++)
System.out.print(" miMatriz[i][j] +"\t");
}
System.out.print("");
}
for (int i = 0;i < miMatriz.length;i++)
{
for (int j = 0;j < miMatriz.length;j++)
{
miMatrizTraspuesta [j][i] = miMatriz [i] [j];
***********************************************************************************
**************
Programa que lee por teclado números enteros y los guarda en

una matriz de n filas y m columnas.
A continuación muestra los valores leídos, el mayor y el menor
y las posiciones que ocupan.
1.Programa que lee por teclado números enteros y los guarda en

una matriz de n filas y m columnas. ( no ingresarlas por teclado)
A continuación muestra los valores leídos, el mayor y el menor
y las posiciones que ocupan.

Scanner datos=new Scanner(System.in);
int filas, columnas, num, menor = 999, mayor = 0;

String indicemen = "", indicemay = "";
System.out.print("Ingresa el numero de filas: ");

filas = datos.nextInt();
System.out.print("Ingresa el numero de columnas: ");
columnas = datos.nextInt();
int[][] array = new int[filas][columnas];
for (int i = 0; i < filas; i++) {

for (int j = 0; j < columnas; j++) {
System.out.print("Ingresa un valor para el indice [" + i + "][" + j + "] : ");
num = datos.nextInt();
array[i][j] = num;
}
}
System.out.print("\nArray ingresado:\n");
System.out.print(" " + array[i][j] + " ");
}
System.out.println("");
}

if (array[i][j] <= menor) {
menor = array[i][j];
indicemen = "[" + (i +1) + "][" + (j+1) + "]";
}
if (array[i][j] >= mayor) {
mayor = array[i][j];
indicemay = "[" + (i+1) + "][" + (j+1) + "]";
}
}
}
System.out.println("El menor numero de la matriz es: "+menor);
System.out.println("Se encuentra en el indice: "+indicemen);
System.out.println("El mayor numero de la matriz es: "+mayor);
System.out.println("Se encuentra en el indice: "+indicemay);
}
}
***********************************************************************************
**************************************
2. Crear una matriz de 4×4 de números enteros que inicialmente esta vacía, nos
piden hacer un menú con estas opciones:
Rellenar TODA la matriz de números, debes pedírselo al usuario.
Suma de una fila que se pedirá al usuario (controlar que elija una correcta)
Suma de una columna que se pedirá al usuario (controlar que elija una correcta)
Sumar la diagonal principal (ver ejemplo)
Sumar la diagonal inversa (ver ejemplo)
La media de todos los valores de la matriz
IMPORTANTE: hasta que no se haga la primera opción, el resto de opciones no se
deberán de ejecutar,
simplemente mostrar un mensaje donde diga que debes rellenar la matriz.
public class CGTSesion509 {

Scanner sn = new Scanner(System.in);
//Matriz cuadrada de 4x4

int matriz[][] = new int[4][4];
//Variables utilizadas
boolean salir = false;
int opcion, fila, columna;
//Utilizado para indicar si hemos entrado en la opcion

boolean rellenado = false;
//Menu
do {
//Mensajes del menu
System.out.println("Menu:");
System.out.println("1. Rellenar Matriz");
System.out.println("2. Sumar fila");
System.out.println("3. Sumar columna");
System.out.println("4. Suma diagonal principal");
System.out.println("5. Suma diagonal inversa");
System.out.println("6. Media elementos");
System.out.println("7. Salir");
System.out.println(" ");
System.out.print("Elijir una opcion: ");
opcion = sn.nextInt();
switch (opcion) {
case 1:
rellenarMatriz(sn, matriz);
//Ahora si podemos acceder al resto de opciones

rellenado = true;
break;
case 2:
if (rellenado) {
//Validamos la fila
do {
System.out.print("Elige una fila: ");
fila = sn.nextInt();
} while (!(fila >= 0 && fila < matriz.length));
System.out.println("La suma de los valores de la fila [" + fila
+ "] es: " + sumaFila(matriz, fila));
System.out.println("--------------------------------------------");
} else {
System.out.println("*Debes rellenar la matriz primero*");
System.out.println("-----------------------------------");
}
break;
case 3:
if (rellenado) {
//Validamos la colunma
do {
System.out.print("Elige una columna: ");
columna = sn.nextInt();
} while (!(columna >= 0 && columna < matriz.length));
System.out.println("La suma de los valores de la columna [" + columna
+ "] es: " + sumaColumna(matriz, columna));
} else {
}
break;
case 4:
if (rellenado) {
System.out.println("La suma de la diagonal principal es: " +
sumaDiagonalPrinc(matriz));
} else {
}
break;
case 5:
if (rellenado) {
System.out.println("La suma de la diagonal inversa es: " +
sumaDiagonalInversa(matriz));
} else {
}
break;
case 6:
if (rellenado) {
System.out.println("La media de los valores de la "
+ "matriz es de: " + media(matriz));
System.out.println("------------------------------------------------");
} else {
}
break;
case 7:
salir = true;
break;
default:
System.out.println("*Tienes que meter un valor entre 1 y 7*");
System.out.println("----------------------------------------");
}
} while (!salir);
System.out.println("FIN");
System.out.println("***********");
}
public static void rellenarMatriz(Scanner sn, int[][] matriz) {

for (int j = 0; j < matriz[0].length; j++) {
System.out.print("Escribe un numero en la posicion ["+i+"] ["+j+"] : ");
matriz[i][j] = sn.nextInt();
}
}System.out.println("------------------------------------------");
}
public static int sumaFila(int[][] matriz, int fila) {
int suma = 0;
for (int j = 0; j < matriz.length; j++) {

suma += matriz[fila][j];
}
return suma;
}
public static int sumaColumna(int[][] matriz, int columna) {
int suma = 0;

suma += matriz[i][columna];
}
return suma;
}
public static int sumaDiagonalPrinc(int[][] matriz) {
int suma = 0;
for (int i = 0, j = 0; i < matriz.length; i++, j++) {

suma += matriz[i][j];
}
return suma;
public static int sumaDiagonalInversa(int[][] matriz) {
int suma = 0;
for (int i = 0, j = 3; i < matriz.length; i++, j--) {

}
return suma;
}
public static double media(int[][] matriz) {

double suma = 0, media;

for (int j = 0; j < matriz[0].length; j++) {
}
}
media = suma / (matriz.length * matriz.length);
return media;
}
}
***********************************************************************************
1. Escribe en Java una clase Temperatura que convierta de grados Celsius a

Farenheit y viceversa. Para ello crea dos métodos:
double celsiusToFarenheit(double)
double farenheitToCelsius(double)
Recuerda que, para convertir de una unidad a otra, la fórmula adecuada es:
De Farenheit a Celsius: C = (F – 32) / 1,8
De Celsius a Farenheit: F = (1,8) x C + 32
Escribe también un método main() para poder probar los métodos anteriores a
partir de un número introducido por el usuario del programa
package ClasesPoo;
class Temperatura {
private double tempF, tempC;
public void setFarenheit(double f)
{
tempF = f;
}
public void setCelsius(double c)
{
tempC = c;
}
// Convierte de grados C a grados F
public double celsiusToFarenheit()

{
return (1.8*tempC)+32;
}
// Convierte de grados F a grados C
public double farenheitToCelsius()
{
return (tempF-32)/1.8;
}
}
package ClasesPoo;
class TemperaturaPrueba {

{
int c = 100;
int f = 212;
Temperatura convTemp
Temperatura convTemp = new Temperatura();
convTemp.setCelsius(c);
convTemp.setFarenheit(f);
System.out.println(c + " Grados Celsius son " +
convTemp.celsiusToFarenheit() + " grados Farenheit");
System.out.println(f + " Grados Farenheit son " +
convTemp.farenheitToCelsius() + " grados Celsius");
}
}
***********************************************************************************
*********************
2. Escribe una clase llamada ConversorDivisas que convierta soles a dolares y
viceversa, mediante dos métodos llamados solesTodolares() y
dolaresTosoles(). La clase contará con dos constructores.
El constructor ConversorDivisas() establecerá el tipo de cambio en 0,85.
El constructor ConversorDivisas(double) permitirá configurar el tipo de
cambio al crear el objeto.
Como en el ejercicio anterior, también debes escribir un método main() que
te permita comprobar que el programa funciona correctamente a partir de
datos introducidos por teclado
public class ConversorDivisas {

private double tipoCambio ;
public ConversorDivisas()
{
tipoCambio = 3.40;
}
public ConversorDivisas(double tc)

{
tipoCambio = tc;
}
public double getsolestodolares (double e)

{
return e * tipoCambio;
}
public double getdolarestosoles (double d)
{
return d / tipoCambio;
}
public void settipocambio (double tc)

{
tipoCambio = tc;
}
public double getTipocambio ()

{
return tipoCambio;
}
}
/**
*
* @author Luis
*/
public class FinazasPrueba {
{
Scanner teclado = new Scanner (System.in);
System.out.println ("Que tipo de cambio quieres ?");
double tipo = teclado.nextDouble();
// f1 convertirá con el tipo de cambio por defecto (3.4)
ConversorDivisas f1 = new ConversorDivisas();
// f2 convertirá con el tipo de cambio por defecto (3.4)

ConversorDivisas f2 = new ConversorDivisas(tipo);
double dolares = 100.0;
double soles = 100.0;
System.out.println("Con el tipo de cambio = ");
System.out.println(f1.getTipocambio()+ ":");
System.out.println(dolares + " Soles son ");
System.out.println(f1.getsolestodolares(soles) + " Dólares.");
System.out.println(soles + " Dólares son ");
System.out.println(f1.getdolarestosoles(dolares) + " Soles.\n");
System.out.println("Con el tipo de cambio = ");
System.out.println(f2.getTipocambio()+ ":");
System.out.println(dolares + " Dólares son ");
System.out.println(f2.getsolestodolares(soles) + " Soles.");
System.out.println(soles + " Soles son ");
System.out.println(f2.getdolarestosoles(dolares) + " Dólares");
}
***********************************************************************************
*********************
3.Escribe en Java una clase llamada MiNumero que calcule el doble, el triple y
el cuádruple de un número y permita sumarlo y restarlo con otros números.
Los métodos de la clase deben ser:
Constructor sin parámetros (establecerá el número a cero)
Constructor con parámetro entero (asignará ese valor al número)
Método cambiaNumero(int): permite asignar un nuevo valor al número
Método suma(int): permite sumar una cantidad al número
Método resta(int): permite restar una cantidad al número
Método getValor(): devuelve el valor actual del número
Método getDoble(): devuelve el doble del valor actual del número
Método getTriple(): devuelve el triple del valor actual del número
Método getCuádruple(): devuelve el cuádruple del valor actual del
número.
/**
*
* @author Luis
*/
class MiNumero {
private int n;
// Constructor sin parámetros: establece el número a 0
MiNumero() {
n = 0;
}
// Constructor parametrizado para establecer valor del número
MiNumero(int num) {
n = num;
}
// Asigna un nuevo valor al número
void cambiaNumero(int num) {

n = num;
}
// Suma una cantidad al número
void suma(int num) {

n = n + num;
}
// Resta una cantidad al número
void resta(int num) {

n = n - num;
}
// Devuelve el valor actual del número
int getValor() {
return n;
}
// Devuelve el doble del valor actual del número
int getDoble() {
return n * 2;
}
// Devuelve el triple del valor actual del número
int getTriple() {
return n * 3;
}
// Devuelve el cuádruple del valor actual del número
int getCuadruple() {
return n * 4;
}
}
class MiNumeroPrueba {

MiNumero n1 = new MiNumero(); // Crea un número con valor 0
System.out.print("Por favor, introduzca un número entero: ");
int x = teclado.nextInt();
MiNumero n2 = new MiNumero(x); // Crea un número con valor x
n1.cambiaNumero(5); // Asigna un nuevo valor (5) al número n1
n1.resta(1); // Resta 1 al número n1 (ahora n1 valdrá 4)
n2.suma(n1.getValor()); // Suma a n2 el valor de n1
System.out.println("\n\nPROBANDO LA CLASE miNumero\n\n");
System.out.println("NÚMERO n1");
System.out.println(" Valor actual = " + n1.getValor());
System.out.println(" Doble = " + n1.getDoble());
System.out.println(" Triple = " + n1.getTriple());
System.out.println(" Cuádruple = " + n1.getCuadruple() + "\n");
System.out.println("NÚMERO n2");
System.out.println(" Valor actual = " + n2.getValor());
System.out.println(" Doble = " + n2.getDoble());
System.out.println(" Triple = " + n2.getTriple());
System.out.println(" Cuádruple = " + n2.getCuadruple() + "\n");
}
}
NÚMERO n1
Valor actual = 4
Doble = 8
Triple = 12
Cuádruple = 16
NÚMERO n2
Valor actual = 9
Doble = 18
Triple = 27
Cuádruple = 36
***********************************************************************************
*********************
4.Crea una clase llamada Peso que tenga estas características:
Un constructor al que se le pase un peso y la unidad de medida en la que
está tomado, que puede ser Lb (libras), Oz (onzas), Kg (kilogramos) o g
(gramos)
Un método getLibras() que nos devuelva el peso en libras.
Un método getOnzas() que nos devuelva el peso en onzas.
Un método getPeso() que nos devuelve el peso en kilogramos.
Puedes encontrar en Internet las equivalencias entre estas unidades de
medida.
public class Peso {

double peso_in;
String unidad_in;
private double gramos = 0;
public Peso (double peso, String unidad)
{
switch (unidad)
{
case "gr":
{
peso_in = peso;
}break;
case "lb":
{
peso_in = peso * 453.592;
} break;
case "kg":
{
peso_in = peso * 1000;
}break;
case "oz":
{
peso_in = peso * 28.3495;
}break;
default :
{break;
}
}
}
public double getLibras()

{
return gramos * 0.002205;
}
// Devuelve el peso en onzas
public double getOnzas()
{
return gramos * 0.035274;
}
// Devuelve el peso en kilogramos
public double getPeso() {
return gramos / 1000;
}
// Devuelve el peso en gramos
public double getGramos() {
return gramos;
}
class PesoPrueba {

Peso p1 = new Peso(10, "oz"); // 10 onzas
Peso p2 = new Peso(10, "lb"); // 10 libras
Peso p3 = new Peso(10, "kg"); // 10 kilogramos
Peso p4 = new Peso(10, "gr"); // 10 gramos
System.out.println("PROBANDO EL METODO getPeso():");
System.out.println("Diez onzas son " + p1.getPeso() + " kg");
System.out.println("Diez libras son " + p2.getPeso() + " kg");
System.out.println("Diez kilogramos son " + p3.getPeso() + " kg");
System.out.println("Diez gramos son " + p4.getPeso() + " kg");
System.out.println("PROBANDO EL RESTO DE GETTERS:");
System.out.println("Diez kg son " + p3.getOnzas() + " oz");
System.out.println("Diez kg son " + p3.getLibras() + " lb");
System.out.println("Diez kg son " + p3.getGramos() + " gr");
}
}
***********************************************************************************
*********************
5.Programa una clase Distancia con dos métodos:
millasAMetros(): tomará como parámetro una distancia expresada en
millas y la transformará en kilómetros.
millasAKilometros(): hará lo mismo, pero convirtiendo las millas en
kilómetros.
(Una milla marina equivale a 1852 metros).
class Distancia {
public double millasAMetros(double millas) {
double metros;
metros = millas * 1852;
return metros;
}
public double millasAKilometros(double millas) {
double km;
km = millas * 1.852;
return km;
}
}
class DistanciaPrueba {
// 1. Leer una cantidad de millas por teclado
System.out.println("Introduce una cantidad de millas: ");
double millas = Double.parseDouble(System.console().readLine());
Distancia d = new Distancia();
// 2. Convertir las millas a metros y guardarlo en una variable
double metros = d.millasAMetros(millas);
// 3. Convertir las millas a km y guardarlo en otra variable
double km = d.millasAKilometros(millas);
// 4. Mostrar los metros y los km
System.out.println(m + " millas son " + metros + " metros");
System.out.println(m + " millas son " + km + " km");
}
}
***********************************************************************************
*********************
6. En un restaurante especializado en huevos fritos con chorizo necesitan un
programa que les calcule cuántos platos de huevos con chorizo pueden
preparar con la cantidad de existencias disponibles en la cámara frigorífica.
Escribe los siguientes métodos:
constructor(int, double): recibirá el número de docenas de huevos y de
kilos de chorizo disponible en el frigorífico.
addHuevos(int): incrementa el número de docenas de huevos.
addChorizos(double): incrementa el número de kilos de chorizo.
getNumPlatos(): devuelvel el número de platos de huevos con chorizo
que se pueden ofrecer con las existencias actuales, teniendo en cuenta
que cada plato necesita una media de 2 huevos y 200 gramos de chorizo.
sirvePlato(): disminuye el número de huevos y de kilos de chorizo
porque se ha servido un plato (2 huevos menos y 200 gramos de chorizo
menos)
getHuevos(): devuelve el número de huevos (no de docenas) que quedan
en la cámara.
getChorizo(): devuelve el número de kilos de chorizo que quedan en la
cámara.
class Restaurante {
private int huevos; // Número de huevos
private int chorizo; // Gramos de chorizo
// Constructor: inicializa los valores de huevos y chorizo
Restaurante(int docenasDeHuevos, double kgDeChorizo) {
// Guardaremos el nº total de huevos, no de docenas
huevos = docenasDeHuevos * 12;
// Guardaremos la cantidad de chorizo en gramos, no en Kg
chorizo = (int) (kgDeChorizo * 1000);
}
// Incrementa el número de huevos
void addHuevos(int num) {
huevos = huevos + (num * 12);
}
// Incrementa la cantidad de gramos de chorizo. El método recibe la
// cantidad expresada en kg, así que la multiplicamos por 1000.
void addChorizo(double num) {
chorizo = (int)(chorizo + (num * 1000));
}
// Calcula cuántos platos se pueden cocinar con las cantidades
// actuales de huevos y chorizo.
int getNumPlatos() {
// Calculamos nº platos posibles con los huevos actuales
int n1 = huevos / 2; // Cada plato necesita 2 huevos
// Calculamos nº platos posibles con los chorizos actuales
int n2 = chorizo / 200; // Cada plato necesita 200 gr de chorizo
// El nº máximo de platos que se pueden preparar
// será el menor entre n1 y n2.
if (n1 < n2) {
return n1;
}
else {
return n2;
}
}
// Resta una cantidad al número de huevos y chorizos,
// como resultado de haber servido un plato
// (2 huevos menos y 200 gr de chorizo menos).
void sirvePlato() {
huevos = huevos - 2;
chorizo = chorizo - 200;
}
// Devuelve el número actual de huevos.
int getHuevos() {
return huevos;
}
// Devuelve el número actual de kg de chorizo.
double getChorizo() {
return ((double)chorizo / 1000);
}
}
class RestaurantePrueba {
// Creamos un restaurante de prueba
// con 4 docenas de huevos y 10 kg de chorizo
Restaurante rest = new Restaurante(4,10);
System.out.println("\n\nPROBANDO LA CLASE restaurante\n\n");
System.out.println("Estado inicial:");
System.out.println("Huevos = " + rest.getHuevos());
System.out.println("Chorizo = " + rest.getChorizo() + " kg");
System.out.print("Número de platos que se pueden preparar = ");
System.out.println(rest.getNumPlatos());
rest.addHuevos(2); // Añadimos dos docenas de huevos
rest.addChorizo(9); // Añadimos nueve kg de chorizo
System.out.println("Estado después de añadir huevos y chorizo:");
System.out.println(“Chorizo = " + rest.getChorizo() + " kg");
rest.sirvePlato(); // Servimos un plato
System.out.println("Estado después de servir un plato:");
rest.sirvePlato(); // Servimos cinco platos
rest.sirvePlato();
rest.sirvePlato();
rest.sirvePlato();
rest.sirvePlato();
System.out.println("Estado después de servir cinco platos más:");
}
}
***********************************************************************************
*********************
7.Se desea construir una clase capaz de convertir cualquier medida de
información en cualquier otra. Al constructor se le pasará un número
entero y una unidad de medida, y existirán métodos para convertir a
cuaquier otra unidad. Por ejemplo:
getByte(): devolverá la cantidad expresada en Bytes.
getBits(): devolverá la cantidad expresada en bits.
getGb(): devolverá la cantidad expresada en gigabits
getMB(): devolverá la cantidad expresada en gigabytes
getMiB(): devolverá la cantidad expresada en mebibytes
Etc.
***********************************************************************************
*****
17. Una empresa que se dedica a la venta de desinfectantes necesita un programa

para gestionar las
facturas. En cada factura figura: el código del artículo, la cantidad vendida en
litros y el
precio por litro.
Se pide de 5 facturas introducidas: Facturación total, cantidad en litros vendidos
del artículo 1
y cuantas facturas se emitieron de más de 600 €.
package bol02ej17;
public class Main {
int codigo; // el código del artículo en cada factura
int litros; // la cantidad de litros en cada factura
float precio; // el precio por litro en cada factura
float importe_factura; // guardará el importe de la factura con la que estemos
trabajando
float facturacion_total; // el importe de todas las facturas
int litros_cod1; // el total de litros vendidos del producto 1 en todas las
facturas
int mas_600; // contador que sirve para llevar la cuenta de cuantas facturas hay de
más de 600 €
facturacion_total = 0;
litros_cod1 = 0;
mas_600 = 0;
for (int i=1;i<=5;i++)
{
System.out.println("Factura nº " + i);
System.out.print("código de producto: ");
codigo=Entrada.entero();
System.out.print("cantidad (litros): ");
litros=Entrada.entero();
System.out.print("precio (litro): ");
precio= (float)Entrada.real();
importe_factura = litros*precio;
facturacion_total += importe_factura;
if (codigo == 1)
litros_cod1 += litros;
if(importe_factura >= 600)
mas_600 ++;
}
System.out.println("\n\n\nResumen de ventas\n");
// facturación total
System.out.println("La facturación total es de: " +facturacion_total + "€");
// litros del articulo 1

System.out.println("Ventas del producto 1: " + litros_cod1 + " litros");
// factura de mas de 600 euros

System.out.println("Factura superior a 600€: " + mas_600);
}
}
18. Igual que el anterior pero suponiendo que no se introduce el precio por litro.
Solo existen tres
productos con precios:
1- 0,6 €/litro, 2- 3 €/litro y 3- 1,25 €/litro.
package bol02ej18;
public class Main {
int codigo; // el código del artículo en cada factura
int litros; // la cantidad de litros en cada factura
float precio; // ahora el precio no se pide por teclado
float importe_factura; // guardará el importe de la factura con la que estemos
trabajando
float facturacion_total; // el importe de todas las facturas
int litros_cod1; // el total de litros vendidos del producto 1 en todas las
facturas
int mas_600; // contador que sirve para llevar la cuenta de cuantas facturas hay
de
más de 600 €
facturacion_total = 0;
litros_cod1 = 0;
mas_600 = 0;
for (int i=1;i<=5;i++)
{
System.out.println("Factura nº " + i);
System.out.print("código de producto: ");
codigo=Entrada.entero();
System.out.print("cantidad (litros): ");
litros=Entrada.entero();
switch (codigo)
{
case 1:
precio = 0.6f;
break;
case 2:
precio = 3f;
break;
case 3:
precio = 1.25f;
break;
default:
precio = 0; // este caso no debe darse
}
importe_factura = litros*precio;
facturacion_total += importe_factura;
if (codigo == 1)
litros_cod1 += litros;
if(importe_factura >= 600)
mas_600 ++;
}
System.out.println ("\n\n\nResumen de ventas\n");
// facturación total
System.out.println("La facturación total es de: " +facturacion_total + "€");
// litros del articulo 1
System.out.println("Ventas del producto 1: " + litros_cod1 + " litros");
// factura de mas de 600 euros

System.out.println("Factura superior a 600€: " + mas_600);
***********************************************************************************
******************
Planteamiento del Problema

El usuario le solicita desarrollar un programa para cálculo de impuestos sobre
ventas.
Este programa tiene como propósito calcular el valor que debe pagarse por concepto
de impuesto sobre ventas e
impuesto al activo neto para un monto dado por el usuario.
Ud. Desarrolla el programa utilizando sus conocimientos adquiridos en Programación
Estructurada, para hacer dos
versiones, una utilizando un estilo procedural, y la otra utilizando un estilo
modular.
Cuando termina el programa y lo muestra al usuario, él le dice que el programa está
bien, pero que también necesita
que para el mismo monto se calcule el impuesto al activo neto.
A continuación se muestra el desarrollo de este ejercicio utilizando tres técnicas
o estilos: Programación Procedural,
Programación Modular y Programación Orientada a Objetos. El funcionamiento del
programa será prácticamente el
mismo en los tres casos, pero observará que utilizando POO el mantenimiento y
extensión del programa se va haciendo
más fácil.
// Programación Procedural: Cálculo de un impuesto
#include <iostream>
using namespace std;
int main()
{ // Definiendo variables
double tasaISV;
double impuestoCalculadoISV;
double valor;
// Capturando valores
cout << "Tasa de Impuesto sobre ventas: ";
cin >> tasaISV;
cout << "\nValor: ";
cin >> valor;
// Cálculos
impuestoCalculadoISV = valor * tasaISV;
// Mostrando resultados
cout << "Para un valor de : " << valor << " y una tasa de: " << tasaISV
<< " el valor de Impuesto sobre Ventas es:" << impuestoCalculadoISV << endl;
system("pause");
return 0;
}
// Programación Procedural: Cálculo de dos impuestos

#include <iostream>
int main()
{
// Definiendo variables
double tasaISV;
double impuestoCalculadoISV;
double tasaIAN;
double impuestoCalculadoIAN;
double valor;
cout << "Tasa de Impuesto sobre ventas: ";
cin >> tasaISV;
cout << "Tasa de Impuesto al activo neto: ";
cin >> tasaIAN;
cin >> valor;
// Cálculos
impuestoCalculadoISV = valor * tasaISV;
impuestoCalculadoIAN = valor * tasaIAN;
cout << "Para un valor de : " << valor << " y una tasa de: " << tasaISV
<< " el valor de Impuesto sobre Ventas es:" << impuestoCalculadoISV << endl;
cout << "Para un valor de : " << valor << " y una tasa de: " << tasaIAN
<< " el valor de Impuesto al Activo Neto es:" << impuestoCalculadoIAN << endl;
Capítulo: Primer Parcial
1
4
system("pause");
return 0;
}
// Programación Modular: Cálculo de un solo impuesto

#include <iostream>
double calcularImpuesto(double, double);
void capturar(double &, double &);
void imprimir(double, double);
int main()
{
double tasaISV;
double valor;
capturar(tasaISV, valor);
imprimir(tasaISV, valor);
system("pause");
return 0;
}
void capturar(double &tISV, double &vlr)
{ cout << "\nTasa de Impuesto sobre ventas: ";
cin >> tISV;
cin >> vlr;
}
void imprimir(double tISV, double vlr)
{
cout << "Para un valor de : " << vlr << " y una tasa de: " << tISV
<< " el valor de Impuesto sobre Ventas es:" << calcularImpuesto(vlr, tISV) << endl;
}
double calcularImpuesto(double v, double t)
{ return v * t;
}
// Programación Modular: Cálculo de dos impuestos

#include <iostream>
double calcularImpuesto(double, double);
void capturar(double &, double &, double &);
void imprimir(double, double, double);
int main()
{
double tasaISV;
double tasaIAN;
double valor;
capturar(tasaISV, tasaIAN, valor);
imprimir(tasaISV, tasaIAN, valor);
system("pause");
return 0;
}
void capturar(double &tISV, double &tIAN, double &vlr)
{
cout << "\nTasa de Impuesto sobre ventas: ";
cin >> tISV;
cout << "\nTasa de Impuesto al activo neto: ";
cin >> tIAN;
cin >> vlr;
}
void imprimir(double tISV, double tIAN, double vlr)
{
cout << "Para un valor de : " << vlr << " y una tasa de: " << tISV
<< " el valor de Impuesto sobre Ventas es:" << calcularImpuesto(vlr, tISV) << endl;
cout << "Para un valor de : " << vlr << " y una tasa de: " << tIAN
<< " el valor de Impuesto al Activo Neto es:" << calcularImpuesto(vlr, tIAN) <<
endl;
}
Capítulo: Primer Parcial 15
double calcularImpuesto(double v, double t) {
return v * t;
}
// PROGRAMACIÓN ORIENTADA A OBJETOS: Cálculo de un impuesto
#include <iostream>
class impuesto {
public:
// Funciones miembro
void capturar();
double calcularImpuesto(double);
void imprimir(double);
// Datos miembro
char nombre [25];
double tasa;
};
int main() {
// Definiendo variables y objetos
impuesto ISV;
double valor;
ISV.capturar();
cout << "Valor: ";
cin >> valor;
ISV.imprimir(valor);
system("pause");
return 0;
}
void impuesto::capturar() {
cin.ignore();
cout << "Nombre de impuesto: ";
cin.getline(nombre, 25);
cout << "Tasa: ";
cin >> tasa;
}
void impuesto::imprimir(double v) {
cout << "Para un valor de : " << v << " y una tasa de: " << tasa
<< " el valor de " << nombre << " es: " << calcularImpuesto(v) << endl;
}
double impuesto::calcularImpuesto(double v) {
return v * tasa;
}
// PROGRAMACIÓN ORIENTADA A OBJETOS: Cálculo de dos impuestos
#include <iostream>
class impuesto {
public:
// Funciones miembro
void capturar();
double calcularImpuesto(double);
void imprimir(double);
// Datos miembro
char nombre [25];
double tasa;
};
int main() {
// Definiendo variables y objetos
impuesto ISV;
impuesto IAN;
double valor;
ISV.capturar();
IAN.capturar();
Capítulo: Primer Parcial
1
6
cout << "Valor: ";
cin >> valor;
ISV.imprimir(valor);
IAN.imprimir(valor);
system("pause");
return 0;
}
// Las Funciones pertenecen a la clase, no al programa principal…
void impuesto::capturar()
{
cin.ignore();
cout << "Nombre de impuesto: ";
cin.getline(nombre, 25);
cout << "Tasa: ";
cin >> tasa;
}
void impuesto::imprimir(double v)
{
cout << "Para un valor de : " << v << " y una tasa de: " << tasa
<< " el valor de " << nombre << " es: " << calcularImpuesto(v) << endl;
}
double impuesto::calcularImpuesto(double v)
{
return v * tasa;
}
// Salida del programa (Con Programación Procedural y Modular)

Tasa de Impuesto sobre ventas: 0.12
Tasa de Impuesto al activo neto: 0.20
Valor: 150000
Para un valor de : 150000 y una tasa de: 0.12 el valor de Impuesto sobre Ventas
es:18000
Para un valor de : 150000 y una tasa de: 0.2 el valor de Impuesto al Activo Neto
es:30000
Press any key to continue . . .
// Salida del programa (Con Programación Orientada a Objetos)

Nombre de impuesto: Impuesto Sobre Ventas
Tasa: 0.12
Nombre de impuesto: Impuesto al Activo Neto
Tasa: 0.20
Valor: 150000
Para un valor de : 150000 y una tasa de: 0.12 el valor de Impuesto Sobre Ventas es:
18000
Para un valor de : 150000 y una tasa de: 0.2 el valor de Impuesto al Activo Neto
es: 30000
Press any key to continue . . .
*****************************************************
Ejercicios Resueltos del libro

“
Una amigable Introducción a la Programacióncon Java, C++ y Visual Basic
”
de los algoritmos resueltos mediante larepresentación de seudo código, by Joseph
EJERCICIOS PROPUESTOS 02
1.
Un restaurante ofrece un descuento de 5% para consumo de hasta s/.100 y un

descuento de 10% paraconsumo mayor, para ambos casos se aplica un impuesto del 19%.
Desarrolle un algoritmo y programación en java,c++ y Visual Basic para determinar
el monto del descuento, el impuesto y el importe a pagar.
Inicio
Variables: {consumo=0, descuento=0,momto_IGV, precio=0}
//EntradaLeer consumo//procesoSi consumo <=100descuento = 0.05*consumoSino Si
consumo >100descuento = 0.10*consumosino
Escribir “Error”
Fin de Simonto_IGV=(consumo-descuento)*0.19precio = consumo-descuento
+monto_IGV//salidaEscribirprecio
Fin
**************************************************************
Un restaurante tiene dos tipos de clientes A y B recibe dos formas de pago

al contado(C) O a plazos (P)Desarrolle un algoritmo y programe en
Java,C++ y Visual basic que permita ingresar el monto de
la compra y seobtenga el monto de descuento o el Monto del Recargo
y el Total a pagar, según la siguiente tabla
Variables { Tipo_cliente, Frm_pago} Caracter
Descuento = 0, Pago_total =0
//Entrada
Leer Pago,Tipo_cliente,Frm_pago
//Proceso
Caso Tipo_cliente
Caso A Si
Frm_pago==”C”
Descuento=Pago*0.20Sino Si
Frm_pago ==”P”
Plazos=Pago*0.10Sino
Imprimir “Error”
Fin de Si
Caso B Si
Frm_pago==”C”
Descuento=Pago*0.15
Sino Si
Frm_pago ==”P”
Plazos=Pago*0.05
Sino
Imprimir “Error”
Fin de Si
Fin de Caso
Pago_total = (pago + Plazos)–Descuento
// salida
Imprimir Pago_total
Fin
Codigo Fuente en VB
Sub Main()
Dim Tipo_cliente, Frm_pagoAs Char
Dim Descuento, Pago_total, Plazos, PagoAs Double
'Entrada
Console.WriteLine("Ingresar monto de Pago")
Pago =Console.ReadLine()
Console.WriteLine("Ingresar tipo de Cliente (A,B)")
Tipo_cliente =Console.ReadLine()
Console.WriteLine("Ingresar Forma de pago (C,P) ")
Frm_pago =Console.ReadLine()
'proceso
Select Case Tipo_cliente
Case "A"
If Frm_pago ="C" Then
Descuento = Pago * 0.2
ElseIf Frm_pago ="P"
Then Plazos = Pago * 0.1
Else
Console.WriteLine("Error al ingresar formas de pago")
Console.Read()
End If
Case "B"
If Frm_pago ="C" Then
Descuento = Pago * 0.15
ElseIf Frm_pago ="P" Then
Plazos = Pago * 0.05
Else Console.WriteLine("Error al ingesar Formas de pago")
Console.Read()
End If
Case Else
Console.WriteLine("Error al ingesar Tipo de cliente")
Console.Read()
End Select
If (Descuento <> 0.0Or Plazos <> 0.0)Then
Pago_total = (Pago + Plazos) - Descuento
'Salida
Console.WriteLine("Total a Pagar = " +Convert.ToString(Pago_total))
Console.Read()
End If
End Sub
End Module
Código fuente c++
#include <iostream>
int main(){
//Declarando variables
char Tipo_cliente,Frm_pago;
float Descuento=0,Pago_total=0,Plazos=0,Pago=0;
//Entrda
cout<<"Ingresar monto de Pago "<<endl;cin>>Pago;
cout<<"Ingresar Tipo de Cliente(A,B) "<<endl;cin>>Tipo_cliente ;
cout<<"Ingresar Forma de Pago(C,P) "<<endl;cin>>Frm_pago ;
//proceso
switch(Tipo_cliente ){
case 'A': {if (Frm_pago=='C' )
Descuento =Pago*0.20;
else if(Frm_pago=='P' )
Plazos = Pago*0.10;
else cout<<"Error al ingresar forma de pago"<<endl;break; }
case 'B': {if (Frm_pago=='C' )
Descuento =Pago*0.15;
Plazos = Pago*0.05;
else cout<<"Error al ingresar forma de pago"<<endl;break;
}
default: cout<<"Error al igresar tipo de Cliente"<<endl;
}
if(Plazos!=0|Descuento !=0 ){
Pago_total =(Pago+Plazos )-Descuento;
//salida
cout<<"Monto Total a pagar = "<<Pago_total <<endl;
}
system ("pause");
return 0;
}
Código fuente en Java

/****
@author Atanacio
*/
public class Problema3 {
// TODO code application logic here
//Declarando variableschar
Tipo_cliente,Frm_pago;
float Descuento=0,Pago_total=0,Plazos=0,Pago=0;
String salida = null;

//EntradaScanner
Entrada= new Scanner(System.in);
System.out.println("Ingresar monto de Pago ");
Pago=Entrada.nextFloat();
System.out.println("Ingresar Tipo de Cliente(A,B) ");
Tipo_cliente= Entrada.next().charAt(0);
System.out.println("Ingresar Forma de Pago (C,P) ");
Frm_pago= Entrada.next().charAt(0);
//proceso
switch(Tipo_cliente ){
case 'A': {if (Frm_pago =='C' )
Descuento =(float) (Pago*0.20);
else if(Frm_pago =='P' )
Plazos = (float) (Pago*0.10);
elsesalida="Error al ingresar forma de pago"; break;
}
case 'B': {if (Frm_pago=='C' )
Descuento =(float) (Pago*0.15);
Plazos = (float) (Pago*0.05);
else
salida="Error al ingresar forma de pago"; break;
}
default: salida="Error al igresar tipo de Cliente";
}
Pago_total =(Pago+Plazos )-Descuento;
//Salida
if(salida!=null){
System.out.println(salida);
System.exit(0);
}
System.out.println("Monto Total a pagar = "+Pago_total );
}
}

Regla de Java

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Regla de Java

Cargado por

Copyright:

Formatos disponibles

Byte : Representa un tipo de dato de 8 bits con signo.

De tal manera que puede

Pedir un número N, y mostrar todos los números del 1 al N. ( Usar while)

public class Numero_Entero {

public class Pregunta3 {

1- Realizar la carga de dos números enteros por teclado e imprimir su suma y su

System.out.println("Ingrese el primer numero:");

System.out.print("La suma de los dos numeros es:");

Hacer un programa que pida una entrada de teclado y usando condicionales,

a) Si la cadena introducida tiene menos de 5 caracteres, entre 5 y 15 caracteres

Ejemplo 1: se pide la entrada y el usuario introduce “vereda”.

ejemplo 2: se pide la entrada y el usuario introduce “ahora vamos a salir a

public static void main(String[] args)

// hints :usar for (para recorrer la cadena ingresada),

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

1. Hacer un programa que muestre las tablas de multiplicar del 1 al 12.

public class JavaApplication9 {

public static void main(String[] args) {

Scanner teclado = new Scanner(System.in);

System.out.print("ingrese rango final: ");

for(int i = n; i <= m; i++ ) {

2. Muestra los números del 1 al 100 (ambos incluidos) divisibles entre 2 y 3.

public class JavaApplication10 {

public static void main(String[] args) {

System.out.println("del 1 al 100 divisibles a 2 y 3");

public class JavaApplication12 {

static Scanner entrada = new Scanner(System.in);

public static void main(String[] args) {

System.out.print("cuantos primos desea generar ? : ");

for (int x = 1; x <= numero; x++){

2. Ordena este arreglo de números .

public class Trabajo {

public static void main(String[] args) {

int num[] = new int[5];

for (int i = 0; i < num.length; i++) {

for (int j = 0; j < num.length; j++) {

if (num[i] <= num[j]) {

for (int i = 0; i < num.length; i++) {

public class ejercicio1 {

public static void main(String[] arg) {

int matriz[][] = new int[7][7];

for (int i = 0; i < matriz.length; i++) {

c[j] = c[j] + a[i][j];

public class ejercicio 3 {

public static void main(String[] arg) {

System.out.print(" la matriz original es: ");

Programa que lee por teclado números enteros y los guarda en

1.Programa que lee por teclado números enteros y los guarda en

public class JavaApplication13 {

Scanner datos=new Scanner(System.in);

int filas, columnas, num, menor = 999, mayor = 0;

System.out.print("Ingresa el numero de filas: ");

int[][] array = new int[filas][columnas];

for (int i = 0; i < filas; i++) {

for (int i = 0; i < filas; i++) {

public class CGTSesion509 {

public static void main(String[] args) {

//Matriz cuadrada de 4x4

//Utilizado para indicar si hemos entrado en la opcion

//Ahora si podemos acceder al resto de opciones

public static void rellenarMatriz(Scanner sn, int[][] matriz) {

for (int i = 0; i < matriz.length; i++) {

public static int sumaFila(int[][] matriz, int fila) {