黑马程序员——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培训、期待与您交流！ ———-