###Java面向对象部分笔记

（对象和类 抽象与封装 继承与多态）

面向对象三大支柱是： 封装 继承 多态

0 面向对象5大原则

单一职责原则（Single-Resposibility Principle）：一个类，最好只做一件事，只有一个引起它的变化。单一职责原则可以看做是低耦合、高内聚在面向对象原则上的引申，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。
开放封闭原则（Open-Closed principle）：软件实体应该是可扩展的，而不可修改的。也就是，对扩展开放，对修改封闭的。
Liskov替换原则（Liskov-Substituion Principle）：子类必须能够替换其基类。这一思想体现为对继承机制的约束规范，只有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础。
依赖倒置原则（Dependecy-Inversion Principle）：依赖于抽象。具体而言就是高层模块不依赖于底层模块，二者都同依赖于抽象；抽象不依赖于具体，具体依赖于抽象。
接口隔离原则（Interface-Segregation Principle）：使用多个小的专门的接口，而不要使用一个大的总接口

1 对象和类

（1）对象和类的基本概念

类是对象的模板，一个类的声明中定义了对象应该有的变量、方法以及构造实例的构造方法。通过声明变量和构造方法可以创建类的实例（类名要大写）

类是一种引用类型，区别于8种基本数据类型，所有变量存储的都是都是对类的一个实例的地址客空间的地址。（注意 变量的声明 对象的创建 以及 对象引用的赋值 这三个过程的区别）

通过 “.” 来访问对象的变量和方法

实例变量 实例方法（与创建的对象绑定）

*静态变量（所有类的实例共享该变量，在公共内存地址，无需创建对象就可以访问） *

静态方法（可以通过类直接调用，无需创建对象）

（也可以通过引用变量来调用）（要加修饰符 static）

常量 ：类中的常量是被所有对象共享的，应当被声明为final static

（实例方法可以调用其对象所有资源，而静态方法只能调用类的静态资源）

匿名对象（直接new了用，不给变量指向它）

声明一个引用对象而不赋值，Java不会给其赋默认值null

如果一个对象的数据域中的引用类型的变量没有引用对象，Java会给其赋默认值null（基本类型会赋 0 /u000 false），但Java不会给方法中的局部变量（包括基本类型）赋默认值

每个变量都代表一个内存地址，基本类型变量指向的内存地址存的是值，而引用类型变量存的是指向是这个对象实际内存地址

不被任何变量指向的对象会被JVM回收掉（垃圾回收）

含有main方法的是会被执行的类，成为主类（main函数是程序程序的入口）其他类都不可运行

一个文件可以有多个类，但只能有一个public类，只有这个public类中才会有main函数，公共类必须和文件同名。（但注意编译的时候每个类都会编译成一个 .class文件）

（2）修饰符

（2.1）可访问性修饰符（四个等级）

（用于确定一个类及其成员的可见性）

package用来组织类，表明类的归属

不添加修饰符被视为可以被同一个package的类访问

public表示可以被任何类访问

private表示只能在它自己的类中被访问（只能用于类的成员上）

如果一个类不是public的，则它只能被同一个package的类访问

构造方法可以是public也可以是private（仅当时静态类不想被创建实例时使用，一般都是公共的）

	同一个类中	同一个package中	在子类中	在不同package中
public	O	O	O	O
protected	O	O	O	X
(default)	O	O	X	X
private	O	X	X	X

protected允许子类可以访问父类的变量，而默认（default）和private不可以

private和protected只可以用于类的变量和方法，而public和默认（default）可以用于类或者类的变量和方法

注意方法的修饰的类型，要在子类中调用或者重写的方法一定要在父类声明时用public或者protected（子类可能不在同一个package内！）

（2.2）防止扩展与重写（final修饰符）

final修饰的类不可以被继承，final修饰的方法不可以被子类重写，final还可以修饰局部变量，这时这个局部变量变量就是常量

（3） 数据域封装

将类的所有变量都设为私有变量，然后通过公共的getter和setter方法进行访问

（4） 调用类的方法的底层细节

