面向对象_内部类

  在学内部类前，我自己先问了自己2个问题！

  1、什么是内部类呢？简单说：就是在一个类中在建立一个类。

  2、而为什么又要搞这个内部类呢？

  我想是为了在于现实中的一些建模问题吧，让事物更加形象。比如要建立“人体”这个类，有很多功能吧，比如“吃饭”，“看书”，而这些功能又需要“嘴巴”，“眼睛”。那么我们就不得不建立“嘴巴”“眼睛”这2个类，那么，在“人体”这个类中建立，则更形象，更接近事物。虽然你也能把“嘴巴”“眼睛”什么的建立在“人体”外，但是从现实中来看，这就...我想这就是内部类的意义吧！

 

  内部类也是类，不同的地方就在于他的访问规则、定义的原则以及自身的一些特点。

  **访问规则

  1.内部类可以直接访问外部类中的成员，包括私有之所以可以直接访问外部类中的成员，是因为内部类总持有了一个外部类的引用，格式：外部类名.this

  2.外部类要访问内部类，必须建立内部对象

  **访问格式

  1.当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中直接建立内部类对象，格式：外部类.内部类名变量名 = 外部类对象.内部类

Outer.Inner in = new Outer().new Inner();

  2.当内部类在成员位置上，就可以被成员修饰符修饰。

    比如，private：将内部类在外部类中进行封装

  ￥￥$$~~特别注意：static中的内部类的一些变换    

              static：内部类就具备static的特性

                  当内部类被静态修饰后，只能直接访问外部类中的静态成员了，出现了访问局限

                  在外部其他类中，访问静态内部类的非静态成员

                  new Outer.Inner().function();

                  在外部其他类中，访问静态内部类的静态成员

                  Outer.Inner.function();

  ￥￥$$~~  注意：

             1、当内部类中定义了静态成员，该内部类必须是静态成员

             2、当外部类的静态方法访问内部类时，内部类也必须是静态的 （虽然书上这样说，但可以不是必须的，比如这个程序：

class Outer
{ 
             class Inner
    {
          void show()
          {
                 System.out.println("fuck man");
           }
    }

public static void fuckMan()
    {
            Outer.Inner fuck=new Outer().new Inner();
                  fuck.show();     /*这样等于建立了 Inner的对象，然后访问show()，所以没问题，但是，这样做，方法fuckMan()和内部类就没有体现意义了。所以一般是利用把内部类Inner看成外部类Outer的成员属性，然后加上static，就可以访问了，然后是满足书上说的“必须”了~~哈哈    */

    }

}

class  InnerClassDemo
{
   public  static  void main(String[] args)
    {
             Outer.fuckMan();
            
    }
}

提示：更具体的看自己的笔记

 

**内部类访问特点：
1，内部类可以直接访问外部类中的成员。
2，外部类要访问内部类，必须建立内部类的对象。

$$￥￥~~注意：

  1、内部类能直接访问外部类中成员，是因为内部类持有了外部类的引用，即，外部类名.this。

  2、内部类也可以存放在局部位置上，但是内部类在局部位置上只能访问局部中被final修饰的局部变量。

 

还有一种为了更简单的书写内部类的一种格式：

**匿名内部类的特点

1.匿名内部类其实就是内部类的简写格式

2.定义内部类的前提：内部类必须是继承一个类或者实现接口

3.匿名内部类的格式：new 父类或者接口(){定义子类的内容}

4.其实匿名内部类就是一个匿名子类对象，而且这个对象内容较大，即带内容的对象

5.匿名内部类中定义的方法最好不要超过三个

来个例子吧：

先来有名字的，在来个匿名的~

//这是有名字的一种方法

interface Inter
{
    void method();
}

class Test
{    
     class MakLove implements Inter //该内部类 名字叫MakLove
     {  
     
         public void method()
          {
            System.out.println("MakLove");
           } 
       
      } 
   
  public static Inter function()
     {
               return new Test().new MakLove();      
      }    

class InnerClassTest
{
   public static void main(String[] args)
   {
         Test.function().method();//看到这东西就意味着，function是static，而Test.function一定要搞个对象出来了，要不就没人和method玩了
    }
}

//现在是匿名的方法
      

interface Inter
{
    void method();
}

 public static Inter function()
    {
     return new Inter()/*这便是没名字的，可怜的孩子，但是很明显，代码比上面少了。提示：这种东西一出现，那么就意味着继承或实现，匿名就这样*/

          {
               public void method()
              {
                 System.out.print("FucDo");     
              }     
 
           };
     }
               
}

class InnerClassTest
{
   public static void main(String[] args)
   {
         Test.function().method();
    }

}