Java SE入门（十五）——修饰符和内部类

Java SE入门（十五）——修饰符和内部类　　iwehdio的博客园：https://www.cnblogs.com/iwehdio/java

一、包和修饰符

系统的分类 java 文件ide

包的特色：url
- 能够有多层结构。如对于com.demo，com和demo是两层包结构。
- 不一样包下的文件名能够重复。
- 包的声明必须是第一行代码。
相同包下的类能够直接访问。spa
不一样包下的类：.net
- 使用写类的全名：包名.全名。如java.util.ArrayList。
- 使用 import 导入：import 类的全名。
- 使用 import 包名 * ：导入了这个包下全部的类，但并无导入子包下的类。
权限修饰符：code
- 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

常见规则：blog
- 用 public 修饰类，一个Java文件中只有一个类。
- 若是一个文件中有多个类，类名和文件名同样的类名，必须用 public 修饰，其余的类不能用 public 修饰。
- 全部成员变量都用 private 修饰。
- 通常成员方法都用 public 修饰。
- 除非不想建立对象，构造方法都用 public 修饰。

二、内部类

内部类：继承
- 分为成员内部类、局部内部类和匿名内部类。
- 仍然是一个独立的类，编译后有独立的 .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();
}

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