泛型，内部类

泛型的意义：

1，自动进行类型的检查

2，自动进行类型的转换

泛型的一些重点：

1，泛型时怎么编译的？ 擦除机制–Object

2，泛型的类型 不参与类型的组成

3，泛型的参数不能是简单类型

看一个简单的泛型示例：

class MyArrayList {

public T[] elem;
public int usedSize;

public MyArrayList() {
    this.elem =(T[]) new Object[10];
}
public void push(T val) {
    this.elem[this.usedSize++] = val;
}
public T get() {
    return this.elem[0];
}

}
public class TestDemo {
public static void main(String[] args) {
MyArrayList myArrayList = new MyArrayList<>();
myArrayList.push(1);
myArrayList.push(2);
int val = myArrayList.get();
System.out.println(val);
MyArrayList myArrayList2 = new MyArrayList<>();
System.out.println(myArrayList);
System.out.println(myArrayList2);
}

}
然后是泛型类的上界是什么？写成静态方法怎么写

class GenericAlg {
// 泛型的上界 ， T实现了Comparable的接口
//或者说Comparable实现了Comparable本身
public T maxValue(T[] array) {
T max = array[0];
for (int i = 0; i < array.length; i++) {
if (array[i].compareTo(max) > 0) {
max = array[i];
}
}
return max;
}
}
//静态方法：
class GenericAlg2 {
// 泛型的上界 ， T实现了Comparable的接口
//或者说Comparable实现了Comparable本身
public static<T extends Comparable> T maxValue(T[] array) {
T max = array[0];
for (int i = 0; i < array.length; i++) {
if (array[i].compareTo(max) > 0) {
max = array[i];
}
}
return max;
}
}
public class TestDemo2 {

public static void main(String[] args) {
    Integer[] array = {1,3,5,7,9};
    System.out.println(GenericAlg2.maxValue(array));
    System.out.println(GenericAlg2.<Integer>maxValue(array));
    //不写Integer会根据实参类型判断
}

public static void main1(String[] args) {
    Integer[] array = {5,2,4,9,7,6,3,8};
    GenericAlg<Integer> gla = new GenericAlg<>();
    System.out.println(gla.maxValue(array));

    GenericAlg2.maxValue(array);

}

}
通配符：？ （通常出现在源码中）看差别 通配符：源码当中

泛型的区别：

1，通配符一般用于读取

2，通配符不仅有上界 <? extends 上界> 还有下界 <? super 下界>

class MyPrint {
public void printf(ArrayList list) {
for (T val : list) {
System.out.print(val+" “);
}
}
}
class MyPrint2 {
public void printf(ArrayList<?> list) {
for (Object val : list) {
System.out.print(val+” ");
}
}
}
边界问题：

只接受 Number 的子类型作为 E 的类型实参

没有指定类型边界 E，可以视为 E extends Object

public class MyArrayList {
…
}
MyArrayList l1; // 正常，因为 Integer 是 Number 的子类型
MyArrayList l2; // 编译错误，因为 String 不是 Number 的子类型
父子类型：

<>里面的东西不参与类型的组成，虽然Object是Number的父类，但在泛型上就不是了

需要使用通配符来确定，<?>会被擦除为

public class MyArrayList { … }
// MyArrayList 不是 MyArrayList 的父类型
// MyArrayList 也不是 MyArrayList 的父类型
// 需要使用通配符来确定父子类型
// MyArrayList<?> 是 MyArrayList<? extends Number> 的父类型
// MyArrayList<? extends Number> 是 MyArrayList 的父类型
内部类：1，实例内部类 2，静态内部类3，匿名内部类 4，本地内部类

1，实例内部类

实例数据成员是什么？普通的成员属性不加static
如何拿到一个实例内部类对象？

不能在实例内部类当中定义一个静态变量，

class OuterClass {
public int data1;
private int data2;
public static int data3;
//实例内部类InnerClass
class InnerClass {
public int data4 = 4;
//public static int data5 = 5;
//不能在实例内部类当中定义一个静态变量，
//实例内部类相当于外部类的普通的成员变量
public static final int data5 = 5;
//被final修饰的常量在编译时能够确定的值
public void test() {
System.out.println(data4);
System.out.println(data5);
}
}
}
//怎么去拿到实力内部类的一个对象
public class TestDemo {
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
//先new一下外部类，拿到外部类的一个引用,再通过外部类的引用new一个对象
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
innerClass.test();
}
}
2，静态内部类

class OuterClass {
public int data1 = 1;
private int data2 = 2;
public static int data3 = 3;

  //1.如何拿到一个静态内部类的实例对象？
 // 2.静态内部类当中是不可以访问外部类的非静态数据成员的，非要访问呢
 

static class InnerClass {
    //static静态方法中不能有this
    public int data4 = 4;
    private int data5 = 5;
    public static int data6 = 6;

    //在构造内部类对象的时候直接传过来外部类的引用
    OuterClass outerClass;
    public InnerClass(OuterClass out) {
        this.outerClass = out;
    }

    public void test() {
        System.out.println(outerClass.data1);
        System.out.println(outerClass.data2);
        System.out.println(data3);
        System.out.println(data4);
        System.out.println(data5);
        System.out.println(data6);
    }
}

}
3.匿名内部类

class Outclass {
public void test() {
System.out.println(“test()”);
}
}
public class TestDemo {

public static void main(String[] args) {

    //匿名内部类
    new Outclass() {
        @Override
        public void test() {
            System.out.println("dsasffa");
        }
    }.test();
}

}
4.本地内部类：没人写

class Outclass {
public void test() {
System.out.println(“test()”);
}
}
public class TestDemo {

public void func() {
    class A {
        //本地内部类
    }
}

}