UNIVERSIDAD TECNOLÓGICA EN LA REGIÓN

NORTE DE GUERRERO

CONCEPTOS

Materia: Programación de Aplicaciones

Maestro: Abel Jerónimo Vargas

Integrantes:
Francisco Javier Gasparillo Pantaleon
Blanca Estrella Pascualeño Visca

Grupo: 9° A
Turno: Vespertino

ING (Ingeniería): Tecnólogias de la Información “ITI”

Chilapa de Álvarez, Gro. A 14 de Mayo del 2019

CLASE:
Una clase es una plantilla para la creación de objetos de datos según un modelo
predefinido. Las clases se utilizan para representar entidades o conceptos. Cada
clase es un modelo que define un conjunto de variables (el estado), y métodos
apropiados para operar con dichos datos (el comportamiento). Cada objeto creado
a partir de la clase se denomina instancia de la clase.

Tipos de Clases

 Class. Public: Son muy comunes, accesibles desde cualquier otra clase en la
misma librería (de otro modo hay que importarlas).
 Class. Abstract: Aquellas que tienen por lo menos un método abstracto. No
implementan sus métodos, sino que dan las bases para que sean
implementados en la herencia.
 Class. Final: Son las que terminan la cadena de herencia. Útiles por motivos de
seguridad y eficiencia de un programa, ya que no permiten crear más
subdivisiones por debajo de esta clase.
 Class. Synchronizable: Especifica que sus métodos son sincronizados,
evitando problemas con los thread (hilo de ejecución), de forma que estos no
pueden empezar a correr un método si no ha acabado el otro.

Ejemplo 1

// Le damos un nombre a la clase

Public class MiPrimeraClase

//Atributos de la clase

Private String Primera1;

Private int Primero2;

//Constructor con el mismo nombre de la clase

Public MiPrimeraClase(){}

Public void metodo1()

Return “metodo1”;

Ejemplo 2

// Le damos un nombre a la clase

Public class animal

//Atributos de la clase

Private String raza;

Private string nombre;

Private int edad;

//Constructor con el mismo nombre de la clase

Public animal(String nuevoNombre)

Nombre = nuevoNombre; //se le da un nombre al animal

Public int getEdad() //método para obtener la edad del animal

Return Edad;

}
Ejemplo 3

// Le damos un nombre a la clase

Public class alumno

//Atributos de la clase

Private String nombre;

Private string apellido;

Private int edad;

//Constructor con el mismo nombre de la clase

Public alumno(String Nombre)

Nombre1 = Nombre; //Nombre del alumno

Public int getEdad() //método para obtener la edad del alumno

Return Edad;

Ejemplo 4

// Le damos un nombre a la clase

Public class escuela

//Atributos de la clase
Private String maestros;

//Constructor con el mismo nombre de la clase

Public escuela(){}

Public void metodo()

Return “metodo”;

Ejemplo 5

// Le damos un nombre a la clase

Public class operaciones

//Atributos de la clase

Private int suma;

//Constructor con el mismo nombre de la clase

Public operaciones(){}

Public void suma()

Return “suma”;

}
OBJETO:

Un objeto no es más que un conjunto de variables (o datos) y métodos (o funciones)

relacionados entre sí. Los objetos en programación se usan para modelar objetos o
entidades del mundo real (el objeto hijo, madre, o farmacéutica, por ejemplo). Un
objeto es, por tanto, la representación en un programa de un concepto, y contiene
toda la información necesaria para abstraerlo: datos que describen sus atributos y
operaciones que pueden realizarse sobre los mismos.

Un objeto de software mantiene sus características en uno o más atributos e

implementa su comportamiento con métodos.

o Es una entidad real o abstracta, con un papel definido en el dominio del

problema.
o Un objeto es una instancia de una clase, que tiene: identidad,
estado(atributos) y comportamiento(metodos).

Ejemplos:

MiPrimeraClase clase = new MiPrimeraClase(123, “primera”);

