黑马程序员——包，内部类总结

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
一内部类
(1)把类定义在一个类的内部。

(2)特点：
A:内部类可以直接使用外部类的成员，包括私有。
B:外部类要使用内部类成员，必须创建对象使用。

(3)内部类的分类：
局部内部类：定义在方法中的内部类

(4)成员内部类
class Outer {
class Inner {

}
}

普通的修饰的时候：
外部类名.内部类名 变量 = 外部类对象.内部类对象;
Outer.Inner oi = new Outer().new Inner();

class Outer {
static class Inner {
void method(){}
}
}

用静态修饰内部类时：
外部类名.内部类名 变量 = 外部类名.内部类对象
Outer.Inner oi = new Outer.Inner();

用静态修饰内部类和方法时：
Outer.Inner.method()
成员内部类：
private：为了数据的安全。
static：为了方便调用。

代码实例

class Demo04_Inner {    public static void main(String[] args)     {        //创建外部类对象        //Out out = new Out();        //访问属性        //String name = out.name;        //调用方法        //out.method();        //创建内部类对象        //out.new In();        //成员内部类创建对象格式        //Out.In x = new Out().new In();        //当使用static修饰内部类后        //System.out.println(Out.name);        //Out.method();        //static修饰后的访问格式：        Out.In  x = new Out.In();        x.method2();        //如果使用static修饰内部类后,又使用static修饰内部类的成员        //Out.In.method2();    }}/*class Out{    String name = "唐嫣";    //内部类可是用private私有化，此时，如果想创建内部类对象，则在该外部类的方法中创建内部类对象并调用方法    private class In    {        public void method2(){            System.out.println(name);        }    }    public void method() {        //安全校验        In in = new In();        in.method2();    }}*/class Out{    static String name = "唐嫣";    static class In    {        public static void method2(){            System.out.println(name);        }    }    public static void method() {        //安全校验        In in = new In();        in.method2();    }}

(5)局部内部类
A:带名字的局部内部类
class Outer {
public void method() {
final int a = 10;
class Inner {
public void show() {
System.out.println(“show”);
System.out.println(a);
}

}
Inner i = new Inner();
i.show();
}
}
代码实例

class Demo05_Inner{    public static void main(String[] args)     {        Out out = new Out();        out.method();    }}class Out{    private String name = "霍建华";    //外部类的普通方法    public void method() {        final int i = 10;        //在方法内定义局部内部类        class In2        {            //定义局部内部类的成员方法            public void method(){                System.out.println(name);                System.out.println(i);            }        }        //创建内部类对象        In2 in2 = new In2();        //使用内部类对象调用内部类方法        in2.method();    }}

B:匿名内部类
a:没有名字的内部类。其本质是一个对象。是通过多态来实现的。
b:前提：存在一个抽象类或者接口。
c:格式：
new 抽象类或者接口() {
重写父类方法;
};
本质：是一个继承了类或者实现了接口的子类匿名对象。
代码实例

class Demo06_Inner {    public static void main(String[] args)     {        Out out = new Out();        out.method();    }}class Out{    //外部类的普通方法    public void method() {        /*定义一个有名字的类，并创建该类的对象，该类继承某个父类，重写父类方法。        //在方法内定义局部内部类        class 类名 extends Fu        {            //定义局部内部类的成员方法            public void inMethod(){                System.out.println("内部类的方法被调用了");            }        }        //创建内部类对象        类名 in2 = new 类名();        //使用内部类对象调用内部类方法        in2.inMethod();        */        /*匿名内部类方式*/        //new 类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)};        //创建一个有名字的匿名内部类对象        Fu fu = new Fu() {            //定义局部内部类的成员方法            public void inMethod(){                System.out.println("匿名内部类的方法被调用了");            }        };        fu.inMethod();        method2(fu);        //匿名对象  同时也是内部类对象   直接调用方法        new Fu() {            //定义局部内部类的成员方法            public void inMethod(){                System.out.println("匿名内部类的方法被调用了");            }        }.inMethod();        //调用参数为自定义类型的方法时，使用匿名内部类对象作为参数传递        method2(new Fu() {            //定义局部内部类的成员方法            public void inMethod(){                System.out.println("匿名内部类的方法被调用了");            }        });        //调用返回值为自定义类型的方法时，使用匿名内部类对象作为返回值。        Fu fu2 = method3();        fu2.inMethod();    }    //自定义数据类型作为参数    public void method2(Fu fu) {        fu.inMethod();    }    //自定义数据类型作为返回值类型    public Fu method3() {        /*        Fu fu = new Fu() {            //定义局部内部类的成员方法            public void inMethod(){                System.out.println("匿名内部类的方法被调用了");            }        };        return fu;        */        return new Fu() {            //定义局部内部类的成员方法            public void inMethod(){                System.out.println("匿名内部类的方法被调用了");            }        };    }}abstract class Fu{    public abstract void inMethod();}

二导包
(1)包就是永远区分相同类在不同文件夹下。其本质就是一个文件夹。

(2)包的作用：让相同类名的类可以存在。为了组织代码。cn.itcast.action cn.itcast.service cn.itcast.db

(3)定义包：
package 包名.包名…;

(4)带包的编译和运行(理解)
A:方式一
手动式
a:javac编译代码
b:手动建立包，把class扔进去
c:java执行，带全路径
B:方式二
自动式
a:通过javac编译自动生成包
javac -d . 文件名
b:通过java运行class文件
java 包名.包名.class文件名不带扩展名

(5)不同包下的类之间的访问。
权限够大才行。以后，我们所有定义的类都用public修饰。

(6)注意
在同一个java文件中，可不可以有多个类?可以。
而我们知道类是可以用public修饰的,那么，可不可以多个类都用public修饰?不可以。
并且，一般的时候，如果有main方法也存在的时候，都是public修饰带main那个类。

三导包
(1)如果多次使用一个多级包的类，每次带全路径太麻烦，我们就考虑使用导包。
(2)导包的格式：
import 包名.包名…;

注意：
在同一个包下如果有多个类被使用，可以使用通配符*来导入，但是不建议。
推荐：使用谁导入谁。

四权限修饰符
(1)用于保证在不同的情况下可以使用
(2)使用如下
本类 同一个包下 不同包下的子类 不同包下的无关类
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y
(3)我们到底怎么用(开发的时候一般都这么做)：
类：
public class Demo {

    }

成员变量：
变量：private String name; 加上相应的getter和setter
常量：public static final int X = 10;

构造方法：
不让外界创建：private Demo(){}
大部分：public Demo(){}

成员方法：
不让外界用：private void show(){}
大部分：public void method(){}
抽象方法：public abstract void function();