黑马程序员——java基础之包和内部类

——- android培训、java培训、期待与您交流！ ———-

包：其实就是文件夹。包也是对我们java文件进行分类管理。    格式：        package 包名;            package com;                //这句话的意思就是说，我们的编译之后的class文件在我们 --- 当前java文件所在文件夹/com文件夹 --- 下边        package 一级目录.二级目录.包名;            package cn.itcast;            意思是说：编译之后的class文件，在我们--- 当前java文件所在文件夹/cn文件夹/itcast文件夹 ---下边    window操作系统，使用\来表示路径的层级。    java中的包使用“.”来表示层级关系。包的定义：    位置：只能放在类的上边，而且是文件有效代码的第一行。    数量：只能有一个。可以没有。有效代码：指的就是能够编译，或者需要编译的代码都是有效代码。带包类的编译和运行：    编译：有两种方式。        手动型：            1.正常的编译。            2.根据包名创建文件夹（手动创建文件夹）。            3.把第1步编译之后的class文件放入，我们第2步创建的文件夹中。        自动型：            1.命令：                javac -d . 文件名.java    运行：        运行时要使用类的全名称。        我们要是用命令：“java 包名.类名”  来运行我们的代码    类的全名称：类的全名称指的是：“包名.类名”    包的命名：        百度：www.baidu.com     包名：com.baidu

package cn.itcast;class PackageDemo {    public static void main(String[] args) {        System.out.println("HelloWorld");    }}

带包类的编译：    1.有了包后，即使在同一个文件夹下，也需要先将别的包编译一下，然后才能使用。不同包之间的相互访问：类必须是公共的public    1.把我们的类名,全都改成类的全名称。    2.把我们需要使用的类，导入到我们本类中。（导包）导包：使用import关键字。    格式：import 包名.类名;   //导入的是一个类，而不是文件夹。    位置：必须方法package下边，但是类的上边。    import com.Demo;导包的注意事项：    1.导包的语句必须是方法package下边，class的上边。    2.导入包的语句可以有多个。    3.import 包名.*; //这句话会导入“包名”这个文件夹下的所有的类        但是不建议使用。    4.导入的是类，而不是文件夹。

package cn;import com.Demo;//import java.util.Scanner;//import java.util.Random;import java.util.*;class Test {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        Random r = new Random();        /*            com.Demo d = new com.Demo();            d.method();        new com.Demo().method();        new com.Demo().method();        new com.Demo().method();        new com.Demo().method();        new com.Demo().method();        new com.Demo().method();        new com.Demo().method();        new com.Demo().method();        new com.Demo().method();        new com.Demo().method();        */        new Demo().method();        new Demo().method();        new Demo().method();    }}

