Java内部类

1.成员内部类：直接在类中定义的类

     在外部为内部类实例化时，需要依赖外部类的对象来创建
     格式：外部类名.内部类名   内部类对象名=外部类对象.new  内部类名
     通常情况下，不建议这样实例化内部类的对象
     解决方法：
     一般在外部类中定义一个方法，对外提供访问内部类的接口

public class interiorKindTest {
    public static void main(String[] args) {
    make s=new make();
    s.interiorKind();
    //在外部为内部类实例化时，需要依赖外部类的对象来创建
    //通常情况下，不建议这样实例化内部类的对象
    //格式：外部类名.内部类名   内部类对象名=外部类对象.new  内部类名
  //  make.ya s2=s.new ya();
  }
}

class make{
    public make(){}

    //一般在外部类中定义一个方法，对外提供访问内部类的接口
    public void interiorKind(){
        //创建内部类对象，使用内部类对象来调用内部类的方法
        ya s1=new ya();
        s1.print();
    }

  private   class ya{
        public  void print(){
            System.out.println("成员内部类");
        }
    }
}

成员内部类

 2.方法内部类：在类中的方法内定义的一个类

      (1)方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外实例化
      (2)方法内部类对象不能使用该内部类所在方法的非final局部变量
 

public class interiorKindTest {
    public static void main(String[] args) {
        niu niu=new niu();    //将外部类实例化调用方法内部类所在的方法
        niu.eat();
   }
}
class niu{
    public  niu(){}
    public void eat(){
        class xn{
            public void print(){
                System.out.println("dsfw");
            }
        }  
        xn x=new xn();  //讲方法内部类实例化
        x.print();  //调用方法内部类中的方法
    }
}

  3.  静态内部类：在类中定义一个静态修饰的内部类

      静态的含义是该内部类可以像其他静态成员一样，没有外部类对象时，也能访问
      静态嵌套类仅能访问外部类的静态成员和方法
  静态内部类实例化时，不会像成员内部类一样依赖外部类的对象，静态内部类不需要先创建外部类的对象
 

public class interiorKindTest {
    public static void main(String[] args) {
//静态内部类实例化时，不会像成员内部类一样依赖外部类的对象，静态内部类不需要先创建外部类的对象
        ace.xx xc=new ace.xx();    //格式有点像成员内部类实例化，但不完全一样
        xc.printf();
  }
}
//...............静态内部类..................
class ace{
    public ace(){}
    private String name;
    static class xx{
        public void printf(){
            System.out.println("静态内部类");
        }
    }
}

  4.匿名内部类：就是没有名字的内部类

 匿名内部类使用原则：
      (1)不能有构造方法，只能有一个实例
      (2)不能定义任何静态成员，静态方法
      (3)不能是public,protected,private,static
      (4)一定是在new的后面，用其隐含实现一个接口或实现一个类
      (5)匿名内部类为局部的，所以局部内部类的所有限制都对其生效
 

      (1)继承式内部类

public class interiorKindTest {
    public static void main(String[] args) {
//----------------------接口式匿名内部类---------------------
        wc wc=new wc();
        wc.print();
  }
}
//...............继承式匿名内部类..................
class wc{
   public void print(){
   //这个大括号就是实现的这个类，没有名字的
       wce wce=new wce() {
           @Override
           //继承过来了需要重写方法
           public void print1() {
               System.out.println("继承式匿名内部类");
           }
       };wce.print1();
   }
}
abstract class wce{
    abstract public void print1();
}

      (2)接口式内部类

public class interiorKindTest {
    public static void main(String[] args) {
//----------------------接口式匿名内部类---------------------
        in in=new in();
        in.print2();
  }
}
//...............接口式匿名内部类..................
class in{
    public void print2(){
        inter w=new inter() {
            public void print22(){
                System.out.println("接口式匿名内部类");
            }
        };w.print22();
    }
}
interface inter{
          void print22();
}

      (3)参数式内部类

public class interiorKindTest {
    public static void main(String[] args) {
//-------------------参数式匿名内部类----------------------
        myClass my=new myClass();
        
      my.print3(new fun() {//调用方法把这个大括号当成一个接口的实现
          @Override
          public void function() {
              System.out.println("参数式匿名内部类");
          }
      });
    }
}
//...............参数式匿名内部类..................
class myClass{
    public void print3(fun fun){
        fun.function();
    }
}
interface fun{
     void function();

}