Вы находитесь на странице: 1из 15

CODIGO

1. USANDO OBJETOS
Rectangulos
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import javax.swing.JComponent;
public class Rectangulos extends JComponent{
public void paintComponent(Graphics g){
Graphics2D g2 = (Graphics2D) g;
Rectangle caja = new Rectangle(75, 75, 50, 50);
//Rectangle caja1 = new Rectangle(100, 115, 80, 160);
g2.setColor(Color.RED);
g2.draw(caja);
//caja.translate(15, 25);
//g2.draw(caja);
g2.setColor(Color.RED);
//g2.draw(caja1);
//caja1.translate(20,20);
//g2.draw(caja1);
//Ellipse2D.Double elipse = new Ellipse2D.Double(5, 10, 80, 80);
//g2.draw(elipse);
//Line2D.Double segmento = new Line2D.Double(0,0,640,480);
//g2.draw(segmento);
g2.drawString("RECTANGULOS", 80,100);
//g2.draw();
}
}
Test rectangulos

import java.awt.Rectangle;
public class TestMovimiento {
public static void main(String[] args) {
Rectangle caja = new Rectangle(5,10,20,30);
caja.translate(15, 25);
System.out.println(caja);
System.out.print("x: ");
System.out.println(caja.getX());
System.out.println("Esperado: 20.0");
System.out.print("y: ");
System.out.println(caja.getY());

System.out.println("Esperado: 35.0");
}

CONTADOR
public class Contador {
private int valor;
public Contador(){
this.valor = 0;
}
public Contador(int valor){
this.valor = valor;
}
public void contar(){
valor += 1;
}

public int getValor(){


return valor;
}
public void reset(){
valor = 0;
}

Test contador
public class ContadorPrueba {
public static void main(String[] args){
Contador numerador = new Contador();
numerador.contar();
numerador.contar();
numerador.contar();
int resultado = numerador.getValor();
System.out.println(resultado);
numerador.reset();
System.out.println(numerador.getValor());
}
}

CARAS
import
import
import
import

java.awt.Color;
java.awt.Graphics2D;
java.awt.Rectangle;
java.awt.geom.Ellipse2D;

public class Caras {


private int x;
private int y;
private int w;
public Caras(int xIni, int yIni, int ancho){
x = xIni;
y = yIni;
w = ancho;
}

public void draw(Graphics2D g2){


int h = 3*w/2;
Ellipse2D.Double cabeza = new Ellipse2D.Double(x, y, w, h);
g2.draw(cabeza);
g2.setColor(Color.GREEN);
Rectangle ojo = new Rectangle(x + 2*w/10, y + 4*w/10,
3*w/20,2*w/10);
g2.fill(ojo);
ojo.translate(9*w/20, 0);
g2.fill(ojo);
Rectangle boca = new
Rectangle(x+7*w/20,y+11*w/10,4*w/10,w/20);
g2.setColor(Color.RED);
g2.fill(boca);
}
}

Caras componentes

public class CarasComponet extends JComponent{


public void paintComponent(Graphics g){
Graphics2D g2 = (Graphics2D)g;
Caras cara1 = new Caras(5, 10, 100);
Caras cara2 = new Caras(120, 140, 100);
cara1.draw(g2);
cara2.draw(g2);
}
}

Caras visor
import javax.swing.JComponent;
import javax.swing.JFrame;
public class CarasVisor {
public static void main(String[] args){
JFrame c = new JFrame();
c.setSize(500, 400);
c.setTitle("Dos Caras");
c.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
CarasComponet comp = new CarasComponet();
c.add(comp);
c.setVisible(true);
}
}
CUATRO RECTANGULOS
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import javax.swing.JComponent;

public class CuatroRectangulos extends JComponent{


public void paintComponent (Graphics g){
Graphics2D g2 = (Graphics2D)g;
Rectangle caja = new Rectangle(10,10,60,80);
System.out.print(caja);
g2.setColor(Color.MAGENTA);
g2.draw(caja);
caja.translate(60,0);
g2.draw(caja);
caja.translate(0,80);
g2.draw(caja);
caja.translate(-60,0);
g2.draw(caja);
Rectangle r1 = new Rectangle(10,200,100,80);
Rectangle r2 = new Rectangle(60,250,100,80);
Rectangle r3 = r1.intersection(r2);
g2.setColor(Color.RED);
g2.fill(r3);
g2.setColor(Color.WHITE);
g2.draw(r1);
g2.draw(r2);
g2.setColor(Color.GREEN);
g2.draw(r3);
}
}
Visor

import javax.swing.JFrame;
public class VerRectangulos {
public static void main(String[] args) {
JFrame ventana = new JFrame();
ventana.setSize(640,480);
ventana.setTitle("Dos rectngulos");
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//Rectangulos componente = new Rectangulos();
CuatroRectangulos componente = new CuatroRectangulos();
ventana.add(componente);
ventana.setVisible(true);
}

2. IMPLEMENTANDO CLASES
CUENTA DE BANCO

/**
El balance de una cuenta de banco puede ser cambiado por

depositos y retiros.
*/
public class CuentaDeBanco
{
/**
Construye una cuenta de banco con balance cero.
*/
public CuentaDeBanco()
{
balance = 0;
numCuenta = 0;
}
/**
Construye una cuenta de banco con un deposito inicial
@param balanceInicial es el deposito inicial al habrir la cuenta
*/
public CuentaDeBanco(int numCuentaInicial,double balanceInicial)
{
numCuenta = numCuentaInicial;
balance = balanceInicial;
}
/**
Depositos de dinero en la cuenta del banco.
@param monto del importe del deposito
*/
public void deposito(double monto)
{
double nuevoBalance = balance + monto;
balance = nuevoBalance;
}
/**
Retiro de dinero de la cuenta del banco.
@param monto el monto a retirar
*/
public void retiro(double monto)
{
double nuevoBalance = balance - monto;
balance = nuevoBalance;
}
/**
Obtiene el balance actual de la cuenta del banco.
@return el balance actual
*/
public double getBalance()
{
return balance;
}
public int getNumCuenta()
{
return numCuenta;
}
public void misterio(CuentaDeBanco eso, double monto){
this.balance = this.balance -monto;
eso.balance = eso.balance + monto;

}
public void adicionaInteres(double tasa){
double nuevoBalance = balance*(1 + tasa/100);
balance = nuevoBalance;
}
private int numCuenta;
private double balance;
}
Test Cuenta de banco
public class PruebaCuentaDeBanco
{
/**
Prueba los mtodos de la clase CuentaDeBanco.
@param args no es usado
*/
public static void main(String[] args)
{
CuentaDeBanco cuentaDeRosa = new CuentaDeBanco(101, 1000);
cuentaDeRosa.deposito(2000);
cuentaDeRosa.retiro(1000);
System.out.println(cuentaDeRosa.getBalance());
System.out.println("Esperado: 2000");
System.out.println(cuentaDeRosa.getNumCuenta());
cuentaDeRosa.misterio(cuentaDeRosa, 1000);
System.out.println(cuentaDeRosa.getBalance());
cuentaDeRosa.adicionaInteres(10);
System.out.println(cuentaDeRosa.getBalance());
//cuentaDeRosa.balance = 0;
}
}

CAJERO

/**
* Un cajero registra todas las ventas y calcula el cambio
*/
public class Cajero {
/**
* Contruye un cajero sin dinero en el
*/
public Cajero(){
compra = 0;
pago = 0;
}
/**
* Registra la venta de un artculo
* @param monto del precio del artculo
*/
public void registroDeVenta(double monto){
compra = compra + monto;
}
/**
* Ingresa el monto pagado por el cliente
* @param monto pagado por el cliente
*/
public void ingresarPago(double monto){
pago = monto;
}
/**

* Calcula el cambio y resetea el cajero para otro cliente


*/
public double darVuelto(){
double cambio = pago - compra;
compra = 0;
pago = 0;
return cambio;
}
private double compra;
private double pago;

}
RELOJ

public class Reloj {


private int hora;
private int minuto;
private int segundo;
public Reloj(){
hora = h;
minuto = m;
segundo = s;
}
Calendar hoy = Calendar.getInstance();
int m = hoy.get(Calendar.MINUTE);
int h = hoy.get(Calendar.HOUR_OF_DAY);
int s = hoy.get(Calendar.SECOND);
public

int getHora(){
return hora;

}
public int getMinuto(){
return minuto;
}
public int getSegundo(){
return segundo;
}
}
Test reloj
public class RelojTest {
public static void main(String[] args) {
Reloj ma = new Reloj();
System.out.print("La hora actual es : ");
System.out.print(ma.getHora());
System.out.print(":");
System.out.print(ma.getMinuto());
System.out.print(":");
System.out.println(ma.getSegundo());
}

CARRO
import
import
import
import
import

java.awt.Graphics2D;
java.awt.Rectangle;
java.awt.geom.Ellipse2D;
java.awt.geom.Line2D;
java.awt.geom.Point2D;

/**

Una forma de carro que puede ser posicionado en cualquier lugar de


la pantalla.
*/
public class Carro
{
/**
Constructores de un carro en un una posicin respecto a la
esquina superio izquierda
@param x la coordenada x desde la esquina superior izquierda
@param y la coordenada y desde la esquina superior izquierda
*/
public Carro(int x, int y)
{
xIzq = x;
ySup = y;
}
/**

Dibuja el carro.
@param g2 el contexto de graphics

*/
public void dibuja(Graphics2D g2)
{
Rectangle cuerpo
= new Rectangle(xIzq, ySup + 10, 60, 10);
Ellipse2D.Double ruedaDelantera
= new Ellipse2D.Double(xIzq + 10, ySup + 20, 10, 10);
Ellipse2D.Double ruedaTrasera
= new Ellipse2D.Double(xIzq + 40, ySup + 20, 10, 10);
// Base de la ventana delantera
Point2D.Double r1
= new Point2D.Double(xIzq +
// Techo de la ventana delantera
Point2D.Double r2
= new Point2D.Double(xIzq +
// Techo de la ventana posterior
Point2D.Double r3
= new Point2D.Double(xIzq +
// Base de la ventana posterior
Point2D.Double r4
= new Point2D.Double(xIzq +

10, ySup + 10);


20, ySup);
40, ySup);

Line2D.Double ventanaFrontal
= new Line2D.Double(r1, r2);
Line2D.Double techo
= new Line2D.Double(r2, r3);
Line2D.Double ventanaPosterior
= new Line2D.Double(r3, r4);

50, ySup + 10);

g2.draw(cuerpo);
g2.draw(ruedaDelantera);
g2.draw(ruedaTrasera);
g2.draw(ventanaFrontal);
g2.draw(techo);
g2.draw(ventanaPosterior);

private int xIzq;

private int ySup;


}
CARRO COMPONENTES
import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.JComponent;
/**
Este componente dibuja dos carros.
*/
public class ComponenteCarro extends JComponent
{
public void paintComponent(Graphics g)
{
Graphics2D g2 = (Graphics2D) g;
Carro carro1 = new Carro(0, 0);
int x = getWidth() - 60;
int y = getHeight() - 30;
Carro carro2 = new Carro(x, y);
carro1.dibuja(g2);
carro2.dibuja(g2);
}
}
Visor de carros
import javax.swing.JFrame;
import javax.swing.JFrame;
public class CarViewer
{
public static void main(String[] args)
{
JFrame frame = new JFrame();
frame.setSize(600, 600);
frame.setTitle("Two cars");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
CarComponent component = new CarComponent();
frame.add(component);
frame.setVisible(true);
}

TIPOS FUNDAMENTALES DE DATOS


CAJA REGISTRADORA
/**
Una caja regitradora totaliza la venta y calcula el cambio debido.
*/
public class CajaRegistradora
{

/**
Construye una caja registradora vacia.
*/
public CajaRegistradora()
{
compra = 0;
pago = 0;
}
/**

Registra el precio de compra de un item.


@param monto el precio de compra del item

*/
public void registraCompra(double monto)
{
compra = compra + monto;
}
/**

Ingrese el pago recibido por el usuario.


@param soles el numero de soles del pago
@param cincuentaCentimos el numero de cincuentaCentimos del pago
@param veinteCentimos el numero de veinteCentimos del pago
@param diezCentimos el numero de diezCentimos del pago
@param cincoCentimos el numero de cincoCentimos del pago
*/
public void ingresePago(int soles, int cincuentaCentimos,
int veinteCentimos, int diezCentimos, int cincoCentimos)
{
pago = soles + cincuentaCentimos * CINCUENTA + veinteCentimos *
VEINTE
+ diezCentimos * DIEZ + cincoCentimos * CINCO;
}
/**
Calcula el cambio adecuado y resetea la maquina para un nuevo
usuario.
@return el cambio adecuado al usuario.
*/
public double darCambio()
{
double cambio = pago - compra;
compra = 0;
pago = 0;
return cambio;
}
public
public
public
public

static
static
static
static

final
final
final
final

double
double
double
double

CINCUENTA = 0.5;
VEINTE = 0.2;
DIEZ = 0.1;
CINCO = 0.05;

private double compra;


private double pago;
}
TEST CAJA REGISTRADORA
public class PruebaDeCajaRegistradora
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);

CajaRegistradora registro = new CajaRegistradora();


System.out.print("Ingrese el precio: ");
registro.registraCompra(0.75);
registro.registraCompra(1.50);
registro.ingresePago(2, 2, 0, 0, 0);
System.out.print("cambio: ");
System.out.println(registro.darCambio());
System.out.println("Esperado: 0.75");

}
}

registro.registraCompra(2.25);
registro.registraCompra(19.25);
registro.ingresePago(21, 0, 3, 0, 0);
System.out.print("cambio: ");
System.out.println(registro.darCambio());
System.out.println("Esperado: 0.10");

NUMEROS
import java.util.Scanner;
public class Numeros {
public static void main(String[] args) {
java.io.PrintStream o = System.out;
int n = 1000000, b;
double f = 4.35;
Scanner in = new Scanner(System.in);
//b = f; error no se piede convertir
o.println(n*n);
o.println(100*f);
o.println(1.0/3);
o.println(7/4);
o.println(7.0/4);
o.println(7/4.0);
o.println(7%4);
o.println(Math.round(f));
o.print("Entero: ");
int a = in.nextInt();
o.println(a);
o.print("float: ");
float x = in.nextFloat();
o.println(x);
o.print("double: ");
double w = in.nextDouble();
o.println(w);
String num = "-345";
int num1 = Integer.parseInt(num);
o.println(num1);

}
}

String f1 = "125.178";
o.println(2*Double.parseDouble(f1));
//o.println(7/4);
o.println(7/4);
o.println(7/4);

TERREMOTO
/**
Una clase que describe lose efectos de un terremoto
*/
public class Terremoto
{
/**
Constructor de un objeto Terremoto.
@param magnitud la magnitud en la escala Richter
*/
public Terremoto(double magnitud)
{
richter = magnitud;
}
/**

Obtiene la descripcion de los efectos de un terremoto.


@return la descripcion de los efectos

*/
public String obtenerDescripcion()
{
String r;
if (richter >= 8.0)
r = "La mayoria de las estructuras caidas";
else if (richter >= 7.0)
r = "Muchos edificio destruidos";
else if (richter >= 6.0)
r = "Muchos edificio considerablemente daados, algunos
colapsados";
else if (richter >= 4.5)
r = "Dao de edificios pobremente construidos";
else if (richter >= 3.5)
r = "Sentido por muchas personas, sin destruccion";
else if (richter >= 0)
r = "Generalmente no sienten las personas";
else
r = "Numeros negativos no son validos";
return r;
}
private double richter;
}

TEST
import java.util.Scanner;
/**
Este programa imprime una descripcion de un tettemoto de una
magnitud dada.
*/
public class CorrerTerremoto{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
System.out.print("Ingrese una magnitud en la escala Richter: ");
double magnitud = in.nextDouble();
Terremoto temblor = new Terremoto(magnitud);
System.out.println(temblor.obtenerDescripcion());
}

IMPUESTO A LA RENTA
public class IR {
public static final int SOLTERO = 1;
public static final int CASADO = 2;
private
private
private
private

static
static
static
static

final
final
final
final

double
double
double
double

RAZON1 = 0.15;
RAZON2 = 0.21;
LIMITE_SOLTERO = 98550;
LIMITE_CASADO = 124100;

private double ingresoImponible;


private int estado;
public IR(double ingreso, int unEstado){
ingresoImponible = ingreso - 25550;
estado = unEstado;
}
public double getImpuesto(){
double impuesto = 0;
if (ingresoImponible <= 0)
return 0;
if( estado == SOLTERO){
if (ingresoImponible < LIMITE_SOLTERO)
impuesto = ingresoImponible * RAZON1;
else
impuesto = ingresoImponible * RAZON2;
}else{
if (ingresoImponible < LIMITE_CASADO)
impuesto = ingresoImponible * RAZON1;
else
impuesto = ingresoImponible * RAZON2;
}
return impuesto;
}
}
CALCULO IR
import java.util.Scanner;
public class IRCalculo {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.print("Ingrese su ingreso anual: ");
double ingreso = in.nextDouble();
System.out.print("Es unste casado? (S/N) ");
String est = in.next();
int estado;
if (est.equalsIgnoreCase("S"))
estado = IR.CASADO;
else
estado = IR.SOLTERO;
IR unIRenta = new IR(ingreso, estado);
System.out.println("Impuesto ala renta: " +
unIRenta.getImpuesto());
}
}

Вам также может понравиться