OCA Java SE 8

Ejercicios no. 1

package com.codemonkey;

import static java.lang.System.out;

import static java.lang.System.err;
import static java.lang.System.exit;

public class Main{

public static void main(String[] args) {

mockDemoA();
mockDemoB();
mockDemoC();
mockDemoD();
mockDemoE();
mockDemoF();

public static void mockDemoF(){

InterfA my_a = new InterfA(){
@Override
public void nada(){
out.println("Nada desde InterfA");
}
};
my_a.nada();

InterfB my_b = new InterfB(){

@Override
public void nada(){
out.println("Nada desde InterfB");
}
};
my_b.nada();

InterfC my_c = new InterfC(){

@Override
public void nada(){
out.println("Nada desde InterfC");
}

@Override
public void algo(){
out.println("Algo desde InterfC");
}
};
 my_c.nada();
my_c.algo();

InterfD my_d = new InterfD(){

@Override
public void nada(){
out.println("Nada desde InterfD");
}

@Override
public void cosa(){
out.println("Cosa desde InterfD");
}
};
my_d.nada();
my_d.cosa();

//Salida:
//Nada desde InterfA
//Nada desde InterfB
//Nada desde InterfC
//Algo desde InterfC
//Nada desde InterfD
//Cosa desde InterfD

public static void mockDemoE(){

TestX testX = new TestX();
//Esto no se puede:
//error: TestX(String) has private access in TestX
//testX = new TestX("Hola");

TestY testY = new TestY();

testY = new TestY(33);

//Esto no se puede: TestZ() es private

//TestZ testZ = new TestZ();
TestZ testZ = new TestZ('X');

TestW testW = new TestW('G');

//Permitido:
//Superclase ref = new ConstructorSubclase();
Abstracta hijaA = new Hija();
hijaA.nada();

Hija hija = new Hija();

hija.nada();
 //Permitido:
//Superclase ref = new ConstructorSubclase();
MadreAbstracta miHija = new HijaNoAbstracta();
miHija.metodoAbstracto();

//Permitido:
//Superclase ref = new ConstructorSubclase();

//Salida:
//TestX
//TestY
//Pusiste:X
//TestW private!!!
//U
//Pusiste:G
//Nada desde Abstracta
//Nada desde Abstracta
//metodoAbstracto desde HijaNoAbstracta

public static void mockDemoD(){

A1 my_a = new A1();
//Esto no se puede: metodoA() es private
//my_a.metodoA();

B1 my_b = new B1();

my_b.metodoB();

C1 my_c = new C1();

my_c.metodoC();

D1 my_d = new D1();

my_d.metodoD();

out.println();

//Superclase ref = new ConstructorSubclase();

Object objA = new A1();
A1 objC = new C1();
B1 objD = new D1();

//Esto no puede ser:

//metodoA() es metodo de A1, ademas es private
//objA.metodoA();

//objC.metodoA();//mismo caso: es private

//objC.metodoC();//metodoC() es de C1, no de A1
 objD.metodoB();//Correcto:metodoB() es propio de B1
//objD.metodoD();//Incorrecto: metodoD() es de D1 y no de B1

//Salida:
//Metodo B de B1
//Metodo C de C1
//Metodo D de D1
//
//Metodo B de B1
//
}

public static void mockDemoC(){

E my_e = new E();
//out.println(my_e.cadena);//Error: cadena es private
out.println(my_e.numero);
out.println(my_e.caracter);
out.println(my_e.verdadero);
out.println(my_e.valor);
out.println(my_e.TAM);
//Salida:
//2
//胈
//false
//Estatico
//100

public static void mockDemoB(){

//Clase ref =new ConstructorClase();
B my_b = new B(new Integer("2"));
out.println(my_b.getNumero());

//Superclase ref = new ConstructorSubclase();

B my_bc = new C();
out.println(my_bc.getNumero());

C my_c = new C();

out.println(my_c.getNumero());

//Esto no puede ser:

//B b = new B();//Constructor no definido en class B

//Esto no puede ser:

//C my_cc = new C(12);//Constructor no definido en class C

//Salida:
//2
//3
//3
 //3
//3

public static void mockDemoA(){

X my_x = new X();
//Salida:
//1
//2.0

out.println();
Y my_y = new Y();
out.println(my_y.numero);
out.println(my_y.cadena);
//Salida:
//12
//Hello
//12
//Hello

out.println();
int millon = 2_000_000;
Z my_z =new Z(millon);
out.println(my_z.millon);
//Salida:
//3000000
//1000000

out.println();
A my_a = new A();
String cadena = null;
try{
my_a.metodo(cadena);
}catch(MyException mex){
mex.printStackTrace();
}finally{
out.println("Ha finalizado este programa");
}

}
}

abstract class AT {
//Esto no compilara, el metodo deberia ser: public abstract void nada();
//public void nada();

//Correcto:
public abstract void nada();
}
interface InterfA{
public abstract void nada();
}

interface InterfB extends InterfA{}

interface InterfC extends InterfA{

void algo();
}

interface InterfD extends InterfB{

void cosa();
}

class InterfBImpl implements InterfB{

@Override
public void nada(){
out.println("Nada desde InterfBImpl");
}
}

abstract class InterfBImplA implements InterfB{

//No esta obligada a implementar
// los metodos firmados de la interface
// InterfB
}

abstract class PadreAbstracto{

public abstract void metodoAbstracto();
}

abstract class HijoAbstracto extends PadreAbstracto{

public abstract void metodoAbstracto();
}

class HijoNoAbstracto extends PadreAbstracto{

@Override
public void metodoAbstracto(){
out.println("metodoAbstracto desde HijoNoAbstracto");
}
}

abstract class MadreAbstracta{

public abstract void metodoAbstracto();
}

class HijaNoAbstracta extends MadreAbstracta{

@Override
public void metodoAbstracto(){
out.println("metodoAbstracto desde HijaNoAbstracta");
 }
}

final class NoHeredable{}

//ESto no se puede:
//error: cannot inherit from final NoHeredable
//class Hija extends NoHeredable{}

abstract class Abstracta{

public void nada(){
out.println("Nada desde Abstracta");
}
}
class Hija extends Abstracta{}

class TestW{
private char car = 'W';

private TestW(){
out.println("TestW private!!!");
car = 'U';
out.println(car);
}

public TestW(char c){

this();
this.car = c;
out.println("Pusiste:"+car);
}
}

class TestZ{
private char car = 'Z';

private TestZ(){
out.println("TestZ private!!!");
car = 'P';
out.println(car);
}

public TestZ(char c){

super();
this.car = c;
out.println("Pusiste:"+car);
}
}

class TestY{
private int numero;//0

TestY(){
out.println("TestY");
 }

protected TestY(int numero){

super();
this.numero = numero;
}

class TestX{
private String cad;//null

public TestX(){
out.println("TestX");
}

private TestX(String cad){

super();
this.cad=cad;
}
}

class A1{
private void metodoA(){
out.println("Metodo A de A1");
}
}

class B1{
protected void metodoB(){
out.println("Metodo B de B1");
}
}

class C1 extends A1{

protected void metodoC(){
out.println("Metodo C de C1");
}
}

class D1 extends B1{

protected void metodoD(){
out.println("Metodo D de D1");
}
}

class D extends Object{

private String cadena = "D";
 protected int numero = 2;
public char caracter = '\u80C8';
boolean verdadero = new Boolean("False");
static CharSequence valor = "Estatico";
public static final int TAM = 100;
}

class E extends D{}

class B extends Object{

private int numero=1;

public B(int numero){

this.numero = numero;

public int getNumero(){

return numero;
}
}

class C extends B{
public C(){
super(3);
out.println(this.getNumero());
}
}

class A{
public void metodo(String cadena) throws MyException{
if(cadena == null){
throw new MyException("La cadena no puede ser null!!");
}
out.println(cadena.toUpperCase());
}
}

class MyException extends Exception{

public MyException(){}

public MyException(String message){

super(message);
}

}
class Z{
int millon = 1_000_000;

public Z(int m){

int millon = this.millon + m;
out.println(millon);
}
}

class Y{
protected int numero = 10;
protected String cadena = "Hola";

{
numero = 11;
cadena = "Hello";
}

public Y(){
numero = 12;
out.println(numero);
out.println(cadena);
}

class X{
private int numero;//0
private double valor;//0.0

static int[] arreglo = new int[3];//0,1,2

static{
arreglo[0] = 1;
arreglo[1] = 2;
arreglo[2] = 3;
}

//error: non-static variable numero cannot be referenced from a static context

//static{
//numero = new Integer("1");
//valor = new Double("2.0");
//}

public X(){
numero = new Integer("1");
valor = new Double("2.0");
out.println(numero);
out.println(valor);
 for(Integer arr: arreglo){
out.println(arr);
}