Programación orientada a objetos

Definiendo clases y atributos

class MiClase{
public int valorPublico;
private int datoPrivado;
}
public class melo {
public static void main(String[] args) {
// TODO Auto-generated method stub
// TODO code application logic here
MiClase instancia =new MiClase();
instancia.valorPublico=17;
System.out.println(instancia.valorPublico);
//instancia.datoPrivado=12345;
//System.out.println(instancia.datoPrivado);
}
}
Definiendo métodos para acceder a atributos privados

Class MiClase{
Private int datoPrivado;
Public void ponerDato(int valor){
this.datoPrivado=valor;
}
Public int devolverDato(){
Return this.datoPrivado;
}
}
Public Class Melo {
Public Static void main(String[] args) {
// TODO code application logic here
MiClase instancia = New MiClase();
instancia.ponerDato(12345);
System.out.println(instancia.devolverDato());
}

Dos variables, misma instancia

Class MiClase{
Public int valorPublico;

}
Public Class Melo {
Public Static void main(String[] args) {
// TODO code application logic here
MiClase instancia = New MiClase();
instancia.valorPublico=17;
MiClase otraVariable = instancia;
System.out.println("Otra variable: "+otraVariable.valorPublico);
System.out.println("Instancia: "+instancia.valorPublico);

Dos variables y dos instancias distintas

Class MiClase{

Public int valorPublico;

}
Public Class Ejercicio2 {
Public Static void main(String[] args) {
// TODO code application logic here

MiClase instancia = New MiClase();

instancia.valorPublico=17;
MiClase otraVariable = New MiClase();
otraVariable.valorPublico=2853;
System.out.println("otraVariable: "+ otraVariable.valorPublico);
System.out.println("Instancia: "+ instancia.valorPublico);
}
}

Constantes

Class MiClase{
Static final Double VALORCONSTANTE=2.7812431;

}
Public Class Ejercicio3 {
Public Static void main(String[] args) {
// TODO code application logic here
MiClase instancia = New MiClase();
System.out.println(instancia.VALORCONSTANTE);
}
}
Constructores y destructores
Class MiClase{
MiClase(){
System.out.println("Ejecuta al instanciar un objeto ");
}
}
Public Class JavaApplication20 {

Public Static void main(String[] args) {

MiClase objeto = New MiClase();

}
El constructor puede tener parámetros

Class MiClase{
String valorPublico;
MiClase(String valor ){
this.valorPublico=valor;
}
void gc() {
Throw New UnsupportedOperationException("Not supported yet."); //To change
body Of generated methods, choose Tools | Templates.
}
}
Public Class ConstructoresyDestructores {
Public Static void main(String[] args) {
MiClase objeto = New MiClase("Hola Mundo");
System.out.println(objeto.valorPublico);

Destructor

En java no hay destructor.

http://labojava.blogspot.com/2012/05/constructores-y-destructores.html
Un constructor con parámetros con valores por defecto
- En java no se permite la asignación de valores por defectos dentro del constructor,
pero se podría realizar asi el ejercicio propuesto en php , haciendo polimorfismo.

Class MiClase{
Public String valorA;
Public String valorB;
Public String valorC;
MiClase(String valorA,String valorB,String valorC){
this.valorA=valorA;
this.valorB=valorB;
this.valorC=valorC;
}
MiClase(String valorA,String valorB){
this.valorA=valorA;
this.valorB=valorB;
this.valorC="Sardina";
}
MiClase(String valorA){
this.valorA=valorA;
this.valorB="Pez Espada";
this.valorC="Sardina";
}
Public void Imprime(){
System.out.println(this.valorA+" .."+this.valorB+" .. "+this.valorC);
}
}
Public Class OBJETOCLASEINSTANCIA {
Public Static void main(String[] args) {
MiClase probar = New MiClase("Bagre");
probar.Imprime();
}
}
 Cambiando la instrucción que instancia con dos parámetros sucede.
Class MiClase{
Public String valorA;
Public String valorB;
Public String valorC;
MiClase(String valorA,String valorB,String valorC){
this.valorA=valorA;
this.valorB=valorB;
this.valorC=valorC;
}
MiClase(String valorA,String valorB){
this.valorA=valorA;
this.valorB=valorB;
this.valorC="Sardina";
}
MiClase(String valorA){
this.valorA=valorA;
this.valorB="Pez Espada";
this.valorC="Sardina";
}
Public void Imprime(){
System.out.println(this.valorA+" .."+this.valorB+" .. "+this.valorC);
}
}
Public Class OBJETOCLASEINSTANCIA {
Public Static void main(String[] args) {
MiClase probar = New MiClase("Bagre", "Delfin");
probar.Imprime();
}
}
 Instancia un objeto dentro de otra clase y accede a los atributos
Class MiClase{
Public Double valorPublico;

}
Class OtraClase{

Public MiClase objeto;

Public void unMetodo(Double valor){

this.objeto=New MiClase();
this.objeto.valorPublico=valor;
}
}
Public Class InstanciarObjetoClase {
Public Static void main(String[] args) {
OtraClase probar = New OtraClase();
probar.unMetodo(3.1415926537);
System.out.println(probar.objeto.valorPublico);

}
}
Llamando un método desde otra clase
Class MiClase{

Public int valorPublico=12;

Public String Aviso(){
Return "Metodo de MiClase";
}
}
Class OtraClase{

Public MiClase objeto;

Public void unMetodo(){

this.objeto=New MiClase();
this.objeto.Aviso();
}
}
Public Class InstanciarObjetoClase2 {
Public Static void main(String[] args) {
OtraClase probar = New OtraClase();
probar.unMetodo();
System.out.println(probar.objeto.Aviso());

}
Recibe un objeto como parámetro de una función
Class MiClase{
Public String valorPublico;
}
Public Class Ejercico12 {
Public Static void Imprimir(Object objeto){
MiClase p = (MiClase)objeto;
p=(MiClase) objeto;
System.out.println(p.valorPublico);
}
Public Static void main(String[] args) {
MiClase probar = New MiClase();
probar.valorPublico="Esta es una prueba...";
Imprimir(probar);
}
}
 Clonando objetos
package clonar;
Class Clonamiento{
Public String valora;
Public Double valorb;
}
Class Clonamiento2 Implements Cloneable
{
Public String valora;
Public Double valorb;
Clonamiento copia = New Clonamiento();
Public Object clone() throws
CloneNotSupportedException
{
Return super.clone();
}
}
Public Class Clonar {

Public Static void main(String[] args) throws

CloneNotSupportedException {
Clonamiento2 objeto = New Clonamiento2();
objeto.valora = "Hola mundo";
objeto.valorb = 3.14159265;
//SE CREA UN OBJETO NUEVO Y SE LE ASIGNA EL OBJETO ANTERIOR
Clonamiento2 objeto2 = (Clonamiento2)objeto.clone();
objeto.valorb = 90123.7;
System.out.println("valores con el original
son:"+objeto.valora+" ,"+objeto.valorb);
 System.out.println("valores con la copia
son :"+objeto2.valora+" ,"+objeto2.valorb);

}
Detectar instancias
Class MiClase Implements Clonable{
Public String valorPublico;
}
Class OtraClase{
Public void Imprimir(){
System.out.println("Esto es una prueba");
}
}
Public Class Ejercicio13 {

Public Static void main(String[] args) throws CloneNotSupportedException {

OtraClase objeto = New OtraClase();
//OtraClase MiClase
If (objeto instanceof OtraClase){
System.out.println("Objeto es instancia de mi clase");
}
Else{
System.out.println("Objeto NO es instancia de mi clase");
}

Métodos estáticos
Class MiClase{
Public Static void Imprimir(){
System.out.println("Hola mundo\n\n");
}
Public Static int sumar(int valA,int valB){
Return valA + valB;
}
}
Public Class Ejercicio14 {
Public Static void main(String[] args) {
MiClase.Imprimir();
int resultado = MiClase.sumar(17, 50);
System.out.println(resultado);
}
}

Serializar un objeto
package parcial;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.*;
 Class MiClase Implements java.io.Serializable {
Public int valora;
Public String valorb;
Public int valorc;

Public MiClase(int valora, String valorb, int valorc)

{
this.valora = valora;
this.valorb = valorb;
this.valorc = valorc;
}
Public MiClase(){

}
}

Public Class Actividad {

Public Static void muestraContenido(String archivo) throws
FileNotFoundException, IOException {
String cadena2;
FileReader f = New FileReader(archivo);
BufferedReader b = New BufferedReader(f);
While ((cadena2 = b.readLine())!= null) {
System.out.println(cadena2);
}
b.close();
}
Public Static void main(String[] args) throws FileNotFoundException,
IOException {
muestraContenido("C:\\Users\\sebastian\\Desktop\\serializado.txt");

MiClase objeto = New MiClase(11, "esto es una prueba", 3333);

String cadena = "C:\\Users\\sebastian\\Desktop\\serializado.txt";
//aqui se serializa el objeto
Try {

//se guarda la serializacion en un archivo

FileOutputStream file = New FileOutputStream(cadena);
ObjectOutputStream out = New ObjectOutputStream(file);

// Method for serialization of object

out.writeObject(objeto);

out.close();
file.close();
}
Catch(IOException ex)
{
System.out.println("IOException is caught");
}

MiClase objeto1 = null;

Try
{
 // Reading the object from a file
FileInputStream file = New FileInputStream(cadena);
ObjectInputStream in = New ObjectInputStream(file);

// Method for deserialization of object

objeto1 = (MiClase)in.readObject();
in.close();
file.close();
String convertedToString = String.valueOf(objeto1);
System.out.println( objeto1.valorb);
}
Catch(IOException ex)
{
System.out.println("IOException is caught");
}
Catch(ClassNotFoundException ex)
{
System.out.println("ClassNotFoundException is caught");
}
}

En java se debe implementar una interfaz llamada serializable.

Comparando objetos

Class MiClase{
Private int valorA;
Private int valorB;

Public int getValorA() {

Return valorA;
}
Public void setValorA(int valorA) {
this.valorA = valorA;
}
Public int getValorB() {
Return valorB;
}
Public void setValorB(int valorB) {
this.valorB = valorB;
}
}
Public Class ComparandoObjetos {
Public Static String comparar(MiClase a,MiClase b){
String resul = "";
If (a.getValorA() == b.getValorA() && a.getValorB() == b.getValorB()){
resul= "Son iguales";
}
Else{
resul="No son iguales";
}
Return resul;
}
Public Static void main(String[] args) {
// TODO code application logic here
MiClase objeto = New MiClase();
objeto.setValorA(11);
objeto.setValorB(222);
MiClase otro = New MiClase();
otro.setValorA(11);
otro.setValorB(222);
String resultado = comparar(objeto, otro);
System.out.println(resultado);
}
}
 Herencia
Class MiClase{
Public int valorPublico;
}
Class ClaseHija extends MiClase{
Public int propiedadHija;
}
Public Class Herencia1 {

Public Static void main(String[] args) {

ClaseHija objeto = New ClaseHija();
objeto.valorPublico=888;
objeto.propiedadHija=555;
System.out.println(objeto.valorPublico);
System.out.println(objeto.propiedadHija);
}
}
 Tipos de acceso en la herencia

Class MiClase{
Public String valorA="público";
Protected String valorB="protegido";
Private String valorC="privado";

}
Class ClaseHija extends MiClase{
Public void Metodo(){
System.out.println(this.valorA);
System.out.println(this.valorB);
System.out.println(this.valorC);//Dará error: undefined
}
}
Public Class Herencia2 {
Public Static void main(String[] args) {
ClaseHija probar = New ClaseHija();
probar.Metodo();
}

}
 Reacción a mismo método en clase padre e hija

Class MiClase{
Public void Imprimir(){
System.out.println("Texto de la clase padre");
}
}
Class ClaseHija extends MiClase{

Public void Imprimir(){

System.out.println("Imprime de la clase hija");
}
}
Public Class Herencia3 {
Public Static void main(String[] args) {
ClaseHija probar = New ClaseHija();
probar.Imprimir();
}
}
 Se añade una instrucción en el método de la clase hija para llamar al método de la clase
padre

Class MiClase{
Public void Imprimir(){
System.out.println("Texto de la clase padre");
}
}
Class ClaseHija extends MiClase{

Public void Imprimir(){

System.out.println("Imprime de la clase hija");
super.Imprimir();
}
}
Public Class Herencia4 {
Public Static void main(String[] args) {
ClaseHija probar = New ClaseHija();
probar.Imprimir();

}
 Un cuidado a tener es que los métodos deben tener el mismo número de parámetros, ver
el siguiente código: (EN EL CASO DE JAVA SI FUNCIONA)
Class MiClase{
Public void UnaFuncion(int valor){
System.out.println("Padre, recibe "+ valor);
}
}
Class ClaseHija extends MiClase{
Public void UnaFuncion(int valorA,int valorB){
System.out.println("Hija recibe: "+ valorA+", "+valorB);
}
}
Public Class Herencia {
Public Static void main(String[] args) {
ClaseHija probar = New ClaseHija();
probar.UnaFuncion(56,78);//En java lo permite si en caso de pasar un
parametro llama al metodo
//de la clase padre , si pasa 2 pues llama al
metodo de la clase Hija

}
}
 Reacción a constructores en clase padre e hija
Como php es un lenguaje no tipado tiene una forma para identificar
internamente a que constructor se esta refiriendo(hija o padre)
java al tener al mismo nombre del constructor llama a los dos.
Class MiClase{
Public MiClase(int valorA, int valorB){
System.out.println("Padre, recibe: "+ valorA+", "+valorB);
}
}
Class ClaseHija extends MiClase{
Public ClaseHija(int valorA, int valorB) {
super(valorA, valorB);
System.out.println("Hija, recibe: "+ valorA+", "+valorB);
}

}
Public Class ReacciónAConstructoresEnClasePadreEHija {

Public Static void main(String[] args) {

ClaseHija probar = New ClaseHija(56, 78);

}
Variando el código para que también ejecute el constructor de la clase padre
Class MiClase{
Public MiClase(int valorA, int valorB){
System.out.println("Padre, recibe: "+ valorA+", "+valorB);
 }
}
Class ClaseHija extends MiClase{
Public ClaseHija(int valorA, int valorB) {
super(valorA, valorB);
System.out.println("Hija, recibe: "+ valorA+", "+valorB);
}

}
Public Class ReacciónAConstructoresEnClasePadreEHija {

Public Static void main(String[] args) {

ClaseHija probar = New ClaseHija(56, 78);

Clases abstractas
abstract Class MiClase{
Public void operar(int valorA,int valorB){
System.out.println("Padre, recibe: "+ valorA+", "+valorB);
}
}
Class ClaseHija extends MiClase{
Public void Imprimir(){
System.out.println("Hola Mundo");
}
}
Public Class ClasesAbstractas {
Public Static void main(String[] args) {
ClaseHija probar = New ClaseHija();
probar.Imprimir();
 probar.operar(123, 678);
MiClase otro = New MiClase();
}

Métodos abstractos

abstract Class MiClase{

abstract void operar();
}
Class ClaseHija extends MiClase{
Public void Imprimir(int valorA,int valorB){
System.out.println("hija, recibe: "+valorA+", "+valorB);
}

Public void operar(){

System.out.println("metodo implementado obligatoriamente en la clase hija");
}
}
Public Class MetodosAbstractos {
Public Static void main(String[] args) {
ClaseHija probar = New ClaseHija();
probar.Imprimir(234,678);
probar.operar();
}
}
 ¿Qué sucede si no se implementa el método abstracto?

abstract Class MiClase{

abstract void operar();
}
Class ClaseHija extends MiClase{
Public void Imprimir(int valorA,int valorB){
System.out.println("hija, recibe: "+valorA+", "+valorB);
}

}
Public Class MetodosAbstractos {
Public Static void main(String[] args) {
ClaseHija probar = New ClaseHija();
probar.Imprimir(234,678);
probar.operar();
}
}
 Evitar la herencia
final Class MiClase{
Public void Imprimir(){
System.out.println("Texto de la clase padre");
}
}
//Se intenta acceder herencia y genera error
Class ClaseHija extends MiClase{
@Override
Public void Imprimir(){
System.out.println("Sobreescribo el metodo ");
}
}
Public Class EvitarLaHerencia {

Public Static void main(String[] args) {

ClaseHija probar = New ClaseHija();
probar.Imprimir();
}

}
 Lista de objetos

import java.util.ArrayList;
Class Nodo {
Private Double valor;
Private Char letra;
Private String cadena;

Public Nodo(Double valor, char letra, String cadena){

this.valor = valor;
this.letra = letra;
this.cadena = cadena;
}

Public void Imprime(){

System.out.println("Valor: " + valor + " Caracter: " + letra + " Cadena: " +
cadena );
}

/**
* @return the valor
*/
Public Double getValor() {
Return valor;
}

/**
* @param valor the valor to set
*/
Public void setValor(Double valor) {
this.valor = valor;
}
 /**
* @return the letra
*/
Public Char getLetra() {
Return letra;
}

/**
* @param letra the letra to set
*/
Public void setLetra(Char letra) {
this.letra = letra;
}

/**
* @return the cadena
*/
Public String getCadena() {
Return cadena;
}

/**
* @param cadena the cadena to set
*/
Public void setCadena(String cadena) {
this.cadena = cadena;
}
}
Class Main {
Public Static void main(String[] args) {
//Declara la lista que almacenará objetos
ArrayList<Nodo> Objetos = New ArrayList<>();

//Adiciona elementos a la lista

Objetos.add(New Nodo(7,'k',"prueba"));
Objetos.add(New Nodo(-9.4,'r',"texto"));
Objetos.add(New Nodo(1.836,'s',"test"));
//Trae un elemento. ¡OJO! Es una referencia (como un acceso directo)
Nodo tmp = Objetos.get(1);
tmp.Imprime();

Objetos.get(0).Imprime();
}
}
 https://repl.it/@AndresRojas/Estructura

Otra forma de crear una lista de objetos sin usar la instrucción array_push
No se puede agregar un valor objeto a una lista sin un add en java ya que el método add es
obligario para añadir elementos a la lista de objetos.

Cambiar un ítem en una lista de objetos

import java.util.ArrayList;
Class Nodo {
Private Double valor;
Private Char letra;
Private String cadena;

Public Nodo(Double valor, char letra, String cadena){

this.valor = valor;
this.letra = letra;
this.cadena = cadena;
}

Public void Imprime(){

System.out.println("Valor: " + valor + " Caracter: " + letra + " Cadena: " +
cadena );
}

/**
* @return the valor
*/
Public Double getValor() {
 Return valor;
}

/**
* @param valor the valor to set
*/
Public void setValor(Double valor) {
this.valor = valor;
}

/**
* @return the letra
*/
Public Char getLetra() {
Return letra;
}

/**
* @param letra the letra to set
*/
Public void setLetra(Char letra) {
this.letra = letra;
}

/**
* @return the cadena
*/
Public String getCadena() {
Return cadena;
}

/**
* @param cadena the cadena to set
*/
Public void setCadena(String cadena) {
this.cadena = cadena;
}
}
Class Main {
Public Static void main(String[] args) {
//Declara la lista que almacenará objetos
ArrayList<Nodo> Objetos = New ArrayList<>();

//Adiciona elementos a la lista

Objetos.add(New Nodo(7,'k',"prueba"));
Objetos.add(New Nodo(-9.4,'r',"texto"));
Objetos.add(New Nodo(1.836,'s',"test"));

//Cambia el objeto tmp. ¿Cambiará en la lista?

Objetos.get(0).Imprime();
Objetos.get(0).setCadena("zzzzzzzzzzzzzzzzzz");
Objetos.get(0).Imprime();

}
}
Polimorfismo

EN ESTE CASO EL POLIMORFISMO

FUNCIONA YA QUE ES JAVA , EN PHP NO
FUNCIONA EL POLIMORFISMO
Class MiClase{
Public void MetodoA(){
System.out.println("Llama al método A con cero parámetros");
}
Public void MetodoA(int par1,int par2){
System.out.println("Llama al método A con dos parámetros");
}
Public void MetodoA(int par1){
System.out.println("Llama al método A con un parámetro");
}
Public void MetodoA(int par1,int par2, int par3){
System.out.println("Llama al método A con tres parámetros: "+par1+",
"+par2+", "+par3);
}
}
Public Class POLIMORFISMO {
Public Static void main(String[] args) {
MiClase prueba = New MiClase();
prueba.MetodoA();
prueba.MetodoA(2,7);
 prueba.MetodoA(8);
prueba.MetodoA(5,9,3);
}

Uso de gettype para detectar el tipo de dato de una variable