一、this关键字
每个类都有一个隐式的变量this，再虚拟机实例化对象时自动赋值的，赋值为当前对象的“引用”。所以每个对象的this都是不一样的，this关键字可以调用本对象的成员属性，成员方法，构造方法。在一个类中，当局部变量覆盖成员变量时必须显示的用this调用成员变量，当用构造方法调用本类其他构造方法时必须显示的调用this()或this(参数)。
二、泛型
在java早期使用的是Object，但是Object涉及强转的问题，本身有很大的类型安全隐患，经常有ClassCastException的问题，最常用的例子是集合举例，如果是Object ，存入的时候可以是任何类型，但是取出时必须强转某一种类型才可以，不然只能用Object接收，如果强转只能用一种类型，如果存入两种类型的话，强转就会报类型错误。所以需要一种你存入什么类型就返回什么类型的机制，泛型就应运而生了。
所谓泛型就是把参数的类型当作参数一样可以传递，当创建对象或者调用方法的时候传过去的一种语法。泛型的<类型>只能是引用数据类型。
泛型有三种应用，泛型类，泛型接口，泛型方法。
泛型类：定义一个类时：用<T>放在类的后面，并且给全类使用。常见的比如List集合。
public class DemoClass<T> {
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}使用的时候，直接传递具体的类型就可以，比如直接给String。
public static void main(String[] args) {
DemoClass<String> d =new DemoClass<>();
}泛型接口：和泛型类一样定义，但是子类再实现的时候有三种选择。比如我定义接口Demo1，用Demo2去实现Demo1。
public interface Demo1<T> {
T show();
}1.丢弃泛型；方法内的泛型部分全部变为Object类型；
public class Demo2 implements Demo1 {
@Override
public Object show() {
return null;
}
}2.指定一个具体类型
public class Demo2 implements Demo1<String> {
@Override
public String show() {
return null;
}
}3.继续支持泛型；(子类常见的方式)
public class Demo2<T> implements Demo1<T> {
@Override
public T show() {
return null;
}
}泛型方法：只在方法上使用泛型，不必兴师动众的在整个类中使用。
定义：
public class DemoClass {
public <T> void show(T t){
System.out.println(t.toString());
}
}使用：
public static void main(String[] args) {
DemoClass d =new DemoClass();
d.show("abc");
d.show(123);
}其中show方法的void可以换成任何返回类型，也就是说也可以使用T，就可以实现返回你传入的类型。
这是泛型的三种基本形式，也是我们平常的基本用法，当然还有一些高级一点的方式。比如同时多类型，通配符，限定泛型的上限，限定泛型的下限。下面一一介绍。
多类型：<T,S,E>，类似于这种形式，你可以定义好多字母，然后使用其中的任意几个。比如刚才的泛型方法：
public class DemoClass {
public <T,S,E> String show(T t,S s){
return t.toString()+s.toString();
}
}前边我们用到的<T> 可传递任何引用类型，并没有明显的约束，所以叫做”无界类型“，其中的T叫做类型参数或类型变量，其实T和S等也有一些约定俗成的写法，比如（E：元素，K：键，N：数字，T：类型，V：值，S、U、V 等），如果你想你的代码很规范优雅，是需要这样写的，但是平时我们都习惯用T，E等。有的时候，那如果你不想让T代表任何类型，希望它受到一定的约束，那么需要将”无界类型“，变”有界类型“，通常使用以下形式
限定泛型的上限：形式类如<T extends UpperBoundType> ，UpperBoundType是上限，T是它的子类。
这里要说一个问题，<Object> 和<String> 什么关系？答案是没关系，尖括号里的Object 只是作为占位符，并不是真实的类别，像是形参，只是一种表示，和T一样，但是，如果<T extends Obejct>中的Object是真实的，它代表了上限类别，既然是上限类别就必须是真实存在的。
例子：
public class DemoClass<T extends Number> {
}public static void main(String[] args) {
DemoClass<Integer> d =new DemoClass<>();
DemoClass<String> d =new DemoClass<String>();//报错
}
如果规定DemoClass的泛型上限是Number ，那么在使用时只能用Number的子类或者它自己，超过Number就不可以的，编译无法通过。
限定泛型的下限：<T super LowerBoundType>， LowerBoundType是下限，那么T就是它的父类。理论上是这样的，但是很遗憾，java不允许这样定义，具体的原因应该是和java实现泛型的原理有关，在后边的扩展我们介绍一下原理。
通配符：<?>，问号代表“未知类型”，注意是未知，而前面的T可以是“任何类型”，它们是不同的。同样，通配符也可以限定上限和下限，并且都是可以定义的。<?>：无限定通配符，<? extends UpperBoundType>:上限通配符，<? super UpperBoundType>:下限通配符。通常在集合中使用，比如list<?>。
使用通配符的原因有说法是由于泛型不能实现类型协变，为了能够达到那种效果所以使用通配符。那什么是协变？比如数组协变
Number[] nums = new Integer[10]; 数组这样设计也是有缺陷的，虽然Integer是Number的子类，但是jvm认为n数组只能存储Integer类型的，如果我在里边放了一个Long类型的，n[1]=123L,那么运行时候就会报错，只是我们没有这么干的。
但泛型如果想实现类似于数组协变的功能，不能使用<Objecy> =<String>这样的形式，我们说过它俩没关系。那么怎么办？可以使用通配符。
List<? extends Number> l =new ArrayList<Integer>();这样就ok了。为什么要这样？开头说过，泛型就是为了替代原始的Object形式，避免强转造成的类型安全问题，那么泛型的出现一定是要保证类型安全的，那么如果使用协变的方式就不行。
列子：猫狗动物
class Animal{}//动物
class Cat extends Animal{};//猫
class Dog extends Animal{};//狗
class JinMaoDog extends Dog{};//金毛
public class Test {
public static void main(String[] args) {
List<?> list =new ArrayList<>();
List<?> list2 = new ArrayList<String>();
List<?> list3 = new ArrayList<Animal>();
list.add(new Dog());//报错
list.add("123");//报错
Object o = list.get(0);
}
}我们发现，使用<?>后，add方法报错了，这就是“未知”的问题，它不知道你是什么类型，也就不能添加任何类型的元素,但是可以实现类似协变的功能，可以定义String也可以定义Animal，也可以取出，因为是任何类型都有可能，所以只能用Object接收。所以List<?>这样的写法意义是什么呢？其实是把？当Object使用的，因为<Object>在泛型已经和真正的Object不一样了，那么通配符<?>的用处就显现了，所以一般用作方法的返回值声明，比如：
public <T,S> List<?> show(T t,S s){
List list =new ArrayList();
if("123".equals(t.toString())){
list.add(t);
}else {
list.add(s);
}
return list;如上方法，如果我有多个类型传入，之后返回一个list，里边的元素根据条件存储不同的类型，那么我既不能定义LIst<T> 也不能定义List<S>,因为是“未知”的，使用List<?>，就可以解决这个问题。
使用的时候：用Object接收
public static void main(String[] args) {
DemoClass d =new DemoClass();
List<?> l = d.show("123", 456);
Object o = l.get(0);
}但看起来好像有回到了最原始的 的Object时代。所以我个人感觉更多的是提示作用，用以告诉使用者这里是未知的
上限通配符:
public static void main(String[] args) {
List<? extends Dog> list1 = new ArrayList<Dog>();
List<? extends Dog> list2 = new ArrayList<JinMaoDog>();
List<? extends Dog> l =new ArrayList<>();
l.add(new Cat());//报错
Animal animal1 = l.get(0);
Dog dog = l.get(0);
}定义的时候，我可以实现类似协变的效果，直接指定ArrayList泛型为Dog或者jinmaodog，只要不超过Dog上限就可以，但是在编译期间，jvm会进行“类型擦除”，就会变成第三个l 的形式，如此一来，？又代表了未知，你不知道是BianMuDog 还是JinMaoDog，JinMao和BianMu是同级关系，add方法仍然不可用。所以取的时候，你不能使用JinMaoDog来接受，因为如果是BianMuDog就会有类型安全问题，只能使用Dog或者Dog的父类接收才是安全的。
下限通配符：
public static void main(String[] args) {
List<? super Dog> list3 = new ArrayList<Animal>();
List<? super Dog> list4 = new ArrayList<Dog>();
List<? super Dog> l =new ArrayList<>();
l.add(new Dog());
l.add(new Animal());//报错
l.add(new JinMaoDog());
Object object = l.get(0);
}
和上限通配符同理，定义的时候可以指定Animal或者Dog，只要不低于Dog这个下限。区别是add方法可以用，因为无论你存入的是JinMaoDog还是BianMuDog都是低于Dog的，而指定的时候都是高于Dog的，所以你存的一定比指定的低。不会发生类型安全问题。而取的时候用Object接收，因为可以是任何类型，高于Dog也可以，低于Dog也可以。
泛型的原理
泛型的本质上是一种语法糖，何为语法糖，这个是计算机术语，指在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。简而言之，语法糖让程序更加简洁，有更高的可读性。比如泛型，switch语句，自动拆箱装箱，可变参数，这些本质上都是语法糖。
语法糖对应的有一个“解语法糖”，对于java泛型来说，解语法糖是发生在编译期间，就是java文件变成class文件的过程中，也就是说对于程序员来说，java文件在编辑的时候，可以直接写成<T>的形式，但它是语法糖，变成class文件后会被解开，你就看不到<T>这东西了，这个解法在Java中叫做“类型擦除”。首先将所有的泛型参数用其最左边界（最顶级的父类型）类型替换。然后移除所有的类型参数。
比如：
public static void main(String[] args) {
List<String> list =new ArrayList<>();
}
查看class文件内容变成了
public static void main(String args[])
{
java.util.List list = new ArrayList();
}
<String>被擦除了。同样在你自定义的类中<T>也会被擦除，变成Object，因为T就是任何类型，所以说jvm运行时不认识泛型的，在编译的时候会被擦除，变成最原始的类型，然后自动加强转，比如上面的代码如果在遍历集合list的话，class文件中会有强转成（String）的代码。
这时再来看<T super LowerBoundType>为什么不能定义，可能就是因为如果要擦除就必须擦掉LowerBoundType，使用它的父类型替换，可是T是不确定的，没法替换，这样就没有意义了，所以这样写不行。
这里简单介绍类型擦除，有兴趣可以去了解学习一下。
三、IO流的总结
136
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
