Universidad Nacional Autónoma de Honduras

Facultad de Ingenierías Técnicas, Ingeniería en Sistemas

Programación II

Resumen Unidad I

Por: Erick Vladimir Reyes Marín

Contenido
Operadores y tipos de datos primitivos en Java ........................................................................................... 4
Tipos de datos primitivos .......................................................................................................................... 4
Operadores aritméticos ............................................................................................................................ 4
Constantes ................................................................................................................................................ 5
Cast de tipos de datos ............................................................................................................................... 6
Sentencias de Control ................................................................................................................................... 6
Operadores Lógicos .................................................................................................................................. 6
Sentencia if Simple .................................................................................................................................... 7
Sentencia if-else e if Anidado.................................................................................................................... 7
Sentencia switch ....................................................................................................................................... 9
Sentencias while y do-while.................................................................................................................... 10
Sentencia for ........................................................................................................................................... 10
Tipos de datos referenciados ...................................................................................................................... 11
String ....................................................................................................................................................... 11
Secuencias de escape.......................................................................................................................... 12
Comparación de Strings ...................................................................................................................... 12
Arreglos ................................................................................................................................................... 13
Argumentos en línea de comandos .................................................................................................... 13
Acceder y asignar valores a un arreglo ............................................................................................... 13
Arreglos Multidimencionales .............................................................................................................. 14
Métodos o funciones .............................................................................................................................. 15
Metodos estáticos y clases de utilería ................................................................................................ 17
La clase Scanner ...................................................................................................................................... 17
La clase Math .......................................................................................................................................... 18
Clases ...................................................................................................................................................... 20
Modificadores de acceso .................................................................................................................... 21
Modificadores de acceso en atributos ................................................................................................ 21
Modificadores de acceso en métodos ................................................................................................ 22
Sobrecarga de métodos ...................................................................................................................... 23
Apuntador this .................................................................................................................................... 24
Constructores ...................................................................................................................................... 24
Operadores y tipos de datos primitivos en Java

Tipos de datos primitivos

Valor
Tipo de dato Tamaño Valor Minimo Valor Máximo por
defecto

byte 8 bits -128 (-2 ^ 7). 127 (inclusive) (2 ^ 7 -1) 0

short 16 bits -32,768 (-2 ^ 15) 32.767 (inclusive) (2 ^ 15 -1) 0

int 32 bits -2147483648 (-2 ^ 31) 2147483647 (inclusive)(2 ^ 31 -1) 0

long 64 bits -9223372036854775808 (-2 ^ 63) 9223372036854775807 (inclusive) (2 ^ 63 -1) 0

float 32 bits 1.40129846432481707e-45 3.40282346638528860e+38 0,0 f

double 64 bits 4.94065645841246544e-324 1.79769313486231570e+308 0,0 f

boolean 1 bit - - false

char 16 bits ‘\u0000′ (o 0). ‘\uffff’ (o 65.535 inclusive)

Operadores aritméticos

Operador Descripción Ejemplo

+ Suma a = b + c;
- Resta a = b - c;
* Multiplicación a = b * c;
/ División a = b / c;
% Modulo o residuo a = b % c;
++ Operador unario de incremento en 1 i++; ++i;
-- Operador unario de decremento en 1 i--; --i;
+= Suma Acumulada a+=b; //es equivalente a: a=a+b;
-= Resta Acumulada a-=b; //es equivalente a: a=a-b;
*= Multiplicación Acumulada a*=b; //es equivalente a: a=a*b;
/= División Acumulada a/=b; //es equivalente a: a=a/b;
Ejemplo operadores aritméticos:
public class Aritmetica{
public static void main(String[] args){
int a = 12;
int b = 10;
int suma = a + b;
int resta = a - b;
int mult = a * b;
int div = a / b;
int modulo = a % b;

System.out.print("Suma :");
System.out.println(suma );
System.out.print("Resta :");
System.out.println(resta);
System.out.print("Multiplicacion :");
System.out.println(mult);
System.out.print("Division :");
System.out.println(div);
System.out.print("Modulo :");
System.out.println(modulo);
}
}

Ejemplo de operadores unarios:

public class OperadoresUnarios{
public static void main(String[] args){
int a = 2;
int b = 2;
System.out.println(a++); //Imprime 2
System.out.println(++b); //Imprime 3
System.out.print("Estado Final (a) :");
System.out.println(a); //Imprime 3
System.out.print("Estado Final (b) :");
System.out.println(b); //Imprime 3
}
}

Constantes
Las constantes son valores que permanecen fijos durante todo el ciclo de vida del programa. Como
estándar se suele nombrar las constantes con todas sus letras en mayúsculas. Su sintaxis es:
final tipoDeDato nombre = valor;

