11.
POO
Crear un Paquete (Package)
1. Crear un Directorio
2. Desde IntelliJ. creamos un nuevo Proyecto: File > New > Project
3. Digitamos el nombre del Proyecto y la carpeta donde los vamos a crear.
4. Creamos un paquete: File > New > Package.
5. Botón izquierdo sobre src y creamos una nueva Clase.
6. Creamos el método Constructor. Este método debe llamarse igual que la clase.
Método Constructor
Un constructor es un método especial utilizado para inicializar objetos. A diferencia de los métodos normales, los
constructores se invocan cuando se crea una instancia de una clase. Tienen el mismo nombre que la clase y no
tienen tipo de retorno. Los constructores son esenciales para
Es el primer método que se ejecuta por defecto cuando creamos una clase, nos permite crear nuevas instancias
de una clase, estableciendo los valores iniciales de los atributos del objeto y prepararlo para su uso. Lo
invocamos con la palabra reservada new seguida del nombre con el que inicializamos la clase y paréntesis.
// Archivo: Coche.java
package poo;
public class Coche {
int ruedas;
int largo; // En cms.
int ancho; // En cms.
int motor; // Caballos de fuerza
int peso; // en kgrs.
// método Constructor
public Coche(){ // Mismo nombre de la clase a la que pertenece
ruedas = 4;
largo = 2500;
ancho = 300;
motor = 1600;
peso = 500;
}
}
// Archivo: UsoCoche.java
package poo;
public class UsoCoche {
public static void main(String[] args) {
//Clase Objeto Constructor
Coche Renault = new Coche(); // Instanciando la Clase Coche
// Renault es un objeto de la clase Coche
System.out.println("Esta auto tiene " + Renault.ruedas + " ruedas");
System.out.println(Renault.ancho); // 300
System.out.println(Renault.largo); // 2500
System.out.println(Renault.motor); // 1600
System.out.println(Renault.peso); // 500
}
}
Encapsulamiento
Indica que los atributos que definen propiedades propias de la clase deben tener visibilidad private . De esta
forma se ofrece seguridad a la información depositada en dichos atributos. En los archivos anteriores, la variable
ruedas la volvemos de tipo private , con ello, dicha variable, ya no puede ser modificada por la clase
Uso_Coche .
//Archivo: Coche.java
package poo;
public class Coche {
private int ruedas; // Con private encapsulamos esta variable con private
// private encapsula la variable para que no pueda ser modificado por otra clase int
largo; // En cms.
int ancho; // En cms.
int motor; // Caballos de fuerza
int peso; // en kgrs.
// método Constructor
public Coche(){ // Mismo nombre de la clase a la que pertenece
ruedas = 4;
largo = 2500;
ancho = 300;
motor = 1600;
peso = 500;
}
}
// Archivo: UsoCoche.java
package poo;
public class UsoCoche {
public static void main(String[] args) {
/*
Clase Objeto Constructor */ Coche Renault = new Coche(); //
Instanciando la Clase Coche
// Renault es un objeto de la clase Coche /* System.out.println("Esta
auto tiene " + Renault.ruedas + " ruedas"); Al hacer la variable rueda como static,,
la clase Uso_Coche ya no la puede ver Para visualizarla se debe realizar asi . . .
*/
System.out.println(Renault.ancho); // 300
System.out.println(Renault.largo); // 2500
System.out.println(Renault.motor); // 1600
System.out.println(Renault.peso); // 500
}
}
Ejemplo de Setter y Getter:
package pqtObjetos;
public class Persona {
//Atributos
private String nombre;
private String apellidoPaterno;
private String apellidoMaterno;
private char sexo;
private int edad;
private String direccion;
//Constructor por defecto
public Persona(){
}
//Constructor de copia
public Persona(Persona persona){
this.nombre=persona.nombre;
this.apellidoPaterno=persona.apellidoPaterno;
this.apellidoMaterno=persona.apellidoMaterno;
this.sexo=persona.sexo;
this.edad=persona.edad;
this.direccion=persona.direccion;
}
//Constructor común
public Persona(String nom, String app, String apm, char sexo, int edad, String dir){
this.nombre=nom;
this.apellidoPaterno=app;
this.apellidoMaterno=apm;
this.sexo=sexo;class Car {
String make;
String model;
int year;
public Car(String make, String model, int year) {
this.make = make;
this.model = model;
this.year = year;
}
@Override
public String toString() {
return "Car{" +
"make='" + make + '\'' +
", model='" + model + '\'' +
", year=" + year +
'}';
}
public static void main(String[] args) {
Car myCar = new Car("Toyota", "Camry", 2023);
System.out.println(myCar); // Output: Car{make='Toyota', model='Camry', year=2023}
}
}
this.edad=edad;
this.direccion=dir;
}
public void mayorEdad(int edad){
if(edad>18)
System.out.println("Es mayor de edad");
else
System.out.println("Es menor de edad");
}
public String mostrarDatos(Persona persona){
String datos="Los datos son: \n";
datos+=persona.nombre+"\n";
datos+=persona.apellidoPaterno+"\n";
datos+=persona.apellidoMaterno+"\n";
datos+=persona.sexo+"\n";
datos+=persona.edad+"\n";
datos+=persona.direccion+"\n";
return datos;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getApellidoPaterno() {
return apellidoPaterno;
}
public void setApellidoPaterno(String apellidoPaterno) {
this.apellidoPaterno = apellidoPaterno;
}
public String getApellidoMaterno() {
return apellidoMaterno;
}
public void setApellidoMaterno(String apellidoMaterno) {
this.apellidoMaterno = apellidoMaterno;
}
public char getSexo() {
return sexo;
}
public void setSexo(char sexo) {
this.sexo = sexo;
}
public int getEdad() {
return edad;
}
public void setEdad(int edad) {
this.edad = edad;
}
public String getDireccion() {
return direccion;
}
public void setDireccion(String direccion) {
this.direccion = direccion;
}
}
package pqtObjetos;
public class Principal {
public static void main(String[] args) {
//Guardamos los datos
Persona persona=new Persona();
persona.setNombre("Linda");
persona.setApellidoPaterno("Gómez");
persona.setApellidoMaterno("Pérez");
persona.setSexo('M');
persona.setEdad(28);
persona.setDireccion("Calle Ariban, Madrid");
//Obtenemos los datos y los imprimimos
String nombre=persona.getNombre();
String app=persona.getApellidoPaterno();
String apm=persona.getApellidoMaterno();
char sexo=persona.getSexo();
int edad=persona.getEdad();
String direccion=persona.getDireccion();
System.out.println("Los datos de la persona son: "+nombre+", "+app+",
"+apm+", "+sexo+", "+edad+", "+direccion);
}
Static
En Java, la palabra clave static se usa para gestionar la memoria y definir miembros que pertenecen a la
clase, no a las instancias de la clase.
Una clase, método o campo declarado como estático puede ser accedido o invocado sin la necesidad de tener
que instanciar un objeto de la clase. En otras palabras, los métodos estáticos pertenecen a la clase, no a una
instancia específica de esta. Se pueden llamar directamente desde la clase sin necesidad de crear una instancia
de la misma.
Cuando una variable se declara como estática, significa que solo existe una copia para toda la clase, en lugar de
que cada instancia tenga su propia copia. Esto implica que solo existe una copia de la variable en memoria,
independientemente de cuántas instancias de la clase se creen.
Métodos Static
No actúan sobre objetos.
No acceden a campos de ejemplar (variables/constantes declaradas en la clase), a menos que sean
también static.
Para llamarlos se utiliza el nombre clase.nombre_metodo.
// Archivo: MetodoStatic. java
public class MetodoStatic {
private static int valorStatic = 0;
private int valorNoStatic = 0;
public static final int valorFinalStatic = 256;
public void setValorStatic(){
valorStatic++;
}
public static int getValorStatic() {
return valorStatic;
}
public void setValorNoStatic(){
valorNoStatic++;
}
public int getValorNoStatic() {
return valorNoStatic;
}
public static int sumar(int a, int b){
// Importante, este método Static no puede acceder a
// la variable valorNoStatic por no ser de tipo Static
// valorNoStatic++; produce un error o hay cambiar su condición.
return a + b;
}
}
// Archivo: Sumando.java
public class Sumando {
public static void main(String[] args) {
// Una clase static se puede llamar sin crear un objeto de la clase en la que
residen.
// Una clase static se puede llamar sin instanciar la clase. int resultado =
MetodoStatic.sumar(7, 5);
System.out.println(resultado);
MetodoStatic contador1 = new MetodoStatic();
MetodoStatic contador2 = new MetodoStatic();
MetodoStatic contador3 = new MetodoStatic();
contador1.setValorStatic(); // 1
contador2.setValorStatic(); // 2
contador3.setValorStatic(); // 3
// No importa qué objeto lo llame, el valor se va compartir para todos
// Como hemos llamado tres veces al método valor(), "valor" tendrá un valor de 3
System.out.println("La variable \"valorStatic\" tiene un valor de " +
MetodoStatic.getValorStatic()); // 3
System.out.println("La variable \"valorStatic\" tiene un valor de " +
contador1.getValorStatic()); // 3
System.out.println("La variable \"valorStatic\" tiene un valor de " +
contador2.getValorStatic()); // 3
System.out.println("La variable \"valorStatic\" tiene un valor de " +
contador3.getValorStatic()); // 3
contador1.setValorNoStatic(); // 1
contador1.setValorNoStatic(); // 2
contador2.setValorNoStatic(); // 1
contador3.setValorNoStatic(); // 1
System.out.println("\nLa variable \"valorNoStatic\" tiene un valor de " +
contador1.getValorNoStatic()); // 2
System.out.println("La variable \"valorNoStatic\" tiene un valor de " +
contador2.getValorNoStatic()); // 1
System.out.println("La variable \"valorNoStatic\" tiene un valor de " +
contador3.getValorNoStatic()); // 1
System.out.println(MetodoStatic.valorFinalStatic); // 256
// Las variables final static y públicas no es neceario instanciar la clase para que
otra clase pueda utilizar la variable valorFinalStatic
// Para invocarla desde otra clase se utiliza <NombreClase>.
<NombreVariablePublicaStaticFinal>
}
}
// Archivo: VariableStatic.java
public class VariableStatic {
static int variableEstatica = 0;
int variableNoEstatica = 0;
public static void main(String [] args){
//Incrementamos la variable estática
VariableStatic.variableEstatica++; // 1
VariableStatic.variableEstatica++; // 2
//Incrementamos la variable no estática VariableStatic variableStatic_1 =
new VariableStatic();
VariableStatic variableStatic_2 = new VariableStatic();
variableStatic_1.variableNoEstatica++;
variableStatic_2.variableNoEstatica++;
//Mostramos resultados
System.out.println(VariableStatic.variableEstatica); // 2
System.out.println(variableStatic_1.variableNoEstatica); // 1
System.out.println(variableStatic_2.variableNoEstatica); // 1
}
}
Palabra Final
La palabra clave final en Java es un modificador de no acceso que puede aplicarse a variables, métodos y
clases. Se utiliza para restringir al usuario la posibilidad de seguir modificando la entidad a la que se aplica.
Final Variables
Una variable final es una constante; una vez inicializada, su valor no puede cambiarse. Debe inicializarse
cuando se declara o dentro de un constructor si es una variable de instancia.
public class FinalInitialization {
final int MAX_VALUE;
public FinalInitialization() {
MAX_VALUE = 100;
}
}
Final Métodos
Un método final no puede ser sobrescrito por subclases, lo que garantiza que la implementación del método
permanezca inalterada.
class Parent {
public final void display() {
System.out.println("Este es un método final.");
}
}
Final Clases
Una clase final no puede subclasificarse, lo que impide la herencia.
public final class FinalClass {
// Códifo
}
Palabra This
La palabra clave this se utiliza principalmente en los siguientes casos:
1. Para hacer referencia a la variable de instancia de la clase actual.
2. Para invocar el método de la clase actual.
3. Para invocar al constructor de la clase actual.
4. Para pasar el objeto actual como parámetro a un método.
5. Para devolver el objeto actual desde un método.
6. Para pasar el objeto actual como parámetro a un constructor.
7. Para acceder a la instancia de la clase externa desde una clase interna.
// Referencia a variables de instancia
public class ThisEjemplo {
int a;
int b;
ThisEjemplo(int a, int b) {
this.a = a; // Para diferenciar las variables. "a" es variable que representa el
argumento
this.b = b; // this.b se refiere a la variable "b" de la clase
}
void display() {
System.out.println("a: " + this.a + ", b: " + this.b);
}
public static void main(String[] args) {
ThisEjemplo objeto = new ThisEjemplo(10, 20);
objeto.display();
}
}
// Invocar un método
public class ThisEjemploMetodo {
void display() {
System.out.println("¡Hola Muchachos!");
}
void invocarMetodo() {
this.display();
}
public static void main(String[] args) {
ThisEjemploMetodo objeto = new ThisEjemploMetodo();
objeto.invocarMetodo();
}
}
public class ThisEjemplo {
int a;
int b;
ThisEjemplo() {
this(7, 3);
}
ThisEjemplo(int a, int b){
this.a = a * 2; // this.a (variable de clase) y a (argumento)
this.b = b * 2; // con This hace referencia a la variable de clase
}
void display() {
System.out.println("a: " + this.a + ", b: " + this.b);
}
@Override
public String toString() {
return "\nnew ThisEjemplo(), como no tiene argumento, busca el constructor sin
argumento.\n" +
"El método toString() permite que cuando nosotros solicitemos información
por\n" +
"la consola del objeto esta sea mucho más clara.\n" +
"Sin el @Override, lo que se imprime es System.out.println(objeto) ->
ThisEjemplo@2a84aee7";
}
public static void main(String[] args) {
ThisEjemplo objeto = new ThisEjemplo();
objeto.display();
System.out.println(objeto);
}
}
public class ThisConstructorEjemplo{
String primerNombre;
String pais;
int edad;
public ThisConstructorEjemplo() {
// Este this llama al constructor con un argumento string
this("Martha");
}
public ThisConstructorEjemplo(String primerNombre) {
// Este this llama al contructor con dos argumentos (String e int)
this(primerNombre, 15);
}
public ThisConstructorEjemplo(String primerNombre, int edad) {
// Este this llama a un contrsctor con tres argumentos (String, int, String)
this(primerNombre, edad, "Australia");
}
public ThisConstructorEjemplo(String primerNombre, int edad, String pais) {
this.primerNombre = primerNombre;
this.edad = edad;
this.pais = pais;
}
void displayValues() {
System.out.println("Primer Nombre : " + primerNombre);
System.out.println("País : " + pais);
System.out.println("Age : " + edad);
}
public static void main(String args[]) {
ThisConstructorEjemplo objecto = new ThisConstructorEjemplo();
objecto.displayValues();
}
}
public class Lampara {
private String color;
private boolean encendida;
public Lampara(String color) {
this.color = color;
}
public Lampara() {
this("Roja");
}
public String getColor() {
return color;
}
public void interruptor() {
encendida = !encendida;
System.out.println("Lámpara: " + encendida);
}
public boolean isEncendida() {
return encendida;
}
@Override
public String toString() {
String onOff = encendida ? "ON" : "OFF";
return "La lámpara es " + color + " y está " + onOff;
}
}
class LamparaCreator {
public static void main(String[] args) {
Lampara lampara = new Lampara();
System.out.println(lampara);
System.out.println(lampara.getColor() + " " + lampara.isEncendida());
lampara.interruptor();
System.out.println(lampara.getColor() + " " + lampara.isEncendida());
System.out.println(lampara);
}
}