基本类型的变量存放在栈中，引用类型的对象被创建后会存放在内存的堆中。当方法被调用时其局部变量被放在栈中。栈中引用类型的变量存的是指向栈中对象的引用。

（待补充）

（5） 不可改变类和对象

通过不可改变类创建的对象就是不可改变对象，比如String

如果一个类是不可改变类，那么其 1数据域必须是私有的，2不能提供setter方法，3没有一个返回指向可变数据域的引用的getter

（6） 局部变量优先于类变量（类变量被隐藏）

（7） this引用

this指向调用对象自身，也可以在构造方法内部用于调用同一个类的其他构造方法（this(其他构造方法的参数列表) 要求这个在构造方法中出现在任何其他可执行语句之前）

当类变量被隐藏时，必须用this来引用

（8） 类的抽象和封装

抽象是指将类的使用和实现分离

封装是指实现的细节被封装并且对用户隐藏

类被称作 抽象数据类型ADT

（9） 类的关系

关联 聚集（has-a 所有者称为聚集对象） 组合（一个对象只归属于一个聚集对象） 继承

（10） 基本类型和包装类型

既可以用数值也可用字符串来构造包装类 new Integer(“7”)

每个包装类都包含 类似 intValue() 的方法进行拆箱

包装类没有无参构造方法，所有包装类的实例都是不可变的

每一个数值包装类都是常量MAX_VALUE和MIN_VALUE，代表基本数据类型的最大最小值（对于·浮点代表最小正值）

都有compareTo方法来进行比较（也可以直接用关系操作符比较）

静态方法 Integer.valueOf(String s) 创建一个新的包装类的对象（将String转化为包装类）

静态方法 Integer.parseInt(String s , int radix) 将String转化为一个十进制基本数据类型（后一个参数是说明这个String中的数是几进制，可以没有）

装箱 开箱 Java允许基本类型和包装类的自动转换，编译器会根据需要自动装箱开箱

（11） BigInteger BigDecimal （去看一下源码是怎么实现的）

new BigInteger(String) 来创建

BigInteger的实例可以是任意大小整数 BigDecimal 没有精读限制，但可以用重载的方法限制来避免除不尽的异常

使用 add subtract multiple divide remainder 来完成算术运算 compareTo来比较

都是不可改变的

（12） String

Java将字符串直接量看做String对象

也可以用char[] 来创造一个字符串

字符串转换成字符数组 toCharArray()

使用format方法格式化字符串

关于new和直接赋值的不同，以及在==下情况的不同

直接赋值而不是使用new关键字给字符串初始化，在编译时就将String对象放进字符串常量池中；使用new关键字初始化字符串时，是在堆栈区存放变量名和内容；字符串的拼接操作在程序运行时，才在堆中创建对象。一般，可以认为使用==”比较的是引用，equals比较的是内容。

String str1 = “java”; //直接赋值而不是使用new关键字给字符串初始化，在编译时就将String对象放进字符串常量池中
String str2 = new String(“java”);//在堆中创建新对象

String str3 = “java”; //直接赋值而不是使用new关键字给字符串初始化，在编译时就将String对象放进字符串常量池中

String s = str1+str2; //字符串的拼接操作在程序运行时，才在堆中创建对象，相当于new
System.out.print(s==”javajava” s1==s3 s1==s2);

答案是 false true false

（13） 正则表达式 使用 字符串.matches(“正则表达式”) 来匹配符合正则表达式的字符串（返回true false）（学习一下正则表达式的规则）

（14） StringBuilder StringBuffer（字符串构造器）（去看一下JDK源码）

StringBuilder 是同步的，只有一个任务被允许执行方法；StringBuffer多任务并发访问的

除了这一点他们的方法都是一样的（单任务Builder更有效）

默认构造容量是16，可以指定容量，指定字符串（3个构造方法）

（如果有用到就去看看其方法如何使用）

2 继承（is-a）（class Apple extends Fruit ）

Java不允许多重继承，但是可以通过接口来实现

定义一个通用的类（父类），之后扩充该类为一个更加特定的类（子类）