Animal ani = new Animal (“chihuahua”, “cloin”, 20);

Alumno alum = new Alumno(“Martin”, “Tomatzin”, 28);

Escuela esc = new Escuela(“Jose”);

Operaciones oper = new aperaciones(“suma”, “resta”, ”multiplicacion”, “divison”);

ATRIBUTO

Es una característica de un objeto, que ayuda a definir su estructura y permite

diferenciarlo de otros objetos. Se define con un identificador y un tipo, el cual indica
los valores que puede almacenar. El conjunto de valores de los campos define el
estado del objeto.

Ejemplos:

Private string marca;

Private string modelo;

Private string color;

Private string matricula;

Private double precio;

Private int edad;

MÉTODOS

Un método en Java es un conjunto de instrucciones definidas dentro de una clase,

que realizan una determinada tarea y a las que podemos invocar mediante un
nombre.

Algunos métodos que hemos utilizado hasta ahora:

– Math.pow()
– Math.sqrt()
– Character.isDigit()
- System.out.println();
Cuando se llama a un método, la ejecución del programa pasa al método y cuando
éste acaba, la ejecución continúa a partir del punto donde se produjo la llamada.

Utilizando métodos:

- Podemos construir programas modulares.

- Se consigue la reutilización de código. En lugar de escribir el mismo código
repetido cuando se necesite, por ejemplo, para validar una fecha, se hace una
llamada al método que lo realiza.
En Java un método siempre pertenece a una clase.
Todo programa java tiene un método llamado main. Este método es el punto de
entrada al programa y también el punto de salida.

Ejemplos:
Int String método(int n)
{
If (n == 0)
{
Return “a”;
}
Return “x”;
}

Static boolean método(boolean n, string mensaje)

{
If (n)
{
Sytem.out.println(mensaje);
}
Return n;
}

Class miclase()
{
//simple clase de ejemplo
i = 123
def f(self);
}
return “hola mundo”;
void mimetodo(){
int i;
for (i=0; i<10; i++){
if (i == 5) return;
system.out.println(i);
}
}

Public class potencia

{
Public static void main(string [] args)
{
Int a,n,r;
a =2;
n =5;
r = (int) Math.pow(a,n);
system.out.println(“resultado con Math.pow:” + Math.pow(a,n));
sytem.out.println(“resultado con r:” +r);
}
}
NIVELES DE ACCESO:
INSTANCIAR UN OBJETO:

//creacion de la clase Automovil

public class Automovil
{
//atributos de la clase automovil

private int anio,cantidadPuertas; //el objeto no tiene acceso a miembros privados

private double galonesGas,kiloRecorridos;
private String marca;

//creamos el constructor de la clase

public Automovil()
{
//inicializamos algunos valores

marca=””;
anio=”1990″;
galonesGas = kiloRecorridos =0.0;
}

//metodo para darle otros valores a los atributos

public void set (int an, int can, double gal, double kil, String mar)
{
anio=an;
cantidadPuertas = can;
galonesGas= gal;
kiloRecorridos=kil;
marca= mar;
}

//metodo para arrancar el auto

public boolean arrancar()

{
//aquí iria tu código
}
//metodo para frenar el auto

public boolean arrancar()

{
//aquí iria tu código
}

/* como el objeto no puede acceder a los atributos

* podemos crear metodo para dicho trabajo */

public int getAnio()

{
return anio;
}

public double getGasolina()

{
return galonesGas;
}

}// fin de la clase Automovil

/* ahora desde la clase main podemos crear y acceder a dicha clase*/

class ProgramaPrincipal
{ public static void main(String arg[]) {

//instanciamos el objeto llamado objetoA a la clase Automovil

Automovil objetoA = new Automovil();

//asignamos valores a los atributos

objetoA.set (2012, 4, 12, 0,”Toyota”);

//llamada a un método de la clase

boolean arranco = objetoA.arrancar();
//obtener un atributo de la clase
int annio = objetoA.getAnio();

}//fin del main

}//fin de la clase ProgramaPrincipal

