CICLO II:

Programación
Básica en Java
 Sesión 6:
Introducción a
Java
Programación Orientada a Objetos (POO)
Objetivos de la sesión
Al finalizar esta sesión estarás en capacidad de:

1. Especificar cómo se inicializa un objeto cuando no existe un constructor

2. Inicializar objetos utilizando un constructor
3. Definir el diagrama de clase insertando el constructor
4. Mostrar la existencia de los paquetes del API de Java y explicar los más importantes.
5. Explicar los conceptos asociados a métodos y campos static
 En Java podemos definir un método que se
ejecute inicialmente y en forma automática.
Este método se lo llama constructor.

El constructor tiene las siguientes características:

•Tiene el mismo nombre de la clase.

•Es el primer método que se ejecuta.
•Se ejecuta en forma automática.
•No puede retornar datos.
•Se ejecuta una única vez.
•Un constructor tiene por objetivo inicializar atributos.
 ¿Qué es un constructor en Java?
● En Java es un método especial dentro de una clase, que se llama automáticamente
cada vez que se crea un objeto de esa clase.

● Un constructor inicializa un objeto cuando se crea. Tiene el mismo nombre que su

clase y es sintácticamente similar a un método. Sin embargo, los constructores no
tienen un tipo de devolución explícito.

● Todas las clases tienen constructores, ya sea que se defina uno o no, porque Java
proporciona automáticamente un constructor predeterminado. En este caso, las
variables de miembro no inicializadas tienen sus valores predeterminados, que son
cero, null y false. Una vez que defines tu propio constructor, el constructor
predeterminado ya no se usa.
 Crear Constructores en JAVA
Los constructores de una clase son fragmentos de código que
sirven para inicializar un objeto a un estado determinado.

Una clase puede carecer de constructor, pero esto no es lo más habitual.

Normalmente todas nuestras clases llevarán constructor.

Esquema de un constructor:

public NombredeLaClase (tipo parámetro1, tipo parámetro2 …, tipo parámetro n ) {

campo1 = valor o parámetro;
campo2 = valor o parámetro;
. . . Los constructores tienen el
campo n = valor o parámetro; mismo nombre que la clase en
} la que son definidos y nunca
tienen tipo de retorno
Constructor – Sintaxis en Java
class className {

// Constructor
nombre de la clase() {
// ...
}

// Otros metodos…
void method1 () {
// ...
}

void method2 () {
// ...
}
}
 Diferenciar
Constructores de Metodos

Un aspecto que nos permite diferenciar

constructores de métodos: un constructor nunca
tiene tipo de retorno mientras que un método
siempre lo tiene.

Es recomendable que en un constructor se

inicialicen todos los atributos de la clase
aunque su valor vaya a ser nulo o vacío.
public class Taxi { //El nombre de la clase

private String ciudad; //Ciudad de cada objeto taxi

Constructor – Ejemplo
private String matricula; //Matrícula de cada objeto taxi
private String distrito; //Distrito asignado a cada objeto taxi
Private int tipoMotor; //Tipo de motor asignado a cada objeto taxi. 0 = desconocido, 1 = gasolina, 2 = diesel

//Constructor: cuando se cree un objeto taxi se ejecutará el código que incluyamos en el constructor
public Taxi (String valorMatricula, String valorDistrito, int valorTipoMotor) {
ciudad = "México D.F.";
matricula = valorMatricula;
distrito = valorDistrito;
La inicialización depende
tipoMotor = valorTipoMotor; de los parámetros que le
} //Cierre del constructor lleguen al constructor

//Método para obtener la matrícula del objeto taxi

public String getMatricula () { return matricula; } //Cierre del método

//Método para obtener el distrito del objeto taxi

public String getDistrito () { return distrito; } //Cierre del método

//Método para obtener el tipo de motor del objeto taxi

public int getTipoMotor () { return tipoMotor; } //Cierre del método

} //Cierre de la clase
 Ejemplo – Estructura en Java
import java.util.Scanner;

public class Estu {

public static void main(String[] args) {
Scanner lea = new Scanner(System.in);
Estudiante e1 = new Estudiante();//creando objeto para instanciar atributos de la clase
/*implementación*/
}
//método promedio
public static float prom(float nota1,float nota2, float nota3) {

return (nota1+nota2+nota3)/3;
}
}
//Clase estudiante
class Estudiante {

public String nombre;

public float nota1, nota2, nota3;
}
 Ejemplo
simple de un constructor:
public class PruebaPrecio {
public static void main(String [] args) {
Precio p; // Crea una referencia de la clase Precio
p = new Precio(); // Crea el objeto de la clase Precio y realiza
// una llamada al metodo constructor
}
}

En el ejemplo de la clase PruebaPrecio, que utiliza una instancia de la clase Precio, la

