我的Android第二章

前言

之前有很多人遇到了关于内部类的问题【主要在android的学习之中会大量的使用到】,内部类是什么,内部类怎么定义,内部类的分类,内部类的好处,内部类如何访问,这里我们来结合代码简单的理解一下

1.内部类是什么?

  当一个类的定义是在另一个类的内部,那么我们就把这个定义在类的内部的类为内部类.

  上代码:

public class Outer{
   class Inner{
       public void show(){
          System.out.println("我是内部类");
       } } }

 

  这段代码中Outer类相对Inner是外部类,其中Inner是一个类,它定义在Outer类内部,那它就是内部类.

2.内部类的分类?

  内部类主要通过类在外部类中的位置来区分

  1.成员内部类{成员级别的类}

  位置:类中方法外定义的类

  顾名思义这个类是定义在外部类的成员中

  上代码:

public class Outer{
   private String aa ;
   class Inner{
       public void show(){
          System.out.println("我是成员内部类");
       }  
   }
   public void show(){
       System.out.println("Inner类没有定义在我这方法中");
   }
}

 

  可以看到,Inner类是与成员aa是一个级别的都是定义在类中方法外的级别,他们统一是成员级别的,像这种情况下定义的类,我们就叫他成员内部类,成员内部类重点就是定义在类中方法外部

 

  2.方法内部类[局部内部类]

  位置:类中方法内定义的类.

  这个类的定义是在类的内部方法的内部

  上代码:

public class Outer{
   private String str;
   public void show(){
       System.out.println("我是show方法");
       class Inner{
          public void InnerMethod(){
              System.out.prinltn("我是局部内部类");
          }
       }
   }
}    

 

  我们可以看到代码中内部类的定义位置在类中方法内,这样的类我们称之为局部内部类,有的地方也叫方法内部类

 

  3.匿名内部类

  特点:是局部内部类的简化形式

  前提:存在一个借口或者类

  格式: new 类名或者接口名称(){

    //要重写接口或者类的方法

  };

  代码:

  提供一个类或者接口,这里我们提供一个接口MyInter:

public interfact MyInter{
    public void show();
}

 

  提供一个类Outer来体现匿名内部类:

public class Outer{
    public void show(){
         MyInter m = new MyInter(){
             public void show(){
                 System.out.println("我是匿名内部类");
             }
         };
    }

}    

3.内部类的访问和好处

  1.成员内部类的访问和好处

    (1)访问规则

    成员内部类可以访问外部类的资源,包括私有,外部类想要访问内部类成员必须创建对象

    基本语法是 外部类名.内部类名 对象名 = new 外部类名().new 内部类名();

public class Outer{
   private String s ;
   class Inner{
     private String s ;
      public void show(){
         System.out.println("你好"); 
         System.out.println(s);                                  //访问外部类的成员
     }  
   }
   
   public static void main(String[] args){
       Outer.Inner inner = new Outer().new Inner();//这是统一的访问方式  
       inner.s ="2" ;
       //外部类访问内部类资源
   }

}    

  2.静态内部类的访问规则

  语法:外部类名.内部类名 对象名 = new 外部类名.内部类名();

public class Outer{
   static class Inner{
        public void show(){
              System.out.println("你好");
        }  
   }
   public static void main(String [] args){
        Outer.Inner inner = new Outer.Inner();
        //静态内部类的访问方法
        inner.show();
   }
}                

   3.根据访问修饰符还可以有private,protected修饰的类

    外部类不能被private,protected修饰,但是内部类可以

public class Outer{

    private class Ts{
        
    }
    protected class Ta{
        
    }

}

-----------注意:使用private修饰的类为了数据的安全,使用static修饰的类访问更方便--------------

  4.局部内部类的好处和访问语法

  好处:保护数据的安全

  代码:

