Exercícios para o projeto de certificação Programador Java
Using Operators and Decision Constructs
Working with Selected classes from the Java API
Working with Methods and Encapsulation
final Fizz z = x; z.x = 6;final char a = 'A', d = 'D'; a e d são char e final
class A{int x;}void m(){x = x+1; //o x é do escopo da variavel mebroint x = 0; //a partir daqui, o x é do escopo da variavel localx = x+1}
java nomeDaClasse chama a classe adequada dentro desse arquivojava BirdDisplay Sparrow "Blue Jay" passando 2 parametrosjavac certification/Test.java; java certification.Test//método 2
System.getProperty(“key1”);
- **classpath**: diretorios, jar que contem as classes e pacotes da aplicação. Padrão é o *diretório corrente (.)*- compilar a classe A.java, definida dentro do pacote b e adicionar o jar program.jar na busca de classes durante a compilação (.) diretório atual `javac -cp program.jar:. b/A.java`- somente p/ usar c/ javac. Não é usado com java para rodar classes dependentes do jar`javac -cp ../proj/lib/supercharge.jar top/sub/A.java`- usar c/ -cp apenas arquivos jar. Não funciona com coringas ou com diretórios- rodar um .class de dentro de um jar `java cp /path/to/lib.jar pacote.Test`- Criar um jar da pasta certification: *jar **-cf library.jar** certification*- **printf** %[index$][flags][width][.precision]type
Locale br = new Locale("pt","BR");System.out.printf(br,"%,f %n", 123456.789); // 123.456,789000```
package lilypad;public class Frog { }///////////////package lilypad;import lilypad.Frog; //classe no mesmo pacoteimport lilypad.Tadpole;//a própria classepublic class Tadpole {private Frog parent;}
package util.log4j;public class Logger{...package util;...util.log4j.Logger logger = new util.log4j.Logger();
import java.util.Date; import java.sql.Date; não compila: erro no import. import java.util.*; import java.sql.Date vai ser usado do Date do pacote sql (mais específico)import static model.Utils.*
import static <package>.<classname>.*; //importa todos os membros static da classeimport static <package>.<classname>.<fieldname>; //importa algum membro static especifico da classeimport static java.util.Collections; \\não compilaimport static pacote.A.a //compila, importa apenas o membro static a
#### Compare and contrast the features and components of Java such as: platform independence, object orientation, encapsulation, etc.- **bytecode** .class é interpretado pela **JVM** que converte em código de máquina, executado pelo **SO** nativo- programa **escrito** e **compilado** apenas 1x pode ser usado em diversas plataformas diferentes.- **OO**: estruturamos o código em entidades *objetos* (compontentes especializados) que possuem dados na forma de *atributos* e comportamento na forma de *métodos*- Cada objeto deve ter *única responsabilidade*, favorecer *reuso de código* e cada mudança no comportamento *reflete em todos os lugares* onde o objeto é usado.- *Encapsulamento* *privar* atributos e implmentação p/ q outros objetos manipule esses atributos. Liberar apenas por meio de métodos *public*[[↑] Back to top](#Anotações-para-certificação-OCA-Programmer-1Z0-808)### Using Operators and Decision Constructs#### Use Java **operators**; use **parentheses** to override operator **precedence**- **atribuição** tipos compatíves ou o valor deverá ser = ou menos abrangente. tipos primitivos: copiamos o valor- float é menos abrangente que double `double d = 20.0f;`- double não cabe em float `float f = 40.0; //não compila`- `float f = 5.5f;` deverá ser atribuido dessa forma- inteiros (long) cabe em decimal `float h = 10l;`- negativação de variaveis```javaint a = 1, b = -a, c = -b; //b = -1 e c= 1
- tipos menos abrangentes que int: **byte, short, char** compilador verifica se esta no range do tipo- estoura byte: -128 a 127 (único itervalo cobrado) `byte b = 200;`- erro: só positivo `char c2 = -1;`- cuidado c/ atribuição com variaveis de tipo mais abrangente```javashort s = 10; char c = s; //não compila pois s (não 10) é short q pode ser negativoshort s = 10; (short) char c = s; //com casting compilachar c = 10; short s = c; //apesar de terem 2 bytes, nao compila pois o range + do char > short (pois compensa o lado negativo q nao tem no char). Com casting funciona```- o lado esquerdo de uma atribuição deve ser sempre uma variável, e não uma chamada a um método ou outro literal `"guilherme".substring(0,2) = "gua";`- se ocorrer uma atribuição durante o calculo da expressão, as variáveis a direita dessa atribuição serão atualizados c/ esse novo valor```javaint k = 1;k += (k = 4) * (k + 2);// k = 1 + (4) * (4 + 2);```- int, long, float ou double podem receber int sem problemas- **referência**- `List<String> names = new ArrayList<>();` <> operador diamante- copiamos o valor da referência (o objeto é o mesmo)- referencias de objetos podem ter o mesmo nome do tipo mas primitivos não```javaString String = "string isa string"; //compila e rodaint int = 1; //não compila```
-i % k o sinal do resto é correspondente ao sinal do dividendo (i), não importando o sinal do divisor. Nesse caso, o sinal do resto é negativo - 1.0 % 0.0 = NaN. Nan é menor que qualquer número
int age = 15; long years = 5;int afterThoseYears2 = age + years;// não compila, o maior tipo era long, devolve longbyte b = 1; short s = 2;byte b2 = i + s; //// não compila, ele devolve no mínimo int
System.out.println(200 / 0); //ArithmeticException200 / 0.0; 3.0/0; 0.0/0; //compila e roda: infinito positivoSystem.out.println('a' > 1);//true
int i = 5; float f = 5.5f; if (i == f) c++ //i é promovido p/ float
System.out.println(1 == 2 & imprimir("hi"));// imprime hi, depois falseSystem.out.println(1 == 2 && imprimir("bye"));//imprime falseint i = 10; System.out.println(i == 2 & i++ == 0);// imprime false, soma mesmo assimint j = 10; System.out.println(j == 2 && j++ == 0); // imprime false, não somaSystem.out.println(false & true); //false
incremento/decremento (unários)
pré sempre a primeira coisa q é feita é o incrementar/decrementar
int i = 10; System.out.println(++i); //imprime 11int j =10; System.out.println(j++); //imprime 10int k = 0;return k++; //vai retornar 0return ++k; vai retornar 1
short b2 = 3; b2 += 4; // compila, dá um desconto pois internamente existe um cast: b2 = (short) (b2 + 4)b2 += 4003245; // -76: compila também, mas estoura o byte
int a = 10;a += ++a + a + ++a;a = a + ++a + a + ++a;a = 10 + 11 + a + ++a;a = 10 + 11 + 11 + ++a;a = 10 + 11 + 11 + 12;a = 44;
int a = 15, b= 20, c= 30; a = b = c; // b recebe c, a recebe b, a= 30int a = 15, b= 20, c= 30; a = (b = c + 5) + 5; // c + 5 = 35, b = 35, 35 + 5 = 40, a = 40
variavel = teste booleano ? verdadeiro : falso;ref.atributo() p/ acessar atributos ou métodos de um objSystem.out.println(15 + ( 0 + " != 150")); // 15 + "0 != 150"; "150 != 150"System.out.println(false & true + "Hello World"); //não compila. Compila apenas se colocar parenteses na operação c/ booleans
"" + 2 + 7; //=27"" + (2 + 7); //=92 + 7 + ""; //=9
double d = 0, d2 = 3.1415;float f = d; //não compila: double não cabe em floatfloat f = (float) d; //compila com castint i = (int) d2;//compila: i= 3 (valor truncado)
static short method(short s){}; method(7); //erro passagem de um valor de um tipo mais abrangente num metodo para um parametro de tipo menos abrangente não compila devido a perda de informação. Utilizar cast qdo possível
String name1 = new String("Mario"); String name2 = new String("Mario");System.out.println(name1 == name2); // false: 2 objetos criados com new
String name1 = "Mario"; String name2 = "Mario"; System.out.println(name1 == name2); //trueString ab = "a" + "b";System.out.println("ab" == ab);//trueString a = "a"; String ab = a + "b"; System.out.println("ab" == ab); // falseString str = "12 text 345678"; String txt1 = "text";String txt2 = str.substring(3, 7); System.out.println(txt1 == txt2); // falseString str = "HELLO WORLD";String upper = str.toUpperCase(); System.out.println(str == upper); // true
String h = new String ("hello ");//Cria 2 objetos, um literal (que vai para o pool) e o outro com o newString h1 = "hello "; //nenhum objeto criado, usa o mesmo do poolString w = "world"; //novo objeto criado e inserido no poolSystem.out.println("hello ");//nenhum objeto criado, usa do poolSystem.out.println(h1 + "world");//criado um novo objeto resultante da concatenação, mas este não vai para o pool: (variavel + literal)System.out.println("Hello " == h1); //Novo objeto criado e colocado no pool (Hello com H maiúsculo).//Logo temos 5 Strings criadas.
for(int i = 0; i< 10; i++)System.out.println(method());}private static String method() {String x = "x"; // A String será colocada no pool apenas na primeira execução do método. Apenas um objeto String será criadoreturn x.toString();}
equals sobreescrever método com seu critério de igualdade
== true qdo comparando os mesmos objetos na memória
System.out.println(s1.equals(s3)); // String mesmo conteúdo: truenew Client("Mario").equals(new Client("Mario"));//false : apesar do mesmo conteúdo, vc deverá sobreescrever o método equals na classe Clientpublic boolean equals(Client second) {return this.name.equals(second.name);}new Client("Mario").equals(new Client("Mario"));//true
if (2 - 1) \\erro: inteiroboolean b1 =false, b2 =true; if(b1=b2) \\b1 agora é true
public int method() {return 5;System.out.println("Will it run?"); //unreachable code}
if(false){...} compila apesar de não executar nada dentro do bloco
public int method(int x) {if(x > 200) //e se x <= 200: ??? missing return mas foi lançado a RtE para não ocorrer o erroreturn 5;throw new RuntimeException();}
case 5 + 5 : são validas mas case > 10não são validadas. Não pode duplicar valores dos cases, mesmo usando expressões.
switch(8); //não compilaint x = 0; switch(x){ } //compila e roda
int option = 4;final int c1 = 5;switch (option) { //Pode ser constante.//o argumento deverá ser sempre compatível com int (igual ou menor que int), wrapper menor ou igual q Integer, String, Enumcase c1: //o valor de cada case deverá ser compatível com o argumento do switch.//Usar literal, variavel final (wrapper c/ final não é cte e não pode ser usado )//inicializada durante sua declaração (nao pode delcarar e inicializar em outra instrução), com literal ou expressões com literal/ variavel final (compile time constant)//null não é válido.//Não pode duplicar casesSystem.out.println("number 1");break; //para não executar os casos q vem abaixodefault: //qdo nenhum caso bater. Pode aparecer no meio dos casesSystem.out.println("number n");break;case 1+1:System.out.println("number 2");break;case 2+c1:System.out.println("number 3");break;case 4:System.out.println("number 4");break;}
while() //vazio não compilawhile (i++<10)final boolean CONDICAO = true;
while(CONDICAO) { // true, true, true …
System.out.println(“do something”);
}
return 1; // compile error
boolean rodando = true; // não final
while(rodando) { // true? false? //compila
System.out.println(“do something”);
}
return 1; // ok
- **unreachable statement** compile error. O compilador só consegue analisar o código com *literais ou constantes*```javawhile(false) { /* code */ } //nao compilawhile(1 > 2) { /* code */ } //nao compilaint a = 1, b = 2;while(a > b) // compilaSystem.out.println("OI");
while(--i < 10){//i vai até o menor valor negativo e depois vai para o maior positivo, saindo do loop}
for(;;){} compila e roda infinitamente for(int i = 1, j= 2;;){//code} ou inicializar diversas variáveis de tipos diferentes. for(a=1, b=2.0, c = true;;){//code}for(;false;) {System.out.println("a");break;} System.out.println("b"); //código dentro e depois do bloco do for nunca será executado pois false é literal for(int i = 0, j= 0;i< 10; i++, j++){//code}for(int i = 0, j= 0;i< 10; i+= 3, System.out.println(i++)){//code}for(;;) {} //int i[] = {1,2,3,4,5}; for (int numbers : i){System.out.println(num);}
l1:{System.out.println("A");l2:{for(;;) break l1;}}
first: second: for (int i = 0; i < 10; i++) {
external:for (int i = 1; i < 10; i++) {internal: for (int j = 1; j < 10; j++) {if (i * j == 25) {break external; // quebrando o for externo}if (i * j == 16) {continue internal; // pulando um iteração do for interno}}}
block: { break block; } compila e roda break de um bloco com label;
class Bottle {void Bottle() {}void Bottle(WaterBottle w) {} //parametro do tipo filha num método da classe mãe}class WaterBottle extends Bottle {}
class Parent {Parent(int x) {}}class Child1 extends Parent{ // compile error// implicit Child1() { super(); }class Child2 extends Parent { Child2() {super(15); // ok}
class X{ private int x; public void method(){}};class Y extends X { public void method2(int x){this.x = x; //erro: nao enexerga private de outra classe, mesmo herdando x } }
class Z extends W {public static void method() {super.method(); // compile error}}
binding do polimorfismo o método chamado é do pai ou da filha ?
class Game { public void play() throws Exception { }}class Soccer extends Game { public void play(String ball) {}}...Game g = new Soccer();g.play("bola");//não compila
não existe sobreescrita de atributos Vai ter o atributo com o mesmo nome da classe mãe, acessível com super ou da própria classe q sobreescreveu, acessível com this
class Base{ int i=10; }class Sub extends Base{ int i=20; } //This i hides Base's i....Sub s = new Sub(); int k = s.i; //assigns 20 to k.k = ((Base)s).i;//assigns 10 to k. The cast is used to show the Base's i.Base b = new Sub(); k = b.i;//assigns 10 to k
- uma variável membro do pai final pode ser redeclarada na filha (shadow)- **toString** sobreescrever de *Object* p/ devolver uma String q represente o objeto ```public String toString()
- o toString() de Object retorna <classname>@<hashcode>
reescrita : subclasse redefine o comportamento do método herdado da superclasse
polimorfismo :
binding : (lookup)
é o inverso dos métodos static
class Vehicle {public void turnon() {System.out.println("Vehicle running!");}}class Car extends Vehicle {public void turnon() {System.out.println("Car running!");} public void turnoff(){}}Vehicle v = new Car();v.turnon(); // Car running!v.turnoff(); //erro de compilação
mesmo nome
class Blip {protected int blipvert(int x) { return 0; } }class Vert extends Blip {protected long blipvert(int x) { return 0; } } //long é diferente de int. Não compila
interface A {void a();//public}class B implements A {void a() {}} //compile error: default é menos visivel q public
class A {public void method() {System.out.println("a");}}class B extends A {public void method() {System.out.println("b");super.method(); }//b,apublic void method2() {method(); //(this), b,asuper.method(); }} //a
super.super.m1()((Y)x2).do2(); antes de invocar o método, é feito casting da variavel de referencia por causa do ()String recovered = objetos[0]; nem todo object é uma StringString recovered = (String) objetos[0];
Object o = new String(); //necessário ocorrer o polimorfismoString s = (String) o;
Moto m = (Moto) vPai p = null; Filha f = (Filha) p;
Car c = new Car();Runnable r = (Runnable) c;
Object c = new Car();boolean b1 = c instanceof Car; // trueboolean b2 = c instanceof Motorcycle; // falseString s = "a"; boolean b = s instanceof java.util.List; // obviamente incompatível : compile error
interface T1{ int VALUE = 1; }interface T2{ int VALUE = 2; }class TestClass implements T1, T2{}...TestClass tc = new TestClass();System.out.println(tc.VALUE); //erro de compilaçãoSystem.out.println(( ( T1) tc).VALUE); //1
class TestClass{ static int si = 10;public TestClass(){ System.out.println(this); } //this = TestClass@3b22cdd0 (toString() de Object)...new TestClass();
this dentro do construtor contem o objeto com suas variaveis preenchidas c/ valores passados ou não dentro do construtor
```java
public class Network {
int id;
Network p;
String s;
Network(){ }
Network(int x, Network n){
id = x;p = this; //this: id = 1, p = nullif(n != null) p= n;
}
main()
Network n1 = new Network(1, null);
- **super()** não chamamos o construtor da classe mãe explicitamente. o compilador coloca automaticamente o *super()*- **this()** chama outro construtor mas da própria classe- não podemos referenciar um método de instância ao invocar um construtor this `this(x()); //não compila`- se o filho chama o construtor do pai e o construtor do pai chama this() (c/ ou s/ argumentos), o construtor chamado é do próprio pai e não do filho- o método chamado sempre será o do objeto filho, mesmo dentro do construtor do pai. Dentro do construtor do filho, pode chamar o método do pai com super.metodo()- *super() e this()* só podem aparecer como primeira instrução do contrutores e apenas uma chamada, mesmo se a classe possuir construtores sobrecarregados- *super() e this()* não podem ser chamados fora dos construtores- **this e variaveis membro** variaveis membro com o mesmo nome da variável local: o acesso é da variável local. this: acessar variavel membro da pr´pria classe ou da classe pai- classe mae e filha com variaveis membro de mesmo nome. Diferenciar usando *this* para a variavel da propria classe e *super* para acessar a variavel da mãe- se não incluir *this* ou *super* será acessado a variavel membro da filha- método **static** não tem *super* e *this* : o código não é executado dentro de um objeto- *this* pode ser usada p/ acessar variaveis membro *static* s/ problemas```javaclass A{int i = 5;}class Test extends A{int i = 10;public static void main() {this.i = 5; // this? compile errorsuper.i = 10; // super? compile errornew A().i = 5;new Test().i = 10;}}
classe abstrata e interfaces não poden ser instanciadas diretamente
compila e roda com classes anonimas
interface TestA { String toString(); }public class Main{public static void main(String... args) {System.out.println(new TestA() {public String toString(){return "test";}});}}
abstract class MyType implements Serializable, Runnableinterface C extends Runnable, Serializable {}interface X {/* public static final */ int i = 5;}interface X {/* public static final */ int i ;} não compila. variavel de interface é final e é preciso inicializa-la implicitamente
public interface IInt{ int thevalue = 0; }public class Sample implements IInt{...Sample s = new Sample();int j = s.thevalue;int k = IInt.thevalue;int l = thevalue;int m = Sample.thevalue;
StringBuffer sb = new StringBuffer();sb.append("Caelum");sb.append(" - ");sb.append("Alura - Casa do Código"); //// Caelum - Alura - Casa do Códigosb.append(false) funciona: Caelum - Alura - Casa do Códigofalse criar objeto do tipo StringBuilder
StringBuffer sb = new StringBuffer(); //capacity = 16 (default)StringBuilder sb2 = new StringBuilder("java");StringBuilder sb3 = new StringBuilder(50) /* não converte p/ "50". É o tamanho inicial do array (length = 0)*/;StringBuilder sb4 = new StringBuilder(sb2);//nao compilaStringBuilder b = "rumble";utilizar qualquer outro tipo de primitivo não funciona
permite chamadas encadeadas : new StringBuffer().append("Caelum").append(" - ").append("Ensino e Inovação") // Caelum - Ensino e Inovação
sb.append("Caelum - Inovação"); //sempre insere no fimsb.append(" no mercado de trabalho ", 0, 11); //sempre insere no fim. Vai inserir apenas "Caelum - Inovação no mercado"sb.insert(9, "Ensino e "); // inserir coisas no meio com indice: Caelum - Ensino e Inovação. Insere no fim quando é passado pro indice o tamanho do StringBuildersb.delete(6, 15); //indice inicial e final (pode ser maior que o tamanho do SB, não da exception de SIOOBEx - Caelum e Inovaçãonew StringBuffer("guilherme").reverse(); //emrehliug
StringBuilder sb = new StringBuilder("12345678"); //capacity = 16 + 8= 24sb.setLength(5); //tamanho = 5 (12345)sb.setLength(10); //tamanho 10 (12345 ) c/ mais 5 espaços em branco
String implicit = "Java";String explicit = new String("Java");char[] name = new char[]{'J', 'a', 'v', 'a'};String fromArray = new String(name);String nameBuilder = new String(new StringBuilder("Java"));
"String".toCharArray() converte o string para um array de charString name = null; // explicit nullnew String(null);String s = null; String s2 = new String(s); "Certificação".startsWith("C"); retorna true/falseString nulled = null; System.out.println("value: " + nulled); /* value: null */ System.out.println(nulled + " value"); // null valueString name = "Java" + ' ' + "Certification" + ' ' + 1500; //Java Certification 1500String value = 15 + 00 + " certification"; \\ 15 certification
"".isEmpty(); /*true*/ " ".isEmpty(); /*false*/substring(beginIndex, endIndex); /* inclui o caractere da posição inicial mas não o da final */ subString(beginIndex); /*a partir do indice passado até o fim */"Java".substring(0, 4); /*Java*/ "Java".substring(0, 3)); /*Jav*/; //limite do endIndex é 4 nesse caso pois p/ descobrir o endIndex é 4-1 = 3 entao o substring vai de 0 a 3. Se beginIndex e endIndex for igual, nao retorna nada e nao da erro.replace(oldChar, newChar); /*substitui todas as ocorrências de um char por outro*/replace(CharSequence target,CharSequence replacement); //atenção: não existe replace sobrecarregado c/ (String, char) ou (char, String). É case sensitivetrim() /*limpa os caracteres brancos das duas pontas do String. SB não tem trim() */"Certification".compareTo("certification"); /* -32 lexicográfico: minusculas são maiores que maiusculas. C < c retorna valor -. Contrário retornaria + */
"guilherme".charAt(20); "guilherme".charAt(-1);String $s = 1 + "" + false + "" + 'a';new String("b") + new StringBuilder("a"); ou new StringBuilder("a") + new String("b"); 
:ss.zzz:ss.zzz2015-02-15T21:32:51.3462015-W07-72015-04620150215Period p = Period.ofDays(1).ofYears(2); // apenas ofYears(2) é usado java.time.format.*
DateTimeFormatException
List s2 = new ArrayList( s1.subList(1, 2) ); //criando uma lista a partir de uma sublista
Client cliente = new Client(); cliente.setName(“John”);
clients.add(cliente); //retorna boolean: true se a lista foi alterada
names.add(“Certification”);names.add(0, “java”); //padrão adiciona no fim. Com indice, adiciona na posição. cuidado c/ a ordem dos parametros
names.contains(“java”); //true
names.remove(“java”) /true, encontra e remove /; names.remove(0) /remove e retorna Certification/; //só remove a primeira ocorrencia daquele objeto
names.size(); //1
Object[] objectArray = names.toArray(); //converte p/ array do Object, não de String
String[] names2 = names.toArray(new String[0]); //cria um array de String, menor. Se o tamanho não é suficiente, cria um novo array do mesmo tamanho
String[] names3 = names.toArray(new String[names.size()]); //cria um array de String, tamanho suficiente p/ os elemntos
ArrayList
ArrayList
names.get(0) /Certification/; clients.get(0).getName()); // John
cliente.setName(“Mayer”); clients.get(0).getName()); // Mayer
names.set(0, “certification”); //altera elemento da posição e retorna o elemento que foi alterado
names.indexOf(“certification”)); // retorna a primeira posição do elemento passado, se não acha, retorna -1
names.lastIndexOf(“john”)); // retorna a última posição do elemento, Se não acha, retorna -1
names.lastIndexOf(“john”,6)); // retorna a última posição do elemento, a partir da posição 6. Se não acha, retorna -1
Collection
Iterator
while (iterator.hasNext()) { //retorna booleano indicando se ainda há elementos p/ percorrer na coleção passada
String current = iterator.next(); //pula p/ o proximo elemento, devolvendo-o
System.out.println(current);
}
#### Write a simple **Lambda** expression that consumes a **Lambda Predicate** expression- trecho de código que pode ser passado como *parametro* para um método ou armazenado numa *variável*- *interface funcional* apenas com 1 método abstract mas pode ter métodos static ou default- uma classe que implementa interface funcional continua sendo classe e não pode ser usada com lambda- *Predicate* interface q recebe um *objeto* e retorna um *boolean*- é generificada. É necessário sempre passar o <Tipo>- `import java.util.function.*;````javaPredicate<Person> matcher = new Predicate<Person>() { //classe anonima@Overridepublic boolean test(Person p) {return p.getAge() >= 18;}};class PersonFilter{public List<Person> filter(List<Person> input,Predicate<Person> matcher){List<Person> output = new ArrayList<>();for (Person person : input) {if(matcher.test(person))output.add(person);}return output;}}List<Person> adults = new PersonFilter().filter(persons, matcher);
lambda + Predicate: precisa de 1 parametro e o código deverá ser uma expressão que retorna um boolean
( parameters ) -> { code }
Predicate<Person> matcher = (Person p) -> {return p.getAge() >= 18;};Predicate<Person> matcher = p -> p.getAge() >= 18;List<Person> adults = pf.filter(persons, p -> p.getAge() >= 18);
Runnable r = () -> System.out.println("a runnable object!");
int a = b = c = 100; //não compilaint b, c; int a = b = c = 100; //compila e roda pois as variaveis foram declaradas inicialmente e depois inicializadas em cadeia em outra instrução
int numbers[] = new int[10]; numbers[0]; //0char c = 'A';char c = 65; //Achar c = '\u03A9'; // unicode :letra omega int i = 0761; double d = 3.1E2 /*310.0*/; float f = 1E4F /* 10000.0f*/;double d = 4. 4. pode ser usado como double = 4.0int a = 123_456_789; A mesma regra vale p/ pontos flutuantesint b1 = 0b_1; \\não compilaint x = 1____3; compila: podemos colocar multiplos underscoresint a = -0; é permitidochar \u0062 = 'a'; \u0062 é bch\u0061r c = 'a'; funciona
abstract assert boolean break byte case catch char class const continue default do double else enum extends false final finally float for goto if implements importint 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
Car a = new Car(); a.age = 5; Car b = new Car();b.age = 5;Object c = a; a==b /*false*/; a==c; //true Person p; /*nao criado*/ p = new Person(); //criadonew Person() /*apenas criado, inacessível*/; Person p = new Person(); //acessívelp =null;. System.gc(); sugere a JVM o GC, que pode ignorar. Não é garantidovoid finalize() da classe Object é chamado qdo o objeto é coletado. Pode sobreescreve-lo para determinar ações quando o objeto é coletadonew Character(´d´);Character c = new Character(´d´); char c2 = c.charValue() converte para char apesar que o unbox tbm faz issocriando
numéricos
Double d1 = new Double(22.5);Double d2 = new Double("22.5");Double d3 = 1; //não compila. boxed de int somente p/ IntegerDouble d4 = 1.0;Integer.valueOf(1);Integer i = 1234;new Double(null);//NPexceptionnew Double(); //não compila. Não existe construtor de wrappers s/ argumentosShort _s = new Short(1); //não compila. 1 é int. O argumento deverá ser short ou um casting ´p/ short
NumberFormatException
int i = Integer.parseInt("12.3"); 12.3 não trunca p/ 12
Boolean
new Boolean(true); new Boolean("true"); new Boolean("TRue") ; //truenew Boolean("T"); new Boolean(null); //falsenew Boolean(); //não compila. Não existe construtor de wrappers s/ argumentos
convertendo
new Long("123").doubleValue(); //convertendo Long para doubledouble d = Double.parseDouble("123.00");int i = Integer.parseInt("12.3"); // 12.3 não trunca p/ 12 NumberFormatExceptionchar one = Integer.parseInt("1"); não compila: conversão de int p/ charint i6 = Integer.parseInt("FF",16); //255 HexaInteger i2 = Integer.valueOf("5AF", 16);String number = Integer.valueOf(256).toString();String l = Long.toString(20, 16);String hexString = Long.toHexString(11); // B, HexadecimalAutoboxing compilador é responsável por transformar os wrapper em primitivos (unboxing) e primitivos em Wrappers (boxing)
Integer intWrapper = Integer.valueOf(1);intWrapper++; //will unbox, increment, then box again.boolean isValid = new Boolean (true)
Float f = 1; não compila não é permitido promoção de primitivo e autoboxing em seguidacomparando
Integer i1 = 1234;Integer i2 = 1234; i1 == i2 /*false (duas ref apontando p/ obj dif)*/; i1.equals(i2) /*true*/;
Integer x = 400;Integer y = x;x++; //x e y agora apontam p/ objetos diferentes e y não é incrementado
Integer i1 = 123; Integer i2 = 123; i1 == i2 /*true*/; i1.equals(i2)) /*true*/ ;Integer a = null; int b = 44; a + b; //throws NPEint[] age; e suas variações
int[] i, j; //i e j são arrays de intint i[], j; //somente i é um array de int. j é int
int[] ages = new int[10];
int i = 4;int ia[][][] = new int[i][i = 3][i]; //dimensão = 4,3,3
int[] numbers = new int[]{1,2,5,7,5};int y[] = new int[3] {0,3,5}; //não compilaCar[] cars = new Car[]{new Car(), null, new Car()}; int[] numbers = {1,2,5,7,5};String[] sa = { }; array de tamanho 0Object obj = new int[] { 1, 2, 3 }; int[] someArray = (int[])obj;
int nums[][] = new int[3][3];nums[0] = new int[2]; //ok
int[][] ints = new int[3][2]; ints[2] ={1,2,3}; não compilanumbers[0] = 10; numbers[-1];
abstract class Exam {}class PracticalExam extends Exam {}class TheoreticalExam extends Exam {}class Test {public static void main(String[] args) {Exam[] exams = new Exam[2];exams[0] = new TheoreticalExam();exams[1] = new PracticalExam();}}
int[] values = new int[10]; long[] vals = values; // compile errorObject[] values= new Object[2] values[0] = "Certification"; String[] vals = (String[]) values;
void m(int i[]){}m(new int[]{1,2,3});
int[][] table;int[][] cube[]; // Um array de três dimensões.int[] [][]hipercube[]; // Um array de quatro dimensões.
int[][] table = new int[10][15];int[][][] cube = new int[10][][];
int[][] weird = new int[2][]; weird[0] = new int[20]; weird[1] = new int[10];int[][][] weird = new int[2][][]; weird[0] = new int[20][]; weird[0][0] = new int[2];
int[][] test = new int[][]{{1,2,3},{3,2,1},{1,1,1}};
short b[][] = new short[4][4];short b2 [][][][] = new short[2][3][2][2]b2[1][1] = b; //b2[1][1] possui 2 dimensoes e b tbm
table[0][1];default qdo modificar métodos default - apenas usar nenhum modificador já é suficiente.void nothing(int i) {if(i >= 0) return; System.out.println("negative");}throw new RuntimeException() Cobrir tudoreturn null apenas quando o tipo de retorno é um objeto. Não compila como retorno com tipos primitivos
public static void method(Object o){System.out.println("Object Version"); }public static void method(java.io.FileNotFoundException s){System.out.println("java.io.FileNotFoundException Version");}public static void method(java.io.IOException s){System.out.println("IOException Version");}...method(null); //vai ser chamado o FileNotFoundException que é o mais específico
void m(double a, double b){}void m(Integer a, Integer b){}m(1,2); // chama o método c/ double
static boolean check(short x)check(10); //não compilacheck((short) 10); //compilashort s = 10; //apesar disso, a atribuição funciona
StaticTest.m1();new Test().method((Object) "random");
void method(int i, double x) {} // okvoid method(double x, int i) {} // oknew Test().method(2.0, 3); // double, intnew Test().method(2, 3.0); // int, doublenew Test().method(2, 3); // compile errorvoid method(Object o, String s) {System.out.println("object");}void method(String s, Object o) {System.out.println("string");}new Xpto().method("string", "string"); // compile error
metodo(String[]... args) varargs de arrays
void probe(int... x) { System.out.println("In ..."); } //1void probe(Integer x) { System.out.println("In Integer"); } //2void probe(long x) { System.out.println("In long"); } //3void probe(Long x) { System.out.println("In LONG"); } //4...Integer a = 4; new TestClass().probe(a); //chama o método 2int b = 4; new TestClass().probe(b); //chama o método 3 (promoção tem prioridade em relação a unbox/box e varargs
public void go(int x, String... y) {System.out.print(y[y.length - 1] + " ");}//referenciandonew Main().go( 2, "hi", "world");
void yingyang(Integer[] ints) {void yingyang(Integer... ints) { //nao compila
não precisa ter um objeto instanciado da classe. Apenas seu nome
public class Rope {public static void swing() {}Rope r = null;r.swing();// não gera NPEx. a chamada é automaticamente mudada p/ Rope.swing()
não usar um método/atributo de instancia dentro de um método static
public class Car{private int weight;public static int getWeight() {return weight; /*compile error*/}}
static int b = getMethod() /*0*/; public static int getMethod() {return a /*0, a ainda nao inicializada*/; } static int a = 15;static int idade = grabAge(); static int grabAge() { return 18;} class A { /* implicito*/ A() {super();} /*default*/} String lastname = “Silveira”; //mudando a ordem das variaveis membro
int length = getLength();
int getLength() {return lastname.length();} //compila e roda
- as variaveis membro do filho ainda possuem os valores default na criação da instancia Pai durante a criação do filho```javaclass A{A() { print(); }...class B extends A{int i = 4;void print() {System.out.println(i); }...A a = new B(); //new B() chama super() que é a criação do pai. Durante a criação do pai é chamado o print do objeto que imprime o this.i (do objeto) que nesse momento esta com valor default (0), não foi inicializado com 4 que é somente qdo termina de construir B
Test() {new Test(); // StackOverflow} class Test {public Test() {} public Test(int i) {}}class Test {public Test() {System.out.println("simple");}public Test(int i) {this(); /*simple*/}}Test() {this(value());} private static String value() {return "value...";} Test(String s) {System.out.println(s);}
package a;public class AccessTest {protected void c(){ }}package b;import a.AccessTest;public class AccessTester extends AccessTest{public static void main(String[] args) {AccessTest ref = new AccessTest();// ref.c(); não compila pois c() só é visível por quem estenda AccessTestAccessTester ref2 = new AccessTester();ref2.c(); //compila e roda pois ref2 é referencia p/ um objeto q estende AccessTest}}
- **default** *package private* visivel apenas dentro do mesmo pacote.- Mesmo com *import*, as classes default não são visíveis.- Se existem outras classes publicas no import, não ocorre erro na linha do import. Se importar especificamente uma classe default, o erro tbm é na instrução do import- **private** só podem ser acessadas de dentro da classe- atributos final precisam ser inicializados na declaração, no bloco de inicialização ou no construtor (quando é atributo de instancia)
public class Student{ArrayList<Integer> scores;public ArrayList<Integer> getScores(){return new ArrayList(scores);}
try {System.out.println("SQLException");} catch(SQLException e){//não compila try {new FileInputStream("a.txt");} catch(FileNotFoundException e){ // tratamento de FileNotFoundException.}try {System.out.println("Ok");} catch (RuntimeException e)
try { // code}catch (ExceptionType1 | Exceptiontype2 ex){ //ex é implicitamente final e não pode receber atribuiçoes dentro do catch// catch block}
catch(MyException me){System.out.println(me); } imprime apenas o nome da exception e a mensagem (se houver)catch(MyException me){me.printStackTrace(); } ira retornar o nome da exception, uma mensagem (se houver) e também todos os métodos chamados com as linhas de código respectivasSystem.exit(0); dentro de um bloco try ou bloco try com finally
public static void methodX() throws Exception { throw new AssertionError(); } //o throws pode ser lançado mesmo de forma desnecessária
class FileAccess {private InputStream is = new FileInputStream("input.txt");FileAccess() throws IOException{}}throw new RuntimeException() jamais será executadothrow null ira compilar mas gerar uma NullPointerExceptionclass FundoInsuficienteException extends Exception{} p/ serem lançadasvocê pode utilizar o throws de uma Exception mesmo que o bloco do código jamais lance essa exception
public void m() throws java.io.IOException{System.out.println("ok");}
void m() throws IOException{throw new FileNotFoundException();}
throws new RuntimeException() errado. O correto é throw new RuntimeException()static import. O correto é import staticif (false) ; else ; //compila if (true) else; //não compila : uma instrução não pode começar c/ else if(true) if(false); //compilado{}while(condicao); //erro de compilação case default: . É default: apenas unreachable code
while (false) { x=3; } Não compilafor( int i = 0; false; i++) x = 3 não compila
switch(“guilherme”) case “guilherme” : …; case “42”: …; case default …; compila e roda s/ problemas
if (false) { x=3; } Compila sem problemasfor( int i = 0; i< 0; i++) x = 3; compila e rodado{ x = 3; } while(false); compila e roda
- componente independente do arquivo (como interface ou outras classes)```javaenum Days {M, T, W, TH, F, SA, SU };for (Days d : Days.values()) //Days.values() retorna um array de DaysSystem.out.printf("%1$s", d);System.out.printf("%n %1$b %n %2$b", Days.M == Days.M, Days.M.equals(Days.M)); //permitido usar == e equals sem problemas
inicialização das variaveis membros
A a = new B()
- 1º : inicialização de atributos e blocos static na ordem que aparecem no código- inicializa apenas membros static- executado apenas uma vez mesmo quando não há criação de instancia- 2º : inicialização de atributos e blocos non-static na ordem que aparecem no código- métodos chamados c/ new- pode tbm inicializar membros static mas não tem preferência de ordem- 3: construtores- não importa se o bloco static/non-static vem antes da declaração das variaveis membros- blocos podem ter variaveis locais que escondem a vasriavel membro
static int x = 2;
static {int x = 3} //somente dentro desse bloco o x=3
```
System.exit() para de executar o programa
native: chama métodos escritos em outras linguagens.
Math
java.lang.Math.*int randomNum = (int)(Math.random() * 101); // 0 to 100Scanner
Scanner myObj = new Scanner(System.in); // Create a Scanner objectSystem.out.println("Enter username");String userName = myObj.nextLine(); // Read user input (String only)System.out.println("Username is: " + userName);
File Handling
File
/Users/name/filename.txt // mac/linux
canRead() Boolean Tests whether the file is readable or not
FileWriter
FileWriter myWriter = new FileWriter("filename.txt");myWriter.write("Files in Java might be tricky, but it is fun enough!");myWriter.close();
File myObj = new File("filename.txt");Scanner myReader = new Scanner(myObj);while (myReader.hasNextLine()) {String data = myReader.nextLine();System.out.println(data);}myReader.close();
Threads
problemas de concorrência
//criando Thread extendendopublic class Main extends Thread {public void run() {System.out.println("This code is running in a thread");}}//criando implementando Runnablepublic class Main implements Runnable {public void run() {System.out.println("This code is running in a thread");}}//running classe q extendeMain thread = new Main();thread.start();//running classe q implementa RunnableMain obj = new Main();Thread thread = new Thread(obj);thread.start();
Inner Classes
class InnerClass {
int y = 5;
}
public static class Point {} //static inner class
public static void main(String[] args){
class Local{} //classe localOuterClass.InnerClass myInner = new OuterClass().new InnerClass(); //inner classOuterClass.Point point = new OuterClass.Point();Local local = new Local();
}
}
- Inner Interfaces```javapublic class Shoot {interface Target {boolean needToAim(double angle);}}
Collections
Arrays
Arrays.asList(5, 10, -5, -10); também funciona [–10, –5, 5, 10]; Collections.binarySearch(numberList, 4); deveria estar na posição 2 => -2 - 1: retornará -3Collection
HashMap
HashMap<String, String> capitalCities = new HashMap<String, String>();capitalCities.put("England", "London");System.out.println(capitalCities);capitalCities.get("England");capitalCities.remove("England");capitalCities.clear(); //remove all items
HashSet
HashSet<String> cars = new HashSet<String>(); cars.add("Volvo");se a.equals(b) então a.hashCode() == b.hashCode()