黑马程序员——面向对象-----内部类

———–android培训、java培训、java学习型技术博客、期待与您交流！————
第一部分： 内部类的概述：
将类定义在另一个类的内部则成为内部类。其实就是类定义的位置发生了变化。在一个类中，定义在类中的叫成 变量，定义在函数中的叫成员函数，那么根据类定义的位置也可以分为成员内部类和局部内部类。

备注：内部类生产的class文件为 “外部类$内部类”，为了标明该内部类是属于具体哪个外部类的。
例如：
class Outer{
    int num = 10;
    class Inner{
     int age = 10;
     //内部类定义函数
     public void print(){
        System.out.println("内部类");
}

}
public void show(){
System.out.println(“外部类”);
}
}
第二部分：
成员内部类的访问方式：
1.内部类可以直接访问外部类的成员属性。(孙悟空相当于内部类飞到牛魔王的肚子里面去)。
2.外部类需要访问内部类的成员属性时需要创建内部类的对象。
（1）.在外部类的成员函数中创建内部类的对象，通过内部类对象对象直接访问内部类的成员。
（2）.在其他类中直接创建内部类的对象。
Outer.Inner inner = new Outer().new Inner();

疑问： 什么时候使用内部类呢？
当我们分析事物时，发现事物的内部还有具体的事物，这时则应该定义内部类了。
比如人体是一个类，人体有心脏，心脏的功能在直接访问人体的其他内容。这时就将心脏定义在人体类中，作为内部类存在。
内部类的优势：成员内部类作为外部类的成员，那么可以访问外部类的任意成员。

第三部分：成员内部类访问细节
class Outer{
int i = 1;
//私有的类，只有在当前Outer类可见
private class Inner{
int i = 10;
//内部类定义函数
public void print(){
System.out.println(i);
}
}
public void show(){
new i.println();
}
}
class Demo1{
public static void main(String []args){
Outer.Inner inner = new OuterInner().new Inner();
inner.print();
}
}

注意： 私有的成员内部类不能在其他类中直接创建内部类对象来访问。

如果内部类中包含有静态成员，那么java规定内部类必须声明为静态的访问静态内部类的形式：Outer.Inner in = new Outer.Inner();

总结：成员内部类(成员属性、成员方法)特点:
1.私有的成员内部类
特点：不能在其他类中直接创建内部类对象来访问
2. 静态的成员内部类
特点：如果内部类中包含有静态成员，那么java规定内部类必须声明为静的
访问静态内部类的形式：
Outer.Inner in = new Outer.Inner();

第四部分：1.4局部内部类
局部内部类概述：包含在外部类的函数中的内部类称之为局部内部类。
访问：可以在包含局部内部类的方法中直接创建局部内部类的对象调用局部内部类的成员。
注意：局部内部类只能访问所在函数的fanal属性。

class Outer{
String name= “外部类的name”;
public void test(){
//局部变量
final int y =100;
//局部内部类
class Inner{ /*

        int x = 10;
        public void print(){
            System.out.println("这个是局部内部类的print方法.."+y);
        }   
    }   
    Inner inner = new Inner();  //这个inner对象什么时候消失？  Inner对象的生命周期比局部变量y的生命周期要长。
    inner.print();
}

}
class Demo5
{
public static void main(String[] args)
{
Outer outer = new Outer();
outer.test();
}
}

第五部分：
匿名内部类：就是没有类名字的内部类。
匿名内部类作用：简化内部类书写。
匿名内部类的前提:必须继承一个父类或者是实现一个接口。
匿名内部类的格式：
new 父类或者接口(){ 执行代码….};
内部类的写法：
abstract class Animal{
public abstract Animal run();
public abstract void sleep();
}
class Outer{
public void print(){
//需求： 在方法内部定义一个类继承Animal类，然后调用run方法与sleep()。
/*
//局部内部类
class Dog extends Animal{

        public void run(){
            System.out.println("狗在跑..");
        }

        public void sleep(){
            System.out.println("狗趴在睁开眼睛睡..");
        }
    }

    //创建对象
    Dog d = new Dog();
    d.run();    
    d.sleep();
    */  
    //匿名内部类 ：匿名内部类只是没有类名，其他的一概成员都是具备的。
    // 匿名内部类与Animal是继承 的关系。  目前是创建Animal子类的对象. 
Animal  a = new Animal(){  //多态

        //匿名内部的成员 
        public Animal run(){
            System.out.println("狗在跑..");
            return this;
        }
        public void sleep(){
            System.out.println("狗趴在睁开眼睛睡..");
        }
        //特有的方法
        public void bite(){
            System.out.println("狗在咬人..");
        }
    };
    a.bite();
    a.run();
    a.sleep();  
}

}
class Demo6
{
public static void main(String[] args)
{
Outer outer = new Outer();
outer.print();
}
}