llamada al constructor se produce en la sentencia p = new Precio();. Mientras que la
ejecución de new genera una nueva instancia y devuelve su dirección de memoria, la
ejecución del constructor Precio() inicializa los valores de los atributos.
Para este caso se inicializa un objeto cuando “no existe” un constructor.
 Ejemplo constructor instanciación
de la clase anterior
class MiClase { En este ejemplo, el constructor de
int x;
MiClase es:
MiClase(){
MiClase(){ //constructor MiClase
x=10;
x=10; }
}
} Este constructor asigna a la
class ConstructorDemo { variable de instancia x de MiClase
public static void main(String[] args) { el valor de 10. Este constructor es
MiClase t1= new MiClase(); // objeto t1 llamado por new cuando se crea un
MiClase t2= new MiClase(); // objeto t2 objeto.
Salida: 10 - 10
System.out.println(t1.x + " - "+t2.x);
}
} MiClase t1= new MiClase();
El constructor MiClase() es llamado en el objeto t1, dando a t1.x el valor de 10.
Lo mismo es cierto para t2. Después de la construcción, t2.x tiene el valor de 10.
Por lo tanto, el resultado del programa es: Salida: 10 - 10
import java.util.Scanner;

Constructor – Ejemplo
public class Alumno { // clase alumno
private Scanner teclado;
private String nombre; // atributo nombre
private int edad; // atributo edad

public Alumno() { // constructor con el mismo nombre de la clase

teclado=new Scanner(System.in); Plantear una clase llamada Alumno y
System.out.print("Ingrese nombre: ");
nombre=teclado.nextLine(); definir como atributos su nombre y su
System.out.print("Ingrese edad: ");
edad=teclado.nextInt();
edad.
}

public void imprimir() { // metodo imprimir En el constructor realizar la carga

System.out.println("Nombre: "+nombre);
System.out.println("Edad: "+edad); de datos.
}

public void esMayorEdad() { // metodo esMayorEdad

if (edad>=18) {
Definir dos métodos para imprimir los
System.out.print(nombre+" es mayor de edad."); datos ingresados y un mensaje si es
} else {
System.out.print(nombre+" no es mayor de edad."); mayor o no de edad (edad >=18)
}
}

public static void main(String[] ar) {

System.out.print("\033[H\033[2J"); // limpia pantalla

//En la main el constructor se llama

//en forma automática cuando creamos
//un objeto de la clase Alumno:
Alumno alumno1=new Alumno(); // creamos el objeto alumno1
alumno1.imprimir(); // llama almetodo imprimir
alumno1.esMayorEdad(); // llama al metodo esMayorEdad
}
}
import java.util.Scanner;
public class Operarios {
Constructor – Ejemplo
private int[] sueldos;//defino sueldo como un arreglo de enteros

public Operarios() { //constructor

Scanner teclado = new Scanner(System.in);
sueldos=new int[5]; //se reserva espacio de memoria para 5 números enteros
for(int f=0;f<5;f++) {
System.out.print("Ingrese valor del salario: ");
sueldos[f]=teclado.nextInt(); //asigno valor al vector
}
}
Se desea guardar los
public void imprimir() {
System.out.println("Los sueldos de los operarios son");
sueldos de 5 operarios en
for(int f=0;f<5;f++) { un vector. Realizar la
System.out.printf(sueldos[f]+"\t"); creación y carga del vector
}
}
en el constructor.

public static void main(String[] ar) {

Operarios op=new Operarios();
op.imprimir();
}
}
 public Operarios() {

import java.util.Scanner; Scanner teclado = new Scanner(System.in);

public class Operarios { sueldos=new int[5];
private int[] sueldos; //defino sueldo como arreglo enteros for(int f=0;f<5;f++) {
System.out.print("Ingrese valor de la componente:");
public Operarios() { //constructor operarios sueldos[f]=teclado.nextInt();
}
Scanner teclado = new Scanner(System.in);
}
sueldos=new int[5];
for(int f=0;f<5;f++) {
System.out.print("Ingrese valor de la componente:"); Como la clase se llama Operarios el constructor
sueldos[f]=teclado.nextInt();//asigno valor al vector tiene el mismo nombre, no disponemos la palabra
} clave void ya que el constructor no puede
} retornar datos.
La ventaja de plantear un constructor es que se
public void imprimir() { //método imprimir
for(int f=0;f<5;f++) { llamará en forma automática cuando se crea un
System.out.println(sueldos[f]); objeto de esta clase:
}
} public static void main(String[] ar) {
Operarios op=new Operarios();
public static void main(String[] ar) {
Operarios op=new Operarios(); // crea objeto op
op.imprimir(); // llamo al método imprimir Cuando se crea el objeto op se llama al método
} constructor.
}
Finalmente llamamos al método imprimir:
op.imprimir();
 API de Java

