//============================== FUNDAMENTOS DA LINGUAGEM ====================================
//ex
package pacote1;

import java.util.*;

public class classe1{
	Date dt = new Date();
}

//ex
public class classe1{
	public classe1(){
	}
}

public class classe2{
	public classe2(){
	}
}

//ex
class t2 {
    public t2() {
    }
    public static void main(String[] args){
        System.out.println("teste");
    }
}

class t3{
    public static void main(String[] args){
        System.out.println("teste2");
    }
}

//ex
class t2 {

    public t2() {
    }
    public static void main(String[] args){
        System.out.println("teste");
    }

    protected class t3{
    }

    private class t4{
    }
}


//ex

1-	Primitivas (Variáveis)
2-	Controle fluxo
3-	Tratamento de Erro
4-	Controle de Pacotes
5-	Modificadores de classe, método e variável
6-	Modificadores de acesso
7-	Palavras-chave de variável
8-	Palavra-chave void
9-	Palavras-chaves reservadas e não utilizadas

[ ] [ ] abstract
[ ] [ ] assert
[ ] [ ] boolean
[ ] [ ] break
[ ] [ ] byte
[ ] [ ] case
[ ] [ ] catch
[ ] [ ] char
[ ] [ ] class
[ ] [ ] const
[ ] [ ] continue
[ ] [ ] default
[ ] [ ] do
[ ] [ ] double
[ ] [ ] else
[ ] [ ] extends
[ ] [ ] false
[ ] [ ] final
[ ] [ ] finally
[ ] [ ] float
[ ] [ ] for
[ ] [ ] goto
[ ] [ ] if
[ ] [ ] implements
[ ] [ ] import
[ ] [ ] instanceof
[ ] [ ] int
[ ] [ ] interface
[ ] [ ] long
[ ] [ ] native
[ ] [ ] new
[ ] [ ] null
[ ] [ ] package
[ ] [ ] private
[ ] [ ] protected
[ ] [ ] public
[ ] [ ] return
[ ] [ ] short
[ ] [ ] static
[ ] [ ] strictfp
[ ] [ ] super
[ ] [ ] switch
[ ] [ ] synchronized
[ ] [ ] this
[ ] [ ] throw
[ ] [ ] throws
[ ] [ ] transient
[ ] [ ] true
[ ] [ ] try
[ ] [ ] void
[ ] [ ] volatile
[ ] [ ] while

//ex NÃO SÃO PALAVRAS RESERVADAS JAVA
1-C++
2-Java escrito errado
3-Conceitos e não comandos
4-Classe em Java e não palavra reservada
[1] overload
[1] unsigned
[1] virtual
[1] friend
[2] Int
[2] protect
[2] extend
[2] implement
[3] method
[3] subclasses
[3] reference
[3] array
[4] String
[4] Float
[4] Integer


//ex
   short s=5;
   short s2=s+8;

//ex
    int x = 20;
    int z = x + 5;
    long y = z + 5;
    short h=4;
    short a = 3 + 2;
    short b=z+5;
    short i=a+2;
    byte d=3;
    byte e=d+1;
    d+=3;
    int c = a / 2;
    System.out.println("" + c);



//ex
    byte f=d++;
    byte g=a++;
    d++;


//ex
       boolean x=true;
       boolean z=False;
       boolean y=false;
       boolean a=0;
       boolean b=null;

//ex
        char b1=945;
        char b2=-4;
        char b3=65000;
        char b3=69000;
        char b8='\ubeef';
        char b4='a';
        char b5='u';
        char b6="u";
        char b7='\uFFFF';
        System.out.print("->"+b1);

//ex
        char b9='\ucobol';


//ex
    int x1=064;
    int x2=069;

//ex
    // hexadecimal
    int x1=0x1a;
    int x2=0x1A;
    int x3=0X1a;
    int x4=0X1A;
    int x5=oX1a;


//ex
        int x=0X0001;
        int y=0xFFFFFFFF;
        int z=0x7FFFFFFF;
        int a=0XDeadCafe;
        System.out.println("x:"+x+" y:"+y+" z:"+z+" a:"+a );


//ex
        int x=5;
        long a=x+2;
        long b=6;
        long c=7l;  //letra "l" minuscula ou "L"
        long d=42353453454554;
        long e=42353453454554L;

//ex
double d=1.2;
    float e=1.2;
    double f=1.2d;
    float g=1.2f;
    double h=15e7;
    float i=3e9;
	float j=9.0;
	double l=.2;
	long x=2e4;

//ex
        float x1=1e1f;
        float x2=2.f;
        float x3=.3f;
        float x4=0d;
        float x5=0e;
        float x6=0f;
        float x7=3.14f;
        float x8=6.022137e+23f;


