学习android学习必备的java基础知识--四大内部类

学习android必备的java基础知识--四大内部类

今天学习android课程，因为我的主专业是JAVA，但是兴趣班却有这其他专业的同学，学习android 需要具备一些java的基础知识，因此就总结了一下关于四大内部类的知识。

备注： java语言中允许类中再次定义类，这种在其它类内部定义的类叫内部类，内部类分为四种:常规内部类(成员内部类),局部内部类(方法内部类),匿名内部类,静态嵌套内部类

一、常规内部类

　　其实常规的内部类就是第一种（成员内部类）　当然　成员内部类由于高内聚，不对外开放原则，比较少用到

/*
 * 定义类
 *
 */
public class BigDog {
    //BigDog 的成员方法
    public void GiveChild(){
        System.out.println("母狗生孩子！");
    }
    //定义成员变量内部类  成员内部类
    public class SmallDog{
        //成员内部类的方法
        public void SamllSuck(){
            System.out.println("吃奶!");
        }
    }
}

　　如何调用成员内部类，在这里定义的内部类，可以实例化创建，但是又因为是类，引用一个类的前提需要new 对象才能通过点方法的调用

/*
 * 定义类
 *
 */
public class BigDog {
    //BigDog 的成员方法
    public void GiveChild(){
        System.out.println("母狗生孩子！");
    }
    //定义成员变量内部类  成员内部类
    public class SmallDog{
        //成员内部类的方法
        public void SamllSuck(){
            System.out.println("吃奶!");
        }
    }
    //测试
    public static void main(String[] args) {
        SmallDog sd = new BigDog().new SmallDog() ;
        sd.SamllSuck();
    }
}

编译一下，我们看到目录中出现了两个class文件，其中有一个文件名叫做BigDog$SmallDog.class，带了一个$符号，这个特点让我们很容易的认出来这是内部类编译后的class文件。

我们来对内部类做一个总结：

1. 内部类就像一个实例成员一样存在于外部类中。
2. 内部类可以访问外部类的所有成员就想访问自己的成员一样没有限制。
3. 内部类中的this指的是内部类的实例对象本身，如果要用外部类的实例对象就可以用类名.this的方式获得。
4. 内部类对象中不能有静态成员，原因很简单，内部类的实例对象是外部类实例对象的一个成员。

内部类创建的方法:

1. 在外部类的内部，可以用可以用SmallDog sd = new  SmallDog() ;  方法直接创建;
2. 在外部类外部，必须先创建外部类实例，然后再创建内部类实例。

二、局部内部类

局部内部类又称之为方法内部类，顾名思义，就是类中的方法定义类：

/*
 * 定义一个类
 */
public class Out {

    //定义一个成员变量
    private String outName;

    //定义一个方法
    public void outFunction(){
        //定义方法变量
        int i = 2 ;
        //定义方法内部类(局部内部类)
        class Inner{
            int j = 3 ;
            //局部内部类的方法
            void print(){
                int x = 4 ;
                System.out.println("此处是局部内部类的方法体内容！");
            }
        }

        //调用Inner 局部内部类
        Inner inner = new Inner();
        inner.print();
    }
    //测试
    public static void main(String[] args) {
        Out out = new Out();    //创建对象
        out.outFunction();        //调用方法
    }
}

最终执行的代码：

我们来对局部内部类进行总结吧：

1. 局部内部类的地位和方法内的局部变量的位置类似，因此不能修饰局部变量的修饰符也不能修饰局部内部类，譬如public、private、protected、static、transient等
2. 局部内部类只能在声明的方法内是可见的，因此定义局部内部类之后，想用的话就要在方法内直接实例化，记住这里顺序不能反了，一定是要先声明后使用，否则编译器会说找不到。
3. 局部内部类不能访问定义它的方法内的局部变量，除非这个变量被定义为final 。

三、匿名内部类

当我们把内部类的定义和声明写到一起时，就不用给这个类起个类名而是直接使用了，这种形式的内部类根本就没有类名，因此我们叫它匿名内部类，同时，在安卓开发中，是使用比较多的，也是最重要的一种内部类

第一： 首选定义一个家长的接口类：Patriarch

/*
 * 定义一个家长的接口类
 *
 */
public interface Patriarch {
    //定义接口方法
    public void JiaoXiaoHai();
}

第二： 定义一个抽象的教师类  并实现一个教师另外的一个身份家长的接口类

 /*
  *
  * 定义一个抽象的教师类  并实现一个教师另外的一个身份  家长 的接口
  *
  */
 public abstract class Teacher implements Patriarch{
     //定义方法
     public void doWork(){
         System.out.println("在工作！");
     }
 }

第三：定义一个具体的教师类  “何教师”  具体化实现类

 /*
  * 具体的教师类  何教师  具体化实现
  */
 public class HeTeacher extends Teacher{

     @Override
     public void JiaoXiaoHai() {
         System.out.println("教两个小孩子！");
     }
 }

最后定义一个测试类：

 /*
  *  定义一个Test类 进行测试
  */
 public class Test {

     //定义一个main 方法
     public static void main(String[] args) {
         //何老师
         HeTeacher heteacher = new HeTeacher();
         heteacher.doWork();
         heteacher.JiaoXiaoHai();
         /*
          * 每次需要具体化实现教师 都必须要进行创建一个对象，也就是说要写一个具体类，这就显得比较复杂麻烦
          */
         System.out.println("===============分割线===================");
         /*
          *    采用匿名局部内的来创建对象
          */
         //创建Teacher
         Teacher Xuteacher = new Teacher(){
             @Override
             public void JiaoXiaoHai() {
                 System.out.println("许老师在教一群孩子！");
             }
         };
         Xuteacher.doWork();
         Xuteacher.JiaoXiaoHai();
     }
 }

由上路的代码可见，其实匿名内部类中，需要具体化对象的实现的话，进行直接匿名创建对象，这样就显得比较方便，不至于每次的要使用不同的具体类都得new 文件 写好，直接采用匿名方式，进行实现便可。

四、静态嵌套类

 静态嵌套类相对于以上三种内部类比较简单，也就是多个一个静态的static关键字

例子： 

 /*
  *     定义一个 类
  */
 public class Out {

     //定义静态变量
     static int x = 1 ; 

     //定义静态内部类
     static class OutClass{
         //定义静态内部类的方法
         void print(){
             System.out.println("此方法是Out类的静态内部类");
         }
     }

     //main 方法测试
     public static void main(String[] args) {
         Out.OutClass out = new Out.OutClass();
         out.print();
     }
 }

静态嵌套内部类和其他静态方法一样只能访问其它静态的成员，而不能访问实例成员。因此静态嵌套类和外部类（封装类）之间的联系就很少了，他们之间可能也就是命名空间上的一些关联。

各位小伙伴，我来一个温习提示下：内部类在Android中应用的非常多，理解和多多使用很重要，希望我的理解加上大家的努力相信可以一直往前的，加油，同时，如果分享中的内容有错，或者小伙伴有何更好的见解，那就多多联系我吧，毕竟我是初学者嘛，再此致敬。