Ejemplo:
final int ALTURA_MAXIMA = 100;
Cast de tipos de datos
Consiste en la funcionalidad de convertir un tipo de dato a otro dependiendo de la compatibilidad entre
ellos, para hacer un cast o conversión de tipos primitivos hay que colocar el tipo al cual se quiere
convertir entre paréntesis, por ejemplo
public class EjemploCast{
public static void main(String[] args){
float a = 10.5f;
int b;
b = (int)a; //Cast o conversión de de tipos
System.out.println("Valor: "+b);//El valor mostrado seria 10
}
}

Sentencias de Control
Las sentencias de control ayudan a dar lógica al flujo del programa dependiendo de las condiciones
acertadas. Las sentencias de control en java son los condicionales: if, if-else y switch, y las cíclicas:
while, do while y for.

Operadores Lógicos

Operador Definición

== Es igual

!= Es distinto

<, <=, >, >= Menor, menor o igual, mayor, mayor o igual

&& Operador and

|| Operador Or

! Operador Not (Negación)

public class EjemploOperadoresLogicos{

public static void main(String[] args){
int a = 2;
int b = 2;
boolean resultado;
resultado = a==b;
System.out.println("a==b: "+resultado);
resultado = a!=b;
System.out.println("a!=b :"+resultado);
resultado = (a!=b) && (a==b);
System.out.println("a!=b && a==b :"+resultado);
}
}
Sentencia if Simple
El if simple permite ejecutar una o un conjunto de instrucciones si una condición evaluada es verdadera
la sintaxis es:
if (condición){
//Instrucciones en caso de que la condición sea verdadera
}

En un dado caso si el contenido dentro del if es únicamente una sola línea entonces las llaves pueden ser
omitidas:
if (condición)
//Una instruccion

Ejemplos:
if ( valor >= 500 ){
descuento = 0.09;
aplicaDescuento = true;
}

if ( edad >= 60 )
aplicaDescuento = true;

Sentencia if-else e if Anidado

El condicionante if-else permite ejecutar instrucciones si la condicionante es verdadera o falsa, su
sintaxis es:
if (condición){
//Instrucciones en caso de que la condición sea verdadera
} else {
//Instrucciones en caso de que la condición sea falsa
}

En un dado caso las instrucciones a ejecutar únicamente son una línea entonces se puede omitir las
llaves:
if (condición)
//Una instrucción
else
//Una instrucción
Las sentencias if pueden estar anidadas dependiendo de la necesidad de construir un flujo mas complejo
su sintaxis es:
if (condicion) {
//Instrucciones
} else if (condicion2) {
//Instrucciones
} else if (condicion3)(
.
.
.
} else {
//Instrucciones en caso no se cumpla ninguna condición
}

Ejemplo:
class IfElseDemo {
public static void main(String[] args) {
int nota = 76;
char grado;
if (nota >= 90) {
grado = 'A';
} else if (nota >= 80) {
grado = 'B';
} else if (nota >= 70) {
grado = 'C';
} else if (nota >= 60) {
grado = 'D';
} else {
grado = 'F';
}
System.out.println("Grado= " + grado);
}
}
Sentencia switch
La sentencia switch evalua una variable y ejecuta ciertas instrucciones dependiendo del valor que la
variable pueda tomar. Su sitaxis es:
switch(expresion){
case valor1 :
//Instrucciones
break;
case valor2 :
//Instrucciones
break;
.
.
.
default : //En caso de que no se cumpla ningún case
//Instrucciones
}

Ejemplo:

public class SwitchDemo {

public static void main(String[] args) {
int mes = 8;
String nombreMes;
switch (nombreMes) {
case 1: nombreMes = "Enero";
break;
case 2: nombreMes = "Febrero";
break;
case 3: nombreMes = "Marzo";
break;
case 4: nombreMes = "Abril";
break;
case 5: nombreMes = "Mayo";
break;
case 6: nombreMes = "Junio";
break;
case 7: nombreMes = "Julio";
break;
case 8: nombreMes = "Agosto";
break;
case 9: nombreMes = "Septiembre";
break;
case 10: nombreMes = "Octubre";
break;
case 11: nombreMes = "Noviembre";
break;
case 12: nombreMes = "Diciembre";
break;
default: nombreMes = "Mes invalido";
break;
}
System.out.println(nombreMes);
}
}
Sentencias while y do-while
Las sentencias while y do while se utilizan para ejecutar instrucciones repetitivas como ciclos o bucles.

Su sintaxis es:
while (condicion){
//Instrucciones
}

do {
//Instrucciones
} while(condicion);

La única diferencia de uno con el otro es que con do-while las instrucciones en su interior se ejecutan al
menos una única vez.

Ejemplo:
class WhileDemo {
public static void main(String[] args){
int contador = 1;
while (contador < 11) {
System.out.println("Contador: " + contador);
contador++;
}
}
}

Sentencia for
Al igual que la sentencia de control while, la sentencia for tiene como objetivo ejecutar instrucciones
repetitivas, con la salvedad de que utiliza un iterador para evaluar su condición.