//ex
        double z1=1e1;
        double z2=2.;
        double z3=3f;
        double z=069;
        double z4=0XC0B0L;
        double z5=.3;
        double z6=0.0;
        double z7=3.14;
        double z8=1e-9d;
        double z9=1e137;
        double z10=4,2;


// assumindo neste exemplo que as variaveis seja do tipo:
       // b =>byte
       // s =>short
       // c =>char
       // i =>int
       // f =>float
       // d =>double
// informe o tipo do resultado da operação
    2      =>
    300    =>
    5000   =>
    2+3    =>
    127+b  =>
    1+s    =>
    c+s    =>
    i+i    =>
    l-1    =>
    5      =>
    5.0    =>
    i/2    =>
    f/2    =>
    d/2    =>
    f+2    =>
    f+1.0  =>
    d+2    =>
    d+5.0  =>

//ex
        char c='A';
        String s1=c;
        String s2=(String)(c);
        String s3=""+c;
        System.out.println(s3);

//ex
        int 100=100;
        boolean False=true;
        int true=1;

//ex
		int _x=5;
		double $z=4;
		$z++;
		String z$b="ola"
		int #a=4;
		int 4b=7;


//ex
        int kksdkfhklasdfhjkashdfjklshdfkjasdfkhaskdfsjkdfhksdhflasjkdfhlksdhfklshdfksdhfksdhflsd=3;
        int $2=3;
        int _1=2;
        int 3andar=3;

//ex
        int x1=9/0;
        int y1=9.0/0;
        float x2=9/0;
        float y2=9.0/0;
        float y4=9.0f/0;
        double x3=9/0;
        double y3=9.0/0;


//ex
    double d= -100.0/0.0;
    if (d==Double.NEGATIVE_INFINITY){
		System.out.print("valor do d:"+d);
	}

//ex
         if (Float.NaN==Float.NaN) {
             System.out.println("igual");
         }
         else {
            System.out.println("diferente");
         }

//ex
         if (-0.0==0.0) System.out.println("igual");
         else System.out.println("diferente");

//ex
    int true=10;

//ex
 	int t=0;
 	if (t) {
		System.out.print("falso");
	}


//ex
    public static void main(String[] args){
        int x=break(10);
    }

    public int break(int z){
        return z+5;
    }


//ex
        int r=2000000000;
        int z=r;
        System.out.println("z:"+z);

//ex

    public void mostra(){
        int quant;
        System.out.print("quant:"+quant);
    }

//ex
       Object o = new int [] {1,2,3,4};
       int i = new Object();
       Object a = new Object[3] {null, new Object(), new Object()};

//ex FAZER OS VETORES DA APOSTILA

//	 	int x[][]={{1,1,1},{2,2,2}};
//	 	int a[]={1,2,3};
//		int b[]={4,5,6};
//	    x[0]=a;
//	    x[1]=b;
//	 	for (int l=0;l<2;l++){
//	 		for (int c=0;c<3;c++){
//	 		  System.out.print(x[l][c]);
//	 		}
//	 		System.out.println("");
//	 	}


//ex
        int [][][]x=new int[3][][];
        x[0]=new int[2][];
        x[1]=new int[3][];
        x[2]=new int[4][];
        for (int a=0; a<x.length; a++){
            for (int b=0; b<x[a].length; b++){
                x[a][b]=new int[a+b+1];
                System.out.println("tam="+x[a][b].length);
            }
        }

//ex
    public static void main(String[] arg){
	        int[]  x=new int[10];
	        for (int i=0; i < x.length; i++) {
	            System.out.println(x[i]);
	        }
    }

