JAVA学习笔记——归纳总结篇（二）

最新推荐文章于 2024-04-18 11:11:16 发布

Nahm Gan

最新推荐文章于 2024-04-18 11:11:16 发布

阅读量404

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/XmYinu/article/details/102712309

版权

java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

JAVA学习笔记——归纳总结篇（二）

内部类

什么是内部类

任何一个类都可以在内部定义另外一个类，前者为外部类，后者为内部类。内部类本身就是类的一个属性，因此它与其他属性的定义一致，由访问控制符、是否静态、类型、变量名组成。类型可为class、enum。

4种内部类：

静态内部类：被static作为静态成员属性存在，可以被任意权限修饰符修饰。如：static class 类名{ }; public static class 类名{ };
成员内部类：作为成员存在，可以被任意权限修饰符修饰。如：private class 类名{ }; public class 类名{ };
局部内部类：定义在方法或者表达式内部。类前不能有权限修饰符。只能在方法内使用。
匿名内部类：没有名字的内部类。因为没名字，所以只能用一次。使用匿名内部类有个前提条件，必须继承一个父类或实现一个接口。

内部类的作用：

内部类的作用：当类与接口（或者是接口与接口）发生方法命名冲突的时候，此时必须使用内部类来实现。用接口不呢饿呢过完全地实现多继承，用接口配合内部类才能实现真正的多继承。
各种内部类的特点：

静态内部类：随着类的加载而产生。静态只能访问外部类的静态成员。
成员内部类：不能有静态信息。可以访问外部类的静态和非静态的方法和成员变量。
局部内部类：不能使用任何的访问修饰符。如果要访问局部变量，那么这个变量必须声明为最终类型，也就是final类型。
匿名内部类：不能定义任何静态成员、方法。定义的方法不能是抽象的。匿名内部类必须实现接口或抽象父类的所有抽象方法。匿名内部类访问的外部类成员变量或成员方法必须用static修饰。匿名内部类主要是那些只需要使用一次，很少被其他地方使用的类，监听器类常写作匿名内部类。可以减少类的个数。

例子：

静态内部类：

OuterClass.java:

public class OuterClass {
    private String ofrist = "外部类第一个变量(非静态)";
    private static String osecond = "外部类第二个变量(静态)";
    
    //静态内部类
    public static class InnerClass{
     private String ifrist = "内部类第一个变量(非静态)";
     private static String isecond = "内部类第二个变量(静态)";
     
     public void InnerClass(){
      //无法访问外部类非静态成员
      //System.out.println(ofrist);  
      System.out.println(osecond);
      System.out.println(ifrist);
      System.out.println(isecond);
     }
    }
}

Test.java:

public class Test {
     public static void main(String[] args) {
         OuterClass.InnerClass oi = new OuterClass.InnerClass();
     }
}

成员内部类：

OuterClass.java:

public class OuterClass {
    private String ofrist = "外部类第一个变量(非静态)";
    private static String osecond = "外部类第二个变量(静态)";
    
    //成员内部类
    public class InnerClass{
     private String ifrist = "内部类第一个变量(非静态)";
     //private static String isecond = "内部类第二个变量(静态)";
     
     public void InnerClass(){
      System.out.println(ofrist);  
      System.out.println(osecond);
      System.out.println(ifrist);
     }
    }
}

Test.java:

public class Test {
     public static void main(String[] args) {
         OuterClass oi = new OuterClass();
         OuterClass.InnerClass inner = oi.new InnerClass();
     }
}

局部内部类：

OuterClass.java:

public class OuterClass {
 private String ofrist = "外部类第一个变量(非静态)";
 private static String osecond = "外部类第二个变量(静态)";
 public static void main(String[] args) {
  OuterClass outer = new OuterClass();
  outer.outerCreatMethod();
 }
 public void outerCreatMethod() {
  class Inner {
   private String ifrist = "内部类第一个变量(非静态)";
   public void innerShow() {
    System.out.println(ifrist);
    //调用外部类的信息
    System.out.println(ofrist);  
    System.out.println(osecond);
   }
  }
  //局部内部类只能在方法内使用
  Inner inner = new Inner();
  inner.innerShow();
 }
}

匿名内部类：

interfance Product
{
  public double getPrice();
  public String  getName();
}

public class Anonymous
{
  public void test (Product p)
  {
      System.out.println(p.getName()+"--------"+p.getPrice());
  }
  public static void main(String [ ] args )
    {
        Anonymous as= new Anonymous ();
          as.test(new Product( )//此处实现接口并实现抽象方法
            {
               public double getPrice( )//实现方法
                 {
                    return 8888;
                  }
                 public String getName( )//实现方法
                  {
                     return "I can do it ";
                  }

            });
    }
}