子类拥有父类的所有属性和方法（父类的构造方法不会被继承），共有属性和方法可以直接使用，但父类的私有属性和方法子类是无法直接使用的，私有方法是用不了的，而私有属性则必须父类提供了get或set才可以访问或修改

分析内存后，会发现，当一个子类被实例化的时候，默认会先调用父类的构造方法对父类进行初始化，即在内存中创建一个父类对象，然后再父类对象的外部放上子类独有的属性，两者合起来成为一个子类的对象

super关键字 指代父类 可以用于调用父类中的普通方法和构造方法

在子类的构造方法中显示的super必须在第一条语句，不可以直接写父类名字（注意即使你不显式的写super，编译器也会自动的将super()作为第一条语句，先调用父类的构造方法）

构造方法链： 当构造一个类的实例时，会调用沿着继承链的所有父类的构造方法（从祖先开始，一层一层调用创建）（所以设计父类的时候最好提供一个无参构造方法，防止子类的构造方法调用时出现错误）

方法重写（覆盖）（overriding）：当父类中的一些方法对子类不适用时，就需要提供一个新的方法来 override 父类中的这个方法。（注意 私有方法和静态方法不可被重写，静态方法一旦被重写，父类中的就会被隐藏，要通过 父类名.方法名 调用）

*遵循 “两同两小一大”原则 *

两同：方法名、参数列表相同。

两小：子类的返回类型（指的是继承关系的大小）、抛出的异常小于等于父类

一大：访问修饰符大于等于父类的访问修饰符（四个等级）

当被重写时，就可以使用super调用父类的原方法

在编写代码时，建议在覆盖一个方法时加上 @override，除了标识的作用，它还会帮助你检查你覆盖的这个方法是否在父类中真的存在。

方法重载（overloading）：多个方法具有相同的名字且拥有不同的参数列表时，就会出现重载，由编译器决定调用哪个方法，这个过程被称为 overloading resolution（重载解析）

方法重载既可以在统一各类中发生，也可以在子类中重载由父类继承而来的方法

Java中所有的类都继承自Object类（Java.lang.Object lang里的东西都不用import （编译器会自己带上））如果一个类没有指定父类，那其父类就默认是Object（所以除了Object所有类都有有父类，都存在继承）

Object的 toString()方法会返回一个描述该对象的字符串，类名+@+该对象16进制的内存地址，我们可以对它进行重写

3 多态

多态意味着父类的变量可以指向子类对象

面向对象三大支柱是： 封装 继承 多态

子类型 父类型d

每个子类的实例都是父类的实例，但是父类的实例不是子类的实例

所以总可以将子类的实例传给父类的变量，但反过来不行

（多态意味着父类型的变量可以引用子类型的对象）

声明类型&实际类型：对象声明时的类型是声明类型，而实际类型是其声明类型或者声明类型的子类，要看具体指向什么。（声明类型决定了编译时匹配哪个方法）

（运行时）动态绑定：由对象的实际类型决定调用哪个方法（是父类的还是子类重写的）（方法可以沿着继承链的多个类中实现，JVM决定运行时调用哪个方法）（先看实际类型，没有的话会从那个子类往祖先找实现的方法？）

对象转换和instanceof运算符

对象转换：对象的引用可以类型转换为对另外一种对象的引用

隐式转换：声明是父类，而赋值是子类的引用（注意此时的类型是父类，不能直接赋给子类的变量，需要显示转换成子类） Object o = new Student();

*显式转换：Student b = (Student) o; *

向上转换：总是可以将子类变量转换为父类变量，子类的实例永远是它父类的实例，可以隐式转换（直接赋值就行）

向下转换：将父类实例转换为子类变量，必须要显式转换（转换的前提是这个父类的实例本来就是子类的实例，只是声明是父类）

*instanceof操作符(是关键字)：用于判断一个对象obj是否为一个类的Class 的对象，或者是其直接或间接子类，或者是其接口的实现类（是则返回true） if(obj instanceof Class) *

Java关键字中每个字母都是小写的