//ex    java class arg0 arg1 arg2
    public static void main(String[] args){
        for (int i=0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }


//============================== OPERADORES E ATRIBUIÇÕES ====================================


//ex
    public static void dobra(int x) {
        x=x*2;
    }

    public static void main(String[] args){
        int a=5;
        dobra(a);
        System.out.println("a:"+a);
    }


//ex
    public static class Hoje{
         int dia,mes,ano;
    }

    public static void dobraDia(Hoje dataAtual) {
        dataAtual.dia=dataAtual.dia*2;
    }

    public static void main(String[] args){
        Hoje hj=new Hoje();
        hj.dia=5;
        dobraDia(hj);
        System.out.println("hj.dia:"+hj.dia);
    }

//ex
    public static void dobra(int[] x) {
        x[0]=x[0]*2;
    }

    public static void main(String[] args){
        int[] a={2};
        dobra(a);
        System.out.println("a[0]:"+a[0]);
    }

//ex
		 Date dt=new Date();
		 dt=null;
		 System.out.println(dt.toString());

//ex
       Object o = new int [] {1,2,3,4};
       int i = new Object();
       Object a = new Object[3] {null, new Object(), new Object()};

//ex

       int b=9;
       int c=b=1;
       System.out.println("c:"+c);
//ex

       int[] a = {5,5};
       int b=1;
       a[b] = b = 0;
       System.out.println("a[0]:"+a[0]);
       System.out.println("a[1]:"+a[1]);

//ex
       int x,y;

       x=1;
       y=x++;
       System.out.println("x:"+x);
       System.out.println("y:"+y);

       x=1;
       y=++x;
       System.out.println("x:"+x);
       System.out.println("y:"+y);

       x=1;
       y=x--;
       System.out.println("x:"+x);
       System.out.println("y:"+y);

       x=1;
       y=--x;
       System.out.println("x:"+x);
       System.out.println("y:"+y);

//ex
       int x=10;
       x-=2;
       System.out.println("x:"+x);

//ex
       int x=19;
       x=+3;
       System.out.println("x:"+x);

//ex
       int x=19;
       int y=-(x+2);
       System.out.println("y:"+y);



//ex
  public static void main(String[] args){
        Date hj=new Date();
        String y="ola";
        System.out.println("hj:"+tipoObj(hj));
        System.out.println("y:"+tipoObj(y));

    }

    public static String tipoObj(Object x) {
       if (!(x instanceof String)) {
           return "NÃO É STRING";
       }
       else {
           return "STRING";
       }
    }

//ex
class Hoje extends Date  {

    public static void main(String arguments[])   {
       Hoje x=new Hoje();
       boolean a=(Hoje instanceof x);
       boolean b=(x instanceof Hoje);
       boolean c=(x instanceof Date);
       boolean d=(x instanceof Object);
       boolean e=(x instanceof String);
       boolean f=x instanceof (Hoje);
    }
}


//ex
       Date hj=new Hoje();
       int h=hj.getHours();
       String msg=(h<=12)?(h<5)?"Bom Madrugada":"Bom Dia":(h>18)?"Boa Noite":"Boa Tarde";
       System.out.println(msg);


//ex
		Vector v=new Vector();
        v.add("teste");
        String S=v.get(0);

//ex
        int x=17 % 5;
        int y=10%3;
        System.out.println("x:"+x+" y:"+y);


// fazer: colocar o do bixesto sem os detalhes dos centenarios

//ex
        char c='A';
        int q=66;
        if (c>q) System.out.println("maior");
        else System.out.println("menor");

//ex
		        byte a=1;
		        byte b=2;
		        byte x=a+b;
		        byte y=(byte)a+b;
		        byte z=(byte)(a+b);
		        float q=3.1;
		        float e=(float)3.1;
		        float f=(float)(e+2.0);

//ex
        int x=(int)5.1;
        int y=(int)4.9;
        System.out.println("x:"+x+" y:"+y);

//ex
        byte x=(byte)130;
        System.out.println(x);

// trabalhar com numero binarios.
//"Só existem 10 tipos de pessoas no mundo: as que entendem números binários e as que não entendem"

// deslocamentos de numeros com sinal
   10100101 << 2
   10100101 >> 2
   10100101 >>> 2

   >> 34 para int igual a >>2

   >> 32 para int igual a >>0 (ou seja nada)
   >> 64 para int igual a >>0 (ou seja nada)

   byte x=-1; x=x>>4;  (converte em int primeiro e o que acontece?)
   byte x=-1; x=x<<3;  (converte em int primeiro e o que acontece?)
   byte x=-1; x=x>>>2;  (converte em int primeiro e o que acontece?)


  ~10100101

   10100101
  +00101001

   10100101
  +10010100

   10100101
&  00101001  AND

   10100101
&  10010100  AND

   10100101
|  00101001  OR

   10100101
|  10010100  OR

   10100101
^  00101001  XOR

   10100101
^  10010100  XOR


// Transforme em binário
   F7
   8A

//ex
 		byte a=1;
        byte x=a;
        x<<=1;
        System.out.println(x);
        byte y=a;
        y>>=1;
        System.out.println(y);
        byte z=a;
        z>>>=1;
        System.out.println(z);

//ex
        int x;
        x=0x80000000 >>31;
        System.out.println(x+" = "+Integer.toBinaryString(x));

        x=0x80000000 >>>31;
        System.out.println(x+" = "+Integer.toBinaryString(x));



//Quando a condição não será executada.
false && (condição) = ??
true && (condição) = ??

false || (condição) = ??
true || (condição) = ??

false ^ (condição) = ??
true ^ (condição) = ??


//ex
        int x=0;
        int y=10;
        if (x>0 && y++>5) {System.out.println("1");}
        System.out.println("x:"+x+" y:"+y);
        if (x==0 && y++>5) {System.out.println("2");}
        System.out.println("x:"+x+" y:"+y);
        if (x>0 || y++>5) {System.out.println("3");}
        System.out.println("x:"+x+" y:"+y);
        if (x==0 || y++>5) {System.out.println("4");}
        System.out.println("x:"+x+" y:"+y);


        if (x>0 & y++>5) {System.out.println("6");}
        System.out.println("x:"+x+" y:"+y);
        if (x==0 & y++>5) {System.out.println("7");}
        System.out.println("x:"+x+" y:"+y);
        if (x>0 | y++>5) {System.out.println("8");}
        System.out.println("x:"+x+" y:"+y);
        if (x==0 | y++>5) {System.out.println("9");}
        System.out.println("x:"+x+" y:"+y);

//ex
	byte ano=04;
    System.out.println("Ano:"+2000+ano);

//Atribuição:
    =,*=,/=,%=,+=,-=,<<=,>>=,>>>=,&=,^=,|=


//ex
        byte b = 4;
        short s = b;
        char ch = b;

//ex
	int[] a = new int[2] { 5, 10};
	int[] c[] = {{},  new int[] {} };
	int b[][] = { {1,2}, new int[2] };
	int d[5] = { 1, 2, 3, 4, 5};
	int e[] = { 1, 2, 3, 4, };


//ex
	static int a[];
	static int b[] = {1,2,3};
	public static void main(String s[]) {
		//System.out.println(a[0]); // Throws a null pointer exception
		System.out.println(b[0]); // This code runs fine
		System.out.println(a); // Prints ‘null’
		System.out.println(b); // Prints a string which is returned by toString
	}


//ex
	public String testMethod ( int a) {
		String tmp;
		if  ( a > 0 ) tmp = "Positivo";
		return tmp;
	}

//ex
		System.out.println( 1 + 2 + "3" );
		System.out.println( "1" + 2 + 3 );


//ex
	int i = 0;
	i = i++;
	i = i++;
	i = i++;
	System.out.println(i);

//ex
    int array[] = new int[5];
	int index = 0;
    array[index] = index = 3;

	for (int c = 0; c < array.length; c++)
	  System.out.println(array[c]);
	System.out.println("index é " + index);


//ex
        int x=0;
        int b=x++;
        x=0;
        int c=++x;
        System.out.println("b:"+b+" c:"+c);

//ex
		x=0;
        if (x++==1) {
            System.out.println("x++");
        }
        x=0;
        if (++x==1) {
            System.out.println("++x");
        }

//ex
 		int[] v={0,1,2,3,4};
        x=0;
        System.out.println("v[x++]:"+v[x++]);

        x=0;
        System.out.println("v[++x]:"+v[++x]);

//ex
        int a=3;
        int b=3;
        boolean x=(a=b);

//ex
        System.out.println((3>2)?2:22.2);
        System.out.println((3>2)?2:"3");

//============================== CONTROLE DE FLUXO,EXCEÇÕES E ASSERTIVAS ====================================

//ex
            int salario = 50;
            if (salario <30) {
            System.out.println("1");
            } else {
            if (salario < 40) {
            System.out.println("2");
            } else {
            System.out.println("3");
            }
            }

//ex
            int salario = 50;
            if (salario < 50)
            if (salario < 40)
            System.out.println("1");
            else
            System.out.println("2");

//ex
			int i=1;
			int j=2;
			if(i==1|| j==2)
				System.out.println("OK");

//ex
            if (false && false || true)
                System.out.println("executou");

//ex
 			if (false && (false || true))
                System.out.println("executou");

//ex
			boolean comprou = false;
            if (comprou=true) {
	               System.out.println("comprou");
            }

//ex
           int x=3;
           if (x=5) {
               System.out.println("");
           }

//ex
           if (0) {
               System.out.println("");
           }
           else {
           }


//ex  //qual o valor de h
public class Teste {
static boolean b;

public static void main(String[] args) {
short h=15;
if (h<60 & !b) h++;
if (h>60);
else if (h>10){
h+=7;
h++;}
else
--h;
h=+2;
}
}

//ex
// [ok] byte,short,char,int
// [não pode] long,float,double

            String texto="123";
            switch (texto.length()){
                case 1:
                    System.out.println("um");
                    break;
                case 2:
                    System.out.println("dois");
                    break;
                case 3:
                    System.out.println("tres");
                    break;
                default:
                    System.out.println("outros");
            }

//ex
            final int um =1;
            int dois =2;
            int tres =3;
            String texto="123";
            switch (texto.length()){
                case um:
                    System.out.println("um");
                    break;
                case dois:
                    System.out.println("dois");
                    break;
                case tres:
                    System.out.println("tres");
                    break;
                default:
                    System.out.println("outros");
            }

//ex
            final int um =1;
            final int dois =2;
            final int tres =3;
            String texto="123";
            switch (texto.length()){
                case um:
                    System.out.println("um");
                    break;
                case um+dois:
                    System.out.println("dois");
                    break;
                case tres+um:
                    System.out.println("tres");
                    break;
                default:
                    System.out.println("outros");
            }

//ex
 	    final int a=2;
            int c=3;
            String texto="123";
            switch (texto.length()){
                case 1+1: System.out.println("dois");
                    break;
                case 1+a: System.out.println("tres");
                    break;
                case c+1: System.out.println("um");
                    break;
                default:
                    System.out.println("outros");
            }

//ex
            Integer i=new Integer(5);
            switch (i) {
                case 1:
                case 2:System.out.println("");
            }

            int x=1;
            switch (x) {
                1:System.out.println("um");break;
                2:System.out.println("dois");break;
            }

            switch (x) {
                case 1:System.out.println("um");break;
                case 2:System.out.println("dois");break;
                case 2:System.out.println("tres");break;
            }

            final int zero;
            final int um=1;
            switch (x) {
                case zero: System.out.println("");; break
                case um: System.out.println("");break;
            }

//ex
            int x=0;
            while (x<=2) {
                System.out.println(x);
                x++;
            }

//ex
            int x=0;
            while (x=2) { }
            while (x) { }
            while (x==2) { }
            while (true) { }

//ex
            int i=0;
            while (i++<5)
               System.out.println("oi");
               System.out.println("ola");

//ex
            int i=0;
            while (++i<5);
               System.out.println("oi");
            System.out.println("ola");

//ex
            int x=1;
            do
                System.out.println(x);
            while (x++<10);

//ex
            int x=1;
            do
                System.out.print("x:");
                System.out.println(x);
            while (x++<0);


//ex

            int x;
            for (x=0; x<5;x++){
                System.out.println(x);
            }


//ex
            for (int x=0; x<5; x++){ }
            for (int x=0,y=0; x<5; x++,y++){ }
            for (int x=0,int y=0; x<5; x++,y++){ }
            for (long x=0,y=0; x<5; x++,y++){ }
            int z=0;
            for ( ; z<5; ){ }
            for ( ; ; ){ }

//ex
            for (int x=0; x<5; x++){ }
            System.out.println(x);

//ex
            int b=3;
            for (int a=1; b!=1; System.out.println("ola")){
                b=b-a;
            }

//ex
            for (int a=1; a<10; a++){
                System.out.println("loop-1");
                if (a>5)
                   continue;
                System.out.println("loop-2");
            }
//ex
            for (int a=1; a<10; a++){
                System.out.println("loop-1");
                continue;
                System.out.println("loop-2");
            }

//ex
            aqui:
            for (int a=1; a<10; a++){
               for (int x=1; x<10; x++){
                 System.out.println("a:"+a+" x:"+x);
                 continue aqui;
               }
               System.out.println("aaa");
            }
            System.out.println("tchau");


//ex
            try {
               // codigo arriscado
            } catch (IndexOutOfBoundsException e) {
                // controle indice fora da faixa
            }

//ex
            try {
               // codigo arriscado
            } catch (IndexOutOfBoundsException e) {
                // controle indice fora da faixa
            } finally {
                   // fecha a arquivo
            }

//ex

            try {
               int x=5/0;
            } catch (Exception e) {
                   e.printStackTrace();
            }


//ex
            try {
               // abre arquivo
                try {
                   // leitura arriscada
                   // impressão dos dados
                } finally {
                   // fecha a arquivo
                }
            } catch (Exception e) {
               // erro ao abrir arquivo
            }

//ex
            try {
               // codigo arriscado
            } catch (Exception e) {
                // controle generico
            } catch (IndexOutOfBoundsException e) {
                // controle indice fora da faixa
            }

// colocar exemplo do curso servlets


//ex
            String s1="1";
            String s2="2";
            String s3="a";
            try {
              int x = Integer.parseInt(s1);
              int y = Integer.parseInt(s2);
              int index = Integer.parseInt(s3);
              int a[] = new int[5];

              a[index] = x/y;
              System.out.println("Tudo está funcionando");
            } catch (ArithmeticException e) {
                   System.out.println("Exceção aritmética");
            } catch (ArrayIndexOutOfBoundsException e) {
                   System.out.println("Exceção de índice de array fora dos limites");
            } catch (NumberFormatException e) {
                   System.out.println("Impossível converter String em número");
            } catch (Exception e) {
                   System.out.println("Exceção genérica");
            }

//ex
		public static void main(String s[]) {
            um();
        }

        static void um(){
            dois();
        }

        static void dois(){
            int x=2/0;
        }


//ex    f7-debug
		public static void main(String s[]) {
            um();
        }

        static void um(){
            try {
               dois();
            } catch (Exception ex) {
                System.out.println("erro no um");
            }
        }

        static void dois(){
            try {
              int x=2/0;
            } catch (Exception ex) {
                System.out.println("erro no dois");
            }
            int b=5/0;
        }


//ex
            String s1="6a";
            int y=0;
            try {
              int x = Integer.parseInt(s1);
              x = x/y;
              System.out.println("Tudo está funcionando");
            } catch (NumberFormatException e) {
                   System.out.println("Impossível converter String em número");
            } finally {
                   System.out.println("passou no finally");
            }
            System.out.println("depois do try");

//ex
            try {
            } catch (Exception e) {
                   System.out.println("Exceção genérica");
            } catch (ArrayIndexOutOfBoundsException e) {
                   System.out.println("Exceção de índice de array fora dos limites");
            } catch (NumberFormatException e) {
                   System.out.println("Impossível converter String em número");
            }



//ex
		class t2  {

			class Ola{
				int x;

				void setX(int a){
					x=a;
				}
			}

			public static void main(String arguments[]) {
				 Ola o=new Ola();
				 o.setX(15);
			}

		}

//ex

IllegalArgumentException e=new IllegalArgumentException("Erro!");
throw e; // exceção foi lançada!

throw new IllegalArgumentException("Erro!");


//ex
     static class Ola{
        int x;

        void setX(int a){
            if (a<=0) {
               throw new IllegalArgumentException("Deve ser maior que zero.");
            }
            x=a;
        }

        int getX(){
            return x;
        }
    }

    public static void main(String arguments[]) {
         Ola o=new Ola();
         o.setX(1);
         System.out.println(o.getX());
         o.setX(0);
         System.out.println(o.getX());
    }


//ex
     static class Ola {
        int x;

        void setX(int a) throws Exception{
            if (a<=0) {
               throw new Exception("Deve ser maior que zero.");
            }
            x=a;
        }

        int getX(){
            return x;
        }
    }

    public static void main(String arguments[])  {
         Ola o=new Ola();
         try {
            o.setX(0);
            System.out.println(o.getX());
         } catch (Exception e){
           System.out.println(e.getMessage());
         }
    }

//ex  - não deve ser feito com o Exception pois permite também todas subExceptions filhas
     static class Ola {
        int x;

        void setX(int a) throws Exception{
            if (a<=0) {
               throw new Exception("Deve ser maior que zero.");
            }
            x=a;
        }

        int getX(){
            return x;
        }
    }

    public static void main(String arguments[]) throws Exception  {
         Ola o=new Ola();
         o.setX(0);
         System.out.println(o.getX());
    }


//ex

class NovaExcecao extends Exception {}

class NovaExcecao extends Exception {
	public NovaExcecao () {}
	public NovaExcecao (String mensagem) {
		super(mensagem);
	}
}


//ex
     static class ParametroZeroExcecao extends Exception {}

     static class Ola {
        int x;

        void setX(int a) throws ParametroZeroExcecao{
            if (a<=0) {
               throw new ParametroZeroExcecao("Deve ser maior que zero.");
            }
            x=a;
        }

        int getX(){
            return x;
        }
    }

    public static void main(String arguments[]) throws ParametroZeroExcecao  {
         Ola o=new Ola();
         try {
            o.setX(0);
            System.out.println(o.getX());
         } catch (ParametroZeroExcecao e){
           System.out.println("parametro errado");
         }
    }


//ex  Às vezes, após a captura de uma exceção, é desejável relançá-la para que outros métodos lidem com ela


public void metodo() throws ExcecaoSimples {
	try {
		// instruções
	}
	catch (ExcecaoSimples ex) {
		// faz alguma coisa para lidar com a exceção
		throw ex; // relança exceção
	}
}


//ex
public class Teste {
    int x=10;
     void  inicio()   {
         if (x>=10)
         a  throw new Exception("Deve ser menor que 10.");
    }

    public static void main(String[] args) {
        Teste t=new Teste();
        t.inicio();
    }
}


//ex
        try {
          System.out.println("forcado");
          System.exit(-1);
          System.out.println("end");
        } finally {
           System.out.println("final");
        }

//ex
    public static void lanca(){
        System.out.println("lanca");
        throw new Error();
    }

    public static void main(String[] args) {
        try {
           System.out.println("1");
           lanca();
        } catch (Exception e){
            System.out.println("2");
        } finally {
            System.out.println("3");
        }
        System.out.println("4");
    }

//ex
    static class Campos{
        String [] nomes=new String[5];
        int quant=0;

        void addNome(String nome){
            quant++;
            assert quant<5:"Campos de mais";
            nomes[quant]=nome;
        }

        int getQuant(){
            return quant;
        }
    }

    public static void main(String arguments[])   {
         Campos c=new Campos();
         c.addNome("Rogerio");
         c.addNome("Tecnoponta");
         c.addNome("Lacerda");
         c.addNome("Santos");
         c.addNome("São Paulo");
         c.addNome("Brasil");
    }




//ex
        int diaDaSemana=2;
        switch (diaDaSemana){
            case 0:System.out.println("carrega pagina-0");break;
            case 1:System.out.println("carrega pagina-1");break;
            case 2:System.out.println("carrega pagina-2");break;
            case 3:System.out.println("carrega pagina-3");break;
            case 4:System.out.println("carrega pagina-4");break;
            case 5:System.out.println("carrega pagina-5");break;
            case 6:System.out.println("carrega pagina-6");break;
            default:assert false:"dia da semana errado";
        }



//ex

        try  {
		   assert false;
		   System.out.println("Assertions estão desabilitadas.");
		} catch (AssertionError a) {
		   System.out.println("Assertions estão habilitadas.");
        }


//fazer: função retornando vetor, função retornando um novo objeto ou um existente.

//====================== PROGRAMAÇÃO ORIENTADA A OBJETOS =============
Características OO em Java: abstração, encapsulamento, herança e polimorfismo
Incluindo:Artefatos: pacote, classe, objeto, membro, atributo, método, construtor e interface

// Carro
package gm;

abstract public class Carro {
    private double motor=1.0;
    private String placa="";
    protected String modelo="";
    protected String cor="";
    public static int quant=0;
    protected int peso=0;

    protected Carro(){
       quant++;
    }

    public int getQuant(){
       return quant;
    }

    public void setPeso(int novoPeso) {
        if (novoPeso>=10)
            peso=novoPeso;
        else
            throw new IllegalArgumentException("Peso deve ser maior que 10");
    }
    public double getPeso(){
        return peso;
    }

    void setMotor(double novoMotor) {
        if (novoMotor>=1 && novoMotor<=2.6)
            motor=novoMotor;
        else
            throw new IllegalArgumentException("Motor deve estar entre[1.0 e 2.6]");
    }
    public double getMotor(){
        return motor;
    }

    public final void setPlaca(String novaPlaca){
        placa=novaPlaca;
    }
    public final  String getPlaca(){
        return placa;
    }

    protected void setModelo(String novoModelo){
        modelo=novoModelo;
    }
    public String getModelo(){
        return modelo;
    }

    protected abstract void setCor(String novaCor);

    public String getCor(){
        return cor;
    }
}

//Vectra
package gm;

public class Vectra extends Carro {

    public Vectra() {
        setModelo("Vectra");
        setMotor(2.0);
        setPeso(2000);
    }

    public void setCor(String novaCor) {
         if (novaCor.equalsIgnoreCase("azul") || novaCor.equalsIgnoreCase("verde"))
            cor=novaCor;
        else
            throw new IllegalArgumentException("Cor ou Azul ou Verde");
    }

    public void setPeso(int novoPeso) {
        if (novoPeso>5000)
            throw new IllegalArgumentException(modelo+"Peso deve ser menor que 5000");
        super.setPeso(novoPeso);
    }

}


//Palio
package fiat;

import gm.*;

public class Palio extends Carro {

    public Palio() {
        setModelo("Palio");
        //setMotor(1.6);
        //this.motor=2.0;
    }

    public void setCor(String novaCor) {
         if (novaCor.equalsIgnoreCase("branco") || novaCor.equalsIgnoreCase("preto"))
            cor=novaCor;
        else
            throw new IllegalArgumentException("Cor ou Branco ou Preto");
    }


    public void setPeso(int novoPeso) {
        if (novoPeso>3000)
            throw new IllegalArgumentException(modelo+": Peso deve ser menor que 3000");
        super.setPeso(novoPeso);
    }

}


//Usando
package programador;

import gm.*;
import fiat.*;

public class Usando {

    public static void main(String[] args) {
        Vectra vectra001 = new Vectra();
        vectra001.setPlaca("CZL2050");
        vectra001.setCor("azul");
        vectra001.setPeso(4000);
        //vectra001.setMotor(2.2);
        System.out.println("Modelo:"+vectra001.getModelo());
        System.out.println("Motor:"+vectra001.getMotor());
        System.out.println("Placa:"+vectra001.getPlaca());

        Palio palio003 = new Palio();
        palio003.setPlaca("CZL2050");
        palio003.setCor("branco");
        palio003.setPeso(2000);
        //palio002.setModelo("AUDI");
        System.out.println("Modelo:"+palio003.getModelo());
        System.out.println("Motor:"+palio003.getMotor());
        System.out.println("Placa:"+palio003.getPlaca());

        System.out.println("Carros:"+palio003.getQuant());


        vectra001.quant=2;    // não preferivel
        System.out.println("Quant:"+Carro.quant);

        palio003.quant=1;     // não preferivel
        System.out.println("Quant:"+Carro.quant);

        Carro.quant=5;       //  preferivel
        System.out.println("Quant:"+Carro.quant);


//        Carro qualquer = new Carro();
//        qualquer.setPlaca("ABC1234");
    }
}


// final
package programador;


public final class Perfeita {    // esta nunca poderá ter subclasses
   public final int TAMANHO = 15;
   // esta variável nunca poderá ter seu valor modificado (uma constante)

   public final void tenteOverride() {
       // este método nunca poderá ser sobrescrito
   }
}



//final-2
    Perfeita() {
        int x=5;
        int y=6;
        int z=metodo(x,y);
    }

    int metodo(final int a,final int b){
       a=a*b;
       return a;
    }



// final-3
    void metodo(){
        final int x=9;
        x=4;
        System.out.println(x);
    }





//
public class Teste1 {
  final int x;

  void Testando(){
  	x=5;
  }
}

//
public class Teste1 {
  final int x;
}

//final-4
public class Teste1 {
  final int x;

  Teste1(){
  	x=5;
  }
}


///
public class Teste1 {

	public static abstract void grava(){
	}
}

//ex
public abstract   class Arquivo {
	abstract synchronized void grava1();
	abstract strictfp void grava2();
	abstract native void grava3();
}


//ex
public class Arquivo {
	public synchronized void grava1(){
	}
}

//ex
public synchronized class Arquivo {
	synchronized int x;
	public synchronized void grava1(){
	}
}

//ex

public class Arquivo {
	public native void grava1(){
	}
}

//ex
public native class Arquivo {
	native int x;
	public native void grava1(){
	}
}

//ex
public strictfp class Arquivo {
	strictfp int x;
	public strictfp void grava1(){
	}
}

//ex

import java.io.*;
import java.util.*;

public class Logon implements Serializable {
  private Date date = new Date();
  private String username;
  private transient String password;

  public Logon(String name, String pwd) {
	username = name;
	password = pwd;
  }

  public String toString() {
	return "Informações: \n   nome: " + username + "\n   data: " + date + "\n   senha: " + password;
  }

  public static void main(String[] args) throws Exception {
	Logon objLogon = new Logon("Tecnoponta", "Java JCSP");
	System.out.println( "Logado a = " + objLogon);   // usa o toString

    // cria um arquivo externo e grava tudo que não é transient
	ObjectOutputStream arq = new ObjectOutputStream(new FileOutputStream("Logon.out"));
	arq.writeObject(objLogon);
	arq.close();

	Thread.sleep(1000); // Espera por um segundo
	System.out.println("Recuperando objeto em "+new Date());
	// Restaurando os dados lendo arquivo
	ObjectInputStream in = new ObjectInputStream(new FileInputStream("Logon.out"));

	objLogon = (Logon)in.readObject();
	System.out.println("Logado a = " + objLogon);
  }
}


//ex

public transient class Arquivo {
	transient int x;
	public transient void grava1(){
	}
}

//ex
public volatile class Arquivo {
	volatile int x;
	public volatile void grava1(){
	}
}

//ex this

	void setMotor(double motor) {
   	     this.motor = motor;
	}


// encapsulamento

public class Teste1 {
    int idade;

	public int getIdade() {
		return idade;
	}

	public void setIdade(int i) {
		idade = i;
	}
}


// Motor

package gm;

public class Motor {
    private double potencia=1.0;
    private int velocidade=0;

	public double getPotencia() {
		return potencia;
	}

	public int getVelocidade() {
		return velocidade;
	}

	void setPotencia(double novaPotencia) {
		potencia = novaPotencia;
	}

	public void setVelocidade(int novaVelocidade) {
		velocidade = novaVelocidade;
	}

	public void acelera(int quanto) {
		velocidade += quanto;
	}

	public void freia(int quanto) {
		velocidade -= quanto;
	}
}


// Carro
	public Motor meuMotor=new Motor();

	protected Carro() {
		quant++;
	}

	void setMotor(double novoMotor) {
		if (novoMotor >= 1 && novoMotor <= 2.6){
			motor = novoMotor;
			meuMotor.setPotencia(motor);
		}
		else
			throw new IllegalArgumentException("Motor deve estar entre[1.0 e 2.6]");
	}


// usando
		palio757.meuMotor.acelera(10);
		palio757.meuMotor.acelera(10);
		palio757.meuMotor.acelera(10);
		System.out.println("velocidade:"+palio757.meuMotor.getVelocidade());


// over
public class Teste1 {
	public void mudaTamanho(int i) { }
}

class OutroTeste extends Teste1 {
	public void mudaTamanho(int i) { }
}

// over
public class Teste1 {
	public void mudaTamanho(int i) { }

	public int mudaTamanho(int i) { }
	private void mudaTamanho(int i)  { }
	public void mudaTamanho(int i) throws Exception{ }

}

class OutroTeste extends Teste1 {
	public void mudaTamanho(int i) { }

}

//polimorfismo

        int dinheiro=40000;
        Carro meuCarro;

        if (dinheiro > 35000)
           meuCarro=new Vectra();
        else
    	   meuCarro=new Palio();

        meuCarro.andar();
        System.out.println("com o "+meuCarro.getModelo());