成都企业网站公司摄影公司网站开发

数据结构

1. 描述和组织数据的方式
2. 集合和数据结构，集合：把数据结构封装起来，不用我们自己实现，直接使用
3. 集合类

类，接口，抽象类

1. 接口扩展（继承）接口
2. 类实现接口
3. 类继承抽象类，实现抽象类中的方法

时间复杂度和空间复杂度

1. 递归的时间复杂度
   

包装类

1. 为什么要有包装类？
   为了让基本数据类型也能像类一样使用，能够调用库方法，实现类的特性

装箱和拆箱

1. 装箱：将基本数据类型给对应的包装类型
2. 拆箱：将包装类型给对应的基本数据类型

public class test {public static void main(String[] args) {Integer a = 10;// 自动装箱,把基本数据类型给包装类型,隐式调用valueOfInteger b = Integer.valueOf(10);// 显示装箱System.out.println(a);System.out.println(b);// 自动拆箱,把包装类型给基本数据类型Integer c = 10;int d = c;System.out.println(d);// 显示拆箱int aa = a.intValue();System.out.println(aa);double bb = a.doubleValue();System.out.println(bb);}
}

泛型

1. 泛型相当于是一个模版，里面可以放任何类型的数据，只要指定了T
2. 泛型将类型进行了传递

// 泛型
class 类名<T,K,V...>
{}

// <>内部必须是包装类型或者是引用类型,不能是基本数据类型
// <>在前面指定了类型,后面的<>内部可以不写类型
MyArray<Integer> myArray = new MyArray<>;

3. 实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值？

可以实现一个泛型类

泛型是如何编译的

1. 擦除机制：擦成object类型，比如T类型会被擦成object类型
2. java是不允许new一个具体的类型的泛型数组的
3. Java 的泛型在 编译时 存在，但在 运行时 会被擦除（Erasure），替换成 Object 或边界类型
4. 本身T类型在编译时被擦除成了object类型，在运行时不存在T，编译器无法确定T类型
   

// java是不允许new一个具体的类型的泛型数组的
public T[] array = new T[]; 

// 写法一
// 建议这么写,安全写法
public Object[] objects = new Object[10];// 写法二
// 不能new一个泛型类型的数组,因为泛型只在编译时存在
public T[] objects = new T[10];
// 编译上虽然能够通过，但是存在问题
// 如果外部调用 Box<String>，但实际存储的是 Object[]，取出时会尝试将 Object 强转为 String，可能失败。
public T[] objects = (T[]) new Object[10];

泛型的上界

1. 在传入泛型的类型时，有时需要对传入的变量做一定的约束，可以通过类型的边界来约束

class 泛型类名称<类型形参 extends 类型边界>{}
class MyArray<E extends Number>{}

MyArray< Integer> l1, 正常，Integer是Number的子类
MyArray< String > l2，报错，String不是Number的子类
泛型的上界指的时它本身（Number）和它的子类

2. 案例

import java.lang.Object;
import java.lang.reflect.Array;
// 泛型类
class MyArray<T>{// 使用Object类型的数组public Object[] objects = new Object[10];public void setValue(int pos,T val){objects[pos] = val;}public T getValue(int pos){return (T)objects[pos];}
}class Person implements Comparable<Person>{@Overridepublic int compareTo(Person o) {return 0;}
}// 泛型类
class Alg<T extends Comparable<T>>{public T findMax(T arr[]){T max = arr[0];for(int i = 0;i < arr.length;i++){if(max.compareTo(arr[i]) < 0){max = arr[i];}}return max;}
}// 泛型方法
class Alg2{public<T extends Comparable<T>> T findMax(T arr[]){T max = arr[0];for(int i = 0;i < arr.length;i++){if(max.compareTo(arr[i]) < 0){max = arr[i];}}return max;}
}Alg3.findMax(arr);
// 静态的泛型方法,直接用类型调用
class Alg3{public static <T extends Comparable<T>> T findMax(T arr[]){T max = arr[0];for(int i = 0;i < arr.length;i++){if(max.compareTo(arr[i]) < 0){max = arr[i];}}return max;}
}public static void main(String[] args) {// 显示实例化alg2.<Integer>findMax(arr2);        // 类型推导实例化Alg2 alg2 = new Alg2();Integer[] arr2 = {1,2,3};int ret1 = alg2.findMax(arr2);System.out.println(ret1);// 普通引用类型的Alg<Integer> b = new Alg<>();Integer[] arr = {1,2,3,5,6};Integer ret = b.findMax(arr);System.out.println(ret);// 自定义类型的Alg<Person> a = new Alg<>();}public static void main1(String[] args) {MyArray<Integer> myArray1 = new MyArray<>();MyArray<String> myArray2 = new MyArray<>();}
}