对象转换的好处：将变量定义为父类型的好处是可以接受任何子类型的值，在需要使用的是时候再具体转换，方便管理使用

注意！成员访问符 . 的优先级高于类型转换，要加括号！((Student) o ).toString()

Object类的equals方法：A.equals(B) 判断两个对象是否一样 ==实现（指向同一对象），在String和Date都被重写，用于比较内容（而不是直接==）

4 抽象类

抽象类不可以创建对象，可以包含抽象方法（可以有普通成员），这些方法将在子类中实现。

抽象类和抽象方法用abstract来修饰，抽象方法只有方法头的定义，不能有方法体（ abstract void time(参数);（注意这些在子类都不能改））

抽象方法不能包含在非抽象类中；抽象类可以有构造方法不能new但是可以给子类调用（所以要声明为protected）；子类可以覆盖父类的方法并定义为abstract（在父类方法于子类中无效时），但子类必须声明为为abstract；父类具体子类也可以抽象；抽象类可以作为声明类型（虽然不能new）；子类可以不完全实现抽象方法（可以不用重复写在子类中），但这样子类也必须是抽象类

5 接口

父类型了相关子类中的共同行为，接口可以用于定义类的共同行为（包括非相关的类）；接口之只包含常量和抽象方法

接口目的在于知名相关或者或者不相关类的多个对象的共同行为

Java中接口被看做特殊的类，每个接口和类一样被便以为独立的字节码文件

（1）接口的声明和使用

声明一个接口：修饰符 interface 接口名{ 常量声明 抽象方法 }

利用extends 接口可以继承其它接口（可以继承多个（相当于它的父类））（称为子接口）

类和接口的关系称为 接口继承 类使用implements来继承接口（和类继承一样）

和抽象类类似，接口不能new，但可以作为数据类型。一个接口的变量可以引用任何实现该接口的类的实例，一旦一个类实现了该接口，这个接口（以及这个接口继承的所有接口 都）相当于它的父类。（显式、隐式转换同样适用）

（2）接口的变量和方法（变量是公共静态的，方法是公共抽象的）

注意！接口中所有数据域都是 public static final 所有方法都是 public abstract 所以Java允许在写接口时忽略这些修饰符（所以继承自接口的方法必须是公共 抽象 实例方法（不允许静态方法））

注意！一个类必须实现它继承接口的所有抽象方法！

（3）接口的静态方法

对于静态方法，以往通常的做法都是将静态方法放在伴随类中。在标准库中，你会看到成对出现的接口和实用工具类， 如 Collection/Collections 或 Path/Paths。

而在 Java SE 8 中，允许在接口中增加静态方法。（所以可以直接写静态方法，伴随类已经过时了）

（4）接口的默认方法

对于接口的方法可以提供一个默认实现，用default标记。大部分时间没什么用（因为一单继承就要被覆盖）

默认方法的一个重要用法是“‘ 接口演化” （interface evolution），因为为接口增加一个非默认方法不能保证“源代码兼容”，所以对于老接口进行新增时往往用默认方法

比如说我们之前类A实现了接口B，现在我们在接口B又新添加了一个方法C，这时候如果C不是default的，那就会出现编译错误（因为A没有实现C）

不过， 假设不重新编译这个类， 而只是使用原先的一个包含这个类的 JAR 文件。这个类 仍能正常加载， 尽管没有这个新方法。 程序仍然可以正常构造 Bag 实例，不会有意外发生。(为接口增加方法可以保证“ 二进制兼容”)。不过，如果程序在一个Bag实例上调用stream 方法， 就会出现一个 AbstractMethodError。

将方法实现为一个默认方法就可以解决这两个问题。 Bag 类又能正常编译了。 另外如果 没有重新编译而直接加载这个类， 并在一个 Bag 实例上调用 stream 方法， 将调用 Collection. stream 方法。

默认方法冲突（这里有很多情况，具体等遇到再仔细看吧）

如果先在一个接口中将一个方法定义为默认方法， 然后又在超类或另一个接口中定义了 同样的方法就会产生冲突，Java用以下规则解决这个问题：

