Show Menu
Cheatography
  1. Home >
  2. Cheat Sheets >

Java Cheat Sheet (DRAFT) by

This is a draft cheat sheet. It is a work in progress and is not finished yet.

Objetos

Instancias
En los lenguajes de progra­mación orientada a objetos un objeto es una instancia de una clase. Esto es, un miembro de una clase que tiene atributos en lugar de variables.
Atributos
Los atributos son las caract­erí­siticas indivi­duales que difere­ncian un objeto de otro y determinan su aparie­ncia, estado u otras cualid­ades. Los atributos se guardan en variables denomi­nadas de instancia, y cada objeto particular puede tener valores distintos para estas variables. Las variables de instancia también denomi­nados miembros dato, son declaradas en la clase pero sus valores son fijados y cambiados en el objeto. Además de las variables de instancia hay variables de clase, las cuales se aplican a la clase y a todas sus instan­cias. Por ejemplo, el número de ruedas de un automóvil es el mismo cuatro, para todos los automó­viles.
Constr­uctores
Un constr­uctor inicializa un objeto al crearlo. Tiene el mismo nombre que su clase y se parece sintác­tic­amente a un método, pero no tienen tipo de return.
Normalmente se usan para dar valores iniciales a las variables de instancia definidas por la clase, o para llevar a cabo otros proced­imi­entos de inicio para crear un objeto comple­tamente formado.
todas las clases tienen constr­uct­ores, los definas o no, porque java ofrece un constr­uctor por defecto que inicializa todas las variables de miembro a 0.
class ClassName {    ClassN­ame() {    } }
-No argument Constr­uctors
using these constr­uctors the instance variables of a method will be initia­lized with fixed values for all objects.
Public class MyClass {    Int num;    MyClass() {       num = 100;    } }

You would call constr­uctor to initialize objects as follows
public class ConsDemo {    public static void main(S­tring args[]) {       MyClass t1 = new MyClass();       MyClass t2 = new MyClass();       System.ou­t.p­rin­tln­(t1.num + " " + t2.num);    } }


Se pueden modificar los atributos de la clase creando una instancia, un nuevo objeto, y accediendo a ellos main{ Humidade h = new Humida­de(); h.num = 1000; }
Humidade int num = 10; Humida­de(­){num = 100;} El roden es 1000, 100, 10
-Param­ete­rized Constr­uctors
Most often, you will need a constr­uctor that accepts one or more parame­ters. Parameters are added to a constr­uctor in the same way that they are added to a method. 
// A simple constr­uctor. class MyClass {    int x;        // Following is the constr­uctor    MyClas­s(int i ) {       x = i;    } }

You would call constr­uctor to initialize objects as follows 
public class ConsDemo {    public static void main(S­tring args[]) {       MyClass t1 = new MyClass( 10 );       MyClass t2 = new MyClass( 20 );       System.ou­t.p­rin­tln­(t1.x + " " + t2.x);    } }
"­thi­s" keyword
Keyword THIS is a reference variable in Java that refers to the current object.
Variables de instancia
Una variable de instancia es un campo declarado dentro de la declar­ación de una clase sin usar la palabra reservada static. Si una clase T tiene un campo a que es una variable de instancia, entonces una nueva variable de instancia a es creada e inicia­lizada a un valor por defecto como parde de cada nuevo objeto creado de la clase T o de cualquier clase que sea subclase de T La bariable de instancia deja de existir cuando el objeto del cual es campo deja de ser refere­nciado, después que cualquier finali­zación necesaria del objeto ha sido completada
variables de clase
Una variable de clase es un campo declarado usando la palabra reservada static dentro de una declar­ación de clase o con o sin la palabra reservada static dentro de una declar­ación de una interfaz. Una variable de clase es creada cuando su clase o interfaz es preparada y es inicia­lizada a un valor por defecto. La variable de clase deja de existir cuando su clase o interfaz es descar­gada.

Métodos

A method in Java is a block of statements that has a name and can be executed by calling (also called invoking) it from some other place in your program. Along with fields, methods are one of the two elements that are considered members of a class. (Const­ructors and initia­lizers are not considered class members.).
Every program must have at least one method for the program to accomplish any work. And every program must have a method named main, which is the method first invoked when the program is run.
  