package com;class QuanXianTest {    public static void main(String[] args) {        QuanXianDemo qxd = new QuanXianDemo();        //访问公共的        qxd.publicMethod();        //访问默认的        qxd.defaultMethod();        //访问受保护的        qxd.protectedMethod();        //访问私有的        qxd.privateMethod();    }}

java中的权限修饰符：    public：公共的。    protected：受保护的    默认的：就是什么都不写。    private：私有的    public：同一个类中,同一包不同类没有关系的俩个类,同一包有继承关系的不同类,不同包有继承关系的不同类，不同包没有关系的俩个类    protected：同一个类中,同一包不同类没有关系的俩个类,同一包有继承关系的不同类,不同包有继承关系的不同类，    默认的：同一个类中,同一包不同类没有关系的俩个类,同一包有继承关系的不同类,    private：同一个类中,    public：公共的。任何地方都可以访问。    protected：受保护的。同一包下或者有继承关系就可以访问。    默认的：就是什么都不写。同一包下可以访问。    private：私有的，只有在同一个类中可以访问。    public > protected > 默认 > private

package com;public class QuanXianDemo {    //公共的    public void publicMethod(){        System.out.println("公共的");    }    //默认    void defaultMethod(){        System.out.println("默认");    }    //受保护的    protected void protectedMethod(){        System.out.println("受保护的");    }    //私有的    private void privateMethod(){        System.out.println("私有的");    }    public static void main(String[] args) {        QuanXianDemo qxd = new QuanXianDemo();        //访问公共的        qxd.publicMethod();        //访问默认的        qxd.defaultMethod();        //访问受保护的        qxd.protectedMethod();        //访问私有的        qxd.privateMethod();    }}

package com;class QuanXianTest1 extends QuanXianDemo {    public static void main(String[] args) {        QuanXianTest1 qxd = new QuanXianTest1();        //访问公共的        qxd.publicMethod();        //访问默认的        qxd.defaultMethod();        //访问受保护的        qxd.protectedMethod();        //访问私有的        qxd.privateMethod();    }}

内部类：就是放在类内部的类。    成员内部类：就是放在类内部，方法外部的类。    局部内部类：放在方法内部的类。成员内部类：    位置：类内部，方法外部。    使用：怎么创建对象。        1.在外部类的方法中创建成员内部类的对象。        2.在外部去创建内部类的对象：                格式：                    Outer.Inner i =  new Outer().new Inner();                    外部类.内部类 对象名 = new 外部类().new 内部类();

//外部类class Outer {    public void method(){        //在方法中创建成员内部类的对象。        Inner i = new Inner();        //使用对象来调用方法        i.fun();    }    //成员内部类    class Inner {        public void fun(){            System.out.println("Inner-fun");        }    }}//成员内部类测试class InnerTest {    public static void main(String[] args) {        //Inner i = new Inner();        //创建一个外部类对象        Outer o= new Outer();        o.method();        //Inner 是 Outer的Inner        Outer.Inner i =  new Outer().new Inner();        i.fun();    }}

人类的内部类:    成员内部类可以被private修饰，而且我们一般都把我们成员内部类私有。    一般我们需要通过我们自己的方法来操作我们的成员内部类。    static也可以修饰成员内部类。当静态修饰成员内部类时，该成员内部类有一个特殊的称呼，叫做静态内部类。        静态内部类就是让我们内部类用起来比较方便而已。        Person.Heart ph = new Person.Heart();        静态内部类的创建对象的方法：            格式：                Person.Heart ph = new Person.Heart();                外部类.内部类 对象名 = new 外部类.内部类();        静态内部类权限修饰符一般为public。

class Person {    //医治方法    public void care(){    }    //心脏类    public  static class Heart {    }    static int  num = 10; //Person.num}class PersonDemo {    public static void main(String[] args) {        //创建对象        //Person.Heart ph = new Person().new Heart();        //Person.Heart ph = new Person.Heart();    }}

//外部类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            System.out.println(Outer.this.num); //10        }    }}public class OuterTest {    public static void main(String[] args) {        //创建内部类对象        Outer.Inner i = new Outer().new Inner();        i.show();    }}

局部内部类：  在方法内部。    创建对象：        局部内部类创建对象，只能在方法内部创建。注意事项：    1.创建对象语句不能在内部类定义的前边。    2.局部内部类在访问局部变量时有限制。        访问：            外部类的成员变量：没问题            内部类的成员变量：没问题            内部类的局部变量: 没问题            外部类的局部变量: 必须是final修饰的变量。（1.7及之前是这样，1.8之后可以访问非final的变量。）

//外部类class Outer {    //int num = 10;    public void method(){        final int num = 30;        //内部类        class Inner{            //int num = 11;            public void test(){                //int num = 20;                System.out.println("Inner-test"+ num);            }        }        //创建局部内部类对象        Inner i = new Inner();        //调用方法        i.test();    }}class JuBuInnerDemo {    public static void main(String[] args) {        Outer o = new Outer();        o.method();    }}

匿名内部类：就是没有名字的内部类    格式：        继承式匿名内部类：new 类名(){ … };            要求，写之前，必须先有一个父类。        接口式匿名内部类: new 接口(){ … };            要求，写之前，必须先有一个接口。匿名内部类，本质上是一个对象。是我们父类或者父接口的对象。

//外部类class Outer {    public void method(){        //匿名内部类        Animal a = new Animal(){            //重写Animal的say方法            public void say(){                System.out.println("Animal-say");            }            public void test(){                System.out.println("Inner-test");            }        };        a.say();    }}abstract class Animal {    public abstract void say();}class NiMingDemo {    public static void main(String[] args) {        Outer o = new Outer();        o.method();    }}

总结：

包：就是文件夹包的定义：    格式：        package 包名;        package 一级目录.二级目录.包名;带包类的编译和运行:自动型编译：    javac -d . 文件名.java运行：    java 包名.类名;导包:格式：    import 包名.类;注意：    1.导入的是类，而不是文件夹。    2.在包的定义的下边，类的上边，可以有多个。    3.import 包名.*;  导入该文件夹下的所有的类。（不建议使用）权限修饰符：public:公共的，所以地方都可以使用。protected:受保护的，继承的。同一包下或者有继承关系的子类可以访问。默认：就是什么都不写。同一个包下可以访问。private：私有的，只有类的内部可以访问。内部类：就是放在类内部类的。成员内部类：放在类中方法之外，就是类的一种特殊的成员，可以看作是特殊的成员变量或成员方法。    1.可以被priavte修饰。还可以被static修饰。    2.可以在外部类的方法中创建内部类的对象。（最常用的做法）    3.可以在外部去创建内部类的对象。        创建对象格式：外部类.内部类 对象名 = new 外部类().new 内部类();    被static修饰的成员内部类叫做：静态内部类。        创建对象格式：外部类.内部类 对象名 = new 外部类.内部类();局部内部类：    就是放在方法中的内部类。    只能在局部内部类所在的方法中创建对象。    注意：        1.创建对象的代码要放在类的定义的下边。        2.访问外部类的局部变量时，只能访问final修饰的变量(1.8之后已经优化)匿名内部类：就是没有名字的局部内部类。格式：    继承时匿名内部类：new 父类(){ …… };  //本质上匿名内部类是父类或父接口的一个子类对象。        要求，使用之前必须先有一个父类。    接口时匿名内部类: new 接口(){ …… };        要求，使用之前必须先有一个接口。

——- android培训、java培训、期待与您交流！ ———-