java内部类以及为什么要用public static void修饰main()函数，String args[]是什么？（浅显的一些探索）

class Outer{
  class Inner{
  //非静态成员内部类
    }
    static class Inner_1
    {
  //静态成员内部类
    }
  public static void main(String args[]){
  /*.........*/
  }
  }

package java_practice;
public class OuterandInner {
    private byte b = 1;
    static String country = "china";
    String home = "shanxi";
    public void systemdemo() {
//        System.out.println(Inner.this.name);//这样是不可以的。
    }
    public String author = "jgdabc";
    class Inner {
        String name = "jgdabc";
        //        static String name_1 = "";//这样不允许
        private String password = ".....";
        public void systemdemo() {
            System.out.println(OuterandInner.this.author);
            System.out.println(author);
            System.out.println(Inner_1.age);
//            System.out.println(name_1);//这样访问不了
            System.out.println(b);//非静态内部类可以访问到外部私有化成员
        }
    }
    static class Inner_1 {
        public static void showdemo() {
            //.....
//            System.out.println(Inner.name);//这样不可以
//            Inner inner = new Inner();//不可以这样去new,因为没有main方法
//            System.out.println(b);//静态局部内部类是不能访问到外部类私有成员的
            System.out.println(country);
        }
        String name_1 = "jgdabc_1";
        private String password_1 = "lmddkskk";
        static int age = 19;
        public void systemdemo() {
//            System.out.println(OuterandInner.this.author);//这样是不可以的
            System.out.println(OuterandInner.country);//这样可以访问，并且直接通过类名进行访问
        }
    }
    public static void main(String args[]) {
        System.out.println("......");
        OuterandInner outerandInner = new OuterandInner();
//        System.out.println(outerandInner.name);//访问不到内部类成员
//        System.out.println(name);//
        System.out.println(outerandInner.author);//自己的成员变量直接可以通过实例访问
        Inner inner = outerandInner.new Inner();
        System.out.println(inner.name + inner.password);
//        Inner inner1 = new Inner();//动态的外部类不能被直接在外部类new()
//        System.out.println(name_1);//不能访问
        OuterandInner outerandInner1 = new OuterandInner();
//        System.out.println(outerandInner1.name);//不能访问
        Inner_1 inner_1 = new Inner_1();//静态的可以直接进行new实例化
        System.out.println(inner_1.name_1 + inner_1.password_1);
        System.out.println(Inner_1.age);//直接通过类名来调用静态成员内部类的静态成员
//        System.out.println(Inner_1.name);//这样是不可以的
        Inner_1.showdemo();//也可以直接通过类名调用静态成员内部类的静态方法。
    }
}

// An highlighted block
        Inner inner = outerandInner.new Inner();

public void systemdemo() {
        class demo_test {
            int age = 19;
            public int id = 123;
//          static String name= "hello";//不可以有静态修饰的成员
//            static void system_demo()
//            {
//                //不可以这样用
//            }
            private String password = "";
            public void show_demo() {
                System.out.println("我是局部内部类");
                   System.out.println(home+b+password);//可以访问到外部类的成员，即便是私有的。
            }
        }
        demo_test demo_test = new demo_test();
        demo_test.show_demo();
//        System.out.println(Inner.this.name);//这样是不可以的。
    }
//    new demo_test();//这样是不可以的

package java_practice;
class demo{
    public void demo()
    {
        System.out.println("demo");
    }
}
public class AnonymousInner {
    public static void main(String args[])
    {
        new demo(){
            public void demo()
            {
                System.out.println("demo重写");
            }
        }.demo();
    }
}

package java_practice;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapDemo01 {
    public static void main(String args[])
    {
        TreeMap tm = new TreeMap<String,String>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //。。。
            }
        });
        tm.put("Hello","world");
        String  set = String.valueOf(tm.keySet());
        System.out.println(set);
        System.out.println(set.getClass());
        System.out.println(set);
    }
}

package java_practice;
public class Student implements Comparable<Student>{
    private int age;
    private String name;
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public String getName() {
        return name;
    }
    @Override
    public int compareTo(Student s) {
        int num = this.age - s.age;
        int num2 = num == 0 ? this.name.compareTo(s.name) : num;
        return num2;
    }
}

package java_practice;
import java.util.Comparator;
import java.util.TreeSet;
public class TreeSetDemo1 {
    public static void main(String args[]) {
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });
        Student s1 = new Student(29, "西施");
        Student s2 = new Student(28, "王昭君");
        Student s3 = new Student(30, "貂蝉");
        Student s4 = new Student(33, "杨玉环");
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        for (Student s : ts) {
            System.out.println(s.getName() + "" + s.getAge());
        }
    }
}

package java_practice;
interface Demo_{
    void demo_d();
}
class Demo_im implements Demo_
{
    @Override
    public void demo_d() {
        System.out.println("实现demo_");
    }
}
public class Demo_de {
    public static void main(String args[])
    {
        Demo_im demo_im = new Demo_im();
        demo_im.demo_d();
    }
}

package java_practice;
interface Demo_{
    void demo_d();
}
public class Demo_de {
    public static void main(String args[])
    {
        Demo_ demo= new Demo_(){
            @Override
            public void demo_d() {
                System.out.println("匿名实现接口");
            }
        };
        demo.demo_d();
    }
}