Hola y bienvenidos a esta elección.
A continuación vamos a estudiar el tema de diseño de clases en Java están listos.
Vamos bien vamos a crear nuestro proyecto vamos a cerrar este proyecto.
Damos el derecho Kloss y también cerramos este proyecto si lo tuviéramos abierto bien ahora vamos a
crear un nuevo proyecto en Phinney Project Llada huid Neiman Application y el nombre del proyecto se
va a llamar diseño clases
y lo vamos a depositar en cursos diagonal Java el nombre del Grupo SM X-COM G.M.
La versión 1.0 y el nombre del paquete vamos a quitarlo ya que si vamos a crear paquetes nos vamos a
crear manualmente no nos deja utilizar la ñ directamente ya que nos comenta que el proyecto contiene
caracteres inválidos así que por esta razón vamos a utilizar diseño clases pero es por esa razón que
estamos cambiando el nombre ya que no permite utilizar la ñ.
Damos en finalizar
crearemos este ejercicio basándonos en el siguiente de Gramma de clases utilizando U.
Ese es el mismo diagrama de clases que comentamos anteriormente vamos a crear la clase de orden.
Posteriormente la clase de producto y finalmente la clase de ventas se muestra cada uno de los atributos
si son privados públicos y también los métodos que vamos a utilizar.
Y ahora vamos a crear nuestra primera clase sobre sols package vamos a crear una nueva clase damos clic
derecho new Java class y el nombre de la clase va a ser producto y lo vamos a depositar en el paquete
de com G.M. ventas así que ese es el paquete que vamos a utilizar y damos fuguen finalizar
vamos a crear posteriormente otra clase de la clase de orden en este caso vamos a trabajar con la clase
de producto y vamos a negar sus atributos es un atributo privado entero llamado Heydi producto posteriormente
agregamos otro atributo privado de tipo string llamado nombre que es el nombre del producto posteriormente
agregamos otro atributo privado de tipo doble llamado precio y finalmente agregamos otro atributo que
es un atributo estático de tipo entero llamado Contador productos
y esta variable la vamos a utilizar para contar el número de objetos de tipo producto que hemos creado.
Para esto vamos a crear un constructor vacío
agregamos Playboy en nombre del constructor producto no reciben ningún argumento ya que ser constructor
vacío y lo único que va a hacer es inicializar nuestra variable de producto apoyándonos de la variable
estática Contador productos
cualquier duda con esta sintaxis pueden revisar la lección de contexto estatico bien ahora vamos a agregar
la sobrecarga de este constructor con dos argumentos constructor sobrecargado de dos argumentos así
que este constructor va a ser públic producto que es igual al nombre de nuestra clase y recibe los argumentos
de nombre de tipo string y el precio de tipo doble para poder crear objetos de tipo producto y lo primero
que va a ser este método es mandar a llamar el constructor privado de esta clase para inicializar el
atributo de producto y posteriormente inicializar los atributos restantes 10 puntos nombre y le asignamos
el valor del argumento que estamos recibiendo y posteriormente disputo precio y también lo inicializar
con el argumento que estamos recibiendo así que con esto ya estamos inicializar todos los atributos
de nuestra clase.
Ahora vamos a agregar los métodos jet set de cada atributo podemos crearlos manualmente o en este caso
para hacerlo más ágil para hacerlo más rápido.
Vamos a apoyarnos de líder así que vamos a dar clic derecho insert Coupet seleccionamos ceder y en este
caso seleccionamos todos los atributos y a continuación vamos a hacer algunos cambios damos vida en
general pero vamos a quitar el método del producto ya que es atributo de producto únicamente se va a
modificar a través del constructor vacío.
Así evitamos este método y únicamente vamos a dejar el método Ogueta y también lo mismo para el contador
productos vamos a quitar su método Zet ya que este contador se va a incrementar únicamente a través
del constructor vacío.
Así que con esto ya tenemos los métodos G.T y C de nuestra clase y ahora agregamos el método autodestruye
así que damos clic derecho insert Kop seleccionamos tu string seleccionamos todos los atributos que
nos muestra de producto nombre y precio y damos clic en general.
Y con eso ya tenemos el método Tsui de nuestra clase de producto.
Bien ahora vamos a crear nuestra clase de orden así que sobre el paquete de ventas vamos a crear también
nuestra clase de orden damos el derecho a new Java class y la clase se va a llamar orden damos y en
finalizar quitamos estos comentarios y agregamos los siguientes atributos agregamos un atributo privado
de tipo entero llamado Heydi orden y ahora vamos a agregar la relación con la clase de productos ya
que una orden va a contener un arreglo de tipo producto así que hacemos lo siguiente declaramos un atributo
privado van a ser elementos de tipo producto y va a ser un arreglo por ello esta variable es en plural
ya que esta variable productos va a apuntar a un objeto de tipo arreglo de productos.
Posteriormente vamos a inicializar este arreglo.
De momento vamos a continuar declarando los atributos declaramos otro atributo de tipo Static entero
llamado Contador órdenes ya que es la variable que va a contabilizar cuántos objetos de tipo orden hemos
creado y agregamos finalmente otro atributo también el tipo entero llamado Contador productos.
Esto para saber cuántos productos hemos agregado al arreglo.
Sin embargo también necesitamos saber el límite de productos que podemos agregar a nuestro arreglo.
En este caso el contador de productos va a contabilizar cuántos productos se han agregado pero también
debemos de saber cuál es el límite así que vamos a definir la siguiente constante Privat estática final
podemos observar que podemos declarar este tributo como final Static o estática final.
El orden de estos modificadores no hay ningún problema podemos intercambiarlo así que en este caso estamos
declarando Prévert Static final va a ser de tipo entero y la variable se va a llamar máx productos y
le asignamos el valor máximo de productos que puede contener este arreglo.
Por ejemplo el valor de 10.
Nosotros podemos modificar el valor de esta constante pero recordemos que una vez que le hemos asignado
un valor a esta constante entonces ya no se puede modificar su valor y debido a que es una constante.
Por eso es que lo estamos definiendo en mayúsculas y si contiene más de una palabra entonces la separamos
con guión bajo esto para que sea fácil de leer esta variable así que es parte de las buenas prácticas
de IAVA al declarar constantes bien ahora vamos a declarar el constructor vació de esta clase y lo que
vamos a hacer es declarar el constructor va a ser público utilizamos el mismo nombre de la clase no
recibe ningún argumento ya que se constructor ovación y lo que vamos a hacer es inicializar nuestro
tributo de Airy orden con ayuda de nuestra variable Contador órdenes
así que utilizamos la variable estática Contador órdenes y con eso le asignamos un valor a cada objeto
de tipo orden que creemos y posteriormente lo que vamos a hacer es inicializar nuestro arreglo de productos
así que en primer lugar aquí lo que hicimos fue declarar la variable declaramos la variable arreglo
y ahora lo que vamos a hacer es inicializar el arreglo así que para inicializar lo vamos a utilizar
el máximo de productos.
Por lo tanto utilizamos nuestra variable productos que es el arreglo y le vamos a asignar un nuevo objeto
de tipo producto y la cantidad de elementos que va a contener este arreglo vamos a utilizar nuestra
constante Max productos y con esto estamos inicializar a nuestro arreglo.
De eso se va a encargar nuestro constructor sin argumentos y va a ser el único constructor que vamos
a tener en esta clase bien como siguiente paso vamos a derogar el método conocido como agregar producto
así que definimos el método va a ser público no va a regresar nada y se va a llamar agregar producto
lo que va a ser este método es que va a recibir un objeto de tipo producto el cual lo va a agregar a
nuestro arreglo así que definimos el argumento producto ahora para agregar un elemento nuevo a nuestro
arreglo.
Bastaría con hacer lo siguiente podríamos utilizar directamente nuestro arreglo de productos.
Posteriormente indicar la posición donde queremos agregar este nuevo elemento.
Para ello vamos a utilizar la variable Contador productos que es esta variable que hemos declarado con
productos y por cada objeto que estemos agregando a nuestro arreglo vamos a incrementar esta variable
así que va a iniciar en cero ya que es el valor por default de esta variable al ser de tipo int.
Vamos a iniciar en cero así que la primera vez que utilicemos esta variable vale 0 y la siguiente vez
que agregamos un producto entonces por ello es que estamos utilizando más más se va a incrementar esta
variable la siguiente vez que la volvamos a utilizar.
Así que cada vez que agregamos un producto se va a estar incrementando esta variable Contador productos
y entonces ya una vez que hemos seleccionado la posición del arreglo donde vamos a agregar el nuevo
producto simplemente le agregamos la referencia del nuevo objeto que vamos a agregar cualquier duda
con esa sintaxis pueden revisar la elección de arreglos.
Lo único diferente es que estamos utilizando la variable Contador productos para ir moviendo el índice
de cada elemento que estamos agregando bien así que con esa sintaxis podría ser suficiente para agregar
un nuevo producto.
Sin embargo qué pasa si hemos superado el límite de los elementos que podemos agregar a nuestro arreglo.
Si pasamos de 10 elementos entonces recordemos que nos va a marcar un error de array indexado Bounce
exception.
Para evitar esta excepción vamos a hacer lo siguiente Vamos a realizar una comprobación si disputo Contador
productos todavía es menor que el máximo de productos entonces podemos agregar este nuevo producto
de lo contrario mandamos el mensaje
se ha superado el máximo de productos y para saber cuál es el máximo de productos que tenemos imprimimos
el valor de la variable.
Max productos damos un formato y con eso ya tenemos todo nuestro código de este método.
Aquí también podemos utilizar Diz para que sepamos que estamos haciendo referencia al atributo de nuestra
clase y básicamente con esa sintaxis estamos agregando un nuevo producto en la posición indicada por
la variable Contador productos y cada vez agregamos un nuevo producto se va a ir incrementando esta
variable.
Bien con esto ya tenemos nuestro método Argar producto y finalmente lo que vamos a hacer es agregar
un método llamado calcular total.
Así que definimos el método públic va a regresar un doble y el método se va a llamar calcular
no reciben ningún argumento y abrimos el cuerpo de este método básicamente para calcular el total lo
que vamos a hacer es sumar cada uno de los productos vamos a sumar el atributo de precio de cada uno
de los productos que hemos agregado al arreglo de productos así que para esto vamos a iterar el arreglo
de productos.
Definimos una variable inicial llamado total igual a cero así que vamos a comenzar con esta variable
temporal para calcular el total sumando cada uno de los precios de cada producto del arreglo y ahora
vamos a recorrer cada uno de los elementos del arreglo también de igual manera cualquier duda con esta
sintaxis pueden revisar la elección de arreglos.
Definimos un contador
declaramos nuestra variable Contador I y ahora vamos a recorrer cada uno de los elementos de la reglón.
Pero vamos a recorrer únicamente los elementos que tengamos agregados a nuestro arreglo de productos
así que no vamos a utilizar la sintaxis de productos punto Olen ya que esto recorrería los 10 elementos
pero realmente no queremos recorrer todos los elementos sobre todo si tenemos elementos de tipo núm
ya que si no hemos agregado productos en todos los elementos del arreglo entonces varias de estas casillas
del arreglo van a contener el valor de Nul habrá entonces cómo podemos saber cuántos elementos realmente
tiene el arreglo.
Para ello recordemos que hemos declarado nuestra variable Contador productos y precisamente ese es el
objetivo de esta variable saber rápidamente con esta variable cuántos elementos se han agregado a nuestro
arreglo ya que cada vez que hemos agregado un elemento a nuestro arreglo esta variable se incrementó
así que en lugar de utilizar esta variable productos punto Leng para recorrer todo el arreglo.
Realmente queremos recorrer solamente los elementos que hemos agregado a nuestro arreglo.
Por ello vamos a utilizar la variable Contador productos y finalmente incrementamos nuestro contador
y más más abrimos nuestro ciclo.
Y básicamente lo que vamos a hacer es acceder a cada uno de los elementos de nuestro arreglo.
Ahora como siguiente paso vamos a declarar una variable temporal para extraer el objeto producto en
la posición que estemos recorriendo así que vamos a definir la variable producto
llamada producto y por medio de nuestra variable arreglo accedemos al arreglo de productos y posteriormente
accedemos al índice que en este momento estamos recorriendo.
Así con esa sintaxis estamos extrayendo cada uno de los objetos de tipo producto que contiene nuestro
arreglo así que con esto estamos obteniendo el objeto de tipo producto lo asignamos a nuestra variable
producto y ahora para acceder al precio básicamente podemos utilizar esta variable producto y accedemos
al método GET precio así que con eso ya podemos acceder al valor del precio de cada producto.
Pero para ir sumando vamos a utilizar nuestra variable total y utilizamos la sintaxis del operador de
composición más igual y esto va a ser equivalente a la siguiente sintaxis total.
Igual vamos a ir agregando cada uno de los precios producto G.T precio así que si realmente la sintaxis
que estamos utilizando.
Estamos haciendo una suma total para ir contabilizando cada uno de los precios de cada producto que
tengamos en nuestro arreglo pero solamente estamos recorriendo los elementos que realmente se han agregado
a nuestro arreglo y no todos los elementos del arreglo que sería el máximo de productos solamente queremos
recorrer las casillas del arreglo que realmente tengan un objeto de tipo producto bien y con esto ya
tenemos en nuestra variable temporal total el precio total de la orden ya que hemos contabilizado el
precio de cada producto y finalmente lo que vamos a hacer después de terminar nuestro ciclo es retornar
el valor de nuestra variable total.
Bien y ahora por último vamos a declarar nuestro método mostrar orden ya que este método de mostrar
orden también debe incluir mostrar cada uno de los elementos de tipo producto que hemos agregado al
arreglo de productos así que se mostrará la orden como si desglosamos un ticket.
Vamos a ver vamos a mostrar el Heydi de la Orden y vamos a ir recorriendo cada uno de los elementos
del producto y vamos a ir recorriendo cada uno de los productos imprimiendo tanto el nombre del producto
como el precio del producto así que es como si desglosamos un ticket de una orden de venta así que vamos
a definir el método public void mostrar orden no reciben ningún argumento y vamos a empezar a imprimir
los elementos de esta orden así que imprimimos orden con el número y accedemos al elemento 10 punto
Heydi orden imprimimos nuestro tributo hay orden.
Posteriormente vamos a imprimir el total de la orden y para eso lo que vamos a hacer es mandar a llamar
nuestro método Calcular total ya que ese es el método que nos va a regresar el total de la orden.
Así aquí es precisamente donde ya empezamos a hacer clases más complejas en este método mostrar orden
estamos mandado llamar otro método que se encarga de realizar el cálculo total de nuestra orden así
que ya estamos combinando todos los elementos que hemos visto en este curso.
Posteriormente vamos a imprimir todos los productos de la orden y para recorrer los productos de la
orden va a ser muy similar a lo que hemos hecho en nuestro método Calcular total no recorrimos el máximo
de productos sino que solamente recorrimos el número de productos que hemos agregado al arreglo así
que vamos así que vamos a utilizar también otro ciclo.
Definimos nuestro contador igual a cero posteriormente y menor y utilizamos la variable Contador productos
para recorrer únicamente los productos que hayamos agregado a nuestro arreglo y no todos los elementos
del arreglo.
Y finalmente incrementamos nuestro contador el cual va a acceder a cada uno de los elementos del arreglo
y como la clase de producto ya tenemos definido el método string va a ser tan sencillo como mandar a
imprimir el objeto producto podemos extraer el objeto producto de manera independiente y posteriormente
mandar imprimir la variable producto o podemos mandar a imprimir directamente el elemento que extraiga
del arreglo así que podemos poner productos que es el nombre de nuestro arreglo y posteriormente accedemos
al índice que queremos extraer de este arreglo.
Así que esto nos va a regresar el objeto producto que hayamos agregado en esta posición del arreglo
y debido a que ya hemos declarado el método string en nuestra clase producto se va a mandar a llamar
de manera automática el método string del objeto producto que extraiga en esta posición.
Si esta sintaxis nos costara trabajo todavía entenderla entonces le recomendamos hacer lo siguiente
tendríamos que extraer el objeto producto en primer lugar así que declara haríamos primero una variable
extraemos el objeto producto en este índice lo asignamos a un objeto llamado producto y posteriormente
mandamos a imprimir simplemente el objeto producto.
Esta sintaxis ya la hemos visto anteriormente así que el único problema que podríamos tener es el entender
la sintaxis para mandar a imprimir directamente el producto pero cualquiera de las dos sintaxis que
hemos mostrado es exactamente igual.
Así que con esto ya tenemos completa nuestra clase de orden y de producto vamos a detener hasta aquí
este vídeo y en el siguiente vídeo vamos a poner a prueba cada una de estas clases aquí simplemente
una corrección.
Aquí me equivoqué en este código debe ser contador productos no debe ser con productos más más ya que
únicamente queremos recorrer los elementos hasta el límite de los elementos que hemos agregado Contador
productos pero esta variable ya no la debemos modificar.
Bien con eso ya tenemos todo nuestro código.