visibility [static] return­-type method­-name (param­ete­r-list) {         statem­ents... }
visibility: The visibility of a method determines whether the method is available to other classes. The options are
-public: Allows any other class to access the method
-private: Hides the method from other classes
-protected: Lets subclasses use the method but hides the method from other classes
static
: This optional keyword declares that the method is a static method, which means that you can call it without first creating an instance of the class in which it’s defined. The main method must always be static, and any other methods in the class that contains the main method usually should be static as well. A non-static method belongs to an object of the class and you have to create an instance of the class to access it.
return­-type: After the word static comes the return type, which indicates whether the method returns a value when it is called — and if so, what type the value is. If the method doesn’t return a value, specify void. String[], Integer, int...
parameter list:En el momento de la creación se deb especi­ficar el tipo de la variable y la variab­le.Al llamar al método se especifica el nombre.
public static int METODO( String[] nomes ){
Pasar por argumento:
-
-

Reference types

Reference types hold references to objects and provide a means to access those objects stored somewhere in memory.
All reference types are a subclass of type java.l­ang.Ob­ject.
Annotation
Array
Provides a fixed-size data structure that stores data elements of the same type.
Class
Designed to provide inheri­tance, polymo­rphism, and encaps­ula­tion. Usually models something in the real world and consists of a set of values that holds data and a set of methods that operates on the data.
Enumer­ation
Interface
Provides a public API and is “imple­mented” by Java classes.

Lists

Arrays
var-name = new type [size];
 
int intArr­ay[];
intArray = new int[20]; // alocar memoria al array
 
int[] intArray = new int[20]; // combining both statements in one
Arrays bidime­nsi­onales
int[][] multi = new int[5]­[10];
 
int[][] multi = new int[5][]; multi[0] = new int[10]; multi[1] = new int[10]; multi[2] = new int[10]; multi[3] = new int[10]; multi[4] = new int[10];
 
int tiempo [][] = new int[7][2];
 
tiempo­[0][1] = 2;
 
int[][] multi = new int[][]{ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } };
 
for( int i = 0; i < t.length; i++ ){ System.ou­t.p­rin­tln­("Día "­+i)­;//el día de la semana for( int j = 0; j < 2; j++ ){ System.ou­t.p­rin­tln­("a las "­+j+­"h: "­+t[­i][­j]);//j - la hora } }
Arraylist class
implements List interface and it is based on an Array data structure
 
ArrayList inherits Abstra­ctList class and implements List interface.
 
ArrayList is initia­lized by a size, however the size can increase if collection grows or shrunk if objects are removed from the collec­tion.
 
ArrayList can not be used for primitive types, like int, char, etc. We need a wrapper class for such cases
 
ArrayL­ist(): This constr­uctor is used to build an empty array list
ArrayList(Collection c): This constr­uctor is used to build an array list initia­lized with the elements from collection c
ArrayList(int capacity): This constr­uctor is used to build an array list with initial capacity being specified // Creating generic integer ArrayList ArrayL­ist­<In­teg­er> arrli = new ArrayList<Integer>();
arrli.add(i);
// Remove element at index 3 arrli.r­em­ove(3);
// Printing elements one by one for (int i=0; i<a­rrl­i.s­ize(); i++) System.ou­t.p­rin­t(a­rrl­i.g­et(­i)+­" ");
Los ArrayList funcionan con objetos y no con tipos primit­ivos, (Integer en vez de int, Character en vez de char...))
Construye ArrayList con valor inicial
ArrayL­ist(int initia­lCa­pacity)
Inserta el elemento en el index especi­ficado, no se peude hacer si la posición no fue creada
add(int index, Object element)
Appends the specified element to the end of this ArrayList.
add(Object o)
 
addAll­(Co­lle­ction c) Appends all of the elements in the specified Collection to the end of this this ArrayList, in the order that they are returned by the specified Collec­tion's Iterator.
Borra todos los elementos
clear()
hace una copia superf­icial
clone()
Devuelve true si contiene el elemento
contai­ns(­Object elem)
Devuelve el elemento en la posición especi­ficada
cars.g­et(0);
Modificar elemento
cars.s­et(0, "­Ope­l");
Busca la ocurrencia del primer elemento
indexO­f(O­bject elem)
 
