黑马程序员---了解开发工具及内部类

---------------------- 黑马程序员 Android培训、期待与您交流！ ---------------------

1：包

    (1)其实就是文件夹。
    (2)作业：把同名称的类放到不同的文件夹下使用。
    (3)格式：
        package xxx.yyy.zzz;
    (4)带包的类的编译和运行：
        A:手动式
            a:javac编译当前类文件。
            b:手动建立包对应的文件夹。
            c:把a的class文件放到b的最终文件夹下。
            d:通过java命令执行。注意了：需要带包名称的执行。
                java cn.itcast.HelloWorld
        B:自动式
            a:javac编译的时候带上-d即可
                javac -d . HelloWorld.java
            b:通过java命令执行。注意了：需要带包名称的执行。
                java cn.itcast.HelloWorld

    
2：导包
    (1)一般来说，用一个类，需要用该类的全路径名称。
       如果多个地方使用，就比较麻烦，所以java提供了导包操作。
    (2)格式：
        import 包名1.包名2...类名;
        
        //下面这种属于把指定包下的类都导入。这种用法不推荐。我们应该用谁导谁。
        import 包名1.包名2...*;
    (3)package，import，class的顺序
        package -- import -- class

3：四种权限修饰符
    (1)案例：
        cn.itcast
            Fu
            Zi
            Demo
        com.liuyi
            Zi
            Demo
    (2)结论:
                                  本类    同包(无关类或者子类)    不同包(子类)    不同包(无关类)
    private                     Y
    默认(什么都没有)    Y        Y            
    protected                 Y        Y                                        Y
    public                       Y        Y                                        Y                     Y

    推荐：
        成员变量    private
        构造方法    public
        成员方法    public

4：不同修饰符修饰的内容
                        类    成员变量    成员方法    构造方法
    private                     Y               Y                Y
    默认              Y        Y               Y                Y
    protected                 Y               Y                Y
    public            Y        Y               Y                Y
    abstract         Y                         Y        
    static                        Y              Y        
    final               Y        Y              Y            

    
    类：public
    成员变量：private
    构造方法：public
    成员方法：public

    注意，常见规则如下：
        以后，所有的类都用public修饰。并且，在一个java文件中，只写一个类。

        以后，所有的成员变量用private修饰。

        以后，所有的成员方法用public修饰。
            如果是抽象类或者接口：
                public abstract + ...

        以后，所有的构造方法用public修饰。
            如果类是工具类或者单例类：
                构造用private修饰


5：内部类
    (1)把类定义在其他类的内部，就被称为内部类。
    (2)访问特点：
        A:内部类可以直接访问外部类成员，包括私有
        B:外部类要想访问内部类成员，必须创建对象。
    (3)内部类的分类：
        A:成员内部类
            a:private 访问的安全性
            b:static 访问的方便
        B:局部内部类
            a:带名字的(类)
            b:不带名字的(对象)
        
            局部内部类访问局部变量必须加final修饰。
            延迟生命周期。
    (4)匿名内部类
        A:是定义在局部位置的没有名字的内部类。    
        B:前提
            存在一个类，抽象类，或者接口。
        C:格式
            new 类或者接口名()
            {
                重写方法;
            }

            本质理解：其实这是一个继承类或者实现接口的匿名的子类对象。
        D:使用
            当你看到方法的形式参数是接口或者抽象类的时候。
            用匿名内部类改进。
    

经典习题总结:

第一题：
    class Fu {
        public void show() {
            System.out.println("show fu");
        }
    }

    //在这里如何写。
    class Zi extends Fu {
        public void show() {
            System.out.println("show zi");
        }
    }

    class FuDemo {
        public void testFu(Fu f) {
            f.show();
        }
    }

    class FuTest {
        public static void main(String[] args) {
            FuDemo fd = new FuDemo();
            //补齐代码,在控制台输出"show zi"
            Fu f = new Zi();
            fd.testFu(f);
        }
    }


    第二题：
    abstract class Fu {
        public abstract void show();
    }

    //在这里如何写。
    class Zi extends Fu {
        public void show() {
            System.out.println("show");
        }
    }

    class FuDemo {
        //如果你看到一个方法的形式参数是一个抽象类名，那么，这里将来接收的肯定是一个子类对象。
        public void testFu(Fu f) {
            f.show();
        }
    }

    class FuTest {
        public static void main(String[] args) {
            FuDemo fd = new FuDemo();
            //补齐代码,在控制台输出"show"
            Fu f = new Zi();
            fd.testFu(f);
        }
    }

    第三题：
    interface Fu {
        public abstract void show();
    }

    //在这里如何写。
    class Zi implements Fu {
        public void show() {
            System.out.println("show zi");
        }
    }

    class FuDemo {
        //如果你看到一个方法的形式参数是一个接口名，那么，这里将来接收的肯定是一个子类对象。
        public void testFu(Fu f) {
            f.show();
        }
    }

    class FuTest {
        public static void main(String[] args) {
            FuDemo fd = new FuDemo();
            //补齐代码,在控制台输出"show zi"
            Fu f = new Zi();
            fd.testFu(f);
        }
    }

总结：
    引用类型：类，接口，数组。

    形式参数是引用类型的时候：
        如果是一个具体类类名，要的是该类的或者其子类对象。
        如果是一个抽象类名，要的是该类的子类对象。
        如果是一个接口名，要的是该接口的实现类的对象。

    返回值是引用类型的时候：
        如果是一个具体类类名，返回是该类或者其子类对象。
        如果是一个抽象类名，返回是该类的子类对象。
        如果是一个接口名，返回是该接口的实现类的对象。

    abstract class Fu {
    
    }

    class Zi extends Fu {
    
    }

    class FuDemo {
        public Fu getFu() {
            //Fu f = new Fu();
            //return f;
            Fu f = new Zi();
            return f;
        }
    }


    结论：
        父亲的地方，可以是父亲或者儿子。
        儿子的地方，只能是儿子。

        子类对象可以当父类对象用，父类对象不能当子类对象用。

匿名内部类的例题 :

    第一种：

            interface Inter {
                public abstract void show();
            }

            class InterDemo {
                public void method(Inter i) {
                    i.show();
                }
            }

            class InterTest {
                public static void main(String[] args) {
                    InterDemo id = new InterDemo();
                    id.method(new Inter(){
                        public void show() {
                            System.out.println("HelloWorld");
                        }
                    });
                }
            }



   第二种：
 
            interface Inter {
                void show();
            }

            class Outer {
                //补齐代码
                public static Inter method() {
                    return new Inter(){
                        public void show() {
                            System.out.println("show");
                        }
                    };
                }
            }

            class OuterDemo {
                public static void main(String[] args) {
                    Outer.method().show();
                }

            }

---------------------- 黑马程序员 Android培训、期待与您交流！ ---------------------