tag:blogger.com,1999:blog-14885304533457988572024-02-08T07:32:25.354+01:00Apuntes, programas y códigos en JavaAprende a programar en Java desde cero gratisJavier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.comBlogger60125tag:blogger.com,1999:blog-1488530453345798857.post-2456943077633112222019-08-07T19:17:00.001+02:002019-08-07T19:18:50.523+02:00Privacy Policy for Broma Detector de Mentiras con Huella<html>
<head>
<title>Privacy Policy</title>
<style> body { font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif; padding:1em; } </style>
</head>
<body>
<h2>
Privacy Policy</h2>
Broma detector de mentiras con huella app as
an Ad Supported app. This SERVICE is provided by
at no cost and is intended for
use as is.
<br />
This page is used to inform visitors regarding
my policies with the collection, use, and
disclosure of Personal Information if anyone decided to use
my Service.
<br />
If you choose to use my Service, then you agree
to the collection and use of information in relation to this
policy. The Personal Information that I collect is
used for providing and improving the Service.
I will not use or share your
information with anyone except as described in this Privacy
Policy.
<br />
The terms used in this Privacy Policy have the same meanings
as in our Terms and Conditions, which is accessible at
[App NameBroma detector de mentiras con huella unless otherwise defined in this Privacy
Policy.
<br />
<strong>Information Collection and Use</strong><br />
For a better experience, while using our Service,
I may require you to provide us with certain
personally identifiable information, including but not limited to Android advertising identifier. The
information that I request will be
retained on your device and is not collected by me in any way.
<br />
The app does use third party services that may collect
information used to identify you.
<br />
<div>
Link to privacy policy of third party service providers
used by the app
<br />
<ul>
<li><a href="https://www.google.com/policies/privacy/" target="_blank">Google Play Services</a></li>
<li><a href="https://support.google.com/admob/answer/6128543?hl=en" target="_blank">AdMob</a></li>
<!----><!----><!----><!----><!----><!----><!----><!----><!----></ul>
</div>
<strong>Log Data</strong><br />
I want to inform you that whenever
you use my Service, in a case of an error in the
app I collect data and information (through third
party products) on your phone called Log Data. This Log Data
may include information such as your device Internet
Protocol (“IP”) address, device name, operating system
version, the configuration of the app when utilizing
my Service, the time and date of your use of the
Service, and other statistics.
<br />
<strong>Cookies</strong><br />
Cookies are files with a small amount of data that are
commonly used as anonymous unique identifiers. These are
sent to your browser from the websites that you visit and
are stored on your device's internal memory.
<br />
This Service does not use these “cookies” explicitly.
However, the app may use third party code and libraries that
use “cookies” to collect information and improve their
services. You have the option to either accept or refuse
these cookies and know when a cookie is being sent to your
device. If you choose to refuse our cookies, you may not be
able to use some portions of this Service.
<br />
<strong>Service Providers</strong><br />
I may employ third-party companies
and individuals due to the following reasons:
<br />
<ul>
<li>To facilitate our Service;</li>
<li>To provide the Service on our behalf;</li>
<li>To perform Service-related services; or</li>
<li>To assist us in analyzing how our Service is used.</li>
</ul>
I want to inform users of this
Service that these third parties have access to your
Personal Information. The reason is to perform the tasks
assigned to them on our behalf. However, they are obligated
not to disclose or use the information for any other
purpose.
<br />
<strong>Security</strong><br />
I value your trust in providing us
your Personal Information, thus we are striving to use
commercially acceptable means of protecting it. But remember
that no method of transmission over the internet, or method
of electronic storage is 100% secure and reliable, and
I cannot guarantee its absolute security.
<br />
<strong>Links to Other Sites</strong><br />
This Service may contain links to other sites. If you click
on a third-party link, you will be directed to that site.
Note that these external sites are not operated by
me. Therefore, I strongly advise you to
review the Privacy Policy of these websites.
I have no control over and assume no
responsibility for the content, privacy policies, or
practices of any third-party sites or services.
<br />
<strong>Children’s Privacy</strong><br />
These Services do not address anyone under the age of 13.
I do not knowingly collect personally
identifiable information from children under 13. In the case
I discover that a child under 13 has provided
me with personal information,
I immediately delete this from our servers. If you
are a parent or guardian and you are aware that your child
has provided us with personal information, please contact
me so that I will be able to do
necessary actions.
<br />
<strong>Changes to This Privacy Policy</strong><br />
I may update our Privacy Policy from
time to time. Thus, you are advised to review this page
periodically for any changes. I will
notify you of any changes by posting the new Privacy Policy
on this page. These changes are effective immediately after
they are posted on this page.
<br />
<strong>Contact Us</strong><br />
If you have any questions or suggestions about
my Privacy Policy, do not hesitate to contact
me at tarsiustudio@gmail.com.
<br />
</body>
</html>
Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-89093200579164693122019-04-17T17:06:00.002+02:002019-04-19T20:33:55.266+02:00Obteniendo Datos de Sorteos de Lotería (O.N.C.E) España.Hola a tod@s, hoy os muestro un programa en el que muestra los resultados de la lotería de la ONCE. Los resultados de los sorteos se obtienen a partir de un fichero xml que la propia empresa hace pública.<br />
La dirección del ficheor XML es: <a href="https://www.juegosonce.es/rss/sorteos2.xml" target="_blank">https://www.juegosonce.es/rss/sorteos2.xml</a>.<br />
Estos sorteos son unos sorteos de mi país, España. Pero eso da igual, se trata de aprender a obtener datos de un fichero XML que está alojado en una URL.<br />
<a name='more'></a>A continuación os dejo un vídeo del programa y debajo de este un enlace para la descarga del código fuente del programa.<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<iframe allowfullscreen='allowfullscreen' webkitallowfullscreen='webkitallowfullscreen' mozallowfullscreen='mozallowfullscreen' width='320' height='266' src='https://www.blogger.com/video.g?token=AD6v5dzrzniBFBkJKFLYsVG42DdWU_OiZNRUf974v4_x5DIZ9HzZ81Dx9H_F8-lMjaLGElvKAYWJ_B6C8SQ4FcIEOQ' class='b-hbp-video b-uploaded' frameborder='0'></iframe></div>
Descarga el código fuente del programa <a href="https://mega.nz/#!GUhxkIoJ!Gt5qXrXLfR5cyIVA-spIdeTd49GpAAQCME7rMNPjwyc" target="_blank">aquí</a>.Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com2tag:blogger.com,1999:blog-1488530453345798857.post-56067302314836789032019-02-24T13:58:00.002+01:002019-04-20T14:20:37.099+02:0024- Interfaces (Parte I)Bienvenidos de nuevo a otro tutorial mas del curso Java para principiantes. Esta vez veremos las interfaces en Java.<br />
Vamos a empezar preguntándonos, <b>¿Qué son las interfaces?</b> <span style="background-color: yellow;">Las interfaces son una herramienta más de la programación en Java que nos va a permitir obligar que las clases que implementen interfaces tengan unas funcionalidades determinadas.</span><br />
Vale, esta definición ahora os puede sonar un poco a chino, pero vosotros quedaros con esta definición, más adelante la comprenderéis. Vamos a ver qué características tienen las interfaces.<br />
<a name='more'></a><br />
<br />
<h3>
CARACTERÍSTICAS DE LAS INTERFACES.</h3>
<ul>
<li> Las interfaces sólo tienen métodos abstractos y constantes. Por lo tanto no se pueden instanciar objetos de interfaces.</li>
<li>Todos los métodos son <b><span style="color: purple;">public</span></b> y <span style="color: purple;"><b>abstract</b></span>. Si no se indica estos modificadores se da por supuesto.</li>
<li>En Java vienen predefinidas muchísimas interfaces en la API, pero nosotros podremos crear nuestras propias interfaces.</li>
</ul>
<br />
Viendo las características de las interfaces os podría sonar a que son parecidas a las <a href="http://tazasdejava.blogspot.com.es/2017/09/23-las-clases-abstractas.html" target="_blank">clases abstractas </a>que vimos en el tutorial anterior, y así es, entonces os podríais preguntar, <b>¿Que diferencia hay en utilizar las clases abstractas o interfaces?</b><br />
Cuando vimos las clases abstractas vimos que podía estar formada sin que tuviera métodos abstractos, las interfaces nos obliga a que todos los métodos sean abstractos. Entonces, <u>¿Por qué no podemos utilizar las clases abstractas en vez de interfaces? </u><span style="background-color: yellow;">Las interfaces solucionan el problema de la herencia simple.</span> Imagínate que tienes una clase que hereda de otra clase, pero quieres que tu clase tenga un determinado comportamiento, una funcionalidad. No puedes heredar de otra clase porque como vimos, java no permite la herencia múltiple, pero <span style="background-color: yellow;">Java sí que permite implementar tantas interfaces como queramos.</span> Es decir, una clase puede estar heredando de otra clase y, a su vez, implementar una interface, dos, o las que necesitemos. En este sentido Java sí que nos permite una especia de herencia múltiple con interfaces.<br />
<br />
La sintaxis para implementar una interface en Java es la siguiente:<br />
<br />
<pre class="brush: java">public class NombreClase implements NombreInterface {
}
</pre>
<br />
Si queremos implementar más de una interface:<br />
<br />
<pre class="brush: java">public class NombreClase implements Interface1, Interface2 {
}
</pre>
<br />
Si una clase hereda de una clase e implementa una interface:<br />
<br />
<pre class="brush: java">public class NombreClase extends ClasePadre implements NombreInterface {
}
</pre>
<br />
Ahora que ya habéis visto un poco de teoría y la sintaxis de las interfaces, vamos a ver a continuación un ejemplo de una interface que viene ya en Java y que es la interface <i><b>Comparable. </b></i>La interface Comparable se utiliza para ordenar objetos. En nuestro ejemplo vamos a crear la clase Trabajador para ordenarlos luego por salario.<br />
<br />
<pre class="brush: java">public class Trabajador {
//Atributos de un trabajador
String nombre;
String puesto;
double salario;
//Constructor para inicializar los valores
public Trabajador(String nombre, String puesto, double salario) {
this.nombre = nombre;
this.puesto = puesto;
this.salario = salario;
}
}
</pre>
<br />
Ahora en una clase llamada Empresa vamos a crear un array de 6 elementos que contendrá objetos de la clase Trabajador.<br />
<br />
<br />
<pre class="brush: java">public class Empresa {
public static void main(String[] args) {
//Creamos el array con capacidad de 6 trabajadores
Trabajador[] trabajadores = new Trabajador[6];
//Creamos trabajadores y los introducimos en el array
trabajadores[0] = new Trabajador("Jose Martinez Navarro", "Dependiente", 1200);
trabajadores[1] = new Trabajador("María Sánchez Giménez", "Encargada de tienda", 1358.45);
trabajadores[2] = new Trabajador("Sonia Alfaro Mínguez", "Reponedora", 985.73);
trabajadores[3] = new Trabajador("Alberto Pérez Portur", "Repartidor", 1025.99);
trabajadores[4] = new Trabajador("Javier Ortega Navas", "Gerente", 2127.77);
trabajadores[5] = new Trabajador("Carmen Serrano Córcoles", "Limpiadora", 868.91);
//bucle for each para recorrer el array
for(Trabajador e : trabajadores) {
//Imprime los trabajadores en orden de introdución
System.out.println(e.nombre + ", " + e.puesto + ", " + e.salario + "€");
}
}
}
</pre>
<br />
Como vemos, así se imprimen los trabajadores en orden en el que los hemos introducido, pero lo que queremos es que nos lo muestre en función del salario. <b>¿Cómo hacemos esto? </b>Para esto vamos a tener que hacer uso de la clase <b><span style="color: blue;">Arrays</span></b> y su método <span style="color: #38761d;"><b>sort</b></span>. Vamos a dirigirnos a la <a href="http://docs.oracle.com/javase/8/docs/api/index.html" target="_blank">documentación de Java</a> para ver con más detalle esto.<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiFlzSSlzlaQsIILVQz9RVWwHf8O2x9BazYJ0uznyru0e_kbsldgpnYW8s6RG6UGSAiaq3CQH9ehMspCoCjt6hwvCeH60JnEaO0ZIUnDgG6ZbhSzsQMp42mhG97dCAevPSjS_ipxhTtdL8/s1600/Captura+de+pantalla+2017-09-24+a+las+14.18.06.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="668" data-original-width="1275" height="332" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiFlzSSlzlaQsIILVQz9RVWwHf8O2x9BazYJ0uznyru0e_kbsldgpnYW8s6RG6UGSAiaq3CQH9ehMspCoCjt6hwvCeH60JnEaO0ZIUnDgG6ZbhSzsQMp42mhG97dCAevPSjS_ipxhTtdL8/s640/Captura+de+pantalla+2017-09-24+a+las+14.18.06.png" width="640" /></a></div>
Como muestra la imagen anterior, la clase <b><span style="color: blue;">Arrays</span></b> tiene sobrecarga de métodos <span style="color: #38761d;"><b>sort</b></span>. Nosotros utilizaremos el que se le pasa como parámetros un array de objetos, que es el que nos va a hacer falta, ya que hemos creado un array que contiene objetos de tipo Trabajador.<br />
Veámos que nos dice la descripción de este método:<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj6RaQLgmBTnoJpLTd00bPmhhsdGtEbz7dKorrcwGzpsAuOB0SKiu4lcscV1QynRCa8APRxStoToa7pTyZIh_ZXkR_tGPiogq9Lq9O7HJ1OkJmyd9pXxdHwIyjIvD_hgworlGRbWKku9m8/s1600/Captura+de+pantalla+2017-09-24+a+las+14.27.32.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="157" data-original-width="1235" height="80" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj6RaQLgmBTnoJpLTd00bPmhhsdGtEbz7dKorrcwGzpsAuOB0SKiu4lcscV1QynRCa8APRxStoToa7pTyZIh_ZXkR_tGPiogq9Lq9O7HJ1OkJmyd9pXxdHwIyjIvD_hgworlGRbWKku9m8/s640/Captura+de+pantalla+2017-09-24+a+las+14.27.32.png" width="640" /></a></div>
Este método nos dice que ordena el array de objetos especificado de forma ascendente. También nos indica que todos los elementos en el array deberán de implementar la interface <b><i>Comparable. </i></b><br />
<b><i> </i></b>Observamos que el método es estático, esto quiere decir que para invocar dicho método en la clase <b><span style="color: blue;">Empresa</span></b> tenemos que hacerlo con el nombre de la clase, es decir, <b>Arrays.sort(Object[])</b><i>. </i><b><i><br /></i></b>
<b><i><br /></i></b>
<br />
<pre class="brush: java">import java.util.Arrays;
public class Empresa {
public static void main(String[] args) {
//Creamos el array con capacidad de 6 trabajadores
Trabajador[] trabajadores = new Trabajador[6];
//Creamos trabajadores y los introducimos en el array
trabajadores[0] = new Trabajador("Jose Martinez Navarro", "Dependiente", 1200);
trabajadores[1] = new Trabajador("María Sánchez Giménez", "Encargada de tienda", 1358.45);
trabajadores[2] = new Trabajador("Sonia Alfaro Mínguez", "Reponedora", 985.73);
trabajadores[3] = new Trabajador("Alberto Pérez Portur", "Repartidor", 1025.99);
trabajadores[4] = new Trabajador("Javier Ortega Navas", "Gerente", 2127.77);
trabajadores[5] = new Trabajador("Carmen Serrano Córcoles", "Limpiadora", 868.91);
//Invocamos el método Arrays.sort(Object[])
Arrays.sort(trabajadores);
//bucle for each para recorrer el array
for(Trabajador e : trabajadores) {
//Imprime los trabajadores en orden de introdución
System.out.println(e.nombre + ", " + e.puesto + ", " + e.salario + "€");
}
}
}
</pre>
<br />
Por lo tanto, debemos de implementar esta interface en la clase Trabajador, que es la clase que contiene el array. Cuando implementemos este interfaz en la clase Trabajador tendremos que sobrescribir todos los métodos que contenga la interfaz, recuerda que los métodos de las interfaces son abstractos y por lo tanto tienen que ser implementados en la clase que implemente la interfaz. Al ser métodos abstractos, tenemos que escribir el cuerpo del método en la clase Trabajador.<br />
Veámos antes, en la documentación de Java qué métodos tenemos para esta interfaz Comparable y qué es lo que hace.<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjO6Rj4pzos7zWiOsHjb6K-2lLnSj73o8CTqxgLwd2WSc4LzUhisXygr182TBrkJ7oN8Nd0NCkU_adjswM7KFkl7AIl1rLnGLa6T58gvbiRBz4nKs6FnBK149aABPeQeKsaFOQ2hh-cIRw/s1600/Captura+de+pantalla+2017-09-24+a+las+15.57.49.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="99" data-original-width="1189" height="52" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjO6Rj4pzos7zWiOsHjb6K-2lLnSj73o8CTqxgLwd2WSc4LzUhisXygr182TBrkJ7oN8Nd0NCkU_adjswM7KFkl7AIl1rLnGLa6T58gvbiRBz4nKs6FnBK149aABPeQeKsaFOQ2hh-cIRw/s640/Captura+de+pantalla+2017-09-24+a+las+15.57.49.png" width="640" /></a></div>
<br />
La interfaz comparable sólamente tiene un método, el método <span style="color: #38761d;"><b>compareTo(T o).<span style="color: black;"> </span></b><span style="color: black;">Al método se le pasa un parámetro de tipo T. Esto quiere decir que T puede ser cualquier objeto, pero no os preocupéis porque la programación genérica la veremos más adelante. Solamente quedaros que se le pasa como argumento cualquier tipo de objeto, en nuestro caso un tipo de dato Trabajador. Veámos qué tiene que hacer este método:</span></span><br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi0i8irAqgtLJlaXT7cP_CkShlQM1pBb3xcHrAx88bY6-MF9e67KGCHxgBv1MI0murc-gdRCIJkCpngoUDdb4G-HJXvU-iyP7_m2-PhixXZNEqyyNhbzZ3jTcHk0MbPDpUbpU6cMQmExcI/s1600/Captura+de+pantalla+2017-09-24+a+las+16.01.41.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="83" data-original-width="1178" height="44" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi0i8irAqgtLJlaXT7cP_CkShlQM1pBb3xcHrAx88bY6-MF9e67KGCHxgBv1MI0murc-gdRCIJkCpngoUDdb4G-HJXvU-iyP7_m2-PhixXZNEqyyNhbzZ3jTcHk0MbPDpUbpU6cMQmExcI/s640/Captura+de+pantalla+2017-09-24+a+las+16.01.41.png" width="640" /></a></div>
<span style="color: #38761d;"><span style="color: black;"> Este método lo que hace es comparar el objeto actual, con el objeto pasado como argumento. Devuelve un entero negativo, cero o o positivo según si el objeto actual es menor, igual o mayor que el pasado por argumento. En nuestro ejemplo, como queremos que estén ordenados por sueldo, tenemos que hacer en este método la comparación del sueldo del objeto actual con el objeto pasado por parámetro</span></span><br />
<span style="color: #38761d;"><span style="color: black;">Volvamos a la clase Trabajador e implementemos esta interfaz y sobrescribamos el método y veamos cómo quedaría la clase Trabajador.</span></span><br />
<br />
<br />
<br />
<span style="color: #38761d;"><span style="color: black;"> </span></span>
<br />
<pre class="brush: java">
public class Trabajador implements Comparable{
//Atributos de un trabajador
String nombre;
String puesto;
double salario;
//Constructor para inicializar los valores
public Trabajador(String nombre, String puesto, double salario) {
this.nombre = nombre;
this.puesto = puesto;
this.salario = salario;
}
@Override
public int compareTo(Object o) {
//Primero debemos hacer un casting porque vamos a comparar tipos
//de datos Trabajador
Trabajador t = (Trabajador) o;
//Ahora comparamos el salario y devolvemos un entero negativo
//cero o un entero positivo
if(this.salario < t.salario){
return -1;
}else if(this.salario > t.salario){
return 1;
}else{
return 0;
}
}
}
</pre>
<br />
Ahora ya tenemos todo terminado, si ejecutamos la clase Empresa veremos cómo se muestran los trabajadores en orden según su salario.<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEisvdFz3LAnqb8dwTNaQCck3rHYV5qXeKyrZ69-RiMm7Mt4HnktJyJZ4OCKbFg124x1fFu8K2_KdkcZDE_AAFc-w3glkKmFUWiHoAg-zbD4NdY-IJSO5bcvaHWb_nT7zOio3nSNYUvNhMY/s1600/Captura+de+pantalla+2017-09-24+a+las+16.11.25.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="258" data-original-width="471" height="350" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEisvdFz3LAnqb8dwTNaQCck3rHYV5qXeKyrZ69-RiMm7Mt4HnktJyJZ4OCKbFg124x1fFu8K2_KdkcZDE_AAFc-w3glkKmFUWiHoAg-zbD4NdY-IJSO5bcvaHWb_nT7zOio3nSNYUvNhMY/s640/Captura+de+pantalla+2017-09-24+a+las+16.11.25.png" width="640" /></a></div>
<br />
<br />
Bueno, pues ya hemos visto un poco qué son las interfaces y sus características, cómo es su sintaxis y también hemos visto un ejemplo de uso de una interfaz que viene en la API de Java<br />
Si tenéis alguna duda no dudéis en dejad en los comentarios y recordad que me podéis seguir en <a href="https://www.facebook.com/tazasjava/" target="_blank">Facebook</a>. Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-66550738924894328612018-08-19T18:03:00.002+02:002018-08-19T18:04:07.333+02:00Aplicación Android Wasea sin AgendaMuy buenas a todos, en el día de hoy les quiero presentar mi nueva aplicación para dispositivos Android. Se trata de la aplicación <span style="background-color: yellow;"><b>Wasea sin Agenda</b></span>.<br />
<b><u>¿Que qué es lo que hace esta aplicación?</u></b> Pues lo que puede hacer esta aplicación es algo que puede resultar muy útil y, es que puedes hablar con cualquiera a través del WhatsApp sin necesidad de tener que agregar el contacto en la agenda del móvil. Util,<b><u> ¿Verdad?</u></b> Pues además puedes descargarte la aplicación gratis.<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhy2cHoQtqG6XReMjCl0oY4aUft_HMakdSMfdbJesVMZ19eLA6S-xLerPLtO7K_t7isSSEQul6GcWIv6wsh2CEsFOLq0JyzpiKO2I73njIqgTfqYBjCcXWdx8K-78E5EzZKh0iIUh-aAxs/s1600/iconodos.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="512" data-original-width="512" height="320" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhy2cHoQtqG6XReMjCl0oY4aUft_HMakdSMfdbJesVMZ19eLA6S-xLerPLtO7K_t7isSSEQul6GcWIv6wsh2CEsFOLq0JyzpiKO2I73njIqgTfqYBjCcXWdx8K-78E5EzZKh0iIUh-aAxs/s320/iconodos.png" width="320" /></a></div>
<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://play.google.com/store/apps/details?id=tarsiustudio.com.waseasinagenda" target="_blank"><img alt=" Descarga Wasea sin Agenda" border="0" data-original-height="250" data-original-width="646" height="123" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiohFgmMvUnWbZvMrw7b-DM7U2N_ZkYv7ljl6s8So9uHa7nquzscDYWtFQoN6EdGqx5KEtEptHm__oGt-TyrPvBbnN5VjpBeXsjQ5ispcPI2usczJbdni3_vsCCoKggnh9KfcUFEPRki7g/s320/google-play-badge.png" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEifd5T4NsZ6nFBEu9Ypk1BNTTfBLGSetsrs4tZzSSxWPReSI0BhL7ywWeGb72GZDdz4HUdn6RIR0xqu-SRdAcGral4_N8W0XyTM6qnIMv5xSGWRxVRDlFSWtqeLboJ2QYiP-dkKaBgWv2A/s1600/Screenshot_2018-08-19-13-11-52-219_tarsiustudio.com.waseasinagenda.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="1280" data-original-width="720" height="400" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEifd5T4NsZ6nFBEu9Ypk1BNTTfBLGSetsrs4tZzSSxWPReSI0BhL7ywWeGb72GZDdz4HUdn6RIR0xqu-SRdAcGral4_N8W0XyTM6qnIMv5xSGWRxVRDlFSWtqeLboJ2QYiP-dkKaBgWv2A/s400/Screenshot_2018-08-19-13-11-52-219_tarsiustudio.com.waseasinagenda.png" width="222" /></a><br />
<br />
<br />
<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiwR_P-rvjEzvLkkNDEUu086eKDOPDlJaSGP0bFOCOqqwwqgdc5e7H_fMzw3PYAygiJLYyQY28aFqV4r7_cqGN72dnTOk1t_Dy64k6mx91yuN3RIT3mm7wEMqrVJv_AtVO6Tii5YIbOX2k/s1600/Screenshot_2018-08-19-13-10-17-438_tarsiustudio.com.waseasinagenda.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="1280" data-original-width="720" height="400" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiwR_P-rvjEzvLkkNDEUu086eKDOPDlJaSGP0bFOCOqqwwqgdc5e7H_fMzw3PYAygiJLYyQY28aFqV4r7_cqGN72dnTOk1t_Dy64k6mx91yuN3RIT3mm7wEMqrVJv_AtVO6Tii5YIbOX2k/s400/Screenshot_2018-08-19-13-10-17-438_tarsiustudio.com.waseasinagenda.png" width="224" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
***Descripción***</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">Wasea sin Agenda es una aplicación que te permite comenzar una conversación por WhatsApp sin tener previamente guardado en tu agenda el contacto. </span></div>
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">La aplicación te permite también, de manera opcional, introducir un mensaje. Este mensaje será automáticamente escrito cuando se abra WhatsApp.</span><br />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">Podrás elegir 248 códigos de países o si lo prefieres, puedes introducir el código de tu país.</span><br />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">En las preferencias, podrás seleccionar un código de país por defecto, esto es muy útil por que a partir de entonces, cada vez que abras la aplicación, aparecerá el país con su código automáticamente.</span><br />
<br style="-webkit-tap-highlight-color: transparent; background-color: white; color: #333333; font-family: Roboto, Arial, sans-serif; font-size: 14px;" />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">***Instrucciones***</span><br />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">Para poder empezar a utilizar Wasea sin Agenda, deberás de seleccionar de una lista el código del país, o también puedes introducir el código de forma manual en el campo correspondiente. Posteriormente introduce el número de teléfono y si lo deseas, también puedes escribir un mensaje (este mensaje será escrito automáticamente al abrir WhatsApp). Para terminar pulsa el botón y, si has escrito el teléfono y el código del país correctamente, se abrirá la aplicación WhatsApp para empezar a hablar con quien tu quieras si agregar el contacto previamente.</span><br />
<br style="-webkit-tap-highlight-color: transparent; background-color: white; color: #333333; font-family: Roboto, Arial, sans-serif; font-size: 14px;" />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">***Términos y Condiciones***</span><br />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">Esta aplicación no sirve para espiar WhatsApp ni interferir conversaciones ni ninguna otra situación ilegal. Wasea sin Agenda utiliza la api de WhatsApp para utilizar la función de chatear en un click.</span><br />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">Tampoco se guarda ni se comparte a terceros ningún dato introducido por el usuario.</span><br />
<div class="separator" style="clear: both; text-align: left;">
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;"><br /></span></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://play.google.com/store/apps/details?id=tarsiustudio.com.waseasinagenda" target="_blank"><img alt=" Descargar Wasea sin Agenda" border="0" data-original-height="250" data-original-width="646" height="123" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi0vIVpIjaJbAV_VO48SGmJrbwU8UWPP7yaZtR4FTTJIvScATd_MwRymSWJ1gNz-soOT_kGAZ4yTFxi8q_fBhWVBm-8PvxSDJ-tTwAPFSa193g_6nAlPhjPfx4ZgE97R0AcU8IFxXyD37k/s320/google-play-badge.png" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;"><br /></span></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-10849773748107861042018-08-16T18:30:00.000+02:002018-08-16T18:33:27.078+02:00Aplicación Android Detector de Mentiras con Huella Dactilar<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgNxWTV7ltgJ_8jnb4_rxEIi9PPBWB61t8n_zYRE7y_3Bi0Ls5LSQ4m2U6IE50-KjIcWMxrZ5fTYM-T1sKP7BnXAJ_Ve0RXjSuoS7NOBn-cdI-OA4j0b1EqIwX6fqYDUhyphenhyphenanLDmdw_7hjs/s1600/icono.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="512" data-original-width="512" height="320" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgNxWTV7ltgJ_8jnb4_rxEIi9PPBWB61t8n_zYRE7y_3Bi0Ls5LSQ4m2U6IE50-KjIcWMxrZ5fTYM-T1sKP7BnXAJ_Ve0RXjSuoS7NOBn-cdI-OA4j0b1EqIwX6fqYDUhyphenhyphenanLDmdw_7hjs/s320/icono.png" width="320" /></a></div>
Hola a tod@s!!!! Hoy os quiero presentar mi primera aplicación que he realizado en Android. Había hecho algunos juegos con Engines y demás, pero esta es la primera app realizada en Android Studio.<br />
<br />
A continuación os pongo el enlace de descarga y algunas capturas y la descripción. La app es totalmente gratuita!!!!<br />
<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjGLtsbmmOwndDXhUN6F5FWhHGO3A3-awcqd-qsF6cpa8v8Gl0Ib_bqJZK7HprDROR3lDJJ79v0FGPM-EaFi093EOfAX_HR-9rNMmwweEFZJ9p-V1uZCcoST1Svlz92g9j_60X1VRGiZwU/s1600/imagenuno.png" imageanchor="1" style="clear: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" data-original-height="598" data-original-width="509" height="320" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjGLtsbmmOwndDXhUN6F5FWhHGO3A3-awcqd-qsF6cpa8v8Gl0Ib_bqJZK7HprDROR3lDJJ79v0FGPM-EaFi093EOfAX_HR-9rNMmwweEFZJ9p-V1uZCcoST1Svlz92g9j_60X1VRGiZwU/s320/imagenuno.png" width="272" /></a></div>
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg1yvFf04gWH_xfKY-MijKUXNz1aBS5QakLR4V8ftEtIbWX97DIev4Tyo3DhqnJkqXEEiykhNlylBOE-bKjRrdHmJ7MmL2JIuh_V1X2ZFRi08Z4IgW1oQ8Cf5U9Eu7NwMC_JgNvxo_QUeY/s1600/imagendos.png" imageanchor="1" style="clear: right; float: right; margin-bottom: 1em; margin-left: 1em;"><img border="0" data-original-height="595" data-original-width="510" height="320" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg1yvFf04gWH_xfKY-MijKUXNz1aBS5QakLR4V8ftEtIbWX97DIev4Tyo3DhqnJkqXEEiykhNlylBOE-bKjRrdHmJ7MmL2JIuh_V1X2ZFRi08Z4IgW1oQ8Cf5U9Eu7NwMC_JgNvxo_QUeY/s320/imagendos.png" width="273" /></a><br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<span style="background-color: yellow;"><b>Lo podéis descargar pulsando en la siguiente imagen:</b></span><br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://play.google.com/store/apps/details?id=studio.javicaor.com.bromadetectordementiras" target="_blank"><img alt=" Descargar Broma detector de mentiras con huella" border="0" data-original-height="250" data-original-width="646" height="123" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhtizjxUB1jZLWTblZcaODEKSfw7zPhiRND6DJ2vK_rO5Hv22uZtgCXXKW0YpyoOvD6glA4a_qHe8ggfMRuU_jcgyPE7r7KOY95W0PqDWsy9K36e_zH7dt4X9FfofMME2xollc7gDOcXls/s320/google-play-badge.png" title="Descargar Broma detector de mentiras con huella" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
***Descripción***</div>
<div class="separator" style="clear: both; text-align: left;">
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">Con el detector de mentiras con huella dactilar, pasarás muy buenos momentos gastando bromas a tus amigos a tu pareja o a cualquier persona. Pensarán que realmente tienes un detector de mentiras de verdad, pero serás tu mismo quien elegirá si dicen la verdad o una mentira.</span></div>
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">Podrás hacerles todo tipo de preguntas como:</span><br />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">¿Engañas a tu pareja?</span><br />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">¿Alguna vez has robado?</span><br />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">¿Te gusta la chica de nombre...?</span><br />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">¿Te gusta el chico de nombre...?</span><br />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">¿Odias a tu jefe?</span><br />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">Y todas las preguntas que quieras. </span><br />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">Con esta aplicación tendrás el control de decidir si tu amigo/amiga dice la verdad o dice una mentira sin que ellos se den cuenta. Tus amigos se quedarán asombrados de que el detector siempre acierta. La aplicación simula el escaneo de la huella dactilar y simula escanear el resultado de la huella. Tus amigos pensarán que funciona igual que un polígrafo, que detecta la sudoración excesiva, aumento del ritmo cardíaco, presión arterial, frecuencia respiratoria, estímulos nerviosos, conductancia de la piel, tensión de la sangre, actividad muscular y variación de la respiración.</span><br />
<br style="-webkit-tap-highlight-color: transparent; background-color: white; color: #333333; font-family: Roboto, Arial, sans-serif; font-size: 14px;" />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">***Instrucciones de uso***</span><br />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">Como se ha dicho ya en la descripción, esta aplicación simula ser un detector de mentiras para gastar bromas. Realmente no detecta si una persona dice una verdad o mentira</span><br />
<br style="-webkit-tap-highlight-color: transparent; background-color: white; color: #333333; font-family: Roboto, Arial, sans-serif; font-size: 14px;" />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">-Para mayor impacto, es mejor si se conocen si la respuesta de tus amigos son verdaderas o mentiras para que puedas decidir que el detector diga que dice la verdad o una mentira</span><br />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">-En primer lugar le harás una pregunta a una persona, cuando conteste si o no le dirás que mantenga el dedo pulsado en la huella dactilar de la pantalla.</span><br />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">-Mientras que la persona tenga pulsado el dedo en la huella dactilar, debes de pulsar el botón de volumen hacia arriba para que el detector diga que la persona dice la verdad. Si quieres que el detector diga que la persona está mintiendo, entonces mientras que esté pulsado la imagen de la huella dactilar debes de pulsar el botón hacia abajo del volumen.</span><br />
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;">-Si no se pulsa ningún botón, por defecto el scanner siempre dirá que la persona dice la verdad.</span><br />
<div class="separator" style="clear: both; text-align: left;">
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;"><br /></span></div>
<div class="separator" style="clear: both; text-align: left;">
<span style="background-color: yellow; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;"><b>Descargar:</b></span></div>
<div class="separator" style="clear: both; text-align: left;">
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;"><br /></span></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://play.google.com/store/apps/details?id=studio.javicaor.com.bromadetectordementiras" target="_blank"><img alt=" Descargar Broma detector de mentiras con huella" border="0" data-original-height="250" data-original-width="646" height="123" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEharWNNkTfS5ap17uO79OYt03SyNKuXuGrcZk2KwqYT_7UHRbf1n-QPNRza4CR4Ly2uV1hIuJtjNO1QWnIoZeflZ_C9uTJ7wLbc6QXY0FiSB-nLJHMmaCc9WrnmykmlIt3RXGZfVp7gkTI/s320/google-play-badge.png" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<span style="background-color: white; color: #333333; font-family: "roboto" , "arial" , sans-serif; font-size: 14px;"><br /></span></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<br />Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-53749641219703621192017-09-22T17:52:00.001+02:002017-09-22T17:52:39.591+02:00Calculadora de Índice de Masa Corporal(IMC)<div class="separator" style="clear: both; text-align: center;">
<iframe allowfullscreen='allowfullscreen' webkitallowfullscreen='webkitallowfullscreen' mozallowfullscreen='mozallowfullscreen' width='320' height='266' src='https://www.blogger.com/video.g?token=AD6v5dzH0ycKajul83MQpYRHroo0o7pH16N3VpDKyVzsRsptecG2Oa4Bk0TIrpMquk3-ij9Kt_4kblpaJqSzFexMeQ' class='b-hbp-video b-uploaded' frameborder='0'></iframe></div>
<br />
<div style="text-align: center;">
<a href="https://mega.nz/#!aFInCKAR!YF8CZHRlQ5IYEjCE35vadICsn_YYBHbu42NmrpT666s" target="_blank"><u><span style="background-color: yellow;">DESCARGAR PROGRAMA EJECUTABLE .JAR</span></u></a></div>
<div style="text-align: center;">
<br /></div>
<div style="text-align: center;">
<a href="https://mega.nz/#!TQYGFA6A!EGYbZZ0cw0XFh3LyXL3h8Y7EzfYWrMBSzUPJX88DQOE" target="_blank"><span style="background-color: yellow;"><u>DESCARGAR CÓDIGO FUENTE</u></span></a></div>
<div style="text-align: center;">
<br /></div>
<div style="text-align: center;">
*Los proyectos se han realizado con el IDE NetBeans</div>
Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-17948035090982250532017-09-11T13:33:00.001+02:002017-09-22T18:15:22.626+02:00Regulador de color RGB Java, haciendo uso de JSlider.<div class="separator" style="clear: both; text-align: center;">
<iframe allowfullscreen='allowfullscreen' webkitallowfullscreen='webkitallowfullscreen' mozallowfullscreen='mozallowfullscreen' width='320' height='266' src='https://www.blogger.com/video.g?token=AD6v5dzRo1p1rN2J0oT3-w9VJNrePX78E599HJ9BZ61RWXc0e2ytEWKfGxuAfeRHi3KkG-r1ALgR49fP9uMflb8QPg' class='b-hbp-video b-uploaded' frameborder='0'></iframe></div>
<br />
<div style="text-align: center;">
<span style="background-color: yellow;"><a href="http://bit.ly/2w0LTn8" target="_blank">DESCARGAR CODIGO FUENTE DEL PROGRAMA.</a></span><br />
<u>Clave de cifrado:
</u> <br />
<div class="selectable" id="chromeclipboard">
!2l2FnMrc57g8H3mz5ZPjdp1c60a56rShnrs1LY7gB2E</div>
</div>
<div style="text-align: center;">
<br />
<span style="background-color: yellow;"><a href="https://mega.nz/#!vAA3FYCZ!cmIn2D7eWcHP_LQph60HhOvn15NOi9pzr_iV3hsjmfQ" target="_blank">DESCARGAR PROGRAMA EJECUTABLE .JAR</a></span><br />
<br />
*Los proyectos se han realizado con el IDE de NetBeans <br />
<br /></div>
Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-91720207019396578922017-09-10T18:15:00.002+02:002017-09-10T18:15:09.219+02:0023-Las Clases AbstractasSeguimos avanzando en el curso de Java para principiantes, hoy vamos a ver las clases abstractas. <b>¿Qué son las clases abstractas?</b><span style="background-color: yellow;"> Las clases abstractas en Java, son un tipo de clase especial que no permite ser instanciada.</span> <b>¿Qué quiere decir que las clases abstractas no pueden ser instanciadas?</b> Quiere decir que de las clases abstractas no podemos crear objetos.<br />
Entonces, si no puedo crear objetos de las clases abstractas, <b>¿Para qué sirven?</b> Las clases abstractas sirven para ser utilizadas como super clases. Por ejemplo, supongamos que tenemos una clase abstracta llamada Persona. A partir de esta clase abstracta Persona podemos crear subclases de dicha clase, como por ejemplo la clase Profesor y la clase Alumno.<br />
<a name='more'></a><span style="background-color: yellow;">La clase Persona será la clase abstracta, no se podrá instanciar.</span><br />
Cuando creemos un proyecto que tengamos que crear una clase que sea una Persona, pues crearemos una clase que herede de la clase Persona. Otro ejemplo de subclases de Persona podrían ser la clase Hombre y/o la clase Mujer. Ambas clases serán subclases de Persona.<br />
<br />
Pero todo esto lo vimos cuando estudiamos la herencia <b>¿verdad?</b> Entonces, <b>¿Qué diferencia hay en crear una super clase y crear una super clase que sea clase abstracta?</b><br />
Bueno, algunas diferencias son las siguientes:<br />
<ul>
<li><u>Las clases abstractas no son instanciables, no podemos crear objetos de dichas clases</u></li>
<li><u>Las clases abstractas, si tienen métodos abstractos nos obligan a sobreescribir dichos métodos en las clases hijas.</u></li>
</ul>
<br />
Una clase abstracta puede contener, o no, métodos abstractos. <span style="background-color: yellow;">Si una clase tiene al menos un método abstracto, dicha clase deberá ser abstracta obligatoriamente</span>, en caso contrario nos dará error.<br />
Para declarar una clase abstracta lo hacemos con la siguiente sintaxis:
<br />
<pre class="brush: java">public abstract class NombreClase {
}
</pre>
<br />
Como hemos dicho ya, las clases abstractas no pueden ser instanciadas, y que las podemos utilizar para que hagan de super clases. Pero también podemos crear métodos abstractos.<br />
Si una clase tiene al menos un método abstracto, la clase deberá ser obligatoriamente abstracta.<br />
Los métodos abstractos tienen una particularidad, y es que no tienen cuerpo, solamente se declaran y se termina con punto y coma ';' <span style="background-color: lime;">El cuerpo de estos métodos se sobreescribirán en las clases hijas</span>. La sintaxis de los métodos abstractos son de la siguiente manera:<br />
<br />
<pre class="brush: java">public abstract tipoDevuelto nombreMetodo();
</pre>
<br />
Como vemos, no lleva las llaves de apertura ni de cierre '{}'.<br />
<br />
<b>¿Para qué sirven los métodos abstractos?</b>A parte ser super clases, los métodos abstractos lo que hacen son obligarnos a sobreescribirlos en las clases hijas los métodos que sean abstractos. Cuando sobreescribamos los métodos abstractos en la clase hija correspondiente, lo haremos para esa clase en particular. <br />
<span style="background-color: yellow;">Puede darse el caso de que una clase abstracta no contenga ningún método abstracto.</span><br />
<br />
Las clase abstractas pueden contener métodos que no sean abstractos igualmente, pero en caso de que tenga algún método abstracto, la clase deberá pasar a ser abstracta.<br />
<br />
Bueno, la teoría está muy bien aprenderla y todo eso, pero vamos a pasar a la acción que seguro que lo veis más facilmente. Vamos a crear una clase <span style="color: blue;"><b>Persona</b></span> que será una clase abstracta, tendrá metodos normales y un método abstracto, que veremos que tendremos que sobreescribir en las clases hijas.<br />
Las clases hijas que crearemos serán la clase <span style="color: blue;"><b>Profesor</b></span> y la clase <b><span style="color: blue;">Alumno</span></b>.<br />
<span style="background-color: orange;"><b>Clase abstracta Persona:</b></span><br />
<br />
<pre class="brush: java">package clasesAbstractas;
public abstract class Persona {
//Podemos crear atributos igualmente que con las clases no abstractas
private String nombre;
private int edad;
//Creamos el constructor
public Persona(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
//Creamos un método abstracto
//Este método lo sobreescribiremos en las clases hijas.
public abstract void accionPersona();
//Creamos métodos setter y getter
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getNombre() {
return nombre;
}
public void setEdad(int edad) {
this.edad = edad;
}
public int getEdad() {
return edad;
}
}
</pre>
<br />
<span style="background-color: orange;"><b>Clase Profesor que hereda de la clase Persona:</b></span><br />
<br />
<pre class="brush: java">package clasesAbstractas;
public class Profesor extends Persona {
//Atributos propios de un profesor
private double sueldo;
private String colegio;
//Constructor
public Profesor() {
super();
}
//Al heredar de una clase abstracta, nos obliga a sobreescribir
//los métodos abstractos de la clase abstracta
@Override
public void accionPersona() {
System.out.println("El profesor enseña a los Alumnos.");
}
/*
No creamos los setter y getter de Profesor para no aumentar el código
*/
}
</pre>
<br />
<span style="background-color: orange;"><b>Por último creamos la clase Alumno, subclase también de Persona:</b></span><br />
<br />
<pre class="brush: java">package clasesAbstractas;
public class Alumno extends Persona {
//Atributos del alumno
private int curso;
private String colegio;
//Constructor
public Alumno() {
super();
}
//Sobreescribimos el método abstracto de la clase abstracta Persona
@Override
public void accionPersona() {
System.out.println("El alumno aprende del profesor");
}
/*
Tampoco creamos los métodos setter ni getter para no aumentar la legibilidad
del código
*/
}
</pre>
<br />
<span style="background-color: orange;"><b>Ahora creamos una nueva clase, que será nuestro programa principal para ver el resultado de nuestros programas:</b></span><br />
<br />
<pre class="brush: java">package clasesAbstractas;
public class Programa {
public static void main(String[] args) {
//Creamos dos instancias, una de la clase Profesor
//y otra de la clase Alumno.
Profesor p = new Profesor();
Alumno a = new Alumno();
//Ahora llamamos a su método accionPersona() que sobreescribimos
//en cada una de las subclases de Persona
p.accionPersona();
a.accionPersona();
}
}
</pre>
<br />
Si ejecutamso el programa nos saldrá la siguiente salida por consola:<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgFTPJzXH7Nit07Jj2mLLnkBGIEeVBC_pMaA4XQNaNVW4FG3wAatNzcf8jVd-700TkCuAPVEfDJNYYR5ETvDq3ke4JnUCbHs-0wKJktWFxBbARRCJ9BCkwy8yLYRgibdzhFdpQ94XWBSt4/s1600/Captura+de+pantalla+2017-09-10+a+las+17.52.14.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="259" data-original-width="449" height="368" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgFTPJzXH7Nit07Jj2mLLnkBGIEeVBC_pMaA4XQNaNVW4FG3wAatNzcf8jVd-700TkCuAPVEfDJNYYR5ETvDq3ke4JnUCbHs-0wKJktWFxBbARRCJ9BCkwy8yLYRgibdzhFdpQ94XWBSt4/s640/Captura+de+pantalla+2017-09-10+a+las+17.52.14.png" width="640" /></a></div>
<br />
<u><i>También podríamos hacer uso de la propiedad es un de las subclases, puesto que un Profesor es una Persona y un Alumno también es una Persona, podríamos hacer lo siguiente:</i></u><br />
<br />
<pre class="brush: java">package clasesAbstractas;
public class Programa {
public static void main(String[] args) {
//Utilización de la propiedad es un de la herencia
Persona p1 = new Profesor();
Persona p2 = new Alumno();
p1.accionPersona();
p2.accionPersona();
}
}
</pre>
<br />
Si volvemos a ejecutar podemos ver el funcionamiento de la propiedad es un de la herencia:<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiUV7xpxsDyuaJ6901K7W3nCc0XezVvgWzaZJ5_whmqDuWhEwlIxv1d6HSuP30WID4l-WN4jXr1cZm0qPiyWVydhHz9FXtjD88iN40Tc_n3YQLRkc9Rr_Hwc3t9NV9cv2YpWRCBhWvkrIY/s1600/Captura+de+pantalla+2017-09-10+a+las+17.56.36.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="260" data-original-width="364" height="456" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiUV7xpxsDyuaJ6901K7W3nCc0XezVvgWzaZJ5_whmqDuWhEwlIxv1d6HSuP30WID4l-WN4jXr1cZm0qPiyWVydhHz9FXtjD88iN40Tc_n3YQLRkc9Rr_Hwc3t9NV9cv2YpWRCBhWvkrIY/s640/Captura+de+pantalla+2017-09-10+a+las+17.56.36.png" width="640" /></a></div>
<br />
<br />
Pues eso es todo referente a las clases abstractas en Java. Ahora como siempre digo, os toca a vosotros, jugad con el código, probad cosas..... y si algo no entendéis o tenéis dudas, do dudéis en dejar vuestro comentario debajo.<br />
Gracias por seguir mis tutoriales y en el siguiente veremos las interfaces y las clases internas.<br />
Recordad también que me podéis seguir en <b><a href="https://www.facebook.com/tazasjava/" target="_blank">Facebook</a></b>.Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com2tag:blogger.com,1999:blog-1488530453345798857.post-83652122445045458202017-09-06T00:51:00.000+02:002017-09-06T00:51:24.671+02:00Colocar un Marco(JFrame) en el centro de la pantalla.Muy buenas a tod@s, hoy os voy a dejar un programa en el que se explicala forma de colocar o situar un <b><span style="color: blue;">JFrame</span></b> o un <b><span style="color: blue;">JWindow</span></b> en el centro de la pantalla. Los ejemplos que vamos a ver están hechos para centrar un <b><span style="color: blue;">JFrame</span></b>, pero serviría de igual forma que para un <b><span style="color: blue;">JWindow</span></b>.<br />
<br />
Es muy común que cuando creemos nuestros programas con interfaces gráficas queramos que se abran en el centro de la pantalla. Java nos proporciona un método que nos facilita mucho saber cual es la mitad horizontal y vertical de cada pantalla en particular. El método que nos hace esta gran labor es <span style="color: purple;"><b>setLocationRelativeTo()</b></span>.<br />
<br />
<a name='more'></a>Antes de poner el código y ver el marco centrado, vamos a ver de dónde viene este método. Para ello, como siempre digo, hay que ir a la <a href="http://docs.oracle.com/javase/8/docs/api/index.html" target="_blank">documentación de Java</a> y buscar la clase <span style="color: blue;"><b>JFrame</b></span>, y desde allí buscar el método <b><span style="color: purple;">setLocationRelativeTo()</span></b>.<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiP-upQp1AXTKKL_QDev26cCVMqB-0LPDdFV6olM2Q14CO9B8A9RQB7yRyiyRskzWTfICSRRqb9KC8cOvPTk2JCXcCPT7mPJ6RzLxrWb6RTee1ABxJ2MdGZ36goOHU3BRLymBLQwu_zTOs/s1600/Captura+de+pantalla+2017-09-05+a+las+20.14.14.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="702" data-original-width="1600" height="280" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiP-upQp1AXTKKL_QDev26cCVMqB-0LPDdFV6olM2Q14CO9B8A9RQB7yRyiyRskzWTfICSRRqb9KC8cOvPTk2JCXcCPT7mPJ6RzLxrWb6RTee1ABxJ2MdGZ36goOHU3BRLymBLQwu_zTOs/s640/Captura+de+pantalla+2017-09-05+a+las+20.14.14.png" width="640" /></a></div>
Si nos fijamos en la imagen anterior, podemos observar que el método <b><span style="color: purple;">setLocationRelativeTo()</span></b> es heredado de la clase <b><span style="color: blue;">Window</span></b>.<br />
Vamos a indagar un poco más y vamos a ver qué nos indica en la descripción de dicho método. Para ello pinchamos en el enlace del método. Si habéis hecho lo que yo, habréis visto que este método tiene una gran descripción, pero nosotros vamos a quedarnos con la que muestra la siguiente imagen:<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhzJ_ydzxt8bI0F3_87QQC4aPxKQlJHpqwgrkfo661dUfYMcP3WoM-Fy9LIr4hj97orfJNKDFIGaNLF6jvtmRQTXHySB1nnRuh9r4A0__AQzX1_uyiyxsI9dnbmPmTHpNrM01L1aBeb7tE/s1600/Captura+de+pantalla+2017-09-05+a+las+20.22.57.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="274" data-original-width="1187" height="146" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhzJ_ydzxt8bI0F3_87QQC4aPxKQlJHpqwgrkfo661dUfYMcP3WoM-Fy9LIr4hj97orfJNKDFIGaNLF6jvtmRQTXHySB1nnRuh9r4A0__AQzX1_uyiyxsI9dnbmPmTHpNrM01L1aBeb7tE/s640/Captura+de+pantalla+2017-09-05+a+las+20.22.57.png" width="640" /></a></div>
<br />
Vemos que hay que pasarle un argumento de tipo Component. Pero si leemos el primer punto dice:<br />
Si el componente es <b>null</b>, o el <span style="color: blue;"><b>GraphicsConfiguration</b></span> asociado con ese componente es <b>null</b>, la ventanda es colocada en el centro de la pantalla.<br />
<br />
<b>¿Qué quiere decir todo esto?</b> Primero, que si realmente queremos aprender a programar debemos saber cómo leer la documentación de Java, esto es importantísimo!!!. En segundo lugar, lo que quiere decir es que si invocamos el método <b><span style="color: purple;">s</span><span style="color: purple;">etLocationRelativeTo(null)</span></b> y le pasamos null como argumento, la ventana será colocada en el centro de la pantalla.<br />
Veamos cómo quedaría el código<br />
<br />
<pre class="brush: java">import javax.swing.*;
public class CentrandoMarco extends JFrame{
public static void main(String[] args) {
CentrandoMarco miMarco = new CentrandoMarco();
}
public CentrandoMarco() {
super("Centrando el marco");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(550, 325);
//Centramos el marco
setLocationRelativeTo(null);
setVisible(true);
}
}
</pre>
<br />
<br />
Así nos quedaría centrado nuestro marco. Facil ¿Verdad? Se que hubiera sido más fácil poner el código con el método que hace el trabajo y ya está, pero esa no es la finalidad de este blog. Mi intención es que sepáis, no solo a centrar el marco en este caso, sino a leer la documentación de Java. No hay mejor tutorial, ni mejor libro que la documentación de Java. Y si el inglés no es lo vuestro no es escusa, podéis utilizar el traductor de Google.Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-68637551994023752362017-09-05T15:32:00.000+02:002017-09-05T15:36:04.587+02:0022-Las clases y paquetesHolaaa!!! Hacía tiempo que no hacía ninguna entrada del curso de Java, perdonadme pero he tenido menos tiempo este verano del que me hubiese gustado. <span style="background-color: #cfe2f3;">Espero que durante estos 2-3meses siguientes terminar el curso de java para principiantes al completo.</span><br />
Después de este curso empezaré otro curso de Java pero nivel medio, en el que seguiremos aprendiendo Java pero a nivel más avanzado. Espero que sea de vuestro agrado y que aprendáis mucho.<br />
<br />
Bueno en este tutorial vamos a ver de nuevo un resúmen de las clases y veremos qué son los paquetes y para qué sirven. Empecemos!!!<br />
<br />
<a name='more'></a><br />
<h3>
Las clases</h3>
En <a href="http://tazasdejava.blogspot.com.es/2016/11/11-programacion-orientada-objetos-en.html" target="_blank">tutorial 11</a> explicamos de forma breve, pero creo que efectiva, lo que es una clase. Java es un lenguaje de programación que para él <span style="background-color: yellow;">TODO</span> es un objeto. Para crear los objetos debemos primero haber creado una clase que contendrá los atributos y métodos de los objetos.<br />
Podemos decir que <u>una clase sirve de plantilla, de molde</u> para crear luego, a partir de dicha clase (plantilla, molde) los objetos. Por ejemplo para crear un <b>objeto coche</b>, primero deberemos de crear una clase que implemente los atributos y métodos comunes a los coches, <b>como marca, modelo, color, matrícula, arrancar(), frenar()....etc.</b> Luego a cada objeto que creemos de la clase coche le daremos los valores específicos a cada uno, cada coche tendrá un color, matrícula, modelo, marca... distinto, o cada coche puede arrancar de distinta forma y/o velocidad.....<br />
<br />
Bueno pero todo esto ya lo sabíamos <b>¿verdad?</b> Entonces os estaréis preguntando por qué estoy repitiendo teoría, con lo engorrosa y mala que es jajaja. Bueno, pues os estoy contando todo esto porque lo que me interesa de este tema es que aprendáis a saber que son y para qué sirven los paquetes en Java, y para eso hay que recordar un poquito solo qué son las clases. Ahora veamos los paquetes.<br />
<br />
<h3>
Los paquetes</h3>
En programación, nos encontraremos muchas veces con que tenemos que hacer un proyecto que utilice infinidad de clases. Es importantísimo tener todas las clases bien organizadas en nuestros proyectos. <u><b>¿Cómo organizamos las clases que tenemos en Java?</b></u> Utilizando los paquetes conseguiremos tener una mejor organización.<br />
<span style="background-color: yellow;">Los paquetes sirven para organizar un conjunto de clases relacionadas entre si, ya sea por finalidad, ámbito o herencia.</span><br />
<span style="background-color: yellow;">Los paquetes también resuelven el problema de clases que tengan el mismo nombre. Se pueden tener 2 o más clases con el mismo nombre, siempre que cada una de las clases que tenga el mismo nombre se encuentre en paquetes distintos.</span><br />
<br />
Java viene con una serie de paquetes que podemos utilizar, de hecho ya hemos estado utilizando algunos paquetes. <u><b>¿Os acordáis cuando utilizámos en el <a href="http://tazasdejava.blogspot.com.es/2016/09/6-introducir-datos-por-teclado-clase.html" target="_blank">tutorial 6</a> la clase Scanner?</b></u> Para utilizar la clase Scanner debíamos importar un paquete, el paquete <span style="background-color: #c27ba0;">java.util.Scanner</span><br />
Dentro del paquete <b>util</b> de Java, tenemos muchas clases que podemos utilizar. Bueno y no solo tenemos el paquete util, tenemos muchos paquetes más que vienen con Java y que podemos utilizar para nuestros proyectos. Todos los paquetes los podemos ver y consultar en la <a href="http://docs.oracle.com/javase/8/docs/api/index.html" target="_blank">documentación de Java</a><br />
<br />
Cuando programamos, podemos hacer uso de muchas clases que vienen en el paquete <b>java.lang</b>, pero en este caso no debemos de importarlo, ya que al ser muy importante y de uso casi seguro en cada proyecto, <u>Java lo importa implícitamente</u>.<br />
<br />
Bueno, hemos visto que Java viene con muchísimos paquetes predefinidos que, si importamos, podemos utilizar para hacer uso de las clases que contiene.<br />
<u><b>¿Cómo importamos paquetes en Java?</b></u> <span style="background-color: yellow;">Para importar paquetes debemos de utilizar import. y la ruta de donde se encuentra el paquete</span><br />
<br />
<pre class="brush: java">import java.util.Scanner;
</pre>
<br />
También podemos importar un paquete completo, y así poder utilizar todas las clases que contenga ese paquete sin tener que importar el paquete cada vez que utilicemos una clase.<br />
<br />
<br />
<pre class="brush: java">import java.util.*;
</pre>
<br />
Utilizando el asterisco al final, indicamos que queremos importar todas las clases del paquete util.<br />
<br />
<u><b>¿Podemos crear nuestros propios paquetes?</b></u> Por supuesto que podemos crear nuestros paquetes, ademas es lo más normal si queremos tener nuestras clases bien ordenadas y organizadas.<br />
Veamos cómo crear paquetes con NetBeans, si utilizas otro IDE la forma de crear paquetes no será igual, pero será de forma muy parecida.<br />
<br />
<b>1-</b>Abrimos NetBeans y en la parte izquierda del programa pinchamos con el botón derecho sobre el proyecto en el que queremos crear el paquete - nuevo - paquete Java.<br />
<br />
<b>2-</b>Ponemos el nombre de nuestro paquete, que por regla general, se suelen poner en minúsculas. Pulsamos en finalizar y ya tendremos creado nuestro paquete.<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjX0PiZEZowfQQi_Qv_dLQVbJTWISCD5w8h-p6IkjJDf9DaMFJr-82LAEJ8U9TGtBgEJCDhR8yzq6_BLHkaOGvYpMtPWWZQ_33WcxI7CqBOnKNef_hnnayY3JcEb19VWWrekRqYvbhhB9Q/s1600/Captura+de+pantalla+2017-09-05+a+las+14.28.26.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="492" data-original-width="722" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjX0PiZEZowfQQi_Qv_dLQVbJTWISCD5w8h-p6IkjJDf9DaMFJr-82LAEJ8U9TGtBgEJCDhR8yzq6_BLHkaOGvYpMtPWWZQ_33WcxI7CqBOnKNef_hnnayY3JcEb19VWWrekRqYvbhhB9Q/s1600/Captura+de+pantalla+2017-09-05+a+las+14.28.26.png" /></a></div>
<br />
Cuando creemos una clase que queremos que se encuentre dentro del paquete <b>paquetePrueba</b> debemos de pinchar sobre paquetePrueba con el botonDerecho y crear una clase nueva.<br />
<span style="background-color: yellow;">También podemos cambiar una clase que pertenecía a un paquete a otro</span>. Para ello pinchamos con el botón derecho sobre la clase a cambiar de paquete - refactorizar - mover y ya movemos la clase al paquete que queramos.<br />
<br />
Pues esto ha sido todo en este tutorial, espero que sepáis ya que son los paquetes y cómo trabajar con ellos. En el siguiente tutorial vamos a estudiar las clases abstractas en Java. Os animo que sigáis con este curso!!!!Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-15371025545749642842017-07-02T21:04:00.000+02:002017-07-02T21:04:10.321+02:00Saber si un año es bisiesto en JavaEn muchos ejercicios he podido ver que se pide saber si un año es bisiesto o no. En estos ejercicios se explica cómo saber si es bisiesto o no un año concreto aplicando los siguientes datos:<br />
<i>Un año es bisiesto si es divisible por cuatro, excepto cuando es divisible por 100, a no ser que sea divisible por 400.</i><br />
<br />
En realidad realizar eso es muy sencillo, sólo habría que utilizar unos cuantos condicionales para poder averiguarlo pero, ¿Para qué hacerlo así cuando podemos utilizar un valioso métdodo de la clase GregorianCalendar?<i> </i><br />
<a name='more'></a>Así es, vamos a ver cómo saber si un año es o no bisiesto utilizando el método isLeapYear(int year) de la clase GregorianCalendar. Veámoslo en el siguiente ejemplo y veréis lo fácil y cómodo que es:<br />
<br />
<pre class="brush: java">
import java.util.*;
public class SaberBisiesto {
public static void main(String[] args) {
GregorianCalendar fecha =(GregorianCalendar) GregorianCalendar.getInstance();
//Utilizamos el método pasándole como parámetro el año que queremos saber
boolean bisiesto = fecha.isLeapYear(2017);
if(bisiesto){
System.out.println("ES BISIESTO");
}else {
System.out.println("NO ES BISIESTO");
}
}
}
</pre> Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-44191743663080810712017-07-02T17:28:00.000+02:002017-07-02T17:28:14.154+02:00Obtener Fecha Actual en Java.En el siguiente código se muestra cómo obtener fecha y hora actual con Java. El código va comentado por lo que no tendréis ningún problema en entenderlo.<br />
Veamos el código:<br />
<a name='more'></a><br />
<br />
<pre class="brush: java">import java.util.Calendar;
import java.util.GregorianCalendar;
public class ObteniendoFecha {
public static void main(String[] args) {
//Obtenemos un calendario utilizando la zona por defecto. El calendario
//devuelto se basa en la hora actual de la zona horaria predeterminada.
Calendar fecha = GregorianCalendar.getInstance();
int dia = fecha.get(Calendar.DAY_OF_MONTH);//obtenemos el día
int mes = fecha.get(Calendar.MONTH)+1;//Ponemos +1 porque empieza a contar los meses por 0
//Es decir, Enero sería el número 0.
int hora = fecha.get(Calendar.HOUR_OF_DAY);//Obtenemos la hora
int minutos = fecha.get(Calendar.MINUTE);//Obtenemos los minutos
int segundos = fecha.get(Calendar.SECOND);//Obtenemos los segundos
int anio = fecha.get(Calendar.YEAR);//Obtenemos el año
//Creamos bucle switch para que según el entero que devuelva el mes
//muestre el nombre del mes, en vez del número de mes.
String mesCaracteres = "";
switch(mes){
case 1: {
mesCaracteres = "Enero";
break;
}
case 2: {
mesCaracteres = "Febrero";
break;
}
case 3: {
mesCaracteres ="Marzo";
break;
}
case 4: {
mesCaracteres = "Abril";
break;
}
case 5: {
mesCaracteres = "Mayo";
break;
}
case 6: {
mesCaracteres = "Junio";
break;
}
case 7: {
mesCaracteres = "Julio";
break;
}
case 8: {
mesCaracteres = "Agosto";
break;
}
case 9: {
mesCaracteres = "Septiembre";
break;
}
case 10: {
mesCaracteres = "Octubre";
break;
}
case 11: {
mesCaracteres = "Noviembre";
break;
}
case 12: {
mesCaracteres = "Diciembre";
}
}
System.out.println("Son las " + hora + ":" + minutos+":" + segundos+
" del día " + dia + " de " + mesCaracteres+ " del año " +
anio);
}
}
</pre>
Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-91133764604300514332017-07-02T13:55:00.002+02:002017-07-02T13:55:14.758+02:0021-Programación Orientada a Objetos (Parte XI). Almacenar Objetos de la misma clase en Vectores. Iterar por un VectorMuy buenas, en este tutorial veremos la última parte del curso dedicada a la programación orientada a objetos, en realidad siempre que trabajemos con Java lo estaremos haciendo con objetos, pero esta va a ser la última parte del curso de Java en la que estudiaremos el comportamiento y utilización de objetos.<br />
A partir de este tutorial del curso y, si has seguido todos los tutoriales hasta ahora, todo lo que veamos a partir de aquí te resultará mas sencillo de entender. La base para aprender a programar está en entender muy bien cómo trabajar con objetos en Java.<br />
<a name='more'></a>Bueno, en este tutorial vamos a ver cómo podemos almacenar objetos de la misma clase en vectores. Para ello vamos a ver cómo utilizar la clase <span style="color: purple;"><b>Vector</b></span> de Java. Al estudiar esta clase utilizaremos los carácter <i>'<'</i> y <i>'>' </i>para indicar en su interior qué clase de objeto podrá almacenar. Todo esto lo veremos más ampliado cuando estudiemos en el curso los genéricos en Java.<br />
<br />
<br />
<h2>
Almacenar Objetos de la misma clase en arrays o vectores.</h2>
Como he mencionado anteriormente, vamos a almacenar objetos en <span style="color: purple;"><b>Vectores</b></span> y, para ello debemos utilizar dicha clase. Como siempre digo es casi obligatorio visitar la documentación de Java para ver cómo funciona esta clase.<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjBeKjLsc1O1TEJVfMyQu5pmaBDQcIvVfcXMyxKGWtwpfvNF1yzK6iJmYapgw9zyqUTc2d8KAI799CxdDXe0WDPZZlJPhgdC4GaPwS0W9UKkoLfExE-GhFfSKMJ1yFoZnxW2kNVQA-VeeQ/s1600/1.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="284" data-original-width="653" height="139" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjBeKjLsc1O1TEJVfMyQu5pmaBDQcIvVfcXMyxKGWtwpfvNF1yzK6iJmYapgw9zyqUTc2d8KAI799CxdDXe0WDPZZlJPhgdC4GaPwS0W9UKkoLfExE-GhFfSKMJ1yFoZnxW2kNVQA-VeeQ/s320/1.png" width="320" /></a></div>
Podemos ver que la clase Vector está dentro del paquete <span style="color: #783f04;"><b>java.util</b></span>, por lo que deberemos de importar dicho paquete para utilizar esta clase.<br />
Seguramente no entendáis que significa la <i><b>E</b></i> que se encuentra entre <i><</i> y <i>></i>. Esto lo veremos cuando veamos lo genéricos, pero lo que indica <b><E></b> es que esta clase podrá contener objetos de una clase, y dicha clase hay que especificarla, indicarla. Por ejemplo: si queremos introducir objetos de la clase String dentro del vector debemos indicarlo de la siguiente manera:<br />
<i>Vector<String> caracteres = new Vector<String>();</i><br />
Fíjate bien que se declara igual que cuando instanciamos un objeto pero con la particularidad de que indicamos entre '<>'. Ahora tenemos un objeto de la clase <b><span style="color: purple;">Vector</span></b> de nombre caracteres.<br />
<i> </i><br />
Si seguimos mirando la documentación nos informa que la clase Vector es una clase que almacena objetos, y dicha clase puede aumentar o disminuir de tamaño según se vayan añadiendo o eliminando objetos, siendo su capacidad por defecto de 10. <u><b>¿Os acordáis de cuando vimos los arrays?</b></u> Estos había que indicarles el tamaño que iban a tener y luego íbamos rellenando el array, sin pasarnos de su tamaño. Esta clase permite que no tengamos que saber cuántos objetos vamos a introducir, sólo debemos de indicar que clase de objetos vamos a introducir, en nuestro caso hemos indicado que introduciremos objetos de la clase <b><span style="color: purple;">String</span></b>.<br />
<br />
La clase <span style="color: purple;"><b>Vector</b></span> dispone de muchos métodos que aquí no se van a ver todos, es imposible, por eso digo que soys vosotros mismos los que deberéis de aprender a mirar la documentación y mirar los métodos disponibles en cada clase y utilizarlos, creando vuestros propios ejemplos, probad cosas...etc. Así es como aprenderéis realmente a programar. La documentación de Java la podéis encontrar en el siguiente enlace <a href="http://docs.oracle.com/javase/8/docs/api/index.html" target="_blank">documentacion Java</a>. Aquí vamos a utilizar el método <b><span style="color: #274e13;">add(E e)</span></b>.<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgreoTBcsomztTvRJDnRdA6AKV5krg7fWTSVHZZCZDdk3ILfZFJ60dSyn3PWisID3QxwV9hHHuMKgKETCFaYFHA-Aj4Yw59XC360fu6ngyvEJxl55lvKDL6E_U79xvlIkaYNEwaCWE49YE/s1600/2.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="58" data-original-width="710" height="32" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgreoTBcsomztTvRJDnRdA6AKV5krg7fWTSVHZZCZDdk3ILfZFJ60dSyn3PWisID3QxwV9hHHuMKgKETCFaYFHA-Aj4Yw59XC360fu6ngyvEJxl55lvKDL6E_U79xvlIkaYNEwaCWE49YE/s400/2.png" width="400" /></a></div>
Este método nos permitirá añadir al Vector un elemento E. Como ya vimos, <b>E indica que debe ser de la clase que le hemos indicado cuando hemos creado el vector</b>, es decir, un String.<br />
Vamos a ver en el siguiente ejemplo como creamos el Vector y añadimos varios objetos String y utilizamos algunos métodos más de esta clase.<br />
<br />
<pre class="brush: java">import java.util.*;
public class ClaseVector {
public static void main(String[] args) {
//Creamos la instancia de Vector
Vector<string> caracteres = new Vector<string>();
String palabra1 = "Árbol";
String palabra2 = "Piscina";
String palabra3 = "Amistad";
String palabra4 = "Cáctus";
//Añadimos los String al Vector
caracteres.add(palabra1);
caracteres.add(palabra2);
caracteres.add(palabra3);
caracteres.add(palabra4);
//Vamos a ver el tamaño que tiene el vector ahora
System.out.println(caracteres.capacity()); //Imprime 10
System.out.println(caracteres.firstElement());//Imprime Árbol
System.out.println(caracteres.size());//Imprime 4</string></string></pre>
<pre class="brush: java"><string><string> </string></string></pre>
<pre class="brush: java"><string><string>caracteres.remove(palabra3);//Borra el objeto palabra3</string></string></pre>
<pre class="brush: java"><string><string> </string></string></pre>
<pre class="brush: java"><string><string> }
}
</string></string></pre>
<br />
En el ejemplo debemos de diferenciar bien los métodos <b><span style="color: #274e13;">capacity()</span></b> y <span style="color: #274e13;"><b>size()</b></span>. El primer método devuelve un entero con el valor de la capacidad del Vector. Entonces, <b><u>¿Por qué devuelve 10?</u></b> <span style="color: blue;">Un Vector al que no le hemos indicado una capacidad con el método <b><span style="color: #274e13;">setSize(int i)</span></b>, crea un Vector con capacidad por defecto de 10.</span> <b><u>Y si quiero introducir más de 10 objetos, ¿Qué pasa?</u></b><span style="color: blue;"> No te preocupes, el Vector irá aumentando o disminuyendo su tamaño según las necesidades.</span><br />
El método <span style="color: #274e13;"><b>size()</b></span> devuelve los objetos que se encuentran dentro del vector.<br />
Ahora mirad vosotros mismos el resto de métodos de la clase Vector, y probad los que os interesen.<br />
<h2>
Iterar por un Vector</h2>
Para iterar un Vector vamos a utilizar un bucle for-each. Un bucle for-each se utiliza asi:<br />
<i>for(Objeto nombreBucle : nombreVector) { }</i><br />
<u>Dónde he puesto nombreVector puede ser también el nombre de un array, o de genéricos que los veremos más adelante.</u><br />
Vamos a ver cómo recorrer el Vector del ejemplo anterior:<br />
<br />
<pre class="brush: java">//Recorremos el Vector con un bucle for-each
for(String i: caracteres){
//Imprimimos cada uno de los elementos
System.out.println(i);
}
</pre>
<br />
Ahora ya os queda a vosotros ensayar, añadir más elementos, eliminarlos, crear un Vector que guarde objetos de Persona por ejemplo.... etc. No me cansaré de decirlo que es la única forma de que realmente aprendáis a programar, no vale solo con saberse la teoría de los tutoriales, si no se ensaya, se practica y se cometen errores no vais a aprender a programar.<br />
Mucho ánimo y en el siguiente tutorial os hablaré un poco de las clases y los paquetes.<br />
Nos vemos!!!!Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-51107748341672354262017-06-11T16:28:00.000+02:002017-07-02T20:37:51.051+02:0020-Programación Orientada a Objetos en Java (parte X). Uso de super y sobrescritura de métodosYa hemos visto en tutoriales anteriores la herencia en Java y la sobrecarga de métodos y, ha llegado el momento de hablar de dos funciones que nos permitirán tener un mayor uso sobre la herencia, buscando siempre la reutilización de código. Vamos a ver en primer lugar la palabra reservada super para terminar finalmente con la sobrescritura de métodos.<br />
<a name='more'></a><br />
<br />
<h2>
Palabra reservada super.</h2>
La palabra super se utiliza para acceder a métodos y/o atributos de la clase padre. Ya vimos el uso de this que hacía referencia a atributos del mismo objeto del que hacía la llamada, pues super se utiliza para llamar a métodos o atributos de una superclase.<br />
Se utiliza mucho en los métodos constructor, para llamar al método constructor de la superclase.<br />
Veámoslo en un ejemplo en el que utilizaremos la clase padre Persona y la subclase Alumno.<br />
<br />
<br />
<pre class="brush: java">public class Persona {
//Atributos
String nombre;
String apellidos;
int edad;
String trabajo;
//Método constructor que inicializa los atributos a los valores que le pasemos
//como argumentos cuando creemos una instancia de esta clase.
public Persona(String nombre, String apellidos, int edad, String trabajo){
this.nombre = nombre;
this.apellidos = apellidos;
this.edad = edad;
this.trabajo = trabajo;
}
//Método constructor que se le pasa como parámetro un objeto de la clase
//Persona. Esto significa que este objeto tendrá los mismos valores en
//los atributos que el objeto pasado como argumento.
public Persona(Persona b){
this.nombre = b.nombre;
this.apellidos = b.apellidos;
this.edad = b.edad;
this.trabajo = b.trabajo;
}
public void mostrarMensaje(){
System.out.println("Esto es la clase Persona, que será superclase de la clase Alumno");
}
}
</pre>
<pre class="brush: java">public class Alumno extends Persona {
//Atributos específicos de Alumno
String curso;
int notaMedia;
String nombreColegio;
//Creamos un método constructor en el que vamos a ver el funcionamiento
//de super.
public Alumno(String nombre, String apellidos, int edad, String trabajo,
String curso, int notaMedia, String nombreColegio){
//super siempre tiene que ir en primer lugar, antes que cualquier
//sentencia. Llamamos al constructor de la superclase con super
super(nombre, apellidos, edad, trabajo);
this.curso = curso;
this.notaMedia = notaMedia;
this.nombreColegio = nombreColegio;
}
//Métodos propios de Alumno
public void calcularNotaMedia(){
//Definiríamos el método para calcular la nota media
}
public void cambiarColegio(String nuevoColegio){
nombreColegio = nuevoColegio;
}
}
</pre>
<br />
Como podemos ver, en la clase Alumno creamos el constructor en el que utilizamos super para llamar al constructor de la clase Persona, que es la super clase de Alumno.<br />
<br />
<h2>
Sobrescritura de Métdos.</h2>
Ya vimos en un tutorial anterior lo que era la sobrecarga de métodos, ahora vamos a ver otra función más que tiene el lenguaje de programación Java, la sobrescritura de métodos.<br />
La sobrescritura de métodos también va ligado con el uso de la herencia. La sobrescritura de métodos es aquel método que es definido en una clase padre y, que en una de sus subclases se incorpora ese método, o métodos, pero de distinta forma que el método de la superclase, normalmente para cambiar la función o añadir funcionalidad al método.<br />
Los métodos sobrescritos tienen el mismo nombre que el método original y antes del método se suele poner la etiqueta @Override para indicar que ese va a ser un método sobrescrito.<br />
No es obligatorio poner esa etiqueta pero es de gran ayuda porque, como hemos dicho, un método sobrescrito tiene el mismo nombre que el método de la clase padre, por lo tanto si no indicamos esta etiqueta, si nos equicamos al escribir el método lo que estaremos haciendo realmente es crear un nuevo método, y no sobrescribirlo que es lo que realmente queremos.<br />
Vamos a ver toda esta teoría co un ejemplo muy claro, siguiendo con las clases de Persona y Alumno.<br />
<br />
<pre class="brush: java">public class Persona {
//Atributos
String nombre;
String apellidos;
int edad;
String trabajo;
//Método constructor que inicializa los atributos a los valores que le pasemos
//como argumentos cuando creemos una instancia de esta clase.
public Persona(String nombre, String apellidos, int edad, String trabajo){
this.nombre = nombre;
this.apellidos = apellidos;
this.edad = edad;
this.trabajo = trabajo;
}
//Método constructor que se le pasa como parámetro un objeto de la clase
//Persona. Esto significa que este objeto tendrá los mismos valores en
//los atributos que el objeto pasado como argumento.
public Persona(Persona b){
this.nombre = b.nombre;
this.apellidos = b.apellidos;
this.edad = b.edad;
this.trabajo = b.trabajo;
}
//Método mostrarNombre que será sobrescrito en la subclase
public void mostrarNombre(){
System.out.println("El nombre de la persona es: " + this.nombre);
}
}
</pre>
<br />
El código de la clase Persona es prácticamente el mismo, lo único que he creado un nuevo método llamado mostrarNombre que muestra el nombre de la persona. A continuación, en la clase Alumno vamos a sobrescribir este método para que muestre el mensaje un poco más personalizado. Por ejemplo no queremos que muestre "el nombre de la persona es...", sino que queremos que diga "El nombre del Alumno es..."<br />
<br />
<pre class="brush: java">public class Alumno extends Persona {
//Atributos específicos de Alumno
String curso;
int notaMedia;
String nombreColegio;
//Creamos un método constructor en el que vamos a ver el funcionamiento
//de super.
public Alumno(String nombre, String apellidos, int edad, String trabajo,
String curso, int notaMedia, String nombreColegio){
//super siempre tiene que ir en primer lugar, antes que cualquier
//sentencia. Llamamos al constructor de la superclase con super
super(nombre, apellidos, edad, trabajo);
this.curso = curso;
this.notaMedia = notaMedia;
this.nombreColegio = nombreColegio;
}
//Métodos propios de Alumno
public void calcularNotaMedia(){
//Definiríamos el método para calcular la nota media
}
public void cambiarColegio(String nuevoColegio){
nombreColegio = nuevoColegio;
}
public String getNombre() {
return nombre;
}
@Override
public void mostrarNombre(){
System.out.println("El nombre del Alumno es: " + this.nombre);
}
}
</pre>
<br />
En la clase Alumno es el mismo código que en otros ejemplos con el único cambio de la sobrescritura del método mostrarNombre().<br />
<br />
<h2>
Utilizar super y la sobrescritura de métodos.</h2>
Bueno hemos visto el uso de la palabra super, que lo utilizábamos para acceder métodos, atributos de la superclase, pero sobre todo cuando queremos llamar al constructor de una superclase.<br />
También hemos visto qué es y como utilizar la sobrescritura de métodos. Pues bien, ahora vamos a ver que a veces, en una superclase podemos crear un método que, más tarde, en una subclase queremos sobrescribir el método pero queriendo que haga la misma funcionalidad que el método de la superclase pero con alguna funcionalidad mas.<br />
En palabras esto suena raro y poco útil, así que vamos a verlo con un ejemplo, utilizando las clases Persona y Alumno que hemos estado utilizando hasta ahora.<br />
<br />
En primer lugar, en la clase Persona creamos un método mostrarDatos() que mostrará los datos de la persona, como su nombre, apellidos, edad y el trabajo que tiene.<br />
<br />
<pre class="brush: java">public class Persona {
//Atributos
String nombre;
String apellidos;
int edad;
String trabajo;
//Método constructor que inicializa los atributos a los valores que le pasemos
//como argumentos cuando creemos una instancia de esta clase.
public Persona(String nombre, String apellidos, int edad, String trabajo){
this.nombre = nombre;
this.apellidos = apellidos;
this.edad = edad;
this.trabajo = trabajo;
}
//Método constructor que se le pasa como parámetro un objeto de la clase
//Persona. Esto significa que este objeto tendrá los mismos valores en
//los atributos que el objeto pasado como argumento.
public Persona(Persona b){
this.nombre = b.nombre;
this.apellidos = b.apellidos;
this.edad = b.edad;
this.trabajo = b.trabajo;
}
public void mostrarNombre(){
System.out.println("El nombre de la persona es: " + this.nombre);
}
//Método que será utilizado en la subclase para sobrescribirlo
//y utilizando la palabra super.
public void mostrarDatos(){
System.out.println("El nombre es: " + this.nombre);
System.out.println("Los apellidos son: " + this.apellidos);
System.out.println("La edad es: " + this.edad);
System.out.println("Trabaja en: " + this.trabajo);
}
}
</pre>
<br />
Ahora, en la clase Alumno sobrescribiremos el método mostrarDatos() de la clase Persona para que también muestre los atributos del Alumno. Como también queremos que muestre los datos de la superclase, utilizaremos la palabra super para llamar al método de la superclase mostrarDatos y solo quedaría sobrescribir el método de la subclase para mostrar los datos de los Alumnos:<br />
<br />
<pre class="brush: java">public class Alumno extends Persona {
//Atributos específicos de Alumno
String curso;
int notaMedia;
String nombreColegio;
//Creamos un método constructor en el que vamos a ver el funcionamiento
//de super.
public Alumno(String nombre, String apellidos, int edad, String trabajo,
String curso, int notaMedia, String nombreColegio){
//super siempre tiene que ir en primer lugar, antes que cualquier
//sentencia. Llamamos al constructor de la superclase con super
super(nombre, apellidos, edad, trabajo);
this.curso = curso;
this.notaMedia = notaMedia;
this.nombreColegio = nombreColegio;
}
//Métodos propios de Alumno
public void calcularNotaMedia(){
//Definiríamos el método para calcular la nota media
}
public void cambiarColegio(String nuevoColegio){
nombreColegio = nuevoColegio;
}
public String getNombre() {
return nombre;
}
@Override
public void mostrarNombre(){
System.out.println("El nombre del Alumno es: " + this.nombre);
}
@Override
public void mostrarDatos(){
super.mostrarDatos();//Llamamos al método de la superclase con super.
//Ahora mostramos los datos del alumno
System.out.println("Está cursando: " + this.curso);
System.out.println("Tiene una nota media de: " + this.notaMedia);
System.out.println("Va al colegio: " + this.nombreColegio);
}
}
</pre>
<br />
Si creamos un objeto alumno y ejecutamos su método mostrar datos, vemos como muestra por pantalla todos los datos:<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhfF6_Ffj-fph9pRdTs2ti1x-UH_dLOUoFoWFczmy6SR_DEvMdFAgSL5DhJa7X45DLzf142alWoUydWBy770efsT_fM9GyA8iKiJnAh0MyOztvcfuvr36bCYmFzBGDtHxPstNS64Ttydpc/s1600/Captura+de+pantalla+2017-06-11+a+las+16.12.35.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" data-original-height="257" data-original-width="393" height="209" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhfF6_Ffj-fph9pRdTs2ti1x-UH_dLOUoFoWFczmy6SR_DEvMdFAgSL5DhJa7X45DLzf142alWoUydWBy770efsT_fM9GyA8iKiJnAh0MyOztvcfuvr36bCYmFzBGDtHxPstNS64Ttydpc/s320/Captura+de+pantalla+2017-06-11+a+las+16.12.35.png" width="320" /></a></div>
Bueno y esto ha sido todo en este tutorial, es<br />
<br />Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-68493601276833821652017-04-28T20:53:00.001+02:002017-04-28T21:01:31.821+02:0019-Programación Orientada a Objetos en Java (IX). La Herencia.Muy buenas a tod@s, en primer lugar pedir perdón por tardar tanto en seguir con los tutoriales pero he estado muy liado con mis estudios. Pero los tutoriales no van a ser dejados a medio y se van a terminar, es más, incluso tengo ya en mente otros tutoriales más como de bases de datos de Oracle, programación en Unity, programación en Android.... Pero todo poco a poco y a su debido tiempo.<br />
<br />
En el tutorial de hoy vamos a aprender qué es la herencia en Java y cómo se utiliza. Bueno, sin más escusas vamos a ver en primer lugar la herencia.<br />
<a name='more'></a><br />
<h2>
La Herencia</h2>
Primero de todo vamos a definir lo que es la herencia, para después ver con ejemplos cómo funciona y cómo utilizarla.<br />
En tutoriales anteriores hemos visto ya qué son las clases y que a través de estas clases podemos instanciar o crear objetos. Cada objeto creado de una clase tendrá los mismos atributos y métodos pero cada uno con sus valores particulares de dicho objeto.<br />
Pues bien, habrá veces que un objeto, por sus características, deba tener unos atributos y/o métodos que ya han sido definidos en otra clase distinta a ese objeto. Con la herencia, ese objeto heredará todos los atributos y métodos definidos en la clase de la que hereda y, además podrá tener sus atributos y métodos particulares de ese objeto.<br />
La clase que hereda de otra clase se le denomina <b>subclase</b>, y la clase que es heredada se le denomina <b>superclase</b>.<br />
En Java sólo es posible la herencia simple, no permitiendo por lo tanto la herencia compuesta, es decir, una clase no puede heredar más de una superclase. Esto quiere decir que una clase sólo puede tener una superclase, aunque una clase puede ser heredada por varias subclases.<br />
Todas las clases descienden de la clase <b>Object</b>.<br />
Para que una clase herede de otra clase se debe de utilizar la palabra reservada <span style="color: purple;"><b>extends</b></span>. Veamos un ejemplo:<br />
<br />
<h3>
</h3>
<pre class="brush: java">public class nombreSubclase extends nombreSuperclase {
}</pre>
<br />
De la forma anterior la clase <span style="color: blue;">nombreSubclase</span> heredará todos los atributos y métodos de la clase <span style="color: blue;">nombreSuperclase</span>.<br />
Una cosa importante, a la vez que lógica, es que <b>una clase heredará de otra clase sólo los métodos y atributos que no sean privados</b>. Si tenemos atributos privados en la superclase, debemos crear los correspondientes set and get para poder acceder a estos valores. Si no sabes lo que son los métodos set and get, dirígete al <a href="http://tazasdejava.blogspot.com.es/2016/11/14-programacion-orientada-objetos-parte.html" target="_blank">tutorial 14</a>.<br />
<br />
Como siempre digo, tanto texto, tan engorroso que parece que la herencia es algo para gente que trabaja en la N.A.S.A. Pero nada más lejos de la realidad, vamos a ver a continuación con un sencillo ejemplo cómo utilizar la herencia. Para ello tenemos creada una <b>clase Persona</b>, con los atributos y métodos básicos que tienen las personas, luego crearemos nuestra <b>clase Alumno</b>. Esta clase Alumno, si nos paramos a pensar, deduciremos que un Alumno es una Persona, por lo tanto heredará los atributos y métodos de esta clase y así no tendremos que volver a definir estos atributos y métodos.<br />
Luego crearemos el programa con el método main principal y observaremos cómo desde un objeto de la clase Alumno podemos acceder a los atributos y métodos definidos tanto en la clase Alumno, como de su superclase Persona.<br />
<br />
<u><b>Clase Persona. Clase que será superclase de la clase Alumno</b></u><br />
<br />
<pre class="brush: java">public class Persona {
//Atributos
String nombre;
String apellidos;
int edad;
String trabajo;
//Método constructor sin parámetros. Este constructor iniciará cada dato
//a su valor por defecto
public Persona(){
}
//Método constructor que inicializa los atributos a los valores que le pasemos
//como argumentos cuando creemos una instancia de esta clase.
public Persona(String nombre, String apellidos, int edad, String trabajo){
this.nombre = nombre;
this.apellidos = apellidos;
this.edad = edad;
this.trabajo = trabajo;
}
//Método constructor que se le pasa como parámetro un objeto de la clase
//Persona. Esto significa que este objeto tendrá los mismos valores en
//los atributos que el objeto pasado como argumento.
public Persona(Persona b){
this.nombre = b.nombre;
this.apellidos = b.apellidos;
this.edad = b.edad;
this.trabajo = b.trabajo;
}
public void mostrarMensaje(){
System.out.println("Esto es la clase Persona, que será superclase de la clase Alumno");
}
}
</pre>
<br />
<u><b>Clase Alumno que será subclase de la clase Persona</b></u><br />
<br />
<br />
<pre class="brush: java">public class Alumno extends Persona {
//Atributos específicos de Alumno
String curso;
int notaMedia;
String nombreColegio;
//Métodos propios de Alumno
public void calcularNotaMedia(){
//Definiríamos el método para calcular la nota media
}
public void cambiarColegio(String nuevoColegio){
nombreColegio = nuevoColegio;
}
}</pre>
<pre class="brush: java"> </pre>
Como vemos, la clase Alumno es una clase muy básica y que no hemos tenido que definir atributos básicos como nombre, apellidos... ya que los heredará de la clase Persona<br />
Ahora vamos a crear el programa dónde crearemos un objeto de Alumno, llamado alumno1 y en el que podremos observar que podemos acceder a todos los atributos y métodos tanto de la propia clase Alumno, como de la superclase Persona (Si hubieran atributos/métodos privados no se podrían acceder a ellos).<br />
<br />
<u><b>Programa principal dónde comprenderemos el uso de la herencia: </b></u><br />
<br />
<pre class="brush: java">public class ProgramaHerencia {
public static void main(String[] args) {
Alumno alumno1 = new Alumno();
//Le ponemos un nombre y apellidos a través del uso de la herencia
alumno1.nombre = "Javier";
alumno1.apellidos = "Carreño Ortega";
alumno1.mostrarMensaje();//Método de la clase Persona que es heredado
alumno1.curso = "2º Primaria";//Propio atributo de la clase Alumno
alumno1.cambiarColegio("Otro colegio nuevo");//Propio atributo de la clase Alumno
}
}</pre>
<pre class="brush: java"> </pre>
<pre class="brush: java"> </pre>
Como hemos podido comprobar, la herencia es una herramienta muy útil para agilizar nuestro trabajo e impedir escribir de nuevo código ya implementado. Las subclases heredan de las superclases y hacen propios los atributos y métodos heredados.<br />
Un buen truco para saber si una clase tiene que heredar de otra es utilizar la expresión "es un/a". Por ejemplo en nuestro caso, un Alumno es una Persona, por lo tanto es muy probable que Alumno tenga que heredar de Persona.<br />
<br />
Bueno y esto est todo en este tutorial, espero que esté todo muy claro y que sigáis atentos a más tutoriales y código fuente que iré publicando.<br />
En el siguiente tutorial veremos de la palabra reservada super y de la sobrescritura de métodos. Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-11645705679830212252017-02-19T14:23:00.002+01:002019-04-20T14:12:36.655+02:00Problema con nextLine(). Se salta una línea.Hola a todos. Seguramente alguna vez te haya pasado que quieras pedir datos por consola y a la hora de ir introduciendo los datos, de pronto te das cuenta que se ha saltado una línea y te preguntes porqué narices hace eso Java. Pues bien sigue leyendo y sabrás porqué pasa esto y aprenderás 3 maneras de solucionarlo.<br />
<br />
<br />
Este problema pasa cuando queremos leer un tipo de dato numético, sea del tipo que sea y seguidamente queremos leer un String. Por ejemplo:<br />
<br />
<pre class="brush: java">import java.util.Scanner;
public class Programa {
public static void main(String[] args) {
Scanner sca = new Scanner(System.in);
int edad;
String nombre;
System.out.println("Introduce edad: ");
edad = sca.nextInt();
System.out.println("Introduce nombre: ");
nombre = sca.nextLine();
}
}
</pre>
<br />
<a name='more'></a><br />
<br />
En este caso pediremos por consola la edad, cuando le demos al enter se mostrará el texto "Introduce nombre: " pero seguidamente acabará el programa y se saltará esa línea.<br />
Esto se debe a que cuando introducimos el número y le damos al enter, se guarda el enter del Scanner y cuando llama al método nextLine() como guarda el enter automáticamente salta pensando que hemos pulsado enter sin introducir nada.<br />
<h4>
¿Cómo solucionamos este problema?</h4>
Pues para solucionar este problema tenemos 3 soluciones:<br />
<br />
1-Leer el tipo de dato como String y luego hacer un casting y convertirlo al tipo de dato que queramos.<br />
2-Después de leer el tipo de dato entero introducimos un nextLine(). Como por ejemplo:<br />
<br />
<pre class="brush: java">import java.util.Scanner;
public class Programa {
public static void main(String[] args) {
Scanner sca = new Scanner(System.in);
int edad;
String nombre;
System.out.println("Introduce edad: ");
edad = sca.nextInt();
sca.nextLine();
System.out.println("Introduce nombre: ");
nombre = sca.nextLine();
}
}
</pre>
<br />
3-La tercera opción es la de utilizar el método skip("\n");<br />
<br />
<pre class="brush: java">
import java.util.Scanner;
public class Programa {
public static void main(String[] args) {
Scanner sca = new Scanner(System.in);
int edad;
String nombre;
System.out.println("Introduce edad: ");
edad = sca.nextInt();
sca.skip("\n");
System.out.println("Introduce nombre: ");
nombre = sca.nextLine();
}
}
</pre>
Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com12tag:blogger.com,1999:blog-1488530453345798857.post-65755137260361242872017-02-19T13:53:00.004+01:002017-04-07T11:56:45.124+02:0018-Programación Orientada a Objetos (parte VIII). Método Constructor. Sobrecarga de Métodos ConstructorEn el siguiente turorial vamos a explicar que es eso del método constructor en Java. En el <a href="http://tazasdejava.blogspot.com.es/2016/11/11-programacion-orientada-objetos-en.html" target="_blank">tutorial 11</a> explicamos cómo se creaba un objeto en Java y vimos que un objeto se instanciaba de la siguiente manera:<br />
<br />
<pre class="brush: java"> Coche cocheRojo = new Coche(); </pre>
<br />
La sentencia anterior crea un cocheRojo de la clase Coche, es decir, un objeto de la clase cocheRojo.<br />
En primer lugar se crea la <b><span style="color: #38761d;">variable cocheRojo</span></b> de la <b><span style="color: #741b47;">clase Coche</span></b>, luego en segundo lugar se referencia con la palabra clave <span style="color: blue;"><b>new</b></span>, al <span style="color: #b45f06;"><b>método constructor</b></span>. Cada vez que creamos un objeto se hace la llamada al método constructor de dicha clase. <b>El método constructor tiene el mismo nombre de la clase</b> <b>y es un método que no devuelve ningún tipo de valor</b>. Por eso después de utilizar new ponemos la misma palabra de la clase, porque se llama al método constructor. El método constructor, si no tiene parámetros se pone los paréntesis vacíos como con cualquier otro método sin parámetros.<br />
<a name='more'></a><br />
<br />
Todo esto puede parecer muy lioso al principio pero, la teoría en programacón es así, lo veréis todo mejor cuando pongamos los ejemplos.<br />
<br />
Nos podemos preguntar, si cuando hemos visto cómo se creaban las clases en Java no hemos creado ningún método constructor. <b>¿Cómo es que cuando se crea un objeto tenemos que llamar al método constructor?</b> Esto es porque si cuando creamos una clase, y esa clase no creamos un método constructor, cuando se cree una instancia de esa clase <b>Java crea un método constructor por defecto sin parámetros</b>. Por eso cuando creamos un objeto siempre hay que llamar al método constructor aunque no hayamos creado ninguno, porque Java llamará al constructor por defecto, es decir al constructor de la clase sin parámetros.<br />
<br />
Bueno, después de este royaco que he metido vamos a lo importante. ¿<b>Para qué sirve un método constructor?</b><br />
<span style="color: blue;"><b>Un método constructor sirve para inicializar un objeto con unos valores iniciales</b></span>. En el siguiente ejemplo crearemos una clase, y en dicha clase crearemos nuestro método constructor y veremos cómo funciona:<br />
<br />
<pre class="brush: java">public class Persona {
//Atributos
private String nombre;
private String apellidos;
private int edad;
private String trabajo;
//Ahora crearemos nuestro método constructor. Como hemos dicho un método
//Constructor sirve para inicializar valores de un objeto concreto.
//por lo que vamos a crear un constructor que inicialice los valores de los
//atributos.
//Un constructor tiene el mismo nombre de la clase, y entre paréntesis
//le pasamos los parámetros que queremos inicializar.
public Persona(String nombre, String apellidos, int edad, String trabajo){
this.nombre = nombre;
this.apellidos = apellidos;
this.edad = edad;
this.trabajo = trabajo;
}
//De esta forma, cuando instanciemos un objeto de esta clase Persona
//y llamemos al constructor debemos pasarlo como parámetros nombre,
//apellidos, edad y trabajo que tomará los valores que le pasemos
//para ese objeto concreto
//Métodos get para recuperar la información. En este ejemplo no vamos a
//crear los métodos set porque no nos van a hacer falta
public String getNombre(){
return nombre;
}
public String getApellidos(){
return apellidos;
}
public int getEdad(){
return edad;
}
public String getTrabajo(){
return trabajo;
}
}
</pre>
<br />
Ahora vamos a crear un par de instancias de la clase Persona para observar cómo trabaja el método constructor. El siguiente código muestra la clase Programa con las explicaciones necesarias:<br />
<br />
<pre class="brush: java">public class Programa {
public static void main(String[] args) {
//Creamos dos objetos de la clase Persona.
/*
Como digimos después del new se llama al constructor. Si recordamos el
constructor de la clase Persona le pasamos como parámetros el nombre,
los apellidos, la edad y el nombre del trabajo. Ahora debemos poner los
argumentos en el mismo orden, es decir, primero el nombre, luego los
apellidos, la edad y por último el nombre del trabajo
*/
Persona yo = new Persona("Javier", "Pérez Rubio", 26, "Informático");
//En este objeto inicializamos los valores a los valores pasados como
//argumentos por el constructor. Ahora vamos a crear otro objeto
Persona otraPersona = new Persona("María", "De la Rosa", 21, "Administrativa");
//Para este objeto le hemos pasado otros valores. Ahora vamos a mostrar
//pantalla todos los valores de los dos objetos.
System.out.println("EL OBJETO YO TIENE EL NOMBRE: " + yo.getNombre()+
" DE APELLIDOS " + yo.getApellidos()+ ", Y TIENE UNA EDAD DE " +
yo.getEdad()+ " Y TRABAJA DE " + yo.getTrabajo());
System.out.println("EL OBJETO OTRAPERSONA TIENE EL NOMBRE: " + otraPersona.getNombre()+
" DE APELLIDOS " + otraPersona.getApellidos()+ ", Y TIENE UNA EDAD DE " +
otraPersona.getEdad()+ " Y TRABAJA DE " + otraPersona.getTrabajo());
}
} </pre>
<br />
<b>Un método Constructor no devuelve ningún tipo de valor, ni siquiera se indica void</b>. Simplemente el método constructor se forma con el nombre de la clase e indicando los parámetros, si lleva.<br />
<br />
Si ejecutamos nos mostrará la siguiente imagen.<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjEW6oWsLi34YbOMWpQ_MBCoNiQwLdILQDYuNm_a_P2wOYjL2k_nzV_wHfZ_16RuUnmg4CapqBeihnKk3DCPUuZcKfID4cYWpkBUP5a2U5HxujrUo2XYLx63WkL0qWrzacN43YrFGfjeWM/s1600/constructor.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="186" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjEW6oWsLi34YbOMWpQ_MBCoNiQwLdILQDYuNm_a_P2wOYjL2k_nzV_wHfZ_16RuUnmg4CapqBeihnKk3DCPUuZcKfID4cYWpkBUP5a2U5HxujrUo2XYLx63WkL0qWrzacN43YrFGfjeWM/s640/constructor.png" width="640" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
</div>
<br />
<b>Hay que tener en cuenta que si no creamos un método constructor Java nos crea uno por defecto sin parámetros que inicializa los valores a los valores por defecto, 0 a los atributos de tipo int, null para los String, false para los boolean...</b> Pero si creamos un método constructor Java ya no creará ningún constructor por nosotros, por lo que si creamos un objeto y para ese objeto hemos creado un constructor con parámetros y cuando instanciemos ese objeto y no le pasamos argumentos al método constructor nos dará un error de compilación, puesto que tendremos que introducir los argumentos que hayamos indicado a la hora de crear el constructor.<br />
Si quisiéramos poder instanciar un objeto y no pasarle argumentos en el constructor deberemos de crearlo nosotros mismos, es decir, los métodos constructor aceptan la sobrecarga. <b>¿Que qué es la sobrecarga del método constructor?</b> Lo vamos a ver a continuación:<br />
<br />
<h4>
SOBRECARGA DEL MÉTODO CONSTRUCTOR</h4>
En el tutorial anterior vimos que era posible la <a href="http://tazasdejava.blogspot.com.es/2016/12/17-programacion-orientada-objetos-parte.html" target="_blank">sobrecarga de métodos</a>. Ahora veremos que también es posible hacer sobrecarga del método constructor. Podemos crear tantos métodos constructor como queramos siempre que sean distintos, es decir, su firma sea distinta. <b>¿Qué quiere decir que su firma sea distinta? <span style="color: blue;">Pues que el número de parámetros y/o el tipo de datos de esos parámetros serán distintos en cada método que se cree.</span></b><br />
En el siguiente ejemplo vamos a seguir con el ejemplo de la clase Persona, en esta clase vamos a crear un total de 3 métodos constructor.<br />
<br />
<pre class="brush: java">public class Persona {
//Atributos
private String nombre;
private String apellidos;
private int edad;
private String trabajo;
//Método constructor sin parámetros. Este constructor iniciará cada dato
//a su valor por defecto
public Persona(){
}
//Método constructor que inicializa los atributos a los valores que le pasemos
//como argumentos cuando creemos una instancia de esta clase.
public Persona(String nombre, String apellidos, int edad, String trabajo){
this.nombre = nombre;
this.apellidos = apellidos;
this.edad = edad;
this.trabajo = trabajo;
}
//Método constructor que se le pasa como parámetro un objeto de la clase
//Persona. Esto significa que este objeto tendrá los mismos valores en
//los atributos que el objeto pasado como argumento.
public Persona(Persona b){
this.nombre = b.nombre;
this.apellidos = b.apellidos;
this.edad = b.edad;
this.trabajo = b.trabajo;
}
public String getNombre(){
return nombre;
}
public String getApellidos(){
return apellidos;
}
public int getEdad(){
return edad;
}
public String getTrabajo(){
return trabajo;
}
}
</pre>
<br />
Ahora crear instancias de la clase Persona y utilizaremos los 3 métodos constructor para que veáis cómo trabajan según qué constructor utilicemos.<br />
<br />
<pre class="brush: java">public class Programa {
public static void main(String[] args) {
//Creamos un objeto de la clase persona que utilizará el constructor
//sin parámetros. Como ya digimos si no indicamos ningún constructor a la
//hora de crear una clase Java nos crea un constructor por defecto que
//no tiene parámetros. Pero si creamos algún constructor y queremos también
//tener un constructor sin parámetros, deberemos de crearlo nosotros mismos
//como hemos hecho en la clase Persona. Java, al crear nosotros un
//constructor ya no crea por defecto ese constructor sin parámetros.
Persona primeraPersona = new Persona();
//Creamos ahora un objeto que utilizará un constructor que le pasamos
//como argumentos los valores que tendrá esa persona
Persona segundaPersona = new Persona("Jose Luís", "Gálvez Soriano",
30, "Cajero");
//Por último creamos un objeto que utiliza el constructor que se le pasa
//como argumento un objeto, el objeto que se le pase será el objeto
//creado anteriormente segundaPersonal.
Persona terceraPersona = new Persona(segundaPersona);
//Ahora vamos a mostrar por pantalla la información de estos 3 objetos
/*
Veremos que primeraPersona mostrará los datos por defecto, segundaPersona
mostrará los datos que le hemos pasado como argumentos y por último
la terceraPersona mostrará los mismos datos que segundaPersona
*/
System.out.println("PrimeraPersona- Nombre: " + primeraPersona.getNombre()+
" Apellidos: " + primeraPersona.getApellidos()+" Edad: " +
primeraPersona.getEdad()+" Trabajo: " + primeraPersona.getTrabajo());
System.out.println("SegundaPersona- Nombre: " + segundaPersona.getNombre()+
" Apellidos: " + segundaPersona.getApellidos()+" Edad: " +
segundaPersona.getEdad()+" Trabajo: " + segundaPersona.getTrabajo());
System.out.println("TerceraPersona- Nombre: " + terceraPersona.getNombre()+
" Apellidos: " + terceraPersona.getApellidos()+" Edad: " +
terceraPersona.getEdad()+" Trabajo: " + terceraPersona.getTrabajo());
}
} </pre>
<br />
Si ejecutamos nos mostrará los datos como en la siguiente imagen:<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgZ33d41XVqJbMufWu5WFB1u4XFxu-VBdrjgr4YksSBVB79q7FisC-inYEmwOZBSN3Cc86SDXIpzzNJHQTemZq_I1WPAqvyohiEigebqNt2zZPefrbJzv5QX6ACWpL6nFqe5tfuUy3OtD4/s1600/constructor.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="120" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgZ33d41XVqJbMufWu5WFB1u4XFxu-VBdrjgr4YksSBVB79q7FisC-inYEmwOZBSN3Cc86SDXIpzzNJHQTemZq_I1WPAqvyohiEigebqNt2zZPefrbJzv5QX6ACWpL6nFqe5tfuUy3OtD4/s640/constructor.png" width="640" /></a></div>
<br />
Bueno eso es todo sobre los constructores, como siempre os digo si tenéis alguna duda no dudéis en enviar un comentario, todos los comentarios serán respondidos.<br />
Nos vemos!!!!!Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com2tag:blogger.com,1999:blog-1488530453345798857.post-25110465885879918132017-02-13T10:00:00.000+01:002017-04-07T11:57:53.029+02:00Invertir Frase o Palabra en Java.El programa que os muestro hoy es capaz de esperar la entrada por teclado por parte del usuario de una palabra o frase, para después invertir el orden. Veamos el código:<br />
<br />
<br />
<pre class="brush: java">import java.util.Scanner;
class InvertirFrase {
public static void main(String[] args) {
Scanner sca = new Scanner(System.in);
String frase;
System.out.println("Introduzca su frase:");
frase = sca.nextLine();
//Convertimos la frase a un array de caracteres(tipo char)
char[]conver = frase.toCharArray();
//Bucle que recorre y muestra la frase invertidamente
for(int x = conver.length-1; x !=-1; x--){
System.out.print(conver[x]);
}
}
}
</pre>
<br />
<a name='more'></a><br />
<br />
Creo que el código no tiene mucha dificultad, aunque la parte más complicada podría ser:<br />
<br />
<br />
<pre class="brush: java">for(int x = conver.length-1; x !=-1; x--){
System.out.print(conver[x]);
}
</pre>
<br />
Este <b>bucle for</b> es el encargado de invertir la frase. El for lo que hace es iniciar la <b><span style="color: blue;">variable x</span></b> al valor que tenga el número de caracteres de la frase - 1. <u><b>¿Por qué -1?</b></u> Pues porque el <b><span style="color: #38761d;">método length() </span></b>cuenta los caracteres totales, por ejemplo "hola" tendrá 4 caracteres. Pero en el array la primera letra, que es la h, no estará en la posición 1, sino que estará en la posición 0. <b>Los arrays siempre empiezan a contar desde 0</b>. Luego se irá repitiendo el bucle mientras que el valor de x sea distinto a -1, que significará que ya ha recorrido todas las letras. Por último cada vez que se repita el bucle el valor de x se resta en 1.<br />
Cada vez que el bucle es repetido se imprimirá el valor de la posición del array actual.<br />
<br />Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-57459250966652423032016-12-31T14:52:00.000+01:002017-04-07T11:57:47.688+02:0017-Programación orientada a objetos (Parte VII). Alcance de las variables y Sobrecarga de métodos.En primer lugar, se que llevaba tiempo sin publicar ningún tutorial, pero es que estoy muy liado y no he tenido tiempo, pero iré publicando conforme pueda, <u><b>no voy a abandonar el blog y voy a terminar los tutoriales de Java</b></u>, además tengo pensado hacer más tutoriales como de bases de datos, Android....<br />
<br />
Ahora vamos a empezar con el tutorial de hoy, en el que hablaremos del alcance de las variables y de la sobrecarga de métodos.<br />
<br />
<h2>
<span style="color: #4c1130;">
Alcance de las Variables</span></h2>
Bueno, ya hemos visto en tutoriales anteriores cómo es la estructura de una clase (atributos y métodos) y cómo crear objetos así, que hay que saber que una variable, según dónde la creemos será visible desde un lugar o no. Podemos diferenciar entre <span style="color: #073763;"><b>variables locales y variables de instancia</b></span><br />
<br />
<h3>
Variables Locales</h3>
<span style="font-weight: normal;">Estas variables no admiten modificadores de acceso, <b>salvo final</b>, y <b>deben ser inicializadas cuando se crean para que puedan ser utilizadas</b>. Estas variables son las que <b>se crean dentro de un método, un bucle for, ocualquier condicional y sólo son visibles dentro de estas instrucciones</b>. Si intentáramos acceder al valor de alguna de estas variables locales nos mostraría un error de que no encuentra esa variable.</span><br />
<br />
<h3>
<b><span style="font-weight: normal;"><b>Variables de Instancia</b> </span></b></h3>
<span style="font-weight: normal;">Estas variables <b>se declaran después de la clase y tienen un alcance global</b>, es decir, se pueden acceder a ellas desde cualquier lugar. Estas variables <b>se declaran fuera de cualquier método, <u>condicional o bucle.</u></b></span><br />
<span style="font-weight: normal;"><b><u>Para acceder a estas variables desde el método main o desde cualquier otro método estático es necesario crear un objeto de la clase.</u></b> </span><br />
<br />
<h2>
<span style="color: #4c1130;">
Sobrecarga de Métodos</span></h2>
<span style="font-weight: normal;">La sobrecarga de métodos suele confundir al principio a los que empiezan a programar en Java, pero no os preocupéis, lo voy a intentar explicar de la manera más sencilla posible y luego veremos algún ejemplo en código que es cómo mejor se aprenden estas cosas.</span><br />
<span style="font-weight: normal;">En primer lugar hay que aprenderse qué es la sobrecarga de métodos. En tutoriales anteriores vimos cómo crear nuestros métodos, que si lo recordáis (si no lo recordáis ir inmediatamente a repasar xD) hay que indicar el modificador de acceso, el tipo devuelto o void si no devuelve nada, el nombre del método, los parámetros si el método lleva parámetro y entre las llaves introducíamos el código. Pues bien imaginad que tenemos un método que lo que hace es sumar dos números y devuelve la suma. Un posible método que haga esto es:</span><br />
<a name='more'></a><br />
<br />
<pre class="brush: java">public int sumar(int x, int y){
int sumaTotal = x + y;
return sumaTotal;
}
</pre>
<br />
<span style="font-weight: normal;">Pero, <u><b>¿que pasaría si quisiéramos sumar dos números de tipo float o tipo double?</b></u>. Java nos permite la sobrecarga de métodos, que <b><span style="color: #4c1130;">no es otra cosa que tener varios métodos con el mismo nombre pero se deben de diferenciar en el <u>tipo de parámetros</u> o en el <u>número de parámetros</u>.</span></b> Así, podemos crear los métodos sumar para que sume números de tipo float y de tipo double.</span><br />
<br />
<pre class="brush: java"> public double sumar(double x, double y){
double sumaTotal = x + y;
return sumaTotal;
}
public float sumar(float x, float y){
float sumaTotal = x + y;
return sumaTotal;
}
</pre>
<br />
<span style="font-weight: normal;">De esta forma tenemos implementados 3 métodos del mismo nombre sumar(). Y según necesitemos un método u otro utilizaremos un método que devuelva un tipo entero, tipo double o tipo float.</span><br />
<br />
<span style="font-weight: normal;">Como he comentado antes, <b>también podemos tener el método con el mismo nombre, el mismo tipo de datos pero que tenga un número diferente de parámetros. </b></span><br />
<br />
<span style="font-weight: normal;">Alguna clase que viene en la API de Java también emplean la sobrecarga de métodos. Por ejemplo si miramos la documentación de la clase Math vemos que el método max() está sobrecargado como vemos en la siguiente imagen.</span><br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhJEJFJ2nZwa4Z87hpcMeI551n2Ht_4n1lbzqPYlOF4xB2Wew_QoxYvUM9HpV9T1fLjK0ZfKmOA5CDm6OoYSVF1opat-DZk8UKyTfmPKaELIr6ETYA10nxVk58E3pDRliGwtHp0y_OeRz8/s1600/sobrecarga.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="146" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhJEJFJ2nZwa4Z87hpcMeI551n2Ht_4n1lbzqPYlOF4xB2Wew_QoxYvUM9HpV9T1fLjK0ZfKmOA5CDm6OoYSVF1opat-DZk8UKyTfmPKaELIr6ETYA10nxVk58E3pDRliGwtHp0y_OeRz8/s400/sobrecarga.png" width="400" /></a></div>
<br />
<br />
<span style="font-weight: normal;">Bueno pues esto es todo, en el siguiente tutorial veremos el método constructor y cómo también se puede hacer la sobrecarga del constructor. Nos vemos!! </span><b><span style="font-weight: normal;"> </span></b>Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-3821379455000227442016-12-19T10:00:00.000+01:002017-04-07T11:57:59.849+02:00Traductor de Jeringozo en Java. El programa que os muestro hoy traduce cualquier palabra o frase al lenguaje Jeringozo. <u><b>¿Que qué es el lenguaje Jeringozo?</b></u> El lenguaje Jeringozo seguramente os suene por haberlo escuchado alguna vez o algunos lo habréis utilizado cuando erais más pequeños. Este lenguaje consiste en agregar la letra "p" después de cada vocal y luego repetir la vocal por ejemplo, para traducir hola sería hopolapa.<br />
Para hacer el programa hemos tenido en cuenta algunos casos especiales, por ejemplo la palabra queso no queremos que nos la traduzca en qupuepesopo, queremos que se quede así: quepesopo. Por lo tanto debemos tener en cuenta hay que tener que pasar por alto la letra "u" cuando no se pronuncia como en queso, bloque, queso...<br />
<a name='more'></a>Veamos el código fuente del programa:<br />
<br />
<pre class="brush: java">import java.util.Scanner;
class Jeringozo {
public static void main(String[] args) {
Scanner sca = new Scanner (System.in);
System.out.println("Introduce la frase:");
String frase = sca.nextLine();
char vocal;</pre>
<pre class="brush: java"> char[]sep = frase.toCharArray();
for(int i = 0; i < frase.length(); i++){
if(frase.charAt(i) == 'a' || frase.charAt(i)== 'e' ||
frase.charAt(i)== 'i'|| frase.charAt(i)=='o'
){
vocal = frase.charAt(i);
System.out.print(sep[i] + "p" + vocal);
}
else if(frase.charAt(i)== 'g' || frase.charAt(i)== 'q' && (frase.charAt(i+1)=='u' &&
frase.charAt(i+2) == 'e'||frase.charAt(i+2)=='i')){
System.out.print(sep[i]);
}
else if(frase.charAt(i)=='u' &&( frase.charAt(i+1) != 'e' && frase.charAt(i+1)!='i')){
vocal = frase.charAt(i);
System.out.print(sep[i] + "p" + vocal);
}
else{
System.out.print(sep[i]);
}
}
System.out.println();
}
}</pre>
<br />
<br />
<ol>
<li>Pasamos la frase a un array de caracteres (tipo <span style="color: blue;"><b>char</b></span>). </li>
<li>Creamos bucle for que recorrerá carácter a carácter la frase.</li>
<li>Condicional if que si el carácter de la posición actual es "a", "e", "i" u "o" entonces la variable vocal de tipo char tendrá el valor de la vocal y se imprime por pantalla la <b>vocal + letra p + vocal</b></li>
<li>Otro condicional que comprueba que si el carácter de la posición actual es "g" o "q" y además la siguiente letra es "u"</li>
</ol>
Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-84589655658991630902016-12-12T10:00:00.000+01:002017-04-07T11:58:05.507+02:00Generar un número aleatorio en Java utilizando la clase Random().Ya vimos cómo crear un número aleatorio utilizando el método <span style="color: #38761d;"><b>random()</b></span> de la clase <b style="color: purple;">Math</b>, <a href="http://tazasdejava.blogspot.com.es/2016/10/clase-math-en-java.html" target="_blank">Tutorial Clase Math</a>, ahora veremos cómo podemos crear un número aleatorio pero utilizando la clase <b><span style="color: purple;">Random</span></b> y haciendo uso de los métodos <span style="color: #38761d;"><b>nextInt()</b></span>,<span style="color: #38761d;"> </span><b><span style="color: #38761d;">nextInt</span><span style="color: #274e13;">(</span></b><b><span style="color: blue;">int bound</span></b><b><span style="color: #38761d;">)</span></b>, <b><span style="color: #38761d;">nextFloat() y</span></b> <b><span style="color: #38761d;">nextDouble()</span></b>, aunque el uso de nextFloat(), nextDouble(), y nextLong() es el mismo, solo cambia el tipo de dato.<br />
Vamos a ver en primer lugar cómo generar un número aleatorio entre 1 y 10.<br />
<br />
<br />
<pre class="brush: java">import java.util.Random;
class NumeroAleatorio{
public static void main(String[] args) {
//Creamos objeto de la clase Random
Random aleatorio = new Random();
int numero = aleatorio.nextInt(10)+1;
System.out.println(numero);
}
}</pre>
<pre class="brush: java"></pre>
<a name='more'></a>Para utilizar la clase <span style="color: purple;"><b>Random</b></span> deberemos de importarla. Luego crearemos un objeto de esta clase y utilizaremos el método <b><span style="color: #38761d;">nextInt()</span></b> para crear el número aleatorio. Dentro de este método le pasamos como argumento un <b><span style="color: blue;">entero</span></b> de valor 10. De esta forma generará un número aleatorio que comprenderá desde el número 0 incluido hasta el número 10 excluido, pero como queremos que comprenda entre el número 1 y 10, ambos incluidos, debemos de poner el <b>+1, </b>así, ahora irá desde el número 1 incluido hasta el número 10 incluido.<br />
<br />
Para generar un número aleatorio con los métodos nextFloat() y nextDouble() se hace de una forma parecida a como vimos para generar números aleatorios con la clase <b style="color: purple;">Math</b>, <a href="http://tazasdejava.blogspot.com.es/2016/08/adivinar-un-numero-aleatorio-entre-0-y.html" target="_blank">Generar números aleatorios con la clase Math</a>.<br />
Cuando utilizamos estos métodos, nos generan un número aleatorio que van desde el 0 incluido hasta el 1 excluido. En el siguiente código fuente podemos observar cómo utilizarlos para crear un número con decimales comprendido entre 1 y 10:<br />
<b style="color: purple;"><br /></b>
<br />
<pre class="brush: java">import java.util.Random;
class NumeroAleatorio{
public static void main(String[] args) {
//Creamos objeto de la clase Random
Random aleatorio = new Random();
double numDoble = (aleatorio.nextDouble()*10) + 1;
System.out.println(numDoble);
float numFlotante = (aleatorio.nextFloat()*10) + 1;
System.out.println(numFlotante);
}
}</pre>
<br />
Pero surgiría el problema de que generaría también el número 10 con decimales, por lo que es mayor a 10. Como lo más normal es que se requieran números enteros podemos hacer un casting a los números aleatorios decimales y convertirlos a enteros y, así, conseguir de nuevo el rango de 1 a 10 ambos incluidos.<br />
<br />
<pre class="brush: java">import java.util.Random;
class NumeroAleatorio{
public static void main(String[] args) {
//Creamos objeto de la clase Random
Random aleatorio = new Random();
double numDoble =(int) (aleatorio.nextDouble()*10 + 1);
System.out.println(numDoble);
float numFlotante =(int) (aleatorio.nextFloat()*10 + 1);
System.out.println(numFlotante);
}
}</pre>
Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-32977074393968261312016-12-09T11:55:00.001+01:002016-12-09T11:58:57.577+01:0016-Programación Orientada a Objetos (Parte VI). Uso de this.<h4>
<u>Utilizar la Palabra clave this</u></h4>
<div>
En algunos tutoriales anteriores se ha hecho uso de la palabra clave this. La palabra clave this se utiliza para hacer referencia a un método o propiedad del objeto actual, es decir, hace referencia al objeto actual en el que nos encontramos.</div>
<div>
Vimos que al crear una clase, ésta estaba formada por atributos y métodos y, estos métodos, en ocasiones se le pasaban variables como parámetros. En muchas ocasiones estos parámetros tienen, por necesidad, el mismo nombre que alguno de los atributos y para poder diferenciar el atributo de la variable pasada como argumento se hace uso del this. </div>
<div>
<br /></div>
<div>
Veámoslo con un ejemplo:</div>
<div>
<br /></div>
<div>
<br /></div>
<pre class="brush: java">class Persona {
String nombre;
String apellidos;
//Creamos los métodos set de nombre y apellidos
public void setNombre(String nombre){
//Con el uso del this diferenciamos el atributo nombre del
//parámetro del mismo nombre
//Así nombre atributos pasará a valer el valor que se pase
//como argumento
this.nombre = nombre;
}
public void setApellidos(String apellidos){
this.apellidos = apellidos;
}
}
</pre>
<br />
<a name='more'></a><br /><br />
Podemos observar que en el método setNombre(String nombre){}; el parámetro tiene el mismo nombre que el atributo de la clase. Por eso hacemos uso del this en este caso, con el this.nombre estamos haciendo referencia al atributo de la clase de ese objeto que estamos utilizando ahora mismo, para indicarle que queremos pasar el valor de nombre que le pasemos como argumento al atributo de el objeto en particular.<br />
Con el método setApellidos(String apellidos){}; pasa exactamente igual y el uso es el mismo.<br />
<br />
Netbeans nos permite ver a qué variable nos estamos refiriendo. Por ejemplo, si hacemos click sobre this.nombre podemos ver como el atributo nombre queda marcado para indicar que estamos haciendo referencia a dicho atributo del objeto y no al del argumento. Si hacemos click sobre nombre dentro del método vemos como se marca el parámetro nombre que le debemos de pasar cuando hagamos la llamada al método.<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjwg75Po-sU3siVAAYWy9HY8C3gKaTtka6dtkuBxUNRt6YMF6fPCIFCZ1ccAvoB3MY02AWI9aVCS0XO_enfv8NyvrzDoIqdb4VWUuHeesFmd6TPr0lCJP38ufMZ3GZIxsS6AcRlw4GC_GA/s1600/1.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="180" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjwg75Po-sU3siVAAYWy9HY8C3gKaTtka6dtkuBxUNRt6YMF6fPCIFCZ1ccAvoB3MY02AWI9aVCS0XO_enfv8NyvrzDoIqdb4VWUuHeesFmd6TPr0lCJP38ufMZ3GZIxsS6AcRlw4GC_GA/s320/1.png" width="320" /></a></div>
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhi1kKxUBpVqJiFrF9MGaSnVBeOkuCHhE31KiwyjSLo-vVSVf0WgPPZxRMUAk8_4GPdH6aak5MPdLOgPWDcWEpjxqjADSQ6bQOFmAHqNPtJyCTP3J67TJWD7694ngPm5cRKng2plx0OVC4/s1600/2.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="180" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhi1kKxUBpVqJiFrF9MGaSnVBeOkuCHhE31KiwyjSLo-vVSVf0WgPPZxRMUAk8_4GPdH6aak5MPdLOgPWDcWEpjxqjADSQ6bQOFmAHqNPtJyCTP3J67TJWD7694ngPm5cRKng2plx0OVC4/s320/2.png" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
A modo de resumen decir que el uso del this indica que nos estamos refiriendo a un objeto concreto, al objeto actual. Si en una clase Coches creamos un objeto ford y en el objeto hacemos uso del this, nos estamos refiriendo a ese objeto ford y no a otro objeto como podría ser seat, audi o cualquier otro objeto de la clase Coches.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<h3>
¿Dónde se puede usar el this?</h3>
<div>
Se puede utilizar en cualquier miembro del objeto actual desde dentro de un método de instancia o un constructor. </div>
<div>
Si intentáramos utilizar this desde un método estático se produciría un error y lanzaría el mensaje "Cannot use this in a static contexto"</div>
<div>
Esto es porque a un método estático se puede acceder sin la instancia del objeto y, por lo tanto no podríamos hacer referencia a propiedades de un objeto concreto (Al ser un método estático se puede acceder a él mediante NombreClase.NombreMétodoEstático, no haría falta crear un objeto o instancia de la clase)</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
En el siguiente tutorial veremos la sobrecarga de métodos</div>
<br />Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-62696010450183702262016-12-05T10:00:00.000+01:002016-12-08T22:08:12.213+01:00Obtener la hora en Java con la Clase CalendarPara obtener la hora, Java nos proporciona la clase <b><span style="color: purple;">Calendar</span></b>. Con la clase <b style="color: purple;">Calendar </b>podremos obtener la hora del sistema de manera separada, es decir, la hora, los minutos y los segundos por separado.<br />
En primer lugar tendremos que instancias la clase <span style="color: purple;"><b>Calendar</b></span>, que se puede hacer de dos maneras:<br />
<br />
<b>1- </b>Obteniendo una instancia directamente de <b style="background-color: white;"><span style="color: purple;">Calendar</span></b><br />
<b style="background-color: white;"><span style="color: purple;"><br /></span></b>
<br />
<pre class="brush: java">Calendar reloj = Calendar.getInstance();
</pre>
<br />
<b>2- </b>Instanciando la clase<span style="color: purple;"><b> GregorianCalendar</b></span><br />
<br />
<pre class="brush: java">Calendar reloj = new GregorianCalendar();
</pre>
<br />
De las dos formas se podrá obtener la hora del sistema, ya que estaríamos utilizando el mismo calendario.<br />
Tanto si utilizamos la primera forma como la segunda debemos de importar las clases <i>java.util.Calendar</i>; o <i>java.util.GregorianCalendar;</i><br />
<i><br /></i>
En segundo lugar lo que haremos será crear las variables que contendrá la hora, los minutos y los segundos.<br />
<br />
<pre class="brush: java">int hora;
int minutos;
int segundos;
</pre>
<br />
Después utilizaremos el método <span style="color: #38761d; font-weight: bold;">get(int valor)</span>. Este método tiene que recibir un argumento de tipo entero que será el valor que queremos obtener, ya se la hora, los minutos, el día, los segundos...<br />
<br />
Por último para pasar como argumento el entero al método <span style="color: #38761d;"><b>get()</b></span>, utilizaremos las constantes que nos ayudarán a encontrar dichos valores. Así tendremos las siguientes constantes:<br />
<br />
<ul>
<li><span style="color: #b45f06;"><b>Calendar.HOUR_OF_DAY</b></span>. Es la hora del día en formado de 24 horas</li>
<li><span style="color: #b45f06;"><b>Calendar.HOUR</b></span>. Es la hora en formato de 12 horas</li>
<li><span style="color: #b45f06;"><b>Calendar.MINUTE</b></span>. Para los minutos</li>
<li><b><span style="color: #b45f06;">Calendar.SECOND</span></b>. Para los segundos<a name='more'></a></li>
</ul>
<div>
Sólo quedaría mostrar la hora completa por pantalla. El programa quedará de la siguiente manera:</div>
<div>
<br /></div>
<pre class="brush: java">import java.util.Calendar;
public class ObtenerHora {
public static void main(String [] args) {
Calendar reloj = Calendar.getInstance();
int hora;
int minutos;
int segundos;
hora = reloj.get(Calendar.HOUR_OF_DAY);
minutos = reloj.get(Calendar.MINUTE);
segundos = reloj.get(Calendar.SECOND);
System.out.println("Son las " + hora + ":" + minutos + ":" + segundos);
}
} </pre>
<br />
Si lo hubiéramos hecho el programa con <span style="color: purple;"><b>GregorianCalendar</b></span> el código sería el siguiente:<br />
<br />
<pre class="brush: java">import java.util.Calendar;
import java.util.GregorianCalendar;
public class ObtenerHora {
public static void main(String [] args) {
Calendar reloj = new GregorianCalendar();
int hora;
int minutos;
int segundos;
hora = reloj.get(GregorianCalendar.HOUR_OF_DAY);
minutos = reloj.get(GregorianCalendar.MINUTE);
segundos = reloj.get(GregorianCalendar.SECOND);
System.out.println("Son las " + hora + ":" + minutos + ":" + segundos);
}
} </pre>
Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-84118582666112288382016-12-02T10:00:00.000+01:002016-12-02T10:00:05.128+01:0015-Programación Orientada a Objetos (Parte V). Parámetros y Argumentos de Métodos en JavaParámetros y argumentos son dos términos, que a menudo son intercambiados erróneamente. El contexto ayuda a diferenciar su significado.<br />
<br />
<ul>
<li>El término parámetro se utiliza para referirse a la variable en la declaración del método</li>
<li>El término argumento se refiere al valor que se envía cuando hacemos la llamada al método.</li>
</ul>
<div>
Hay que recordar que el argumento debe ser del mismo tipo de dato que el parámetro de la declaración del método.<br />
<a name='more'></a>En el siguiente ejemplo se entenderán mejor estos conceptos:</div>
<div>
<br /></div>
<div>
<br /></div>
<pre class="brush: java">class ParametrosArgumentos{
//Atributos de clase
String nombre;
int edad;
//Métodos set and get
public void setNombre(String nom){
nombre = nom;
}
//Método sin parámetros
public String getNombre(){
return nombre;
}
//Cuando creamos el método, lo que se le pasa por paréntesis son
//los parámetros, es decir, el tipo y el nombre de la variable
public void setEdad(int edadPersona){
edad = edad;
}
//Método sin parámetros
public int getEdad(){
return edad;
}
//Método principal para poder crear objetos
public static void main(String[] args) {
ParametrosArgumentos persona1 = new ParametrosArgumentos();
//Cuando hacemos la llamada al método lo que se le pasa es lo que
//se denomina argumento, es decir, el valor que tiene la variable
persona1.setEdad(56);
persona1.setNombre("Ángela");
}
}</pre>
Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com0tag:blogger.com,1999:blog-1488530453345798857.post-27372782621098224992016-11-28T10:39:00.000+01:002016-11-28T10:39:21.297+01:00Programa de Lotería en Java.El programa que voy a compartir hoy es un programa que nos dice cuántas veces ha sido premiado un número de lotería que hemos indicado previamente, en el número de sorteos que indiquemos.<br />
El programa contiene las siguientes características:<br />
<br />
<ul>
<li>Convierte tanto el número del cupón comprado como los números ganadores en números de 5 dígitos, poniendo ceros a la izquierda en caso de que sea necesario.</li>
<li>Imprime qué número ha sido premiado y qué premio ha sido, si última cifra, dos últimas...</li>
<li>Imprime cuántas veces ha salido un número premiado con la última cifra, con las dos últimas cifras, con las tres últimas cifras, las cuatro últimas cifras y cuántas con el premio gordo<a name='more'></a></li>
</ul>
<div>
Para la realización del programa se han utilizado las siguientes clases:</div>
<div>
<ul>
<li>La clase Scanner para la introducción por teclado tanto del número que deseemos comprar como para indicar cuántos sorteos queremos que se realicen.</li>
<li>La clase Formatter para poder dar formato de 5 dígitos a los números y añadir los ceros a la izquierda que sean necesarios en cada caso.</li>
</ul>
<div>
Veamos el programa:</div>
</div>
<pre class="brush: java">import java.util.Formatter;
import java.util.Scanner;
class Cupon {
private int diasCupon;
private int cuponComprado;
private int ultimaCifra = 0;
private int dosUltimasCifras = 0;
private int tresUltimasCifras = 0;
private int cuatroUltimasCifras = 0;
private int premiosGordos = 0;
private int numeroPremiado;
//Métodos
public int getUltimaCifra(){
return ultimaCifra;
}
public int getDosUltimasCifras(){
return dosUltimasCifras;
}
public int getTresUltimasCifras(){
return tresUltimasCifras;
}
public int getCuatroUltimasCifras(){
return cuatroUltimasCifras;
}
public int getPremiosGordos(){
return premiosGordos;
}
//Método que establece el número premiado
public void setNumeroPremiado(){
numeroPremiado = (int) (Math.random()*99999+1);
}
public int obtenerNumeroPremiado(){
return numeroPremiado;
}
public void setCuponComprado(int cuponComprado){
this.cuponComprado = cuponComprado;
}
public int getCuponComprado(){
return cuponComprado;
}
public void setDiasCupon(int diasCupon){
this.diasCupon = diasCupon;
}
public int getDiasCupon(){
return diasCupon;
}
//Método que pasa a números de 5 dígitos el numero comprado
//y el número premiado y muestra por pantalla cuantos
//premios de cata categoría tiene.
public void premios(){
Formatter fmt = new Formatter();
Formatter fma = new Formatter();
String numComprado = String.valueOf(fma.format("%05d", cuponComprado));
String numPremiado = String.valueOf(fmt.format("%05d", numeroPremiado));
//Ultima cifra
if(numPremiado.substring(4).equals(numComprado.substring(4)) &&
!numPremiado.substring(3).equals(numComprado.substring(3))){
ultimaCifra++;
System.out.println("El cupon comprado " + getCuponComprado() +
" tiene el reintegro del número premiado: " + obtenerNumeroPremiado());
}
//Dos ultimas cifras
if(numPremiado.substring(4).equals( numComprado.substring(4)) &&
numPremiado.substring(3).equals(numComprado.substring(3)) &&
!numPremiado.substring(2).equals(numComprado.substring(2))){
dosUltimasCifras++;
System.out.println("El cupon comprado " + getCuponComprado() +
" tiene las 2 últimas cifras del número premiado: " + obtenerNumeroPremiado());
}
//Tres ultimas cifras
if(numPremiado.substring(4).equals( numComprado.substring(4)) &&
numPremiado.substring(3).equals(numComprado.substring(3)) &&
numPremiado.substring(2).equals(numComprado.substring(2)) &&
!numPremiado.substring(1).equals( numComprado.substring(1))){
tresUltimasCifras++;
System.out.println("El cupon comprado " + getCuponComprado() +
" tiene las 3 últimas del número premiado: " + obtenerNumeroPremiado());
}
//Cuatro últimas cifras
if(numPremiado.substring(4).equals(numComprado.substring(4)) &&
numPremiado.substring(3).equals(numComprado.substring(3)) &&
numPremiado.substring(2).equals(numComprado.substring(2)) &&
numPremiado.substring(1).equals(numComprado.substring(1)) &&
!numPremiado.substring(0).equals(numComprado.substring(0))){
cuatroUltimasCifras++;
System.out.println("El cupon comprado " + getCuponComprado() +
" tiene las 4 últimas cifras del número premiado: " + obtenerNumeroPremiado());
}
//Premio gordo
if(numPremiado.substring(4).equals(numComprado.substring(4)) &&
numPremiado.substring(3).equals(numComprado.substring(3)) &&
numPremiado.substring(2).equals(numComprado.substring(2)) &&
numPremiado.substring(1).equals(numComprado.substring(1)) &&
numPremiado.substring(0).equals(numComprado.substring(0))){
premiosGordos++;
System.out.println("El cupon comprado " + getCuponComprado() +
" tiene el PREMIO GORDO, ENHORABUENA: " + obtenerNumeroPremiado());
}
}
}
//Clase con el método main. Ejecución del programa
public class SorteoLoterias {
public static void main(String[] args) {
Scanner miScanner = new Scanner(System.in);
//Creamos objeto de la clase Cupon
Cupon miCupon = new Cupon();
System.out.print("Introduce el número de cuón que desee comprar: ");
miCupon.setCuponComprado(miScanner.nextInt());
System.out.print("Introduce el número de sorteos que desee participar: ");
miCupon.setDiasCupon(miScanner.nextInt());
//Bucle que se repite el número de veces que indiquemos
//en el número de sorteos
for(int i = 1; i <= miCupon.getDiasCupon(); i++){
miCupon.setNumeroPremiado();
miCupon.premios();
}
System.out.println("Premios de ultima cifra: " + miCupon.getUltimaCifra());
System.out.println("Premios de 2 últimas cifras: " + miCupon.getDosUltimasCifras());
System.out.println("Premios de 3 últimas cifras: " + miCupon.getTresUltimasCifras());
System.out.println("Premios de 4 últimas cifras: " + miCupon.getCuatroUltimasCifras());
System.out.println("Premios Gordos: " + miCupon.getPremiosGordos());
}
}</pre>
<pre class="brush: java"></pre>
<br />
Al ejecutar el programa tendrá una salida como la de la siguiente imagen:<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg1_3lphWCn6OASsVf_bLF0UiyjDzGHQQSgl5grvo6h4y358A-M2sN4T0BCso4BvnEF1L5of9zaAQdCoWoB_d2Opsfft-JibWoEzby0DC-HMzCkp-RFATFbzZchcEZ1kQrvCH0ER-vHhLI/s1600/salida.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="145" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg1_3lphWCn6OASsVf_bLF0UiyjDzGHQQSgl5grvo6h4y358A-M2sN4T0BCso4BvnEF1L5of9zaAQdCoWoB_d2Opsfft-JibWoEzby0DC-HMzCkp-RFATFbzZchcEZ1kQrvCH0ER-vHhLI/s400/salida.png" width="400" /></a></div>
<br />
<div>
<ul>
<li>Cuando en el método premios() se utiliza la clase Formatter para dar formato al número y que este tenga 5 dígitos se convierte lo que devuelve, que es un tipo de la clase Formatter, en String utilizando String.valueOf().</li>
<li>Hay que crear dos objetos de la clase Formatter para poder dar formato a las dos variables que tenemos, numComprado y numPremiado.</li>
<li>Dentro del método premios() hay muchos condicionales if que lo que harán es que, mediante el uso del método substring y el método equals de la clase String comprobamos si el número comprado tiene la última cifra, las dos últimas cifras, las tres últimas cifras... iguales al número premiado. </li>
</ul>
</div>
Javier Carreñohttp://www.blogger.com/profile/14054792188943004309noreply@blogger.com1