Su sintaxis es:
for (inicializacion; condicion_de_terminacion;incrementador) {
//Instrucciones
}

Ejemplo:

class ForDemo {
public static void main(String[] args){
for(int i=1; i<11; i++){
System.out.println("Contador: " + i);
}
}
}
Tipos de datos referenciados
Los tipos de datos referenciados son aquellos que son definidos como clases, ya sean propias del lenguaje
Java o definidas por el programador.

Las clases son estructuras de datos que son creadas para fines específicos, pueden estar estructuradas
con sus propios atributos y métodos.

Al proceso de creación de un objeto a partir de una clase se le llama instanciación, a la estructura

resultante se le conoce como objeto o instancia. Para instanciar o crear un objeto a partir de una clase se
utiliza la palabra reservada new.

Por ejemplo:
String cadena = new String("Cadena");

En donde:

String: es la clase base para la creación del objeto.

cadena: es el nombre asignado al objeto resultante después del proceso de instanciación.

new: es la palabra reservada utilizada para crear un objeto a partir de una clase existente.

String("Cadena"): es el llamado al constructor de la clase, el constructor es el encargado de

inicializar los atributos internos de la clase.

String
String es una clase propia del lenguaje Java, la cual está diseñada con el objetivo de manipular cadenas de
caracteres. Esta clase ha tenido un diseño especial dentro del lenguaje java debido a su gran uso dentro
de cualquier tipo de aplicación, los objetos resultantes a partir de esta clase pueden ser instanciados
simplemente con el uso de comillas.

Las siguientes instrucciones son equivalentes para instanciar un objeto del tipo String:
String cadena = new String("Cadena");
String cadena = "Cadena";
Secuencias de escape
Las secuencias de escape son conjuntos de caracteres utilizados dentro de las cadenas para realizar
operaciones específicas o imprimir caracteres que no pueden ser incluidos de forma normal.

Secuencia de escape Descripción

\n Ir al principio de la línea siguiente
\b Retroceso
\t Tabulador horizontal
\r Ir al principio de la línea
\" Imprimir comillas
\' Imprimir comilla simple
\\ Imprimir contra pleca

Ejemplo:
public class DemoCaracteresEscape{
public static void main(String[] args){
System.out.println("Linea 1\nLinea 2");
System.out.println("\tLinea con tabulacion");
System.out.println("\"Texto entre comillas\"");
}
}

Resultado:

Comparación de Strings
En el caso de la comparación de Strings el operador == no es efectivo si se utiliza el operador new
debido a que este operador está diseñado para comparar tipos primitivos, si se utiliza este operador
para comparar tipos referenciados lo que hace es comparar instancias, sin embargo no compara el
contenido, por lo cual los tipos referenciados disponen de un método llamado equals que permite
comparar el contenido de un objeto con otro.

Ejemplo
Arreglos
Un arreglo o array es una estructura de datos o una colección de valores del mismo tipo, se utilizan para
agrupar valores en común. Estos valores se almacenan en una determinada posición que puede ser
accedida por medio de un índice numérico entero.

Su sintaxis básica es:

tipo[] nombreArreglo = new tipo[cantidadElementos];

Alternativa:
tipo[] nombreArreglo;
nombreArreglo = new tipo[cantidadElementos];

Ejemplos:
byte[] edad = new byte[4];
short[] edad = new short[4];
int[] edad = new int[4];
long[] edad = new long[4];
float[] estatura = new float[3];
double[] estatura = new double[3];
boolean[] estado = new boolean[5];
char[] genero = new char[2];
String[] nombre = new String[2];

Ejemplo inicialización en línea:

double[] estatura = {1.73, 1.67, 1.56}; //Arreglo de 3 elementos

Argumentos en línea de comandos

Al momento de definir el método main en la clase principal se envía como parámetro un arreglo de
Strings, estos pueden ser capturados a partir de parámetros enviados por medio de la línea de
comandos.

Acceder y asignar valores a un arreglo

Para asignar o acceder a los valores de un arreglo basta con escribir el índice del elemento a obtener.
Hay que tomar en cuenta que el índice del primer elemento siempre será 0 y el último elemento será el
tamaño del arreglo menos uno (n-1).

Ejemplo:
char[] genero = new char[2];
genero[0] = 'F';
genero[1] = 'M';
System.out.println("Primer Valor: " + genero[0]);
System.out.println("Segundo Valor: " + genero[1]);
Ejemplo utilizando ciclos:

int[] numeros = new int[10];

//Almacenar valores
for (int i=0; i < numeros.length;i++)
numeros[i] = (i+1) * 10;

//Mostrar valores
for (int i=0; i < numeros.length;i++)
System.out.println("Elemento["+i+"]= "+numeros[i]);

Arreglos Multidimencionales
En Java es posible crear arreglos con más de una dimensión permitiendo crear matrices de m x n
elementos.

