内部类和泛型

内部类

在一个类的类中声明的类叫内部类

    public class Outer {
        public void hi() {
            System.out.println("Hello,This is Outer Class");
        }

        public class Inner {
            public void sayHello() {
                System.out.println("Hello,This is Inner Class");
            }
        }
    }

为什么有内部类

• 内部类可访问外部类中的私有实例变量。
• 当内部类的访问修饰符为private时，内部类只能在外部类的内部使用。

内部类的实例化

//方法一
Outer.Inner inner = new Outer().new Inner();
inner.sayHello();
//方法二
Outer o = new Outer();
Inner inner = o.new Inner();
inner.sayHello();

内部类中使用外部类实例变量

    public class Outer {
        private String name = "Tom";

        public void hi() {
            System.out.println("Hello,This is Outer Class");
        }

        public class Inner {
            public void sayHello() {
                System.out.println("Hello," + name);
            }
        }
    }

当内部类和外部类实例变量相同时，内部类想调用外部类的实例变量，需要（外部类名.this.属性）

public class Outer {
        private String name = "Tom";

        public void hi() {
            System.out.println("Hello,This is Outer Class");
        }

        public class Inner {
            private String name = "Jerry";

            public void sayHello() {
                System.out.println("Hello," + Outer.this.name);
                System.out.println("Hello," + this.name);
            }
        }
    }

在外部类内部创建内部类对象

直接newinner()即可

    public class Outer {
        private String name = "Tom";

        public void hi() {
            Inner inner = new Inner();
            inner.age = 20;
            inner.sayHello();
        }

        private class Inner {
            private int age = 10;

            public void sayHello() {
                System.out.println("Hello," + Outer.this.name + "\t" + age);
            }
        }
    }

静态内部类

• 静态内部类不能使用外部类的非静态属性，并且在创建时可以不使用外部类对象
• 静态内部类中只能调用外部类的静态变量和静态方法

    public class Outer {
        public static String name = "Tom";

        public static void hi() {
            System.out.println("xixi");
        }

        public static class Inner {
            public String name = "Jerry";

            public void say() {
                Outer.hi();
                System.out.println("Hello" + Outer.name);
                System.out.println("Hi!" + name);
            }
        }
    }

局部内部类

• 局部内部类创建在一个方法中，作用范围在这个方法中
• 为什么使用局部内部类
  1. 解决一个复杂的问题，想创建一个类来辅助你的解决方案，但又不希望这个类是公共可用的。
  2. 在方法内部实现一个接口，并返回对其的引用

    public class Outer {
        public void hi() {
            class Inner {
            public void sayHello() {
                System.out.println("Hello");
                }
            }
            Inner inner = new Inner();
            inner.sayHello();
        }
    }

• 局部内部类使方法中定义的变量，变量必须声明为final

    public class Outer {
        public void hi() {
            final String name = "tom";
            class Inner {
            public void sayHello() {
                System.out.println("Hello" + name);
                }
            }
            Inner inner = new Inner();
            inner.sayHello();
        }
    }

匿名局部内部类

• 没有名字的局部内部类

泛型<Generic>

为什么使用泛型设计程序

• 泛型程序设计意味着编写的代码可以被很多不同类型的对象所重用。 一个泛型类（generic class）就是具有一个或者多个类型变量的类。

泛型类的定义

• Java中泛型类的定义比较简单，例如：public class Test<T>{ }。这样就定义了一个泛型类Test，在实例化该类时，必须指明泛型T的具体类型，例如：Test<Object> t = new Test<Object>();，指明泛型T的类型为Object。

泛型方法

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

  
  Paste_Image.png
  

  调用静态方法：

Paste_Image.png