内部类

public class Show0 {
    /**
     * 把一个类定义在另一个类的内部，就是内部类。
     * 
     * 
     */
    private int id=123;
    private String name="hero";
    public showInner0 createInner0(){
        return new showInner0();

    }
    class showInner0{
        int stuId=id;
        String name="tom";
        public void say(){
            System.out.println(name);
        }
    }


    class showInner1{

    }

    public static void main(String[] args) {
        //showInner1 inner1=new showInner1();这样报错
        //如果要在外部类的非静态方法之外的地方创建内部类，就要用OuterClass.innerClass明确的写出它的类型
        Show0 s=new Show0();
        Show0.showInner0 inner0=s.createInner0();
        inner0.say();

        //内部类可以访问外部类的所以成员而不需要任何条件
    }


}

package com.hero.show;
    /**
     * 创建内部类对象，内部类引用外部类
     * @author hero
     *
     */
public class Show1 {
    public class Inner{
        public Show1 outer(){

            return Show1.this;   //对外部类对象的引用，在编译期就被知晓，没有运行时的开销
        }
    }
}


    class hero1{
        Show1 show1=new Show1();
        Show1.Inner inner=show1.new Inner();  //创建对象的时候应该这样创建，必须使用外部类的对象来创建内部类对象
        //在拥有外部类对象之前是不能创建内部类的，因为内部类对象会暗暗的连接到创建它的外部类对象上。但是，如果创建的是嵌套类即
        //静态内部类，那么他就不需要对外部类对象的引用。

    }

package com.hero.show;
/**
 * 内部类与向上转型
 * @author hero
 *  内部类向上转型成父类，尤其是转型成接口的时候
 */
public class Show2 {
    private class BMW implements Car{
        //宝马实现了car
    }
    protected class OFO implements Bike{
        //ofo实现了bike
    }

    public Car CarFactory(){
        return new BMW();//隐藏细节,内部类是private
        //外部是以Car来调用对象，连这个对象是什么类都不知道
    }

    public Bike BikeFactory(){
        return new OFO();//隐藏细节
    }
}

package com.hero.show;
/**
 * 在方法和作用域内的的内部类
 * @author hero
 *
 */
public class Show3 {
    //在方法里创建类

    public Car CarFactory(){
        class BMW implements Car{//这个类是方法的一部分，所以在这个方法之外是不可以访问他的

        }
        return new BMW();
    }

    //---------------------------------------------------
    public Car test(){
        if(true){
            class BMW implements Car{//写在if语句的作用域内

            }

            return new BMW();
        }
        return null;
    }

}

package com.hero.show;



/**
 * 匿名内部类
 * @author hero
 *
 */
public class Show4 {

    public Car shopping(final String name){
        return new Car() {

            private String love=name; //内部类如果要-直接-使用外部的对象，必须是final的
            //如果外部的对象是传给父类的，不是直接使用的，可以不用final

        };
    }

}

package com.hero.show;

import com.hero.show.Show5.hungry;

/**
 * 嵌套类，如果不需要内部类和外部类有联系，将内部类声明为static
 * 普通的内部类对象隐式的保存了一个引用,指向创建他的外围类对象。
 * 但是static就不是，嵌套类意味着：
 * 1.创建嵌套类对象，不需要外围类对象
 * 2.不能从嵌套类的对象中访问非静态的外围类对象
 * 普通的内部类不可以有static字段，也不能包含嵌套类，但是嵌套类可以有
 * @author hero
 *                  
 */
public class Show5 {
    public  static class hungry{

    }



}


    class dinner{
        hungry h=new hungry();
    }