Su sintaxis es:
tipo[][]… [] nombreArreglo = new tipo[dimensión1][dimensión2]…[dimensiónN];

Alternativa:
tipo[][]… [] nombreArreglo;
nombreArreglo = new tipo[dimensión1][dimensión2]…[dimensiónN];

Ejemplo:
//Asignar valores
for (int i = 0;i<matriz.length;i++){
for (int j = 0;j<matriz[i].length;j++){
matriz[i][j] = (i+1) * (j+1);
}
}

//Imprimir valores
for (int i = 0;i<matriz.length;i++){
for (int j = 0;j<matriz[i].length;j++){
System.out.println("Elemento ["+i+"]["+j+"]: "+matriz[i][j]);
}
}
Matriz resultante:

[0] [1] [2] [3] [4]

[0] 1 2 3 4 5
[1] 2 4 6 8 10
[2] 3 6 9 12 15
[3] 4 8 12 16 20
[4] 5 10 15 20 25

Ejemplo de inicialización en línea:

int[][] matriz = {{1,2},{3,4},{5,6}};

Métodos o funciones
Los métodos o funciones son un mecanismo que permite dividir el código en bloques independientes los
cuales pueden ser llamados desde varios lugares dentro de un programa. Un método puede recibir
parámetros para ser procesados, ejecutar una acción o devolver un valor.

La estructura básica de un método es:

[tipoAcceso] [static] tipoDevuelto nombreMetodo([lista parámetros]) {
// Instrucciones
[return valor;]
}

Ejemplo:
static int sumar(int a, int b){
return a + b;
}

El prefijo static indica que el método puede ser llamado incluso si no se ha creado una instancia de la
clase que lo contiene.
Ejemplo completo:
public class MetodosAritmeticos{
static int sumar(int a,int b){
return a+b;
}
static int restar(int a,int b){
return a-b;
}
static int dividir(int a,int b){
return a/b;
}
static int multiplicar(int a,int b){
return a*b;
}
public static void main(String[] args){
int x = 5;
int y = 4;
System.out.println("Suma: " + sumar(x,y));
System.out.println("Resta: " + restar(x,y));
System.out.println("Multiplicacion: " + multiplicar(x,y));
System.out.println("Division: " + dividir(x,y));
}
}

Ejemplo utilizando switch:

public class MetodoOperaciones{

static int operacion(int a,int b,String op){
int resultado;
switch (op){
case "suma":
resultado = (a+b);
break;
case "resta":
resultado = (a-b);
break;
case "multiplicacion":
resultado = (a*b);
break;
case "division":
resultado = (a/b);
break;
default:
resultado = 0;
break;
}
return resultado;
}

public static void main(String[] args){

int x = 5;
int y = 4;
System.out.println("Suma: " + operacion(x,y,"suma"));
 System.out.println("Resta: " + operacion(x,y,"resta"));
System.out.println("Multiplicacion: " +
operacion(x,y,"multiplicacion"));
System.out.println("Division: " + operacion(x,y,"division"));
}
}

Metodos estáticos y clases de utilería

La clase Scanner
Esta clase permite obtener información ingresada por el usuario a través de la consola. Su uso se hace
creando una instancia de la clase scanner y enviando como parámetro la entrada estándar del sistema.

Su sintaxis es:
Scanner entrada = new Scanner(System.in);

Para que el compilador de Java pueda detectar la clase Scanner hay que importarla del paquete java.util
de la siguiente manera:
java.util.Scanner;

De esta manera se podrán crear objetos o hacer instancias de la clase Scanner. Para obtener valores
ingresados por el usuario hay que utilizar los metodos next de la clase Scanner.

Ejemplo:
import java.util.Scanner;

