Documentos de Académico
Documentos de Profesional
Documentos de Cultura
a Objetos (Object
Oriented Programming)
Parte 1
Está basada en varias técnicas que nos permiten desarrollar y mantener mucho
más fácil programas de una gran complejidad, incluyendo herencia, cohesión,
abstracción, polimorfismo, acoplamiento y encapsulamiento.
• An entity that has state and behavior is known as an object e.g., chair, bike,
marker, pen, table, car, etc.
• It can be physical or logical (tangible and intangible).
• The example of an intangible object is the banking system.
• Identity: An object identity is typically implemented via a unique ID. The value
of the ID is not visible to the external user. However, it is used internally by
the JVM to identify each object uniquely.
Un objeto es una instancia de una clase. Una clase es una plantilla o un plano
desde el cual los objetos son creados. Entonces un objeto es la
instancia(resultado) de una clase.
Definición de objetos:
Operador NEW
• Una clase podríamos decir que es un molde con el cual podemos crear
infinidad de objetos con características parecidas.
Coche:
digamos que estos serán cada una de las piezas o características del
etc.
• Una clase está formada por los métodos y las variables que definen las
características comunes a todos los objetos de esa clase. Precisamente la
clave de la OOP está en abstraer los métodos y los datos comunes a un
conjunto de objetos y almacenarlos en una clase.
◦ Fields
◦ Methods
◦ Constructors
◦ Blocks
◦ Nested class and interface
Fields;
Methods;
Constructors;
Blocks;
Clases abstractas
1. No pueden ser instanciadas.
2. Usadas solamente como superclases.
3. Organizan características comunes a algunas clases y especifican una
interfaz común para todas sus subclases.
4. Pueden tener métodos abstractos (métodos sin implementación).
Clases finales
Cabe decir que en un inicio solo se verá el tema de clases concretas o comunes
y a medida del curso de irán viendo cada una de ellas
Por ejemplo:
• Los atributos de un auto podrían ser color, peso, largo, ancho, tipo de
motor; etc.
Comportamientos
Por ejemplo:
▪ Una persona puede Caminar, saltar, gatear, trepar, hablar, gritar, etc.
▪ Un auto puede Arrancar, frenar, acelerar, girar, apagarse, etc.
▪ Un ordenador puede encenderse, apagarse, hibernar.
class <class_name>
{
//sentencias
class <class_name>
{
//sentencias
return int|byte|short|long|…|Objeto;
Método: puede ser un procedimiento o una función, pero este pertenece a una
clase, además que estos pueden acceder a los atributos y cambiar los estados e
los objetos.
{
//sentencias
//sentencias
return value;
Se usan para lograr la reutilizaron de código. Estos se pueden escribir una vez y
usarse muchas veces. Esto permite que el código no se tenga que escribir cada
vez que se tenga que usar. También provee una fácil modificación y legibilidad
agregando o eliminando un fragmento de código.
La declaración del método provee información sobre los atributos del método,
visibilidad, tipo de retorno nombre y argumentos.
Estas partes juntas son conocidas como el method header.
Nombramiento de métodos
Al definir un método, recuerde que el nombre del método debe ser un verbo y
comenzar con una letra minúscula. Si el nombre del método tiene más de dos
palabras, el primer nombre debe ser un verbo seguido de adjetivo o sustantivo.
En el nombre del método de varias palabras, la primera letra de cada palabra
debe estar en mayúsculas, excepto la primera palabra.
Los métodos get y set son métodos de una clase los cuales permiten retornar o
asignar un nuevo valor a una variable con la finalidad de modificar sus estados,
dado que por la encapsulación, los datos sensibles estén ocultos de los
usuarios el uso de estos es esencial por:
// Getter
public String getName() {
return name;
}
// Setter
public void setName(String newName) {
this.name = newName;
}
}
Es usado cuando nos vamos a referir a una variable del objeto en este caso
serían las variables (que denominamos atributos).
Se usa para:
// Setter
public void setName(String name)
{
this.name = name;
}
}
Otros usos:
• main: Es aquel método que inicia la entrada al programa. Este método se sitúa
en la clase cuyo nombre dio a la JVM. Y es static ya que es llamada por la
JVM en tiempo de ejecución justo antes que se cree cualquier objeto.
static: Tu puedes hacer un método estático por el uso del keyword static.
Esto nos permite no crear un objeto para mandarlo llamar. Static methods
son métodos los cuales se invocan sin crear los objetos, así no se
necesita algún objeto para llamarlo.
String args[]: El método main, permite aceptar datos del usuario. Acepta
un grupo de strings, los cuales es llamando un array de strings. Es usado
para contener los argumentos desde la línea de comandos en forma de
valores string.
1. public static void main(String args[])
2. static public void main(String args[])
3. static public void main(String[] x)
4. static public void main(String []x)
5. static public void main(String...args)
class OverloadMain
{
public static void main(int a) //overloaded main method
{
System.out.println(a);
}
public static void main(String args[])
{
System.out.println("main method incoked");
main(6);
}
}
• Clase: Son aquellos métodos, que compartes todos los objetos que se
instancia de una clase ya que esa actividad es común en todos.También son
llamados static methods.
De esa misma manera existen los métodos de clase existen las variables de
clase cuyo funcionamiento es parecido a los métodos en el sentido de
llamarlas.
class StaticMethodClass
{
private static int a;
public static void staticMethod(int a) //overloaded main method
{
StaticMethodClass.a=a;
System.out.println(StaticMethodClass.a);
}
class Main
{
public static void main(String … args) //overloaded main method
{
StaticMethodClass.staticMethod(6);
}
Los Atributos de clase son aquellos que son comunes en todas las instancias
de la clase y solo se inician una vez.
Estos, tanto los de clase como de instancia pueden ser variables o constantes,
para estas últimas se necesita agregar la keyword final antes del [tipo de dato].
Una constante por convención es public static final.
Cabe señalar que los métodos de clase se pueden relacionar con variables de
clase únicamente. Pero los métodos de instancia, pueden relacionarse con
métodos de clase, variables de clase y variables de instancia.
• Instancia
Son aquellos métodos que se definen en una clase y no son estáticos. Estos a
diferencia de los de clase, deben ser invocados con un objeto de esa clase.
public class InstanceMethodExample
{
public static void main(String [] args)
{
//Creating an object of the class
InstanceMethodExample obj = new InstanceMethodExample();
//invoking instance method
System.out.println("The sum is: "+obj.add(12, 13));
}
int s;
//user-defined method because we have not used static keyword
public int add(int a, int b)
{
s = a+b;
//returning the sum
return s;
}
}
PI=3.1416927 PI=3.1416927
• Finales
Son aquellos, que no pueden ser sobreescribir en otra clase derivada (se verá
más a fondo en herencia). Y su principal intención es que el contenido no sea
cambio por alguien externo.
De la misma manera existen variables finales, las cuales son las que
denominamos constantes y estos indican que el valor asignado no cambiará a
lo largo de la ejecución del programa. Y por convención los identificadores se
escriben con mayúscula.
Estos métodos no tienen cuerpo y se conocen cómo abstractos por solo tener
un header, En otras palabras, no tienen implementación. Siempre son
declarados en clases abstractas, lo que significa que que las clases por sí
mismas deben ser abstractas si tiene al menos un método abstracto.
Además de lo anterior, otra definición valida es que los métodos abstractos son
aquellos que necesitan una clase abstracta para existir y representan una
acción, función o proceso común en todas las clase que deriven de ella.
• Factory method
1. New keyword
try {
// date object
Date d = new Date();
Class cls = d.getClass();
System.out.println("Time = " + d.toString());
3. Clone
Crea una copia exacta del un objeto, crea una nueva instancia de la clase a
partir del objeto e inicializa todos los campos igual que el objeto clonado
correspondiente.
s1.id=101;
s1.name="Sonoo";
Student s2=new Student();
s1.insertRecord(111,"Karan");
s2.insertRecord(222,"Aryan");
s1.displayInformation();
s2.displayInformation();
3. Constructor
<class_name>(){}
class Student4
{
int id;
String name;
//creating a parameterized constructor
Student4(int i,String n)
{
id = i;
name = n;
}
//method to display the values
void display()
System.out.println(id+" “+name);
}
de un objeto.
Un constructor no debe tener un tipo de dato Debe tener un tipo de dato o void keyword
EL compilador provee un default constructor su no tiene Los métodos no son proporcionados por el
Tiene el mismo nombre que la clase Puede o no tener el mismo nombre que la
clase.
Ejemplo:
Supongamos que tienes que realizar la suma de dos numero dados pero
puede haber cualquier numero de argumentos, si escribes el método como
a(int x, int y) pada dos parametros y b(int x, int y, int z) para tres
parametros entonces puede ser difícil para ti como para otros
programadores entender el comportamiento de cada método por que sus
nombres dos diferentes.
class Adder
{
static int add(int a,int b)
return a+b;
}
static int add(int a,int b,int c)
return a+b+c;
}
}
class Adder
{
static int add(int a, int b)
return a+b;
}
static int add(double a, double b)
return a+b+c;
}
}
Cabe señalar que todos los métodos sobrecargados, deben arrojar el mismo
tipo de dato.
{
void sum(int a,long b)
System.out.println(a+b);
}
void sum(int a,int b,int c)
System.out.println(a+b+c);
}
public static void main(String args[])
{
OverloadingCalculation1 obj=new OverloadingCalculation1();
obj.sum(20,20,20);
}
class OverloadingCalculation1
{
void sum(int a, int b)
System.out.println("int arg method invoked");
}
void sum(long a, long b)
System.out.println("long arg method invoked");
}
public static void main(String args[])
{
OverloadingCalculation1 obj=new OverloadingCalculation1();
obj.sum(20,20);//now int arg sum() method gets invoked
}
class OverloadingCalculation1
{
void sum(long a, int b)
System.out.println("a arg method invoked");
}
void sum(long a, int b)
System.out.println(“b arg method invoked");
}
public static void main(String args[])
{
OverloadingCalculation1 obj=new OverloadingCalculation1();
obj.sum(20,20);//now int arg sum() method gets invoked
}