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");
}
}
//Wenn Sie einen Konstruktor in einer Superklasse vorbereiten, wird er in einer abgeleiteten Klasse immer von einem Super aufgerufen. Wenn jedoch kein Argument vorhanden ist, wird er explizit aufgerufen.
//Es ist nicht notwendig und es ist in Ordnung, den Konstruktor der Superklasse aufzurufen, wenn Sie mit diesem usw. zu einem anderen Konstruktor wechseln.
class spclass {
int A=1000;
spclass(String s){
System.out.println("Super Klassenkonstruktor");
}
}
class konsutoTest extends spclass{
int A=1000;
konsutoTest(){
this("s");
System.out.println("Abgeleiteter Klassenkonstruktor");
}
konsutoTest(String s){
super("s");
System.out.println("Abgeleiteter Klassenkonstruktor");
}
}
interface intaTest{
public void process(); //Öffentlich, wenn dem Modifikator nichts zugeordnet ist
}
class Sample implements intaTest{
public void process(){}; //Du musst öffentlich oder stark sein
}
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 {
//Überprüfung des Standardkonstruktors
new konsutoTest();
//Polyforismus
//Setzen Sie eine Instanz von B in A, aber am Ende ist die Instanz von B nur der Unterschied von A.
//Wenn Sie es in das Feld von A legen, können Sie nur das Ding von A sehen, aber die überschriebene Methode spiegelt sich in A wider
//Da der Wert des Feldes entsprechend der Box ausgegeben wird, sollten Sie vorsichtig sein, wenn er überschrieben wird, wenn ein Problem mit der Politik vorliegt.
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!
//Datumsproblem
//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;//Klein bis groß ist in Ordnung
fff=(float)ddd;//Besetzung von groß nach klein
ddd=iii;
iii=(int)ddd;//Beim Casting werden die Ziffern gelöscht
double v=10.0+10;//int geht in double
long l=10+10;//Weil sich der int-Typ implizit in LONG ändert
lll=lll+iii;//Es ist okay, weil long auch int enthält
System.out.println("StringBuilder<StringBuilder> =Ursprünglicher Wert" + stb.toString() +"StringBuilder<StringBuilder> =Nummer" +stb.length());//NULL, da es sich um einen Referenztyp handelt
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<>();//Nein, da es eine Typenbezeichnung gibt
ArrayList list2 = new ArrayList();//Alles ist in Ordnung, da es generisch ist und kein Typ angegeben ist
System.out.println("ArrayList<Integer> =" + ALL2);//NULL, da es sich um einen Referenztyp handelt
System.out.println(list);//Da es sich um einen Referenztyp handelt, NULLt. Wenn jedoch eine Instanz erstellt wird, wird [] eingegeben.
ll.add(10);
list.add("10");
list2.add('B');
System.out.println(ALL2);//NULL, da es sich um einen Referenztyp handelt
System.out.println("ArrayList<Integer> =" + ll);//NULL, da es sich um einen Referenztyp handelt
System.out.println("ArrayList<String>=" + list);//Da es sich um einen Referenztyp handelt, NULLt. Wenn jedoch eine Instanz erstellt wird, wird [] eingegeben.
System.out.println("Zeichenfolge=" + stt);//NULL, da es sich um einen Referenztyp handelt
System.out.println("Array=" + ALL);//Da es sich um einen Referenztyp handelt, NULLt. Wenn jedoch eine Instanz erstellt wird, wird [] eingegeben.
System.out.println(bl);
System.out.println(bll[0]);
System.out.println(bll.length + "← Anzahl der Arrays Inhalt" + bll[0]);//Sie können die Nummer nur mit der Instanz des Arrays abrufen. Der Inhalt wird mit 0 initialisiert.
System.out.println(args);//Argumente müssen int sein[0]Machen Sie einen Hash-Code mit 0
//Außergewöhnliche Praxis
Main.test();
System.out.println("XXXXXXXX");
}
catch(RuntimeException e){
System.out.println(e);
}
catch(Exception e){
System.out.println("Nicht erreichbar");
}
}
public static void RuntimeExceptionTest()
{
//Ungeprüfte Ausnahme: Sie müssen es nicht werfen, sondern beim Anrufer abfangen
//Es ist nicht notwendig, es zu beschreiben.
if(2==1)
{
throw new RuntimeException();
}
else{
throw new NullPointerException();
}
}
public static void test() throws Exception
{
//throw wirft dem Anrufer einen Fehler zur Verarbeitung durch den Anrufer
st=100;
if(1==1)
{
throw new RuntimeException();
}
else
{
throw new Exception();
}
}
}
Recommended Posts