public class EntradaDatos{

public static void main(String[] args){
String nombre;
int a;
int b;
int suma;
Scanner entrada;
entrada = new Scanner(System.in);
System.out.print("Cual es su nombre: ");
nombre = entrada.next();
System.out.print("Ingrese un numero: ");
a = entrada.nextInt();
System.out.print("Ingrese otro numero: ");
b = entrada.nextInt();
suma = a + b;
System.out.print("Hola " + nombre + ", la suma de los numeros que
ingreso es: " + suma);
entrada.close();
}
}
Salida:

La clase Math
Esta clase permite realizar cálculos matemáticos a partir de metodos estáticos (static, ose que no es
necesario crear un objeto del tipo Math para acceder a ellos). Esta clase está dentro del paquete
java.lang

Algunos de sus metodos:

Función
Significado Ejemplo de uso Resultado
matemática
abs Valor absoluto int x = Math.abs(2.3); x = 2;
atan Arcotangente double x = Math.atan(1); x = 0.78539816339744;
sin Seno double x = Math.sin(0.5); x = 0.4794255386042;
cos Coseno double x = Math.cos(0.5); x = 0.87758256189037;
tan Tangente double x = Math.tan(0.5); x = 0.54630248984379;
exp Exponenciación neperiana double x = Math.exp(1); x = 2.71828182845904;
log Logaritmo neperiano double x = Math.log(2.7172); x = 0.99960193833500;
pow Potencia double x = Math.pow(2.3); x = 8.0;
round Redondeo double x = Math.round(2.5); x = 3;
random Número aleatorio double x = Math.ramdom(); x = 0.20614522323378;

Ejemplo:
import java.util.Scanner;

public class EntradaDatos{

public static void main(String[] args){
int opcion;
double valor;
int potencia;

Scanner entrada;
entrada = new Scanner(System.in);
System.out.println("Que operacion desea realizar?");
System.out.println("1 Potencia de un numero");
System.out.println("2 Valor absoluto");
System.out.println("3 Raiz cuadrada");
System.out.println("4 Numero random");
System.out.println("0 Salir");
do{
System.out.print("----------------\nOpcion: ");
opcion = entrada.nextInt();
switch (opcion){
case 1:
System.out.print("Valor: ");
valor = entrada.nextDouble();
System.out.print("Potencia: ");
 potencia = entrada.nextInt();
System.out.println("Resultado: "+Math.pow(valor,
potencia));
break;
case 2:
System.out.print("Valor: ");
valor = entrada.nextDouble();
System.out.println("Valor Absoluto: "+Math.abs(valor));
break;
case 3:
System.out.print("Valor: ");
valor = entrada.nextDouble();
System.out.println("Raiz Cuadrada: "+Math.sqrt(valor));
break;
case 4:
System.out.println("Numero aleatorio: "+Math.random());
break;
}
}while(opcion!=0);

System.out.println("Fin del programa");

entrada.close();
}
}
Clases
Una clase es una estructura de datos que permite encapsular acciones y características en común de un
elemento, convirtiéndolo así en un tipo de datos definido por el programador. Este tipo de dato se
conoce como tipo referenciado.

Una clase se compone de los siguientes elementos:

class Circulo{
int x;
int y;
int diametro;
String color; Nombre de la clase
Variables
Atributos Miembro double calcularArea(){
return 0;
} Métodos miembro

void colorear(){

}
}

Ejemplo de definición e implementación

Circulo.java
class Circulo{
int x;
int y;
int diametro;
String color;

double calcularArea(){
return Math.PI * Math.pow((diametro/2),2);
}

void colorear(){
}
}

Principal.java

public class Principal{

public static void main(String[] args){
Circulo circulo = new Circulo();
circulo.x = 10;
circulo.y = 15;
circulo.diametro = 30;

System.out.println("X: " + circulo.x);

System.out.println("Y: " + circulo.y);
 System.out.println("Diametro: " + circulo.diametro);
System.out.println("Area: " + circulo.calcularArea());
}
}

Salida:

Modificadores de acceso
Los modificadores de acceso son una funcionalidad que permite limitar o permitir la visibilidad de clases
y sus miembros (atributos y métodos), los modificadores de accesos básicos son:

public: Permite acceso.

private: No permite acceso.

En el caso de la definición de clases el modificador de acceso deberá ser public, se puede utilizar el
modificador private en clases internas (clases dentro de clases).

Modificadores de acceso en atributos

Los modificadores de acceso en atributos definen la visibilidad del atributo dentro y fuera de la clase a la
cual pertenecen.

Un atributo con el modificador de acceso private, únicamente podrá ser accedido dentro de la clase a la
que pertenece y mediante los métodos definidos dentro de la clase, es decir si se crea una instancia de
dicha clase el atributo no podrá ser accedido de la forma nombreObjeto.nombreAtributo.

Un atributo con el modificador de acceso public, podrá ser accedido dentro y fuera de la clase, es decir,
el atributo podrá ser accedido de esta forma: nombreObjeto.nombreAtributo.

Ejemplo:

Circulo.java
public class Circulo{
private int x;
private int y;
private int diametro;
public String color;

int obtenerDiametro(){
 /*diametro es un atributo private, lo que significa que es visible
dentro de la clase y dentro de los metodos miembro*/
return diametro;
}
}

Principal.java

public class Principal{

public static void main(String[] args){
Circulo circulo = new Circulo();
System.out.println("Diametro: "+circulo.obtenerDiametro());
System.out.println("Color: "+circulo.color);
System.out.println("X: "+circulo.x); //Error, X no es visible
}
}

Modificadores de acceso en métodos

Los modificadores de acceso en métodos al igual que en los atributos definen la visibilidad del atributo
dentro y fuera de la clase a la cual pertenecen.

Un método con el modificador de acceso private, únicamente podrá ser accedido dentro de la clase a la
que pertenece y mediante otros métodos definidos dentro de la clase, es decir si se crea una instancia
de dicha clase el atributo no podrá ser accedido de la forma nombreObjeto.nombreMetodo().

Un método con el modificador de acceso public, podrá ser accedido dentro y fuera de la clase, es decir,
el método podrá ser accedido de esta forma: nombreObjeto.nombreMetodo().

Ejemplo:

Circulo.java

public class Circulo{

private int x;
private int y;
private int diametro;
public String color;

public int obtenerDiametro(){

return diametro;
}
private double calcularArea(){
return 0;
}
public void imprimirArea(){
System.out.println("El area es: "+calcularArea());
}
}

Principal.java
public class Principal{
public static void main(String[] args){
Circulo circulo = new Circulo();
System.out.println("Diametro: "+circulo.obtenerDiametro());
System.out.println("Calculo de area: "+circulo.calcularArea());//Error
circulo.imprimirArea();
}
}

Sobrecarga de métodos
La sobrecarga de métodos o funciones es una característica que permite crear varios métodos con el
mismo identificador dentro de una clase, lo que diferencia a un método de otro es la cantidad, tipos de
parámetros.

Ejemplo:

SobrecargaOperaciones.java

public class SobrecargaOperaciones{

public static int sumar(int a, int b){
return a + b;
}

public static double sumar(double a, double b){

return a + b;
}

public static float sumar(float a, float b){

return a + b;
}

public static int sumar(int a, int b, int c){

return a + b + c;
}
}

Principal.java

public class Principal{

public static void main(String[] args){
System.out.println("Suma enteros: " + SobrecargaOperaciones.sumar(5,6));
System.out.println("Suma double: " + SobrecargaOperaciones.sumar(5.25,6.55));
System.out.println("Suma float: " + SobrecargaOperaciones.sumar(4.3f,4.5f));
System.out.println("Suma tres enteros: " + SobrecargaOperaciones.sumar(4,5,12));
}
}

Salida:
Apuntador this
El apuntador this es una funcionalidad que permite acceder a atributos y métodos dentro de la propia
clase, es muy útil para diferenciar los atributos y métodos propios de las clases versus parámetros de u
otros elementos del mismo nombre.

En algunas ocasiones el uso de este apuntador es opcional.

Ejemplo:
public class Circulo{
private int x;
private int y;
private int diametro;
public String color;

public void establecerX(int x){

this.x = x;
}

public void establecerY(int y){

this.y = y;
}

public int obtenerDiametro(){

return diametro;
}
private double calcularArea(){
return 0;
}
public void imprimirArea(){
System.out.println("El area es: " + this.calcularArea());
}
}

Constructores
Un constructor es un método especial definido dentro de una clase, el objetivo principal de dicho
método es inicializar los atributos internos de la clase o ejecutar métodos internos de inicialización.

El constructor es el primer método en ejecutarse al crear una instancia de una clase, un constructos
lleva el mismo nombre de la clase y no tiene valor de retorno. Por defecto aunque no sea definido, se
crea un constructor vacío sin parámetros, un método puede sobrecargarse siguiendo las reglas de
sobrecarga de un método normal.

Un constructor deberá tener el modificador de acceso public, si no es así, no se podrá crear una
instancia de dicha clase.

Ejemplo:
public class Circulo{
private int x;
private int y;
private int diametro;
public String color;

public Circulo(int x, int y){

this.x = x;
this.y = y;
}

public Circulo(int x, int y, int diametro){

this.x = x;
this.y = y;
this.diametro = diametro;
}

public int obtenerDiametro(){

return diametro;
}
private double calcularArea(){
return 0;
}
public void imprimirArea(){
System.out.println("El area es: "+calcularArea());
}
}

Clases envolventes (Wrappers)

Son clases que modelan los tipos de datos primitivos tales como enteros y flotantes, que son los únicos
elementos en Java que no son clases.