● Los programas se construyen combinando nuevos métodos y clases con los

predefinidos en la API de Java.

● Las clases son agrupadas en paquetes y pueden ser importadas y reusadas.

● La API de Java contiene una colección enorme de clases predefinidas que

contienen métodos para ejecutar cálculos matemáticos, manipulación de strings,
de caracteres, operaciones de entrada/salida, operaciones de bases de datos,
archivos, y muchas más.
 API de Java
Interfaz de programación de aplicaciones
(Application Programming Interface)

La API de Java es una biblioteca de clases preescritas,

incluidas en el entorno de desarrollo de Java.

La biblioteca contiene componentes para administrar entradas,

programación de bases de datos y mucho más.

La biblioteca se divide en paquetes y clases . Lo que significa

que puede importar una sola clase (junto con sus métodos y
atributos) o un paquete completo que contiene todas las clases
que pertenecen al paquete especificado.

Para usar una clase o un paquete de la biblioteca, debe usar

la palabra reservada import
API de Java
 Métodos static
y atributos static
La mayoría de los métodos se ejecutan en respuesta a las llamadas Que se hacen de ellos en
objetos específicos, sin embargo, hay otros que no. En ocasiones un método realiza una tarea
que no depende del contenido de ningún objeto. En este caso se aplica a la clase en la que
está declarado como un todo y se conoce como método static.
Consideraciones:
○ Sólo existen una vez por clase, independientemente del número de instancias
(objetos) de la clase que se haya creado y aunque no exista ninguna.
○ El método o el atributo se comportan siempre de la misma manera
○ Se puede acceder a los miembros estáticos utilizando el nombre de la clase.
○ Un método estático no puede acceder a miembros no estáticos directamente, tiene
que crear primero un objeto
 Métodos static
y atributos static
Algunas Reglas:

● Los métodos y atributos estáticos se llaman así:

NombreClase.metodoEstatico(<args>);
NombreClase.atributoEstatico;

● Para acceder a los métodos y atributos no estáticos se necesita de una

instancia (objeto) de la clase:
NombreClase nombreObjeto = new NombreClase();
● Los miembros no estáticos se llaman así:
nombreObjeto.metodoNormal();
nombreObjeto.atributoNormal;
 Métodos static
y atributos static
Algunas Reglas:

● Cuando la llamada a un método o atributo estático de la clase se realiza

dentro de la propia clase se puede omitir el nombre de la misma:

metodoEstatico();
atributoEstatico;

en vez de:

NombreClase.metodoEstatico();
NombreClase.atributoEstatico;
 Atributos estáticos

En la representación de Diagrama de clase, los atributos estáticos se representan

subrayados, los públicos con un prefijo + y los privados con un prefijo -.
 Métodos estáticos

En la representación de Diagrama de clase, los métodos estáticos se representan

subrayados.
 Métodos estáticos

La diferencia entre un método

estático y un método normal
es que el método estático se
llama a través de su nombre
de clase, sin que se cree
ningún objeto de esa clase.
class StaticDemo {
int x; //Variable de instancia normal
static int y; //Variable estática
Atributos estáticos
public int suma(){ // método suma
return x+y;
}
}

class Test{
public static void main(String[] args) {
System.out.print("\033[H\033[2J"); // limpia pantalla

StaticDemo ob1=new StaticDemo(); //creando objeto ob1

StaticDemo ob2=new StaticDemo(); //creando objeto ob2

ob1.x=10;
ob2.x=12;
System.out.println("Por supuesto, ob1.x y ob2.x son independientes.");
System.out.println("ob1.x: "+ob1.x+"\nob2.x: "+ob2.x);
System.out.println();

//Cada objeto comparte una copia de una variable estática

System.out.println("La variable estática 'y' es compartida.");
StaticDemo.y=100; //llamado atributo estatico nom_clase.atibuto
System.out.println("Cambio de StaticDemo.y a 100");
System.out.println("ob1.suma(): "+ob1.suma()); //x=10 + y=100
System.out.println("ob2.suma(): "+ob2.suma()); //x=12 + y=100
}
}
 Métodos estáticos
// Ejemplo de método estático
class Static_Eje
{
static int valor=1024; //Un atributo estático

//Un método estático valDiv2

public static int valDiv2(){
return valor/2;
}
NomClase atributo estatico
public static void main(String[] args) {
System.out.print("\033[H\033[2J");

System.out.println("El valor es: "+Static_Eje.valor);

System.out.println("Valor dividido 2: "+Static_Eje.valDiv2());
NomClase . metodo estático
Static_Eje.valor=4;
System.out.println("El valor es: "+Static_Eje.valor);
System.out.println("Valor modificado dividido 2: "+Static_Eje.valDiv2());
}
}