ASOCIACIÓN:
La asociación se podría definir como el momento en que dos objetos se unen para
trabajar juntos y así, alcanzar una meta.

Un punto a tomar muy en cuenta es que ambos objetos son independientes entre
sí.

Ejemplo Asociación:

public class Cliente {

private int id;

private String Nombre;
private String Apellido;
private CreditCard creditCard;

public Cliente() {
//Lo que sea que el constructor haga
}

public void setCreditCard(CreditCard creditCard) {

this.creditCard = creditCard;
}

// Más código aquí

}

COMPOSICIÓN:

La composición es un tipo de relación dependiente en dónde un objeto más

complejo es conformado por objetos más pequeños. En esta situación, la frase
“Tiene un”, debe tener sentido:
  El auto tiene llantas
 La portátil tiene un teclado.
 Los objetos que componen a la clase contenedora, deben existir desde el
principio. (También pueden ser creados en el constructor, no sólo al momento de
declarar las variables como se muestra en el ejemplo).
 No hay momento (No debería) en que la clase contenedora pueda existir sin
alguno de sus objetos componentes. Por lo que la existencia de estos objetos no
debe ser abiertamente manipulada desde el exterior de la clase.

Ejemplo Composición:

public class Laptop {

private String marca;
private String modelo;
private String servicio;
private Teclado teclado = new Teclado();

public Laptop() {
//Lo que sea que el constructor haga
}

HERENCIA:
Permite definir una clase tomando como base a otra clase ya existente. Esto es una
de las bases de la reutilización de código, en lugar de copiar y pegar.

En java, como ya vimos la herencia se especifica agregando la claúsula extends

después del nombre de la clase. En la claúsula extends indicaremos el nombre de
la clase base de la cuál queremos heredar.

Al heredar de una clase base heredaremos tanto los atributos como los métodos,
mientras que los constructores son utilizados, pero no heredados.

Ejemplo:
Construyamos la clase Taxista.java con el siguiente código:

public class Taxista extends Persona {

private int nLicencia;
public void setNLicencia(int num)
{
nLicencia = num;
}
public int getLicencia()
{
return nLicencia;
}
}

Y construyamos ArranqueTaxista.java:

public class ArranqueTaxista {

public static void main (String arg[]){
Taxista tax1 = new Taxista();
tax1.setNombre("Luis");
tax1.setEdad(50);
System.out.println( tax1.getNombre());
System.out.println(tax1.getEdad());
}
}

Ahora intentemos usar el constructor que existía en la clase Persona que recibia el
nombre de la persona y vamos a usarlo para la clase Taxista. Para ello
construyamos la clase ArranqueTaxista2.java:

public class ArranqueTaxista2 {

public static void main (String arg[]){
Taxista tax1 = new Taxista("Jose");
tax1.setEdad(50);
System.out.println( tax1.getNombre());
 System.out.println(tax1.getEdad());
System.out.println(tax1.getNLicencia());
}
}

Se genera un error de compilación, debido a que los constructores no se heredan,

sino que hay que definir nuestros propios constructores. Agreguemos en la clase
Taxista los siguientes constructores:

public Taxista(int licencia)

{
super();
nLicencia = licencia;
}
public Taxista(String nombre,int licencia)
{
super(nombre);
nLicencia = licencia;
}
 REGERENCIAS BIBLIOGRÁFICAS

http://luis.izqui.org/resources/ProgOrientadaObjetos.pdf

https://ferestrepoca.github.io/paradigmas-de-
programacion/poo/poo_teoria/concepts.html?fbclid=IwAR1ZmucaPZLx7WuhDqLhcOELxCt03ggeY
WlVBw-TIzWmmLHP71WZmSqe-HA

http://puntocomnoesunlenguaje.blogspot.com/2012/04/metodos.html

http://panamahitek.com/que-son-las-clases-en-java/