import java.util.*;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.time.*;
import java.time.format.*;
class A{
int A=100;
public void test(){
System.out.println("testA");
}
public void test2(){
System.out.println("test2");
}
}
class B extends A{
int A=1000;
public void test(){
System.out.println("testB");
}
public void test3(){
System.out.println("test3");
}
}
class c extends A{
int A=1000;
public void test(){
System.out.println("testc");
}
public void test4(){
System.out.println("testc");
}
}
//Si vous préparez un constructeur dans une super classe, il sera toujours appelé par un super dans une classe dérivée, mais s'il n'y a pas d'argument, il sera appelé explicitement.
//Ce n'est pas nécessaire, et il est correct d'appeler le constructeur de la super classe lors du passage à un autre constructeur avec ceci, etc.
class spclass {
int A=1000;
spclass(String s){
System.out.println("Constructeur de super classe");
}
}
class konsutoTest extends spclass{
int A=1000;
konsutoTest(){
this("s");
System.out.println("Constructeur de classe dérivée");
}
konsutoTest(String s){
super("s");
System.out.println("Constructeur de classe dérivée");
}
}
interface intaTest{
public void process(); //Public si rien n'est attaché au modificateur
}
class Sample implements intaTest{
public void process(){}; //Vous devez être public ou fort
}
public class Main {
protected static int st;
protected static boolean bl;
protected static int[] bll;
protected static String stt;
protected static ArrayList ALL;
protected static ArrayList ALL2;
protected static StringBuilder stb=new StringBuilder(5);
public static void main(String[] args) throws Exception {
//Examen du constructeur par défaut
new konsutoTest();
//Polyforisme
//Mettez une instance de B dans A, mais à la fin l'instance de B n'est que la différence de A
//Si vous le mettez dans la case de A, vous ne pouvez voir que la chose de A, mais la méthode remplacée est reflétée dans A
//La valeur du champ est sortie en fonction de la boîte, donc soyez prudent si elle est remplacée si vous avez un problème avec la politique.
A a=new B();
a.test();
a.test2();
System.out.println(a.A);
B b=(B)a;
b.test3();
System.out.println(b.A);
// Your code here!
//Problème de date
//LocalDateTime date = LocalDateTime.of(2015,9,15,1,1);
LocalDate date = LocalDate.of(2015,9,15);
System.out.println(date);
System.out.println(date.format(DateTimeFormatter.ISO_DATE));
double ddd=10.1d;
float fff=10f;
int iii=100;
String sss;
long lll=10;
ddd=fff;//Petit à grand est OK
fff=(float)ddd;//Diffusez du grand au petit
ddd=iii;
iii=(int)ddd;//La diffusion laissera tomber les chiffres
double v=10.0+10;//int va en double
long l=10+10;//Parce que le type int change implicitement en LONG
lll=lll+iii;//Ce n'est pas grave car long contient également des int
System.out.println("StringBuilder<StringBuilder> =valeur initiale" + stb.toString() +"StringBuilder<StringBuilder> =nombre" +stb.length());//NULL car il s'agit d'un type de référence
try{
RuntimeExceptionTest();
}
catch(RuntimeException e){
System.out.println(e);
}
try{
bll=new int[3];
ArrayList<Integer> ll = new ArrayList<Integer>();
ArrayList<String> list = new ArrayList<>();//Non car il y a une désignation de type
ArrayList list2 = new ArrayList();//Tout est OK car il est générique et aucun type n'est spécifié
System.out.println("ArrayList<Integer> =" + ALL2);//NULL car il s'agit d'un type de référence
System.out.println(list);//Puisqu'il s'agit d'un type de référence, NULLt Cependant, lorsqu'une instance est créée, [] est entré.
ll.add(10);
list.add("10");
list2.add('B');
System.out.println(ALL2);//NULL car il s'agit d'un type de référence
System.out.println("ArrayList<Integer> =" + ll);//NULL car il s'agit d'un type de référence
System.out.println("ArrayList<String>=" + list);//Puisqu'il s'agit d'un type de référence, NULLt Cependant, lorsqu'une instance est créée, [] est entré.
System.out.println("chaîne=" + stt);//NULL car il s'agit d'un type de référence
System.out.println("tableau=" + ALL);//Puisqu'il s'agit d'un type de référence, NULLt Cependant, lorsqu'une instance est créée, [] est entré.
System.out.println(bl);
System.out.println(bll[0]);
System.out.println(bll.length + "← Nombre de tableaux Contenu" + bll[0]);//Vous pouvez obtenir le nombre uniquement avec l'instance du tableau. Le contenu est initialisé avec 0.
System.out.println(args);//args doit être int[0]Créer un code de hachage avec 0
//Pratique exceptionnelle
Main.test();
System.out.println("XXXXXXXX");
}
catch(RuntimeException e){
System.out.println(e);
}
catch(Exception e){
System.out.println("Pas atteignable");
}
}
public static void RuntimeExceptionTest()
{
//Exception non cochée: vous n'avez pas à le lancer, à l'attraper à l'appelant
//Il n'est pas nécessaire de le décrire.
if(2==1)
{
throw new RuntimeException();
}
else{
throw new NullPointerException();
}
}
public static void test() throws Exception
{
//jette une erreur à l'appelant pour traitement par l'appelant
st=100;
if(1==1)
{
throw new RuntimeException();
}
else
{
throw new Exception();
}
}
}
Recommended Posts