黑马程序员技术交流社区

标题: 包的总结 [打印本页]

---

作者: Animal    时间: 2015-6-3 22:22
标题: 包的总结
包：
        概述：其实就是文件夹。
        包的命名规则：所有单词都小写，多个单词间用.隔开。
        顺序问题：
                package --》 import --》 class
        带包的类，如果编译和运行？
                第一种：手动建包。
                        1、用javac命令把源文件编译成.class字节码文件。
                        2、手动建立文件夹。
                        3、把第一步生成的字节码文件放到文件夹中。
                第二种：自动建包。
                        javac -d . 源文件名.java
                如何运行：
                        java 包名1.包名2....源文件名
        不同包下类之间的访问的常见问题：
                1、找不到Demo类。
                        用全路径名称。
                2、程序包cn.itcast不存在。
                        先编译该包下的类（创建对应的包），然后在使用。
                3、无法访问Demo类。
                        用public修饰Demo类。
        如何导包：
                import 包名1.包名2.包名3...类名;

访问权限修饰符：
        private：强调只在本类中使用。
                只能在本类中被访问。
        默认：强调的是在同一包下使用。
                本类，同一包下的类
        protected：强调的是给子类使用。
                本类，同一包下的类，不同包的子类。
        public：任何地方。
                该项目的任意地方。
        注意：
                成员变量：private
                成员方法：public

修饰符可以修饰哪些成员：
        常见规则：
                1、所有类的，用public修饰，并且一个java文件中只写一个类。
                2、所有的成员变量，用private修饰。
                3、所有的构造方法，用public修饰。
                        注意：如果是工具类，或者单例类，构造方法用private修饰。
                4、所有的成员方法，用public修饰。
                        如果是抽象方法，用public abstract修饰。

内部类：
        概述：把一个类B，定义在类A中，类B就是内部类（内置类，嵌套类）。
        特点：
                1、内部类可以直接使用外部类的成员，包括私有成员。
                2、外部类如果想要使用内部类的成员，必须创建内部类的对象。
       
        分类和使用：
                分类：
                        成员内部类：
                        局部内部类：定义在方法中。
                                注意：局部内部类访问局部变量，该局部变量必须加final修饰。
                                原因：
                                        为了延长该局部变量的生命周期。
                在测试类中，如何直接使用内部类？
                        格式：
                                外部类名.内部类名 变量名 = 外部类对象.内部类对象;
                        实例：
                                Outer.Inner oi = new Outer().new Inner();
        内部类的访问权限修饰符：
                private：为了安全考虑。
                static：为了方便调用。
                        注意，如果内部类是静态的，在测试类中，怎么创建内部类的对象呢？
                                外部类名.内部类名 变量名 = new 外部类名.内部类名();
                        实例；
                                Outer.Inner oi = new Outer.Inner();

        内部类的字节码文件的命名规则：
                1、如果生成的字节码文件的格式是： 类名A$编号类名B，这种形式，类B就是局部内部类。
                2、如果生成的字节码文件的格式是： 类名A$类名B，这种形式，类B是成员内部类。

匿名内部类：
        概述：没有名字的局部内部类。
        前提：要有一个类，还要有一个抽象类(接口)
        格式：
                new 抽象类名或者接口名()
                {
                        重写抽象类或者接口的抽象方法。
                        还可以定义自己的新的方法。
                };
        理解：相当于是一个 继承了抽象类或者实现了接口的 匿名的 子类对象。
        什么时候使用匿名内部类？
                1、当一个抽象类或者接口中的抽象方法少于3个的时候，我们就可以考虑使用匿名内部类。
                2、当我们看到一个方法的形参的数据类型是一个抽象类或者接口的时候，就可以考虑使用匿名内部类。
                总结：所有父类或者父接口出现的地方，都可以用子类对象替代。
                有一个接口（抽象类）： Animal: void eat();
                有一个Test类： void print(Animal a)
                                                {
                                                        a.eat();
                                                }
                在测试类AnimalTest中调用print方法。

        有一个接口：
                Inner :  void show();
        有一个类：
                Outer： void method()
                                {

                                        //通过匿名内部类的形式调用接口中的show方法
                                }
        在测试类中测试：
                interface Inner
                {
                        public abstract void show();
                }
                class Outer
                {
                        public void method()
                        {
                                //通过匿名内部类的形式调用接口中的show方法
                                new Inner()
                                {
                                        public void show()
                                        {
                                                System.out.println("这是一个实现了Inner接口的匿名的子类对象");
                                        }
                                }.show();
                        }
                }









               
        外部类：Outer
                内部类：
                        Inner1：private修饰，
                                show()
                        Inner2：static修饰
                                print();
                                method().静态方法。
        在测试类中进行测试。

        //这个是外壁垒
        class Outer
        {
                //这个是内部类Inner1
                private class Inner1
                {
                        public void show()
                        {
                                System.out.println("这个是内部类Inner1的show方法");
                        }
                }//这个是Inner1的大括号

                //这个是内部类Inner2
                static class Inner2
                {
                        public void print()
                        {
                                System.out.println("这个是内部类Inner2的print方法");
                        }
                        public static void method()
                        {
                                System.out.println("这个是内部类Inner2的静态方法method");
                        }
                }//这个是Inner2的大括号
                public void function()
                {
                        Inner1 i = new Inner1();
                        i.show();
                }
        }//这个是外部类Outer的大括号
        class Test
        {
                public static void main(String[] args)
                {
                        //使用Inner1中的show方法
                        Outer o = new Outer();
                        o.function();

                        Outer.Inner2 o1 = new Outer.Inner2();
                        o1.print();
                        Outer.Inner2.method();
                }
        }

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2