09 - 包，权限，修饰符，内部类

1. 包

    1.1. 为什么要有包？
        * 将字节码(.class)进行分类存放 
        * 包其实就是文件夹
    
    1.2. 包的概述 
        举例：
            学生：增加，删除，修改，查询
            老师：增加，删除，修改，查询
        
        方案1：按照功能分
            com.heima.add
                AddStudent
                AddTeacher
            com.heima.delete
                DeleteStudent
                DeleteTeacher
            com.heima.update
                UpdateStudent
                UpdateTeacher
            com.heima.find
                FindStudent
                FindTeacher
        
        方案2：按照模块分
            com.heima.teacher
                AddTeacher
                DeleteTeacher
                UpdateTeacher
                FindTeacher
            com.heima.student
                AddStudent
                DeleteStudent
                UpdateStudent
    
    1.3. 包的注意事项
        * A:package语句必须是程序的第一条可执行的代码
        * B:package语句在一个java文件中只能有一个
        * C:如果没有package，默认表示无包名
        
    1.4. 如何编译运行带包的类
        * a:javac编译的时候带上-d即可
            * javac -d . HelloWorld.java
        * b:通过java命令执行。
            * java 包名.HellWord
        
    1.5. 包的编译，运行例如：
            package com.gooagoo;
                
            class Test {
                public static void main(String[] args) {
                    //System.out.println("Hello World!");
                    int i = 1;
                    i = i++;
                    int j = i++;
                    int k = i + ++i * i++;
                    System.out.println(i);  // 4
                    System.out.println(j);  // 1
                    System.out.println(k);  // 11 
                    
                }

            }
            
            编译：运行；
                javac -d . Test.java
                java com.gooagoo.Test
            
            生成的字节码文件都在，com.gooagoo.当前目录下面；

1.6. 不同包下类之间的访问：
        * 为什么要有import：其实就是让有包的类对调用者可见,不用写全类名了 
        
        Demo1_Package.java
        -----------------------------
        /*
            * A:定义包的格式
                * package 包名;
                * 多级包用.分开即可
            * B:定义包的注意事项
                * A:package语句必须是程序的第一条可执行的代码
                * B:package语句在一个java文件中只能有一个
                * C:如果没有package，默认表示无包名
        */
        package com.heima;
        import com.baidu.Person;
        import com.xxx.Student;
        //import java.util.Scanner;        //在开发中我们用的都是导入具体的类
        import java.util.*;                //*代表通配符,他会到该包下挨个匹配,匹配上就导入
        class Demo1_Package {
            public static void main(String[] args) {
                Person p = new Person("张三",23);
                System.out.println(p.getName() + "..." + p.getAge());
                //p.print();            //在不同包下的无关类,不允许访问,因为是protected修饰的

                /*Scanner sc = new Scanner(System.in);
                int x = sc.nextInt();
                System.out.println(x);*/
                
                Student s = new Student("李四",24);
                System.out.println(s.getName() + "..." + s.getAge());
                s.method();
            }
        }
        
        
        Person.java
        ----------------------------------
        package com.baidu;
        public class Person {
            private String name;
            private int age;

            public Person(){}

            public Person(String name,int age) {
                this.name = name;
                this.age = age;
            }

            public void setName(String name) {
                this.name = name;
            }

            public String getName() {
                return name;
            }

            public void setAge(int age) {
                this.age = age;
            }

            public int getAge() {
                return age;
            }

            protected void print() {
                System.out.println("print");
            }
        }
        
        Student.java
        ----------------------------------
        package com.xxx;
        import com.baidu.Person;
        public class Student extends Person {
            public Student(){}

            public Student(String name,int age) {
                super(name,age);
            }

            public void method() {
                print();
            }
        }
        
        ----------------------------------

 

2. 四种权限修饰符

                 本类     同一个包下(子类和无关类)    不同包下(子类)       不同包下(无关类)
    private      Y        
    默认          Y                   Y
    protected    Y                   Y                     Y
    public       Y                   Y                     Y                      Y

 

