内部类&包&权限修饰符

类中可以有平行类

一个文件中可以有多个并列关系的类

注意：一个java源文件中，只能有一个类被public修饰，且该类类名必须与文件名一致。

package com.offcn.Inner;

public class Inner {
}

class Outter2{
}

 内部类：

为什么存在内部类，因为内部类隐藏了代码，提高了安全性。

内部类的概述：

1.定义在类内部的类，就叫内部类，可以定义在方法的内部，也可以定义在类的内部。

2.根据定义的位置不同，可以分为：

　　　　　　　　　　成员内部类

　　　　　　　　　　局部内部类

3.成员内部类：

　　　　　　　　　　普通的成员内部类

　　　　　　　　　　私有的成员内部类

　　　　　　　　　　静态的成员内部类

4.局部内部类（方法内部类）：

5.根据表示的方式不同，可以分为：

　　　　有名字的内部类

　　　　匿名内部类

普通的成员内部类：

1.　　定义在成员位置上的类，就是成员内部类

2.　　定义格式：

　　　　class  内部类类名{

　　　　内部类成员

　　}

3.　　成员内部类的说明：

　　1.内部类可以直接访问外部类的所有成员，包括私有成员。

　　2.外部类访问内部类的成员，必须先创建内部类的对象。

　　3.在外部类以外，创建内部类的对象的格式：

　　　　外部类名.内部类名 内部类对象名 = new 外部类名( ).new 内部类名( );

代码示例：

class Demo01_普通的成员内部类 {
    public static void main(String[] args) {
        Body.Heart bh = new Body().new Heart();
        bh.show();

        Body b = new Body();
        b.test();
    }
}

class Body {
    private double hight = 149.0;

    class Heart {
        int beats = 80;

        public void show() {
            System.out.println(hight + "..." + beats + "...扑通扑通的跳");
        }
    }

    public void test() {
        Heart h = new Heart();
        h.show();
    }
}

 私有的成员内部类：

1.也是一个成员内部类，在成员内部类上加上一个private关键字。

2.访问方式说明：

　　1.在外部类以外，不能直接访问外部类中的私有成员内部类。

　　2.可以在外部类中，定义一个访问私有成员内部类的公有方法，让外界可以调用公有方法，间接的访问外部类中的私有成员内部类。

代码示例：

class Demo02_私有的成员内部类 {
    public static void main(String[] args) {
        Body b = new Body();
        //Body.Shen bs = b.new Shen();
        b.zouShen();
    }
}

class Body {
    private double hight = 149.0;

    private class Shen {
        int age = 40;

        public void show() {
            System.out.println("该走心的时候别TM找我..." + hight + "..." + age);
        }
    }

    public void zouShen() {
        Shen s = new Shen();
        s.show();
    }
}

 静态的成员内部类：

1.也是一个成员内部类，在成员内部类前加上一个static关键字。

2.访问特点：

　　1.静态成员内部类是外部类的静态成员，所以可以通过外部类名.内部类名的方式直接访问，而不需要创建外部类的对象。

　　2.静态内部类中的非静态成员，需要将所在的内部类对象创建出来以后，才能被调用。

　　3.总结;一个类是否需要创建对象，不取决于该类是否是静态，而取决于要访问的成员是否静态。

3.静态成员内部类的对象创建格式：

　　外部类名.内部类名　内部类对象名 = new 外部类名.内部类名（）；

代码示例：

class Demo03_静态成员内部类 {
    public static void main(String[] args) {
        //System.out.println("Hello World!");
        Body.Gan bg = new Body.Gan();
        bg.show();
    }
}

class Body {
    private double hight = 149.0;

    static class Gan {
        String color = "black";

        public void show() {
            Body b = new Body();
            System.out.println(b.hight + "..." + color + "求你了哥，放过我吧别喝了");
        }
    }

    public static void test() {}
}

 局部内部类：

1.局部内部类：定义在方法中的内部类

2.局部内部类的访问说明：

方法中的局部变量，外部都没有办法访问到

3.解决办法：

在方法内部，创建局部内部类的对象，调用对象的方法。

外界调用局部内部类所在的方法，间接的创建局部内部类的对象，间接的访问局部内部类的方法

局部变量 必须final 才能被内部类引用

代码示例：

class Demo04_局部内部类 {
    public static void main(String[] args) {
        //Fei f = new Fei();
        //通过调用breath方法，间接的访问局部内部类中的show方法
        breath();
    }

    public static void breath() {
        int f = 30;

        class Fei {
            String color = "black";

            public void show() {
                System.out.println(f + "..." + color + "...饶了我吧受不了了太呛了");
            }
        }
        //创建局部内部类对象
        Fei fei = new Fei();
        //调用局部内部类方法
        fei.show();
    }
}

 

匿名内部类：

没有名字的内部类

代码示例：

//new Car() 无参构造方法 
        new Car(){
            //重写父类drive方法 对象
            public void drive(){
                System.out.println("anthor car is running ... ");
            }
        }.drive();

 

class Demo05_匿名内部类 {
    public static void main(String[] args) {
        IPlayImpl ipi = new IPlayImpl();
        ipi.playGame();

        IPlay ip = new IPlay() {
            @Override
            public void playGame() {
                System.out.println("wanyouxi");
            }
        };
        ip.playGame();
        ip.playGame();
    }
}

interface IPlay {
    public abstract void playGame();
}

class IPlayImpl implements IPlay {
    @Override
    public void playGame() {
        System.out.println("玩游戏");
    }
}

 包：命名：域名倒着写：com.baidu.map(全球唯一)

	private	默认不写	protected	public
本类	Y	Y	Y	Y
本包	N	Y	Y	Y
子类	N	N	Y	Y
其他	N	N	N	Y