Java SE入门（十二）——修饰符与内部类

iwehdio的博客园：https://www.cnblogs.com/iwehdio/

1、包和修饰符

系统的分类 java 文件

• 包的特点：

  • 可以有多层结构。如对于com.demo，com和demo是两层包结构。
  • 不同包下的文件名可以重复。
  • 包的声明必须是第一行代码。

• 相同包下的类可以直接访问。

• 不同包下的类：

  • 使用写类的全名： 包名.全名。如java.util.ArrayList。
  • 使用 import 导入：import 类的全名。
  • 使用 import 包名 * ：导入了这个包下所有的类，但并没有导入子包下的类。

• 权限修饰符：

  • public公有：可以在当前类、相同包下不同的类、不同包下的类使用。
  • default默认（无任何修饰符）：可以在当前类、相同包下不同的类使用。
  • private私有：可以在当前类下使用。
  • protected受保护的：可以在当前类、相同包下不同的类使用。
  • default只能在当前包下使用，protected被继承时可以让子类对象使用。

• 修饰符总结（可以修饰什么）：

  修饰符	类	成员变量	成员方法	构造方法
  public	Y	Y	Y	Y
  default	Y	Y	Y	Y
  protected		Y	Y	Y
  private		Y	Y	Y
  abstract	Y		Y
  static		Y	Y
  final	Y	Y	Y

• 常见规则：

  • 用 public 修饰类，一个Java文件中只有一个类。
  • 如果一个文件中有多个类，类名和文件名一样的类名，必须用 public 修饰，其他的类不能用 public 修饰。
  • 所有成员变量都用 private 修饰。
  • 一般成员方法都用 public 修饰。
  • 除非不想创建对象，构造方法都用 public 修饰。

2、内部类

• 内部类：

  • 分为成员内部类、局部内部类和匿名内部类。
  • 仍然是一个独立的类，编译后有独立的 .class 文件。

• 成员内部类：成员位置上的普通类。

  • 内部类是外部类的成员，和成员方法和变量的位置一致。

  • 可以在外部类的成员方法中创建内部类的对象。

  • 内部类可以访问外部类中的成员和私有成员。

  • 如果要直接访问内部类需要导入，或者使用 外部类名.内部类名 的格式。

  • 例：

    /*方法1：import导入
    import Outer.Inner;*/
    public class Demo {
        public static void main(String[] args){
            //方法2：外部类名.内部类名
            Outer.Inner i = new Outer().new Inner();
            i.function();
        }
    }
    class Outer{
        private int num = 10;
        public void method(){
            Inner i = new Inner();
            i.function();
        }
        class Inner{
            public void function(){
                System.out.println("Inner");
            }
        }
    }
    

  • 成员内部类的修饰符：

    • 如果用 private 则无法在其他类中访问。
    • 可以用 public 、 default 和 protected。
    • 可以使用 static ，不用创建外部类对象；Outer.Inner i = new Outer.Inner();。如果内部类中还有静态方法，可以也不用创建内部类对象；Outer.Inner.function();。

• 局部内部类：与局部变量的位置相同。

  • 定义在成员方法中，调用要在声明之后。

  • 出了所定义的方法就消失了。

  • 例：

    public class Demo {
        public static void main(String[] args){
            Outer o = new Outer();
            o.method();
        }
    }
    class Outer{
        private int num = 10;
        public void method(){
            class Inner{
                public void function(){
                    System.out.println("Inner");
                }
        	}
            Inner i = new Inner();
            i.function();
        }
    }
    

• 匿名内部类：看成是没有名字的局部内部类，定义在方法中。

  • 必须在定义匿名内部类的时候创建对象。

  • 格式：

    new 父类/接口(){
        //如果是继承父类，可以重写父类的方法；
        //如果是实现接口，必须实现接口的所有方法。
        @Override
        public void function(){
            System.out.println("Inner");
        }
    }.function();
    

  • 原理：创建了继承这个类的子类对象或实现这个接口的子类对象。

  • 也可以向上转型，通过父类对象的多态接收匿名内部类：

    Inner i = new Inner{
        //如果是继承父类，可以重写父类的方法；
        //如果是实现接口，必须实现接口的所有方法。
        @Override
        public void function(){
            System.out.println("Inner");
        }
    };
    i.function();
    

  • 应用场景：

    • 作为参数进行传递，一般用于只使用一次的场景。

    • 例：

      public class Demo{
          public static void main(String[] args){
              method(
                  new Animal{
                      @Override
                      public void eat(){
                          System.out.println("Cat");
                      }
                  }
              )
          }
          public static void method(Animal a){
              a.eat;
          }
      }
      public interface Animal{
          public abstract void eat();
      }
      

iwehdio的博客园：https://www.cnblogs.com/iwehdio/