Java基础——package+权限修饰符+内部类

package

package就是文件夹，将字节码(.class)进行分类存放 。
包的注意事项：

• 包的写法：package 包名
• package语句必须是程序的第一条可执行的代码
• package语句在一个java文件中只能有一个
• 如果没有package，默认表示无包名

带包的类的编译和运行

编译：在D盘下有Person_Test.java ，在D盘下打开dos命令行执行 javac -d . Person_Test.java 命令就会生成一个D:/com/heima/Person_Test.class
运行：在D盘下打开dos命令行(当前路径下，不要跑到D:/com/heima去打开dos) 执行java com.heima.Person_Test

不同包下类之间的访问

1)类的全路径名 变量名 = new 类的全路径名();
​
案例：一个java文件里面是Demo1_Package类

    package com.heima;
        class Demo1_Package {
            public static void main(String[] args) {
                //Person p = new Person();          //报错：不同包下的类不能直接访问
                com.baidu.Person p = new com.baidu.Person();    //类的全路径名
        }
    }


    package com.baidu;
    class Person {
        String name;
        int age;
    }

2)package和class之间加入一个"import 包;"然后就可以直接访问不同包下的类了
​
案例：一个java文件里面是Demo2_Package类

    package com.heima;
    import com.baidu.Person;            //导包
    class Demo2_Package {
        public static void main(String[] args) {
            Person p = new Person();    //导包后，就能直接访问了
        }
    }



    package com.baidu;
    class Person {
        String name;
        int age; 
    }

​

修饰符

权限修饰符的访问权限

1.png

• private: 是为本类准备的
• 默认：是为同一个包下的类准备的
• protected：是为子类准备的，无论子类在任何地方
• public： 为所有类准备的

每个内容一般都用什么修饰符修饰

• 类：public
• 成员变量：private
• 构造方法：public （当定义一个工具类的时候 可以用private）
• 成员方法：public
• 接口中的成员变量：public static final
• 接口中的成员方法：public abstract

内部类

类内部的类就叫做内部类

访问特点

• 外部类访问内部类里面的内容 ，必须创建内部类的对象来访问
• 内部类访问外部类的内容， 直接访问包括私有

代码：

    class Demo1_InnerClass {
        public static void main(String[] args) {
            //报错，因为内部类是写在其他类的内部 不能这样直接创建内部类的对象
            //Inner i = new Inner();
            //i.method();
            //创建内部类对象格式：外部类名.内部类名 = 外部类对象.内部类对象
            Outer.Inner oi = new Outer().new Inner();   
            oi.method();
        }
    }

    class Outer {
        private int num = 10;//外部类的私有属性
        class Inner {
            String name = "内部类";
            public void method() {
                System.out.println(num);//内部类访问外部类的内容， 直接访问包括私有
            }
        }

        public void show(){
            //System.out.println(name);//报错：外部类不能直接访问内部类的内容
            Inner i = new Inner();
            //这样才是正确的，外部类访问内部类里面的内容，必须创建内部类的对象来访问
            System.out.println(i.name);
        }
    }

成员私有内部类

    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();
        }
    }

成员静态内部类

    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 Test_InnerClass {
        public static void main(String[] args) {
            
            Outer ot = new Outer();
            ot.num = ot.num - 5;

            Outer.Inner oi = ot.new Inner();
            oi.show();
        }
    }
    class Outer {
        public int num = 10;
        class Inner {
            public int num = 20;
            public void show() {
                int num = 30;
                System.out.println(num);//访问的是局部变量 30
                System.out.println(this.num);//访问的是成员变量 20
                //外部类名.this访问的是当前外部类对象的num 5
                //因为当前外部类对象ot的num值已经改变成了5 ot.num=ot.num-5
                System.out.println(Outer.this.num); 
                System.out.println(new Outer().num);//一个新的外部类对象的num 10
            }
        }
    }

局部内部类访问局部变量，局部变量前面必须加final修饰，为了延长局部变量的生命周期

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();  
        //当method()方法执行完毕后，i还存在着,就会导致如果i对象还想访问num，而
        //num已经消失了，访问不到了。所以在num前面加final 永远放到常量池里面去，常量池的
        //东西永远都不会消失(虚拟机挂掉才会消失)
    }
}

​

匿名内部类

前提：有一个接口或者抽象类或者普通的类
格式：

new 接口名或者抽象类名(){
    重写方法;
};

本质：就是接口或者抽象类或者普通类的一个子类对象
代码：

interface Inter{
    public abstract void show();
}
class Demo {
    public static void main(String[] args){
        new Inter(){
            public void show(){
                System.out.println("hehe");
            }
        }.show();
    }
}

• 匿名内部类可以重写多个方法, 但是一般开发中就让其重写一个方法。
• 匿名内部类是不能向下转型的,因为没有子类类名，所以不能使用匿名内部类里面的特有方法。
• 当我们看到一个方法的参数类型是抽象类或者接口的时候， 我们调用这个方法的时候，可以考虑用匿名内部类来实现。

课后习题：补齐代码，使得控制台输出HelloWorld

    interface Inter { 
        void show(); 
    }
    class Outer { 
    //补齐代码
    }
    class OuterDemo {
        public static void main(String[] args) {
            Outer.method().show();
        }
    }

今天学习了package和导包（import）之后是不是觉得编译步骤很复杂啊？下节我们将学习用Eclipse来编译运行程序。想了解更多学习知识，请关注微信公众号“阿Q说”，获取更多学习资料吧！你也可以后台留言说出你的疑惑，阿Q将会在后期的文章中为你解答。每天学习一点点，每天进步一点点。

​
​
​