3. 常见修饰符

    * A:修饰符：
        * 权限修饰符：private，默认的，protected，public
        * 状态修饰符：static，final
        * 抽象修饰符：abstract
    
    * B:类：
        * 权限修饰符：默认修饰符，public
        * 状态修饰符：final
        * 抽象修饰符：abstract
        
        * 用的最多的就是：public
        
    * C:成员变量：
        * 权限修饰符：private，默认的，protected，public
        * 状态修饰符：static，final
        
        * 用的最多的就是：private
        
    * D:构造方法：
        * 权限修饰符：private，默认的，protected，public
        
        * 用的最多的就是：public
        
    * E:成员方法：
        * 权限修饰符：private，默认的，protected，public
        * 状态修饰符：static，final
        * 抽象修饰符：abstract
        
        * 用的最多的就是：public
        
    * F:除此以外的组合规则：
        * 成员变量：public static final
        * 成员方法：
            * public static 
            * public abstract
            * public final
        

 

4. 内部类

    4.1. 成员内部类
    class Demo1_InnerClass {
        public static void main(String[] args) {
            //Inner i = new Inner();
            //i.method();
            //外部类名.内部类名 = 外部类对象.内部类对象
            Outer.Inner oi = new Outer().new Inner();            //创建内部类对象
            oi.method();  // 10 
     
        }
    }

    /*
    * A:内部类概述
    * B:内部类访问特点
        * a:内部类可以直接访问外部类的成员，包括私有。
        * b:外部类要访问内部类的成员，必须创建对象。
        * 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
    * C:案例演示
        * 内部类极其访问特点
    */

    class Outer {
        private int num = 10;
        class Inner {
            public void method() {
                System.out.println(num);
            }
        }
    }
    
    //---------------------------------------------------------------------------
    class Demo2_InnerClass {
        public static void main(String[] args) {
            //Outer.Inner oi = new Outer().new Inner();
            //oi.method();

            Outer o = new Outer();
            o.print();
        }
    }

    class Outer {
        private int num = 10;
        private class Inner {
            public void method() {
                System.out.println(num);
            }
        }

        public void print() {
            Inner i = new Inner();
            i.method();
        }
    }
        
        
    4.2. 静态内部类
    class Demo1_InnerClass {
        public static void main(String[] args) {
            //外部类名.内部类名 对象名 = 外部类名.内部类对象;
            Outer.Inner oi = new Outer.Inner();
            oi.method();

            Outer.Inner2.print();
        }
    }

    class Outer {
        static class Inner {
            public void method() {
                System.out.println("method");
            }
        }

        static class Inner2 {
            public static void print() {
                System.out.println("print");
            }
        }
    }
    
    //---------------------------------------------------------------------------
    
    class Test1_InnerClass {
        public static void main(String[] args) {
            Outer.Inner oi = new Outer().new Inner();
            oi.show();
        }
    }
    //要求：使用已知的变量，在控制台输出30，20，10。
    //内部类之所以能获取到外部类的成员,是因为他能获取到外部类的引用外部类名.this
    class Outer {
        public int num = 10;
        class Inner {
            public int num = 20;
            public void show() {
                int num = 30;
                System.out.println(num);
                System.out.println(this.num);
                System.out.println(Outer.this.num);
            }
        }
    }
    
    
    4.3. 局部内部类
    class Demo1_InnerClass {
        public static void main(String[] args) {
            Outer o = new Outer();
            o.method();
        }
    }
    //局部内部类
    class Outer {
        public void method() {
            final int num = 10;
            class Inner {
                public void print() {
                    System.out.println(num);
                }
            }

            Inner i = new Inner();
            i.print();
        }

        /*public void run() {
            Inner i = new Inner();                //局部内部类,只能在其所在的方法中访问
            i.print();
        }*/
    }
        
    
    4.4. 匿名内部类
    class Demo1_NoNameInnerClass {
        public static void main(String[] args) {
            Outer o = new Outer();
            o.method();
        }
    }
    /*
    * A:匿名内部类
        * 就是内部类的简化写法。
    * B:前提：存在一个类或者接口
        * 这里的类可以是具体类也可以是抽象类。
    * C:格式：
    * 
            new 类名或者接口名(){
                重写方法;
            }
    * D:本质是什么呢?
        * 是一个继承了该类或者实现了该接口的子类匿名对象。
    * E:案例演示
        * 按照要求来一个匿名内部类
    */

    interface Inter {
        public void print();
    }

    class Outer {
        class Inner implements Inter {
            public void print() {
                System.out.println("print");
            }
        }

        public void method(){
            //Inner i = new Inner();
            //i.print();
            //new Inner().print();
            //Inter i = new Inner();            //父类引用指向子类对象
            
            new Inter() {                        //实现Inter接口
                public void print() {            //重写抽象方法
                    System.out.println("print");
                }
            }.print();
        }
    }

    //---------------------------------------------------------------------------

    class Demo2_NoNameInnerClass {
        public static void main(String[] args) {
            Outer o = new Outer();
            o.method();
        }
    }

    interface Inter {
        public void show1();
        public void show2();
    }
    //匿名内部类只针对重写一个方法时候使用
    class Outer {
        public void method() {
            /*new Inter(){
                public void show1() {
                    System.out.println("show1");
                }

                public void show2() {
                    System.out.println("show2");
                }
            }.show1();

            new Inter(){
                public void show1() {
                    System.out.println("show1");
                }

                public void show2() {
                    System.out.println("show2");
                }
            }.show2();*/

            Inter i = new Inter(){
                public void show1() {
                    System.out.println("show1");
                }

                public void show2() {
                    System.out.println("show2");
                }

                /*public void show3() {
                    System.out.println("show3");
                }*/
            };

            i.show1();
            i.show2();
            //i.show3();                        //匿名内部类是不能向下转型的,因为没有子类类名
        }
    }
        

    //---------------------------------------------------------------------------
    class Demo3_Con {
        public static void main(String[] args) {
            Person p = new Person();
            //p.Person();
        }
    }

    class Person {
        //public void Person() {                        //不是构造方法,是一个普通方法
        public Person() {
            System.out.println("Hello World!");
        }
    }

    //---------------------------------------------------------------------------    
    class Demo4_Override {
        public static void main(String[] args) {
            
        }
    }

    class Person {
        public void print() {
            System.out.println("Person");
        }
    }

    class Student extends Person {
        public void print() {
            System.out.println("Student");
        }
    }

    class Father { 
        public Person method() {
            return new Person();
        }
    }

    class Son extends Father {
        public Student method() {
            return new Student();
        }
    }
    //---------------------------------------------------------------------------    
    class Test1_NoNameInnerClass {
        public static void main(String[] args) {
            //如何调用PersonDemo中的method方法呢?
            PersonDemo pd = new PersonDemo ();
            //pd.method(new Student());
            pd.method(new Person() {
                public void show() {
                    System.out.println("show");
                }
            });
        }
    }
    //这里写抽象类，接口都行
    abstract class Person {
        public abstract void show();
    }

    class PersonDemo {
        
        //public void method(Person p) {        //Person p = new Student();        //父类引用指向子类对象
        /*
        Person p = new Person(){
            public void show() {
                System.out.println("show");
            }
        };
        */
        public void method(Person p) {
            p.show();
        }
    }

    class Student extends Person {
        public void show() {
            System.out.println("show");
        }
    }        
        
    //---------------------------------------------------------------------------        
    class Test2_NoNameInnerClass {
        public static void main(String[] args) {
            //Outer.method().show();            //链式编程,每次调用方法后还能继续调用方法,证明调用方法返回的是对象
            Inter i = Outer.method();
            i.show();
        }
    }
    //按照要求，补齐代码
    interface Inter { 
        void show(); 
    }

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

    //要求在控制台输出”HelloWorld”