isEmpty()
devuelve el índice de la última ocurrencia
lastIn­dex­Of(­Object elem)
Quita el elemento del índice especi­ficado
cars.r­emo­ve(0)
Returns the number of components in this ArrayList.
size()
 
toArray() ,] toArra­y(O­bject[] a)
Trims the capacity of this ArrayList to be the ArrayL­ist's current size.
trimTo­Size()
 
Pasando por argumento
public void Analys­eAr­ray­(Ar­ray­Lis­t<I­nte­ger> array) { // Do something } ... ArrayL­ist­<In­teg­er> A = new ArrayL­ist­<In­teg­er>(); Analys­eAr­ray(A);
Bidime­nsi­onales Crear:
ArrayL­ist[][] table = new ArrayL­ist­[10­][10]; table[­0][0] = new ArrayL­ist(); // add another ArrayList object to [0,0] table[­0][­0].a­dd(); // add object to that ArrayList
Sacar tamaño del ArrayList
int size = listOf­Ban­ks.s­ize();
Sacar tamaño de ArrayList bidime­nsional
list.g­et(­0).g­et(0)
Añadir elementos
arrlist.add(15);
// adding element 25 at third position arrlis­t.a­dd(­2,25);
Pasar arraylist bidime­nsional por método
ArrayL­ist­<Ar­ray­Lis­t<I­nte­ger­>> dispon­ibi­lidade
Agregar valor en array bidime­nsional
ArrayL­ist­<Ar­ray­Lis­t<I­nte­ger­>> d = new ArrayL­ist­<Ar­ray­Lis­t<I­nte­ger­>>(); for( int i = 0; i < d.size(); i++ ){ for( int j = 0; j < d.get(­i).s­ize(); j++ ){ d.get(­i).a­dd(0); }

Arrays multid­ime­nsi­onales

Classes

 

Variables

Globales
Java doesn't techni­cally support global variables. As a pure object­-or­iented language, everything needs to be part of a class.
The static modifier tells Java that the variable can be used across all instances of the class.

If

If
if (a > b) { max = a; } else { max = b; }
Operador ternario
max = (a > b) ? a : b;
Booleanos
if( !contiene ){}

Switch case

int c; switch(c){ case 1: case 2: case 3: resultado = x; case 4: resultado = y; default: resultado = z;}

Bucles

for simpli­ficado
for (String str : list) { System.ou­t.p­rin­tln­(str); }
Object[] humidades = new Object­[10]; for( Object h : humidades ){
for
for (int i = 0; i < list.s­ize(); i++) { System.ou­t.p­rin­tln­(li­st.g­et­(i)); }

Packages

Packages are used in Java in order to prevent naming conflicts, to control access, to make search­ing­/lo­cating and usage of classes, interf­aces, enumer­ations and annota­tions easier, etc. A Package can be defined as a grouping of related types (classes, interf­aces, enumer­ations and annota­tions ) providing access protection and namespace manage­ment.

Clase Scanner

Para string
Scanner sc = new Scanne­r(S­yst­em.in);
 
String a = sc.nex­tLi­ne();
Para char
c = sc.nex­t().ch­arA­t(0);
Después de un scan.n­ext­Int()
sc.nex­tLi­ne();

Tipos primitivos

En Java hayq ue especi­ficar lso tipos primitivos antes que usarlos.
String
String.le­ngth(); String usa " "
char
char usa ' '
Para forzar tipos (explicit casting)
int random­Number = (int)(­Mat­h.r­and­om());

Interfaces

Un interfaz es una lista de acciones que puede llevar a cabo un determ­inado objeto. En una clase además de aparecer los métodos aparecía el código para dichos métodos, en cambio en un interfaz sólo existe el prototipo de una función, no su código.
En java un interfaz define la lista de métodos, pero para que una clase posea un interfaz hay que indicar explíc­ita­mente que lo implementa mediante la claúsula implem­ents.
Donde modif.v­is­ibi­lidad puede ser public o bien sin especi­ficar, es decir visibi­lidad pública (desde cualquier clase se puede emplear el interfaz) o de paquete (sólo se puede emplear desde clases del mismo paquete).
nombreInterfaz por convenio sigue las mismas reglas de nomenc­latura que las clases, y en muchos casos acaba en able (que podíamos traducir como: ser capaz de).
-La claúsula opcional extends se emplea para conseguir que un interfaz hereda las funciones de otro/s interf­aces, simple­mente listaI­nte­rfaces es una lista separaada por coma de interfaces de los que se desea heredar.
-
 
[modif.vi­sib­ilidad] interface nombre­Int­erfaz [extends listaI­nte­rfaces]          { 	         prototipo método1; 	          .. 	         prototipo método1;          }
En muchas ocasiones un interfaz es empleado para definir un compor­tam­iento, que poster­ior­mente será implem­entado por diversas clases, que podrían no tener nada que ver entre ellas, pero que todas se compor­tarán igual de cara al interfaz. Es decir, todas tendrán las funciones indicadas por el interfaz.
Cuando varios objetos de distintas clases pueden responder al mismo mensaje (función), aún realizando cosas distintas se denomina polimo­rfismo.
An interface is a reference type in Java. It is similar to class. It is a collection of abstract methods. A class implements an interface, thereby inheriting the abstract methods of the interface. Along with abstract methods, an interface may also contain constants, default methods, static methods, and nested types. Method bodies exist only for default methods and static methods. Writing an interface is similar to writing a class. But a class describes the attributes and behaviors of an object. And an interface contains behaviors that a class implem­ents. Unless the class that implements the interface is abstract, all the methods of the interface need to be defined in the class.
An interface can contain any number of methods.
An interface is written in a file with a .java extension, with the name of the interface matching the name of the file.
The byte code of an interface appears in a .class file.
Interfaces appear in packages, and their corres­ponding bytecode file must be in a directory structure that matches the package name.
However, an interface is different from a class in several ways, including −
You cannot instan­tiate an interface.
An interface does not contain any constr­uctors.
All of the methods in an interface are abstract.
An interface cannot contain instance fields. The only fields that can appear in an interface must be declared both static and final.
An interface is not extended by a class; it is implem­ented by a class.
An interface can extend multiple interf­aces.
 
contrato entre as clases concretas que a implem­enten, xa que a clase que o faga atópase obrigada a definir os métodos abstractos que a compoñen.
 
Podemos dicir que as interfaces simulan a herdanza múltiple xa que unha clase pode implem­entar calquera numero de interf­aces, ademais as interfaces poden herdar un ou mais números de interfaces mediante a palabra extends
 
Todos os métodos dunha interfaz son implic­ita­mente public abstract, non é necesario especi­ficalo na declar­ación do mesmo.

Ficheros

Crear ficheros
Escribir fichero
File f = new File(r­uta­yar­chivo);
Escribir objetos a fichero
Primero hay que implem­entar la clase Serial­izable desde la clase del objeto
 
public class Student implements Serial­izable {}
Luego, abrir o crear un nuevo fichero con FileOu­tpu­tStream
 
FileOu­tpu­tStream fileOut = new FileOu­tpu­tSt­rea­m(f­ile­path);
Crear un Object­Out­put­Stream dándole el anterior FileOu­tpu­tStream como argumento al constr­uctor.
 
Object­Out­put­Stream objectOut = new Object­Out­put­Str­eam­(fi­leOut);
Usar el método Object­Out­put­Str­eam.wr­ite­Object para escribir el objeto que quieras al fichero.
 
object­Out.wr­ite­Obj­ect­(se­rObj);
 
for(int i=0;i<­arr­ayp­er.s­iz­e()­;i++) { oos.wr­ite­Obj­ect­(ar­ray­per.ge­t(i)); }
Cerrar el flujo
object­Out.cl­ose();
  
package com.ja­vac­ode­gee­ks.j­av­a.core;   import java.i­o.F­ile­Out­put­Stream; import java.i­o.O­bje­ctO­utp­utS­tream;   public class Object­IOE­xample {       private static final String filepa­th=­"­C:­\\Us­ers­\\n­iko­s7­\\De­skt­op­\\ob­j";       public static void main(S­tring args[]) {           Object­IOE­xample objectIO = new Object­IOE­xam­ple();           Student student = new Studen­t("J­ohn­"­,"Fr­ost­"­,22);         object­IO.W­ri­teO­bje­ctT­oFi­le(­stu­dent);     }       public void WriteO­bje­ctT­oFi­le(­Object serObj) {           try {               FileOu­tpu­tStream fileOut = new FileOu­tpu­tSt­rea­m(f­ile­path);             Object­Out­put­Stream objectOut = new Object­Out­put­Str­eam­(fi­leOut);             object­Out.wr­ite­Obj­ect­(se­rObj);             object­Out.cl­ose();             System.ou­t.p­rin­tln­("The Object  was succes­fully written to a file");           } catch (Exception ex) {             ex.pri­ntS­tac­kTr­ace();         }     } }
Recuperar los atributos del objeto
 
 public static Object crearO­bjeto( float altitud, int valor ){         Humidade h = new Humidade( altitud, valor );         System.ou­t.p­rin­tln­(" "­+h+­"­"­+h.a­lt­itu­de+­" "­+h.v­alor);         return h;     }
Recuerda guardar los métodos de fichero en un try catch
Escribir tetxo a ficheros
Creando fichero al abrir el flujo
 
FileOu­tpu­tStream foos = new FileOu­tpu­tSt­rea­m(new File("t­ext­o.t­xt"));
Usando fichero existe­nte­/cerar uno nuevo
FileOu­tpu­tStream foos = new FileOu­tpu­tSt­rea­m("t­ext­o2.t­xt­");
Escrib­iendo la cadena en el fichero
foos.w­rit­e(c­ade­na.g­et­Byt­es(­"­utf­-8"), 0, cadena.le­ngt­h());
  
Primer parámetro: cadena a escribir, getBytes(): This method encodes this String into a sequence of bytes using the platform's default charset, storing the result into a new byte array.
Segundo parámetro: lugar desde donde se dejó de escribir
Tercer parámetro: número de carácteres a escribir
Escribir float, etc a fichero (en binario)
Leer objeto de fichero
Abrir flujo
FileIn­put­Stream fis = new FileIn­put­Str­eam­("me­teo.da­t");
Abrir input de objeto
Object­Inp­utS­tream ois = new Object­Inp­utS­tre­am(­fis);
 
Object obj = ois.readObject();
Persoa l = (Persoa) ois.re­adO­bje­ct();
 
Object­Inp­utS­tream ois = new Object­Inp­utS­tre­am(­fis); for ( int i = 0; i <pe­rso­as.s­ize(); i++ ){ Persoa per = (Persoa) ois.re­adO­bje­ct(); System.ou­t.p­rin­tln­(""+p­er.a­pe­lid­o+" y "­+pe­r.cp); persoa­sLe­ida­s.a­dd(­per); }
Leer varios objetos de un fichero
catch (FileN­otF­oun­dEx­ception ex) { Logger.ge­tLo­gge­r(E­3E1­E2.c­la­ss.g­et­Nam­e()­).l­og(­Lev­el.S­EVERE, null, ex); }`
 
try {
boolean engadir = true;
FileInputStream fis = new FileIn­put­Str­eam­("me­teo.da­t"); Object­Inp­utS­tream ois = new ObjectInputStream(fis);
while(engadir){
Object obj = ois.readObject();
if(obj != null){­obj­eto­sLe­ido­s.a­dd(­obj);
else{engadir = false; }
for( int i = 0; i < objeto­sLe­ido­s.s­ize(); i++ ){
System.ou­t.p­rin­tln­("Objeto leído "­+ob­jet­osL­eid­os.g­et­(i));}}
Hacer casting de un tipo objeto con el objeto que queremos
Humidade h = (Humidade) humida­des.ge­t(i);
 
public static ArrayList LER() throws FileNo­tFo­und­Exc­eption, IOExce­ption, ClassN­otF­oun­dEx­cep­tion{ FileIn­put­Stream fis = new FileIn­put­Str­eam­("ca­sas.da­t"); Object­Inp­utS­tream ois = new Object­Inp­utS­tre­am(­fis); boolean saidaDatos = true; ArrayL­ist­<Ca­sa> casasl­eidas = new ArrayL­ist­<>(); try{ while( saidaDatos ){ Casa casa = (Casa) ois.re­adO­bje­ct(); System.ou­t.p­rin­tln­("Casa leida: "­+ca­sa+­" ID "­+ca­sa.i­d+­" NH "­+ca­sa.h­ab­+" M "­+ca­sa.m2); casasl­eid­as.a­dd­(casa); } }catch­(EO­FEx­ception ex){ System.ou­t.p­rin­tln­("no hay más que leer"); } return casasl­eidas; }
Ficheros de acceso aleatorio
 
Random access files permit nonseq­uen­tial, or random, access to a file's contents. To access a file randomly, you open the file, seek a particular location, and read from or write to that file.
Crea un flujo de fichero de acceso aleatorio desde el que leer y, opcion­alm­ente, al que escribir el archivo especi­ficado por el argumento de Fichero/el archivo con el nombre especi­ficado
Random­Acc­ess­Fil­e(File file, String mode)
 
The java.i­o.R­and­omA­cce­ssF­ile.se­ek(long pos) method sets the file-p­ointer offset, measured from the beginning of this file, at which the next read or write occurs.
raf.se­ek(0);
 
System.ou­t.p­rin­tln­("El­emento a visual­iza­r"); int x = sc.nex­tInt(); Random­Acc­essFile raf = new Random­Acc­ess­Fil­e("i­ndi­ces.in­d", "­r"); raf.se­ek(x); int posicion = raf.re­adI­nt(); Random­Acc­essFile rafO = new Random­Acc­ess­Fil­e("d­ato­s.d­at", "­r"); rafO.s­eek­(po­sic­ion); System.ou­t.p­rin­tln­(""+r­afO.re­adU­TF());

Superclase

 

Subclases

 

Determinar la clase de un objeto

 

Herencia

This allows you to establish a hierarchy for your classes. A class that inherits from some other class (referred to as a superc­lass) is called a subclass. While a subclass inherits methods and behaviors from a superc­lass, it can also declare new fields and methods (as well as override superclass methods).
The subclass inherits state and behavior in the form of variables and methods from its superc­lass. The subclass can use just the items inherited from its superclass as is, or the subclass can modify or override it.
Subclases
A subclass is defined with the extends keyword. For example, the syntax ClassB extends ClassA establ­ishes ClassB as a subclass of of ClassA. Java only supports single inheri­tance, meaning a subclass cannot extend more than one superc­lass.
Constr­uctores de subclases
Because a constr­uctor initia­lizes an instance of a class, they are never inherited; however, the subclass must call a superclass constr­uctor as it is an extension of a superclass object. This can be done in either of the two ways shown below.
class MySupe­rclass{ // superclass instance variable: String myString; // superclass default (empty) constr­uctor: MySupe­rcl­ass(){} // superclass parame­terized constr­uctor: MySupe­rcl­ass­(String myString){ // initialize instance variable this.m­yString = myString; } }
1) The subclass makes an explicit call to the superc­lass' parame­terized constr­uctor (i.e.: it calls super(...);): class MySubclass extends MySupe­rclass{ // subclass constr­uctor: MySubc­las­s(S­tring myString){ // explicit call to superclass constr­uctor: super(­myS­tring); } }
2) The subclass makes an implicit call to the superc­lass' default constr­uctor (i.e.: a behind­-th­e-s­cenes call to super(); happens automa­tic­ally): class MySubclass extends MySupe­rclass{ MySubc­las­s(S­tring myString){ // behind­-th­e-s­cenes implicit call to superc­lass' default constr­uctor happens // subclass can now initialize superclass instance variable: this.m­yString = myString; } }
In the second example above, observe that we are initia­lizing a field (myString) that isn't even declared in that class; the reason why this works is because it's inherited from MySupe­rclass and therefore can be accessed with the this keyword.
Overriding
If a class inherits a method from its superc­lass, then there is a chance to override the method provided that it is not marked final.
class Animal { public void move() { System.ou­t.p­rin­tln­("An­imals can move"); } } class Dog extends Animal { public void move() { System.ou­t.p­rin­tln­("Dogs can walk and run"); } } public class TestDog { public static void main(S­tring args[]) { Animal a = new Animal(); // Animal reference and object Animal b = new Dog(); // Animal reference but Dog object a.move(); // runs the method in Animal class b.move(); // runs the method in Dog class } } This program will throw a compile time error since b's reference type Animal doesn't have a method by the name of bark.h­ttp­s:/­/ww­w.t­uto­ria­lsp­oin­t.c­om/­jav­a/j­ava­_ov­err­idi­ng.htm
 
As a subclass, your class inherits member variables and methods from its superc­lass. Your class can choose to hide variables or override methods inherited from its superc­lass.
 
las subclases no heredan métodos privados
 
se pueden usar métodos protected
 
public class Oral extends Examen{
int temporesp;
@Override
public void ALTA(){
super.A­LTA();
Scanner sc = new Scanne­r(S­yst­em.in);
System.ou­t.p­rin­tln­("tempo de respos­ta");
this.t­emp­oresp = sc.nextInt();
}

Abstra­cción

Defien modelo de objeto
Las clases abstractas pueden o no tener métodos abstra­ctos, métodos sin cuerpo ( public void get(); )
Las clases abstractas pueden tener también constr­uctores
class TimesTwo extends Product { public TimesTwo() { super(2); } }
pero si tiene al menos un método abstracto deben ser clases abstractas
No se pueden instanciar
para suar una clase abstracta tienes que heredarla desde otra clase, y ofrecer implem­ent­aciones para sus métodos abstractos
Los métodos abstractos no tienen cuerpo y demandan que sus subclases incluyan ese método
Todas las clases que hereden de la clase deben o Override el método abstracto o declararse ellas como abstractas
public abstract class Animal {
String name;
abstract String sound(); //all classes that implement Animal must have a sound method }

public class Cat extends Animal {
public Cat() {
this.name = "­Gar­fie­ld";
}
@Override
public String sound(){ //impl­emented sound method from the abstract class & method
return "­Meo­w!";
}
}
A diferencia de las interf­aces, no tienes por qué implem­entar todos los métodos
If the subclass has a method with the same name as the parent’s method that the subclass extends, the subclass’ method overwrites the parent. If you want to use the parent class’s method instead, you use the super keyword, like this: super.s­ta­rtR­obot();

Métodos de cadena

 
X2 = sc.nex­tLi­ne(); X2 = X2.toU­ppe­rCa­se();

Polimo­rfismo

 
Polymo­rphism means "many forms", and it occurs when we have many classes that are related to each other by inheri­tance.
 
class Animal { public void animal­Sound() { System.ou­t.p­rin­tln­("The animal makes a sound"); } } class Pig extends Animal { public void animal­Sound() { System.ou­t.p­rin­tln­("The pig says: wee wee"); } } class Dog extends Animal { public void animal­Sound() { System.ou­t.p­rin­tln­("The dog says: bow wow"); } }

Abstra­cción

 
Abstract class: is a restricted class that cannot be used to create objects (to access it, it must be inherited from another class).
 
Abstract method: can only be used in an abstract class, and it does not have a body. The body is provided by the subclass (inherited from).
 
An abstract class can have both abstract and regular methods
 
// Abstract class abstract class Animal { // Abstract method (does not have a body) public abstract void animal­Sou­nd(); // Regular method public void sleep() { System.ou­t.p­rin­tln­("Zz­z"); } } // Subclass (inherit from Animal) class Pig extends Animal { public void animal­Sound() { // The body of animal­Sound() is provided here System.ou­t.p­rin­tln­("The pig says: wee wee"); } }

Interface

 
An interface is a completely "­abs­tract class" that is used to group related methods with empty bodies:
 
// interface interface Animal { public void animal­Sou­nd(); // interface method (does not have a body) public void run(); // interface method (does not have a body) }
 
To access the interface methods, the interface must be "­imp­lem­ent­ed" (kinda like inherited) by another class with the implements keyword (instead of extends). The body of the interface method is provided by the "­imp­lem­ent­" class:
multiple interfaces
// DemoClass "­imp­lem­ent­s" FirstI­nte­rface and Second­Int­erface class DemoClass implements FirstI­nte­rface, Second­Int­erface {

Java Enums

 
An enum is a special "­cla­ss" that represents a group of constants (uncha­ngeable variables, like final variab­les).
 
enum Level { LOW, MEDIUM, HIGH }
 
public class MyClass { enum Level {
You can also have an enum inside a class: