SCS

De todo un poco

Definición de atributos
La definición de atributos solo es valida fuera de todo método o constructor y no se puede repetir el nombre.

protected int a = 0;
private int b;  //atributos
int h; //variable global, no es atributo
contructor(){
int h; //local
}

public static void main(String [] args){

}

public int c = 0; //atributo.
metodo1(){

}

- Un atributo con el modificador de aceso <private> es visible desde otra clase siempre y cuando este en dentro de la clase que fue definida. 
Ej.

public class EjAP{
private int a = 23;
class EjHP{
System.out.println("El resultado es: "+23);
}

}

output> El resultado es: 23

Precedencia de operadores
La precedencia de operadores en java es la siguiente

imagen 1: Precedencia de operadores

> Diferencia entre count++ y ++count

count++ : significa que primero envía lo que tiene y después suma.
++count: primero suma y después envia.

Para demostrarlo se propone el siguiente código java

public class EjPO{

int count = 0;
int count1 = 0;

public static void main(String [] a){

   m1(count++);
  System.out.println("count> "+count);

   m1(++count1);
   System.out.println("count1> "+count1);

}

static void m1(int x){
System.out.println("x> "+x);
}

}

output -----------------------------------------------------------------------------------
x> 0
count> 1

x> 1
count1>1

>Ejemplo con un String

public class EjS{
  int a=1
  String str = null:
 public static void main(String [] b){
  a++;
  System.out.println(str + a +8 );

  }
}

output---------------------------------------------
>null28

Cómo null (aun cuando NO se asigno como "null" ) se considera como una cadena entonces concatena el valor de a (es 2) y después concatena el número 8.

*En caso de tener lo siguiente
int cont = 0;
System.out.println(++con + 2);

El resultado sería 3, porque primero suma uno a con y luego suma con + 2. Lo anterior es diferente a tener
int cont = 0;
System.out.println(con++ + 2);

En el cual el resultado es 2, porque con no incrementa sino hasta que se imprime por consola, si  de duplica la impresión ahora si ya imprimiría 3.


>Ejemplos de precedencia de operadores en java
Considerando que se tiene una clase el método main se harán los ejemplo con impresiones por consola para ejemplificar la acción de los operadores en los siguiente ejemplos.

Ejemplo multiplicación
int cont = 1;
System.out.println("cont> "+ con + 1 * 8 );

output------------
> cont> 18

En este caso primero se concatena cont> y con, luego se hace la operación  1*8 y el resultado se concatena a lo que ya teníamos, es decir cont> 1 se le concatena 8.
*En el caso de la división es exactamente lo mismo porque se tienen la misma precedencia.

Ejemplo operador multiplicación *
En este caso tenemos una expresión en diferentes formas

     con = 1;
     con = con + 3 * 4 + 5;
     System.out.println("con> "+con);

output ------------------
con> 18

Se ve la precedencia claramente, primero hace la multiplicación 3 * 4 = 12, luego suma lo que tiene con  después suma 5, entonces 12 + con + 5 = 18, porque con = 1;

Ejemplo operador paréntesis ()
con = 1;
     con = (con + 3) * (4 + 5);
     System.out.println("con> "+con);

output ------------------
con> 36

En este caso primero va y hace lo que hay dentro de los paréntesis, quedando así con + 3 = 4 y del otro lado 4 + 5 = 9, luego multiplica 4 * 9 = 36, esto debido a que los paréntesis tienen más prioridad que el operador *.


Reglas- No puedes usar super en un contexto static.
- Sobrecarga: significa que un método se puede llamar igual, mismo tipo de dato pero con más argumentos.

- Polimorfismo incluye: Sobrescritura y sobrecarga
- Sobrescritura: se refiere a que en la herencia se escribe el mismo método de la clase superior en la clase hija, tomando en cuenta que el modificador de acceso (public, private, protected y package) debe ser igual o menor* al método que tiene la clase padre.

*Menor se refiere a que tiene menor restricción: Ej. si en la clase padre tiene private en la clase hija debe ser, private o public, protected o package, pero si en la clase padre tiene public entonces en la clase hija debe ser a fuerza public puesto que ya no hay más modificadores de acceso con menor restricción.

- Es posible que un método se llame igual, con diferente tipo de dato y diferentes argumentos en una misma clase. Ej.

public void met1(){}
public void met1(int a){}
public int met1(int a, int b){ return a;}
public String met1(String a ){return a;}

- Lo siguiente no es permitido. Considerando los siguientes métodos
public void str(){}
public String str(){return "";}

- De lo anterior
      *- Se llaman igual Y: Modificas su tipo de dato, y numero o tipo de argumentos. (Polimorfismo)
      *- Se llaman igual Y: No modificas el tipo de retorno, pero, SI modificas los argumentos. (polimorfismo             - Sobrecarga).