java的内部类

内部类：

成员内部类：就是类中的一个普通成员，就是普通的成员变量，成员方法

特点：内部类可以访问外部类的成员。

内部类的静态成员方法也是只能访问外部类的静态成员变量

创建：

  outer.inter in=new outer().new inter();

public class outer {
    private String name;
    int age=30;
//成员内部类
    class inter
    {
        private String name;
        int age=20;
        static int a;
        public static void print()
        {
            a=10;//可以访问外部类的成员
        }
        public void test()
        {
            int age=10;
            System.out.println(age);//10
            System.out.println(this.age);//20
            System.out.println(outer.this.age);//30
        }
        public inter() {
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
}

public class test {
    public static void main(String[] args) {
        outer.inter in=new outer().new inter();//注意
        in.setName("hh");
        in.test();
    }
}

静态内部类：有static修饰的内部类，属于外部类自己特有

特点：只能访问外部类的静态成员

创建：
 outer.inter in=new outer.inter();

public class outer {
    private int age;
    private static String Oname;
    public static class inter
    {
        private String name;
        public static int a;
        public void test()
        {
            //System.out.println(age);//Non-static field 'age' cannot be referenced from a static context
            //不能访问外部类的实例成员
            System.out.println(Oname);//可以访问外部类的静态成员
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public static int getA() {
            return a;
        }

        public static void setA(int a) {
            inter.a = a;
        }
    }
}

public class test {
    public static void main(String[] args) {
        outer.inter in=new outer.inter();//注意

    }
}

匿名内部类：特殊的局部内部类，程序员不用给这个类起名

这个匿名内部类编译成一个子类，然后会立即创建一个子类对象出来 

public class test {
    public static void main(String[] args) {
        //匿名内部类
        //1：把这个匿名内部类编译成一个子类，然后会立即创建一个子类对象出来
        animal a=new animal() {
            //在子类中重写抽象方法
            @Override
            public void cry() {
                System.out.println("miao");
            }
        };
        a.cry();
    }
}
abstract class  animal
{
    public abstract void cry();
}

匿名内部类通常作为一个参数传输给方法

public class test2 {
    public static void main(String[] args) {
        /*running r1=new running() {
            @Override
            public void run() {
                System.out.println("dog run");
            }
        };
        go(r1);*/

        go(new running() {
            @Override
            public void run() {
                System.out.println("dog run");
            }
        });
    }
    public static void go(running r)
    {
        r.run();
    }
}
interface running
{
    void run();
}

枚举类：

枚举类特点：

public enum A{

X,Y,Z;

}

枚举类的第一行只能罗列一些名称，这些名称都是常量，并且每个常量记住的都是枚举类的一个对象。

枚举类的构造器都是私有的，因此枚举类对外不能创建对象

枚举类都是最终类，不可以被继承

枚举类从第二行开始，可以定义类的其他各种成员

public enum A {
    X,Y,Z;
    
}

public class test {
    public static void main(String[] args) {
        //A a1=new A();//error,不能创建对象
        A a1=A.X;
        A a2=A.Y;

        A[]arr=A.values();//获取枚举类的所有对象
    }
}

抽象枚举：
 

public  enum mei {
//相当与new mei()-->匿名内部类，创建一个子类，最后会返回一个子类对象
    X() {
        @Override
        public void run() {
            System.out.println("run");
        }
    },Y("小明"){//有参构造
        @Override
        public void run()
        {
            System.out.println(getName()+"run");
        }
    };
    public abstract void run();
    private String name;

    mei() {
    }

    mei(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

枚举的应用：
用来表示一组信息，然后作为参数传输

泛型：

定义类，接口，方法时，同时声明了一个或多个类型变量

泛型的本质：把具体的数据类型作为参数传给类型变量 

public class mylist<E> {
    private Object []arr=new Object[10];//定义一个Object类数组（E是object类型）
    private int size=0;//记录当前位置
    public boolean add(E e)
    {
        arr[size++]=e;
        return true;
    }
    public E get(int index)
    {
        return (E) arr[index];
    }

}

 测试：

public class test {
    public static void main(String[] args) {
        mylist<String> list = new mylist<>();
        list.add("java");
        String e= list.get(0);
        System.out.println(e);

    }
}

泛型方法：

通配符：？，可以在使用泛型时表示一切类型

上下限：？extends animal:表示？能接收的必须是animal或者其子类

                ？super animla:表示？能接收的必须是animal或者其父类 

public class test {
    public static void main(String[] args) {
        String s=get("jj");
        System.out.println(s);
        ArrayList<animal> animals=new ArrayList<>();
        animals.add(new dog());
        animals.add(new cat());
        go(animals);
        
    }
    public static <T>T get(T e)
    {
        return e;
    }
   /* public static <T extends animal> void go(ArrayList<T>animals)
    {
        
    }*/
    //？ 通配符，在使用泛型的时候代指一切类型 ？extend animal(上限)
    public static void go(ArrayList<? extends animal>animals)
    {
        
    }
}

class animal
{
    
}
class dog extends animal{
    
}
class cat extends animal{
    
}

 注意：

泛型是工作在编译阶段的，一旦程序被编译成class文件，class文件就不存在泛型了，这就是泛型消除。

泛型不支持基本数据类型，只能支持对象类型（引用数据类型）