public class  Outer{
    public void show(){
       private final int a ;
       class Inner{//成员内部类不能被private,public,protected修饰
          public void meth(){
            System.out.println("我是局部内部类");
System.out.println("访问show方法变量a"+a+",这个变量必须加final");
          }
       }
       //方法中才能访问Inner
      Inner i = new Inner();
       i.meth();
   }
}    

  注意:局部内部类访问的局部变量必须加final修饰,局部内部类的访问只能在方法内部new

  好处是:可以随着方法的调用完毕而销毁

  5.匿名内部类的使用和好处[Android中常见的调用方法]

  1)先看一个例子,简单的多态

       定义一个接口MyInter

public interface MyInter{
   public void show();
}

    2)此时我们想实现这个接口,调用方法,所以我们可以定义一个类实现MyInterImpl1接口

public class MyInterImpl1 implements Myinter{
    public void show(){
        System.out.println("我是实现接口一");
    }
}

   3)定义测试类MainTest

public class MainTest{
   public static void main(String[] args){
      MyInter i = new MyInterImpl1();
      //根据多态原则我们调用
      i.show();
      ///输出我是实现接口一      
   }
}

  4)问题来了:我还想要一个实现类或者说我的某个方法中需要一个MyInter的实现类,根据多态原则,我们需要一个与MyInterImpl1不一样的实现类

    简单,我们在定义一个

public class MyInterImpl2 implements Myinter{
    public void show(){
        System.out.println("我是实现接口二");
    }
}

      5)同样调用

public class MainTest{
   public static void main(String[] args){
      MyInter i = new MyInterImpl2();
      //根据多态原则我们调用
      i.show();
      ///输出我是实现接口二     
   }
}

   6)但是此时我们有问题了,我们可能有很多的需要实现的地方,当时有的时候这些实现的类可能仅仅只是使用一次,我们就可能不会在调用,

    难道我们都要给他们专门写一个类来描述吗?假设现在MyInterImpl3这个类实现了MyInter,方法描述中提供了一个添加的算法

public class MyInterImpl2 implements Myinter{
    public void show(){
        System.out.println(1+2);
    }
}

    上面的代码我们可能只执行一次,我们只调用一次,这个时候怎么办,java提供了一个概念,匿名内部类

    改变MainTest中的代码:

public class MainTest{
   public static void main(String[] args){
     //下面我们使用匿名内部类的语法   
      MyInter i = new MyInter(){
          public void show(){
              System.out.println("你好,我是匿名内部类”);
          }  
      };
    i.show();
   }
}

 

  上面的代码中,我们可以看到,类名或者接口名 对象名 = new 类名或者接口名(){

      //实现代码

    };这样的语法

    这样的好处第一个可以体现出来,我们可以看到,无需再新建一个类来实现MyInter接口,只需要提供一个匿名内部类,他就像直接实现了MyInter接口一样,

  实现里面的方法,实例化接口,调用接口的方法,根据多态,实则调用实例化类的方法,这就是匿名内部类的第一个好处;

  我们再来看看

public class MainTest{
   public static void main(String[] args){
       mainShow(?????);//这里我们可以怎么用到匿名内部类呢?
   }
   static void mainShow(MyInter i){
       i.show();
   }
}

  代码改写:

public class MainTest{
   public static void main(String[] args){
       mainShow(new MyInter(){
           public void show(){
              System.out.println("我是匿名内部类");
           }
       });
        
   }
   static void mainShow(MyInter i){
       i.show();
   }
}        

  代码改变后,可以看到,匿名内部类作为参数传递,那么可以大胆的想到参数是随着方法调用完毕由虚拟机回收的,那么匿名内部类作为参数传递,我们可以认为匿名内部类可以减少资源的消耗

 

以上是我对内部类的一些理解,如果有什么建议,希望大家一起讨论

 

 

 

 

 

 

  

 

posted @ 2016-11-16 15:14  小明000  阅读(356)  评论(0编辑  收藏  举报