1 ) 超类优先。 如果超类提供了一个具体方法， 同名而且有相同参数类型的默认方法会被忽略。

2 ) 接口冲突。 如果一个超接口提供了一个默认方法， 另一个接口提供了一个同名而且 参数类型(不论是否是默认参数)相同的方法， 必须覆盖这个方法来解决冲突。

（5）一些实用的接口

1. Comparable接口：定义了compareTo，用于比较

public interface Comarable<E> {

​ public int compareTo(E o);

}

如果自定义的类也要实现对象间比较，要继承并实现这个接口（自定义比较逻辑）

这是一个泛型接口，所有包装类和Date都实现了这个接口，所以他们之间是可以比较大小的

2. Cloneable接口：定义了clone，用于创建一个对象拷贝

public interface Cloneable{ }

一个空的接口称为标记接口，及不含常量也不含方法，用来表示一个类拥有某些特定属性

实现Cloneable接口的类标记为可克隆的，并且它的对象可以使用在Object类中定义的clone()方法克隆

Object类中对clone()方法头：

protected native Object clone() throws CloneNotSupportedException

native表示不是用Java写的，但它是JAM针对自身平台来实现的

6 Java 复制

Java中有三种复制方式：直接赋值复制、浅复制、深复制

1 直接赋值复制

基本类型复制的是值，对象复制的是引用

后两种方式都是基于Object中的clone()方法来复制的，它的原理是创建一个新的Object对象，然后把所有成员都按照直接赋值复制方式复制一份

2 浅复制

重写Object中的clone()方法，克隆一个对象，但是数据域中的抽象成员复制的是引用

要在目标类上implements Cloneable接口，然后重写这个方法（改成public）

public Object clone() throws CloneNotSupportedException{

return super.clone();

}

在使用clone()方法时注意要显式转换一下（因为声明类型是Object的）

House house2 = (House)house1.clone()

这里要注意，Object中的clone()方法是将原始对象的每个数据域复制给目标，基本类型直接赋值，而抽象类型复制的是引用

另一种代码：

class Resume implements Cloneable{
public Object clone() {
 try {
 return (Resume)super.clone();
 } catch (Exception e) {
e.printStackTrace();
 return null;
  }
}  
}

3 深复制（两种实现方式）

深复制为包括数据域的对象在内的全部克隆（其实就是把对象成员再用clone给克隆了再赋值）（克隆的范围扩大到类的成员）

但这里有一个问题，如果成员的成员也是对象，那样第三层将复制的还是引用，有没有办法直接解决这个问题？

1 利用Object中的clone()方法实现代码：

class Student implements Cloneable { String name;
int age;
Professor p;
Student(String name, int age, Professor p) { this.name = name;
this.age = age;
this.p = p;
}
public Object clone() {
Student o = null; 
  try {
o = (Student) super.clone();
} catch (CloneNotSupportedException e) {
System.out.println(e.toString()); 
}
o.p = (Professor) p.clone();
return o; 
}
}

2 利用序列化实现深复制：

在 Java 语言里深复制一个对象，常常可以先使对象实现 Serializable 接口，然后把对
象(实际上只是对象的一个拷贝)写到一个流里，再从流里读出来，便可以重建对象。

7 泛型

泛型可以使我们在编译时而不是运行时检测出错误

泛型可以将类型参数化，使我们可以定义带泛型类型的类或方法，随后编译器会用具体的类型来替换它。

泛型类型和或方法允许用户指定和这些类和方法一起工作的对象类型，如果试图使用一个不相容的对象，编译器就会检测出这个错误。

从JDK1.5开始，Java允许定义泛型 类、接口、方法

<T>或<E>表示形式泛型类型，随后可以用一个实际具体类型来替换他。替换的过程称为 泛型实例化

泛型类型只能是引用类型

注意！在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦除，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。

受限的泛型类型（确定泛型的上下边界）：将泛型定义为<E extends 类A>表明泛型E必须是A的子类型（泛型的上下边界添加，必须与泛型的声明在一起）

泛型类和接口

