黑马程序员—— 7,内部类

------<ahref="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

                                                        黑马程序员——  7,内部类

/*
    内部类的介绍与例子
*/
class Person //外部类，外部类不能被私有化
{
   private int x=10;
         private  class Xinzang//内部类，内部类可以被私有修饰
         //如果内部类被私有修饰之后，外部类调用时还是可以建立内部类的对象
         {
                   void  function()
                   {
                        System.out.println("人类心脏跳动"+x);
//内部类可以直接访问外部类成员（包括外部类私有成员）
            //这句话打印的是“人类心脏跳动10”
                   }
        
         }
         void  method()
         {
               Xinzang a=new Xinzang();//外部类的方法要访问内部类成员，先要建立内部类对象
 
                     a.function();
         }
}
class Animal
{
         private  int x=50;
         class  Xinzang  //动物类里面也有一个心脏类
         {
                   void  function()
                   {
                       System.out.println("动物心脏跳动"+x);
                   }
         }
         void  method()
         {
              Xinzang a=new Xinzang();
                    a.function();
         }
}
class Bird//鸟类
{
         private  int y=16;
         class  Xinzang
         {
                   inty=17;
                   void   function()
                   {
                            inty=18;
           System.out.println("鸟的心脏跳动"+y);
//打印的是“鸟的心脏跳动18”
                            System.out.println("鸟的心脏跳动+this"+this.y);
//打印的是“鸟的心脏跳动+this17”
                            System.out.println("鸟的心脏跳动+Bird.this"+Bird.this.y);
 //打印的是“鸟的心脏跳动+Bird.this16”
 
                   }
         }
         void  method()
         {
              Xinzang a=new Xinzang();
                    a.function();
         }
}
class Neibulei//其他类
{
         public  static void main(String[] args)
         {
                   Personren=new Person();
       ren.method();
                   Animal.Xinzang  s=new Animal().new Xinzang();
                   /*
                   在其他类直接访问内部类时，引用型变量前面要写全称
                   而且后面既要新建外部类对象又要新建内部类对象。
                   */
                   s.function();
                   /*Person.Xinzangs2=new Person().new Xinzang();
                   如果内部类被私有化了就不能在其他类直接访问,否则编译出问题
        */
       Bird s3=new Bird();
                   s3.method();
                   System.out.println("HelloWorld!");
         }
}

/*
    内部类的一些小知识点
         以下是讨论局部的内部类
*/
 
class Person  //外部类
{
         int  cishu=12;
         void  method(final int ji)//ji是method方法的局部变量
         /*
         为什么这里可以用final修饰ji呢？
         因为method方法在栈内存中每执行一次就会释放消失，
         执行过程中ji被锁定，执行完一次后method被释放，
         第二次method被调用，接收的ji被锁定，这和第一次接收的ji的值不一致也没有关系
         */
         {
                   //ji++;这句话编译不通过，因为接收过来的ji被锁定了，不可以更改
                   int  cishu =13;
                   final  int ji2=23;//ji2也是method方法的局部变量
              class Xinzang
                   //类成员的内部类,因为static只能够修饰成员变量和成员方法，
                    //所以此时，类成员的内部类不可以静态化
              {
                             int cishu =14;
                             /*
                             static void function1(){}
                             内部类中存在静态成员，该内部类就是静态的,
                             但是这个Xinzang类是类成员的内部类，不能被静态化，
                             所以，static voidfunction1(){}不能静态化
                             */
                             void function()
                             {
                                      int cishu =15;
                                 System.out.println("人类的心脏跳动+"+cishu);
                                      //这句话打印的是“人类的心脏跳动+15”
                                      System.out.println("人类的心脏跳动+this"+this.cishu);
                  //这句话打印的是“人类的心脏跳动+this14”
                                      System.out.println("人类的心脏跳动+Person.this"+Person.this.cishu);
                  //这句话打印的是“人类的心脏跳动+Person.this12”
                             }
              }
                    class Shenzang//肾脏类，也是类成员的内部类
                    {
                                      void function()
                                 {
                     System.out.println("打印的是ji_"+ji);
                                                System.out.println("打印的是ji2_"+ji2);
 /*
 对于类成员的内部类所在的局部的变量来说，类成员的内部类只可以访问带有final修饰的所在局部的局部变量
*/                              }
                    }
                    new Xinzang().function();//匿名对象一次调用Xinzang类
                    new Shenzang().function();
         }
}
class Neibulei2  //其他类
{
         public  static void main(String[] args)
         {
       Person a=new Person();
                   a.method(78);
                   System.out.println("HelloWorld!");
         }
}

/*
  匿名内部类的一些介绍
*/
abstract class Xinzang//抽象的心脏类
{
  public  abstract void method();
}
interface Shenzang//肾脏接口
{
         publicabstract void method();
}
class Niming
{
         publicstatic void main(String[] args)
         {
       Xinzang a=new Xinzang(){
                  
                   publicvoid method()
                   {
                            Syatem.out.println("心脏在跳动");
                   }
                   };//直接在一个大括号里面实现抽象的心脏类，这就是匿名内部类
                   //这种形式就是匿名内部类，匿名内部类实际可以理解为带内容的子类对象
                   a.method();
 
       new Xinzang(){
                  
                   publicvoid method()
                   {
                            Syatem.out.println("心脏在跳动");
                   }
                   }.method;
 
                   newShenzang(){
         public   void  method()
                     {
                         System.out.println("肾脏处问题了");
                     }
 
                   }.method;
                   //接口就是特殊的抽象类，所以，在匿名内部类的写法上都是相同的
                   System.out.println("HelloWorld!");
         }
}