--Underbar (_) peut être utilisé pour les littéraux (avec les restrictions suivantes)
float f = 0.0f;
byte b = 0b1000000;
→ 128 en raison d'une erreur
byte b = (byte)0b1000000;
→-OK pour 128
int a = 1;
long b = a;
float f = 0.0f;
double d = f;
--Cast est requis pour l'affectation au type inférieur (downcast)
long a = 1;
int b = (int)a;
double d = 0.0;
float f = (float)d;
String a = "aaa"
String b = "aaa"
System.out.println(a == b);
→ true s'affiche
int num = 10;
if (num == 100)
System.out.println("A");
else if (num > 10)
System.out.println("B");
else
if (num == 10)
System.out.println("C");
else
if (num == 10)
System.out.println("D");
Interprétation du compilateur
int num = 10;
if (num == 100) {
System.out.println("A");
} else if (num > 10) {
System.out.println("B");
} else {
if (num == 10) {
System.out.println("C");
} else {
if (num == 10) {
System.out.println("D");
}
}
}
--Long et boolean ne sont pas inclus dans les types qui peuvent être passés à l'instruction switch!
//Forme basique
int [] a;
//Ce n'est pas bien
int [3] a;
--Ne définissez pas le nombre d'éléments et la valeur initiale en même temps lors de l'initialisation du tableau (erreur de compilation)
//Forme basique
int [] a = new int []{1, 2};
//Ce n'est pas bien
int [] a = new int [2]{1, 2};
//Forme basique
int [] a = new int []{1, 2};
//Ce n'est pas bien
int [] a;
a = {1, 2};
--Pas de précautions particulières
--Déclaration d'argument de longueur variable --Définissez comme suit
void sample(int... num) {
for (int i = 0; i < num.length; i++) {
System.out.println(num[i]);
}
}
void sampl(int... num, int pos) {
→ Erreur
}
public class Main {
int num;
private static void test() {
num++;
→ Erreur de compilation
System.out.ptintln(num)
}
public class Main {
public static void main(String [] args) {
Main m = new Main();
System.out.println(m.calc(2, 3));
→2,3 peut également être interprété comme un double par conversion de type implicite, donc
Je ne peux pas déterminer laquelle des méthodes surchargées appeler. .. ..
→ Erreur de compilation dans "Appel de méthode ambigu"
}
private double calc(double a, int b) {
return (a + b) / 2;
}
private duoble calc(int ak double b) {
return (a + b) / 2;
}
}
public class Main {
public Main() {
System.out.println("A");
this("B");
→ Erreur de compilation
}
public Main(String str) {
System.out.println("B");
}
public static void main(String [] args) {
Main m = new Main();
}
}
--protected peut être référencé dans des classes héritées (mais ne peut pas être appelé comme méthode d'instance) Bien sûr, il est probable que ce soit mal compris.
package other;
public class Book {
private String isbn;
public void setIsbn(String isbn) {
this.isbn = isbn;
}
protected void printInfo() {
System.out.println(this.isbn);
}
}
package pkg;
import other.Book;
public class StoryBook extends Book {}
package pkg;
public class Main {
public static void main(String [] args) {
StoryBook sb = new StoryBook();
sb.setIsbn("xxxx-xxxx-xxxx");
sb.printInfo();
→ Erreur de compilation
}
}
interface Worker() {
void work();
}
class Employee {
public void work() {
System.out.println("work");
}
}
class Engineer extend Employee implements Worker { }
public class Main {
public static void main(String [] args) {
Worker w = new Engineer();
→ le travail est sorti (aucune erreur de compilation ne se produit)
}
}
public class Main {
private static String name;
static {
if (name.length() == 0) {
→ longueur avec nom non initialisé()Provoque une erreur car vous avez appelé
name = "sample"
}
public static void main(String[] args){
System.out.println("hellow " + name);
}
}
--Pour le double try-catch-finally, la clause finally est toujours exécutée
public class Main() {
public static void main(String[] args) {
try {
try {
String[] array= {"a", "b", "c"};
System.out.println(array[3]);
} catch (ArrayIndexOuntOfBoundsException e) {
System.out.println("D");
} finally {
System.out.println("E");
→ exécuté
}
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("F");
} finally {
System.out.println("G");
→ exécuté
}
}
}
→"D E G"Est affiché
public class Main() {
public static void main(String[] args) {
System.out.println(test(null));
→ Afficher A
}
private static String test(Object obj) {
try {
System.out.println(obj.toString());
} catch (NullPointerException e) {
return "A";
→ A est mis sur la pile
} finally {
System.out.println("B");
→ Sortie B avant retour
}
}
}
→"B A"Est affiché
--Comment générer un objet String
String a = new String("sampl");
String b = "sample"
String c = String.valueOf("sample");
--Lorsque vous concaténez (+) un objet String auquel nul est attribué, il est converti en "nul" et concaténé.
String a = null;
a += "null";
System.out.println(a)
→"nullnull"Est affiché
--StringBulider gère les données en interne avec char [] et dispose d'un tampon de 16 caractères par défaut
StringBuilder sb = new StringBuilder("abcde");
System.out.println(sb.capacity());
→ 21 est souvent utilisé(16 caractères dans le tampon+5)
Concernant la syntaxe des expressions lambda --Si vous omettez la parenthèse du milieu dans l'expression lambda, le processus peut être décrit en une phrase. Pour le moment, le retour ne peut être décrit
Le retour ne peut pas être omis lorsque la parenthèse du milieu est décrite dans l'expression lambda.
Function f = str -> "hello " + str;
Function f = str -> { return "hello " + str };
--Une variable portant le même nom qu'une variable locale déclarée dans une méthode lambda ne peut pas être utilisée comme variable d'expression lambda
public class Main {
public static void main(String[] args) {
String val = "A";
Function f = (val) -> { System.out.println(val); };
→ Erreur de compilation
}
interface Function { void test(String val); }
→ Interface fonctionnelle
}
public class Sample {
public static void main(String[] args) {
int cnt = 0;
Runnable r = () -> {
for (cnt = 0; cnt < 10; i++) {
→ Erreur de compilation(Pas définitif. .. ..)
System.out.println(cnt++);
}
}
new Thread(r).start();
}
}
Recommended Posts