可以定义泛型接口和泛型类（虽然将元素类型设置为Object也可以容纳所有对象，但不能编译时检测出错误）

带泛型类型的类的构造方法还是和没有的时候一样

不能对确切的泛型类型使用instanceof操作

带泛型的类或者接口，其类和接口名就是带<E>的，表示了它里面使用了泛型E。对于类来说，在new这个类的实例的时候或者声明这个类的实例，再表明实际类型。对于接口来说，在类继承此接口时，要么在类继承时标明实际类型，要么类也一起加上泛型

public class Stack<E1,E2,E3> {}
Stack<String,Integer,Double> stack = new Stack<>();


public interface Comparable<E> {
  public int compareTo(T o);
}
public interface Generator<T> {
    T next();
}

/**
 * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
 * 即：class FruitGenerator<T> implements Generator<T>{
 * 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"
 */
class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
}
/** 
* 当实现泛型接口时确定泛型实际类型时，类名就不用再加<>
*/
class MeetGenerator implements Generator<String>{
    @Override
    public String next() {
        return null;
    }
}

泛型方法

泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。

/**
 * 泛型方法的基本介绍
 * @param tClass 传入的泛型实参
 * @return T 返回值为T类型
 * 说明：
 *     1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
 *     2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
 *     3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。(在类上已经定义的泛型类型是可以使用的)
 *     4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
 */
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
}
public class Generic<T>{     
        private T key;
        public Generic(T key) {
            this.key = key;
        }
     //虽然在方法中使用了泛型，但是这并不是一个泛型方法。
     //这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。
     //所以在这个方法中才可以继续使用 T 这个泛型。
        public T getKey(){
            return key;
        }
}
/** 
     * 这才是一个真正的泛型方法。
     * 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
     * 这个T可以出现在这个泛型方法的任意位置.
     * 泛型的数量也可以为任意多个 
     */
     public <T,K> K showKeyName(Generic<T> container){ }



 //当在泛型类中定义泛型方法
class GenerateTest<T>{
        public void show_1(T t){
            System.out.println(t.toString());
        }
  //在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
  //由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
        public <E> void show_3(E t){
            System.out.println(t.toString());
        }
 //在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
        public <T> void show_2(T t){
            System.out.println(t.toString());
        }
    }

注意！如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法。（否则非法）

public class StaticGenerator<T> {
    /**
     * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
     * 如：public static void show(T t){..},此时编译器会提示错误信息：
          "StaticGenerator cannot be refrenced from static context"
     */
    public static <T> void show(T t){
    }
}

泛型通配符（通配泛型）

Ingeter是Number的一个子类，Generic<Ingeter>与Generic<Number>实际上也是相同的一种基本类型。但是在使用Generic<Number>作为形参的方法中，不能使用Generic<Ingeter>的实例传入。Generic<Integer>不能被看作为``Generic`的子类。由此可以看出:同一种泛型可以对应多个版本（因为参数类型是不确定的），但是不同版本的泛型类实例是不兼容的。

所以需要一个在逻辑上可以表示同时是Generic<Integer>和Generic<Number>父类的引用类型。由此类型通配符应运而生。

FruitGenerator<?> t = new FruitGenerator<>();

类型通配符一般是使用？代替具体的类型实参，注意了，此处？是类型实参，而不是类型形参 。此处的？和Number、String、Integer一样都是一种实际的类型，可以把？看成所有类型的父类，是一种真实的类型。（不能用于类和方法要使用的泛型的声明，是用在调用和使用上）

可以解决当具体类型不确定的时候，这个通配符就是 ? ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

有三种形式的通配泛型，<?>表示任意类型 <? extends T> 表示是T或T的一个子类型 <? super T>表示是T或T的一个父类型 （其中T是泛型类型）

public void showKeyValue1(Generic<? extends Number> obj){
}
public <T> void showKeyValue1(Generic<? extends T> obj){
}

具体关系看一下P12的那个图就会清晰了

原始类型和向后兼容

没有指定具体类型的泛型类称为原始类型（相当于指定的类型是Object，ArrayList相当于ArrayList