泛型,内部类

对于泛型,不要求怎么使用,要求看源码时能看懂就行。

泛型的意义:

1,自动进行类型的检查

2,自动进行类型的转换

泛型的一些重点

1,泛型时怎么编译的? 擦除机制--Object

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

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

看一个简单的泛型示例:

class MyArrayList<T> {
    
    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<Integer> myArrayList = new MyArrayList<>();
        myArrayList.push(1);
        myArrayList.push(2);
        int val = myArrayList.get();
        System.out.println(val);
        MyArrayList<String> myArrayList2 = new MyArrayList<>();
        System.out.println(myArrayList);
        System.out.println(myArrayList2);
    }

}

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

class GenericAlg <T extends Comparable> {
    //<T extends Comparable> 泛型的上界 , 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 extends Comparable> 泛型的上界 , T实现了Comparable的接口
    //或者说Comparable实现了Comparable本身
    public static<T extends Comparable<T>> 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<T> {
    public void printf(ArrayList<T> list) {
        for (T val : list) {
            System.out.print(val+" ");
        }
    }
}
class MyPrint2<T> {
    public void printf(ArrayList<?> list) {
        for (Object val : list) {
            System.out.print(val+" ");
        }
    }
}

边界问题

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

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

public class MyArrayList<E extends Number> {
...
}
MyArrayList<Integer> l1; // 正常,因为 Integer 是 Number 的子类型
MyArrayList<String> l2; // 编译错误,因为 String 不是 Number 的子类型

父子类型:

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

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

public class MyArrayList<E> { ... }
// MyArrayList<Object> 不是 MyArrayList<Number> 的父类型
// MyArrayList<Number> 也不是 MyArrayList<Integer> 的父类型
// 需要使用通配符来确定父子类型
// MyArrayList<?> 是 MyArrayList<? extends Number> 的父类型
// MyArrayList<? extends Number> 是 MyArrayList<Integer> 的父类型

内部类: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 {
            //本地内部类
        }
    }
}

 

 

 

 

 

 

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 深蓝海洋 设计师:CSDN官方博客 返回首页