JAVA 0.002 内部类

> 内部类的实现和使用场景

#先说使用场景
内部类就是定义在一个类内部的类
通常用于以下场景：
* 在一个类中，我们希望有一个方法可以返回一个满足某个接口的对象
* 我们直接在这个类里声明一个类，让它满足这个接口
* 然后返回这个类，在返回过程中向上转型成接口对象
**下面内部类的第一个例子就是这样的**
#内部类
* 内部类就是定义在一个类中（甚至可以是方法中，代码段中）的类，他可以访问本类的所有成员。
* 如果内部类定义在方法或者代码块中，出了方法和代码块，就无法访问他了
* 非static的内部类，在类外部构建对象，需要其外部类的引用
* 非static的内部类不能有static的数据和方法
* 内部类是独立的实体，如果外部类被继承，和内部类没关系
* 内部类也会编译成独立的class文件，命名方式是外部类$内部类.class
```
import java.util.*;

public class test{
    public static void main(String[] args){
        company c = new company("abc");
        company.employee e = c.new employee("Peter");//这种方式可以建立内部类
        e.get_name();
        e.get_c_n();

//这就是刚才要的例子
        person p = c.get_person("Lina");
        p.get_name();
    }
}

interface person{
    void get_name();
}

class company{
    String company_name;
    company(String n){
        company_name = n;
    }
    public void get_company_name(){
        System.out.println(company_name);
    }
    class employee implements person{ //company 和 employee 不能理解成父子类关系，一个公司可以有多个雇员，雇员是个体，并没有公司的属性 
        String name;
        employee(String n){
            name = n;
        }
        public void get_name(){
            System.out.println(company_name+" "+name);//可以直接访问类的成员
        }
        public void get_c_n(){
            company.this.get_company_name();//用 父类.this 可以获得父类对象
        }
    }
    public person get_person(String n){
        return new employee(n);
    }
}
```
##内部匿名类
* 匿名内部类是一个没有名字的，继承某一个类/接口的内部类
```
import java.util.*;

public class test{
    public static void main(String[] args){
        company c = new company("abc");
        person p = c.get_person("Luke");
        p.get_name();
    }
}

abstract class person{
    String name;
    person(String n){
        name = n;
    }
    abstract void get_name();
}

class company{
    String company_name;
    company(String n){
        company_name = n;
    }
    person get_person(String n){
        return new person(n) {
            void get_name(){
                System.out.println(company_name+" "+name);
            }
        };
    }
}
```
##嵌套类（内部静态类）
* 可以含有静态数据
* 可以放在接口中（一般接口内不允许有实现）
```
import java.util.*;

public class test{
    public static void main(String[] args){
        the_num a = new the_num();
        a.set_num(2);
        a.get_num();
        the_num.math.n_1(a.get_num());
    }
}

interface num{
    void set_num(int i);
    int get_num();
    static class math{
        static void n_1(int i){
            System.out.println(i+1);
        }
    }
}

class the_num implements num{
    int n;
    public void set_num(int i){
        n = i;
    }
    public int get_num(){
        return n;
    }
}
```

乱读天书， 不求甚解

乱读天书，不求甚解