 Proveen un mecanismo para envolver (wrap) valores primitivos en un objeto, de esta manera los
datos primitivos pueden tener actividades o comportamientos que son reservados solo para los
objetos.
 Proveen funciones útiles para realizar conversiones a cadena u otros tipos primitivos.
 Para cada tipo primitivo existe una clase envolvente, nombrada igual que su dato primitivo pero
su nombre empieza con mayuscula. Estas clases se encuentran en java.lang.

Tipo primitivo Clase Constructor

boolean Boolean boolean or String
byte Byte byte or String
char Char char
double Double double or String
float Float float, double, or String
int Integer int or String
long Long long or String
short Short short or String
Para realizar conversiones existen los siguientes métodos:

 xxxValue()
 parseXxx()
 valueOf()
 toString()

xxxValue()

Cuando se necesita el valor númerico de un envolvente a un primitivo podemos utilizar cualquiera de los
muchos métodos xxxValue()
Integer var = new Integer(42);
byte b = var.byteValue();
short s = var.shortValue();
double d = var.doubleValue();

parseXxx() y valueOf()

Ambos parseXxx() y valueOf() toman un String como argumento y muestran NumberFormatException si

la cadena no esta formada propiamente. La principal diferencia de estos métodos es:

parseXxx() - regresa el primitivo nombrado.

valueOf() - regresa un nuevo objeto wrapped del tipo del que fue invocado.

double d = Double.parseDouble("3.14");
long L1 = Long.parseLong("154614");
Long L2 = Long.valueOf("154614");

Métodos de la clase String

MÉTODO DESCRIPCIÓN
length() Devuelve la longitud de la cadena
indexOf(String) Devuelve la posición de la primera aparición de carácter
lastIndexOf(String) Devuelve la posición de la última aparición de carácter
charAt(n) Devuelve el carácter que está en la posición n
substring(n1,n2) Devuelve la subcadena comprendida entre las posiciones n1 y n2-1
toUpperCase() Devuelve la cadena convertida a mayúsculas
toLowerCase() Devuelve la cadena convertida a minúsculas
equals(String) Compara dos cadenas y devuelve true si son iguales
equalsIgnoreCase(String) Igual que equals pero sin considerar mayúsculas y minúsculas
valueOf(N) Método estático. Convierte el valor N a String. N puede ser de cualquier tipo.
trim() Elimina espacios en blanco a principio y al final de la cadena
split(String) Descompone una cadena en partes dependiendo de un delimitador
concat(String) Concatena una cadena con otra
contains(String) Devuelve verdadero si una cadena esta contenida dentro de otra
Ejemplo de uso:
public class MetodosString{
public static void main(String[] args){
String cadena1 = "Java y c++ son lenguajes orientados a objetos";

System.out.println("Tamaño de la cadena: " + cadena1.length());

System.out.println("Ubicacion de la palabra \"lenguajes\": " +
cadena1.indexOf("lenguajes"));
System.out.println("Indice de la ultima aparicion de la letra a: " +
cadena1.lastIndexOf("a"));
System.out.println("Caracter en la posicion 9: " + cadena1.charAt(13));
System.out.println("Subcadena del indice 7 al 9: " + cadena1.substring(7,10));
System.out.println("Texto en mayusculas: " + cadena1.toUpperCase());
System.out.println("Texto en minusculas: " + cadena1.toLowerCase());
System.out.println("Concatenar: " + cadena1.concat(", pero Java es mas nuevo"));
System.out.println("Verificar si la cadena contiene la palabra objetos: " +
cadena1.contains("objeto"));
}
}

Resultado:
Metodos estaticos de la clase JOptionPane
La clase JOptionPane esta contenida en el paquete javax.swing y contiene metodos estaticos para poder mostrar y recibir
información por parte del usuario. Sus principales metodos son:

JOptionPane.showInputDialog Muestra un cuadro de diálogo con un cuadro de texto que permite capturar
informacion introducida por el usuario, al valor de retorno de este metodo es un
String con el texto introducido por el usuario.
Ejemplo:

String resultado = JOptionPane.showInputDialog("Introduzca un mensaje");

El metodo esta sobrecargado para poder modificar el titulo y el icono a mostrar,

ejemplo:

String resultado = JOptionPane.showInputDialog(null, "Introduzca un

mensaje", "Titulo",JOptionPane.PLAIN_MESSAGE);

El primer parametro es el componente padre, por el momento usaremos el valor null.

Las posibles opciones para el icono a mostrar son las siguientes:

JOptionPane.ERROR_MESSAGE //0
JOptionPane.INFORMATION_MESSAGE //1
JOptionPane.WARNING_MESSAGE //2
JOptionPane.QUESTION_MESSAGE //3
JOptionPane.PLAIN_MESSAGE //1

JOptionPane.showMessageDialog Muestra un cuadro de dialogo con el mensaje definido en el segundo parametro.

Ejemplo:

JOptionPane.showMessageDialog(null, "Hola Mundo");

Al igual que el método anterior, este método esta sobrecargado para cambiar el titulo
y el icono, por ejemplo:
JOptionPane.showMessageDialog(null, "Hola Mundo",
"Este es el titulo", JOptionPane.ERROR_MESSAGE);

El primer parametro es el componente padre, por el momento usaremos el valor null.

Las posibles opciones para el icono a mostrar son las siguientes:

JOptionPane.ERROR_MESSAGE //0
JOptionPane.INFORMATION_MESSAGE //1
JOptionPane.WARNING_MESSAGE //2
JOptionPane.QUESTION_MESSAGE //3
JOptionPane.PLAIN_MESSAGE //1

JOptionPane.showConfirmDialog Muestra un cuadro de dialogo con un mensaje y 3 botones por defecto, estos botones
son:

Yes(Si): Si el usuario oprime este boton el valor de retorno es 0

No: Si el usuario oprime este boton el valor de retorno es 1
Cancel(Cancelar): Si el usuario oprime este boton el valor de retorno es 2

Ejemplo:
int operacion = JOptionPane.showConfirmDialog(null, "Esta seguro que
desea eliminar el registro?");
A continuación se muestra un ejemplo completo del uso de los metodos estaticos de la clase JOptionPane:

package ejemplos.joptionpane;

import javax.swing.JOptionPane;

public class Operaciones{

static int operacion(int a,int b,int operacion){
int resultado;
switch (operacion){
case 1:
resultado = ( a + b );
break;
case 2:
resultado = ( a - b );
break;
case 3:
resultado = ( a * b );
break;
case 4:
resultado = ( a / b );
break;
default:
resultado = 0;
break;
}
return resultado;
}
public static void main(String[] args){
int operacion = 0;
do{
operacion = Integer.valueOf(JOptionPane.showInputDialog("Que operacion desea realizar: \n "
+ "0 Salir\n "
+ "1 Suma\n "
+ "2 Resta\n "
+ "3 Multiplicacion\n "
+ "4 Division\n"));
int a;
int b;
if (operacion != 0) {
a = Integer.valueOf(JOptionPane.showInputDialog(null, "Introduzca el valor para a: "));
b = Integer.valueOf(JOptionPane.showInputDialog(null, "Introduzca el valor para a: "));
JOptionPane.showMessageDialog(null, "Resultado = " + operacion(a, b, operacion));
} else {
operacion = JOptionPane.showConfirmDialog(null, "Esta seguro que quiere salir?");
}

} while (operacion != 0);

}
}

La clase Color
Esta clase es una utileria para manejar información sobre colores utilizando el estandar RGB (Red, Green, Blue).
La clase Color se encuentra en el paquete java.awt
Se puede instanciar utiliazando los siguientes constructores:

Color(int r, int g, int b) //Red, Green, Blue

Color(int r, int g, int b, a) //Red, Green, Blue, Alpha

Existen constantes estaticas que permiten obtener una instancia de los colores basicos, estas constantes estaticas son las
siguientes:

Color.BLACK;
Color.BLUE;
Color.CYAN;
Color.DARK_GRAY;
Color.GRAY;
Color.LIGHT_GRAY;
Color.GREEN;
Color.MAGENTA;
Color.ORANGE;
Color.PINK;
Color.RED;
Color.WHITE;
Color.YELLOW;

Esta clase por si sola no tiene mucha funcionalidad, provee una variedad de metodos utiles sin embargo para poder aplicar un
color a determinada forma o componente se debe utilizar la clase Graphics2D.

Las clases Point, Dimension y Rectangle

Estas clases son utiles para trabajar con coordenadas en pixels.

La clase Point es de utilidad para mantener información específica sobre un punto en la pantalla. Uno de los metodos
principales de la clase point es distance(Point p); cuyo resultdo es la distancia entre dos puntos.

Ejemplo:

Point p1 = new Point(5,3);

Point p2 = new Point(10,34);
p1.distance(p2);

La clase Dimension es de utilidad para almacenar valores de dimensiones de componentes como ventanas, paneles etc, su
constructor principal es:

Dimension d = new Dimension(200,500);

La clase Rectangle es una utileria que permite mantener informacion sobre las coordenadas de un rectángulo su principal
constructor es:

Rectangle(int x, int y, int width, int height)

Esta clase tambien contiene metodos sobrecargados muy útiles para trabajar con rectangulos, por ejemplo:

contains(); Verifica si un punto o un rectangulo esta contenido dentro del rectangulo.

intersects(); Verifica si un rectangulo se intersecta con otro rectangulo.

Ejemplo:

Rectangle r = new Rectangle(0,0,100,200);

La clase Graphics2D
Esta clase permite dibujar formas y figuras basicas dentro de un contenedor. Esta clase es una version
mejorada de la clase Graphics.

Sus metodos más comunes son los siguientes:

Forma Descripcion
Linea g.drawLine(35, 45, 75, 95);

drawLine(int x1, int y1, int x2, int y2)

Rectangulo g.drawRect(35, 45, 25, 35);

drawRect(int x, int y, int width, int length)

Rectangulo con g.drawRoundRect(35,45,25,35,10,10);

esquinas redondeadas
drawRoundRect(int x, int y, int width, int length, int arcWidth, int arcHeight)

Ovalo / Circulo g.drawOval(25, 35, 25, 35);

g.drawOval(25, 35, 25, 25); → circle

drawOval(int x, int y, int width, int length)

Arco g.drawArc(35, 45, 75, 95, 0, 90);

drawArc(int x, int y, int width, int length, int startAngle, int arcAngle)

Poligono int [ ] x = {20, 35, 50, 65, 80, 95};

int [ ] y = {60, 105, 105, 110, 95, 95};

g.drawPolygon(x, y, 6);

drawPolygon(int x[ ], int y[ ], int n)

Texto g.drawString("Java is cool!", 40, 70);

drawString(String str, int x, int y);