/*
     * Java中的JUnit单元测试
     * 
     * 步骤：
     * 1.选中当前工程 - 右键选择：build path - add libraries -JUnit4 - 下一步
     * 2.创建Java类，进行单元测试。
     *   此时的Java类要求：①此类是public的 ②此类提供公共的无参的构造器
     * 3.此类中声明单元测试方法。
     *   此时的单元测试方法：方法的权限是public，没有返回值，没有形参
     * 
     * 4.此单元测试方法上需要声明注解：@Test，并在单元测试类中导入：import org.junit.Test;
     * 
     * 5.声明好单元测试方法以后，就可以在方法体内测试相关的代码。
     * 6.写完代码以后，左键双击单元测试方法名，右键run as - JUnit Test
     * 
     * 说明：
     * 1.如果执行结果没有任何异常：绿条
     * 2.如果执行结果出现异常：红条
     * 
     */

    /*
     * object类中toString()的使用：
     * 
     * 1.当我们输出一个对象的引用时，实际上就是调用当前对象的toString()
     * 
     * 2.Object类中的toString()的定义：
     *      public String toString(){
     *          return getClass().getName() + "@" + Integer.toHexString(hashCode());
     *      }
     * 
     * 3.像String、Date、File、包装类等都重写了Object类中的toString()方法。
     *   使得在调用对象的toString()时，返回"实体内容"信息
     * 
     * 4.自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"
     */

    /*
     * 面试题：==和equals() 区别
     * 
     * 一、回顾== 的使用：
     * ==：运算符
     * 1.可以使用在基本数据类型变量和引用数据类型变量中
     * 2.如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）
     *  如果比较的是引用数据类型变量：比较两个对象的地址值。即两个引用是否指向同一个对象实体
     * 补充：==  符号使用时，必须保证符号左右两边的变量类型一致。
     *
     * 二、equals()方法的使用：
     * 1.是一个方法，而非运算符
     * 2.只能适用于引用数据类型
     * 3.Object类中equals()的定义：
     *      public boolean equals(Object obj){
     *          return (this == obj);
     *      }
     *      说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同，即两个引用是否都指向同一个对象实体。
     *
     * 4.像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是
     *   两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。 
     *
     * 5.通常情况下，我们自定义的类如果使用equals()的话：也通常是比较两个对象的"实体内容"是否相同。那么，我们
     *   就需要对Object类中的equals()进行重写
     *   重写的原则：比较两个对象的实体内容是否相同。
     */

一、package关键字的使用

1. 为了更好的实现项目类的管理，提供包的概念
2. 使用package声明类或接口所属的包，声明在源文件的首行
3. 包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、"见名知意"
4. 每"."一次，就代表一层文件目录

补充，同一个包下，不能命名同样的接口、类
不同的包下，可以命名同样的接口、类

二、import关键字的使用

import：导入

1. 在源文件中显式的使用import结构导入指定包下的类、接口
2. 声明在包的声明和类的声明之间
3. 如果需要导入多个结构，则并列写出即可
4. 可以使用"xxx.*"方式，表示可以导入xxx包下的所有结构
5. 如果使用的类或接口是java.long包下定义的，则可以省略import结构
6. 如果使用的类或接口是本包下定义的，则可以省略import结构
7. 如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示

8. 使用xxx.*"方式表明可以调用xxx包下的所有结构，但是如果使用的是xxx子包下的结构，则仍需要显式导入

9. import static :导入指定类或接口中的静态结构:属性或方法

    * 1.this可以用来修饰：属性、方法、构造器
    * 
    * 2.this修饰属性和方法
    *   this理解为：当前对象 或 当前正在创建的对象
    * 
    *   2.1在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，
    *   通常情况下，我们选择省略"this"。特殊情况下，如果方法的形参和类的属性同名时，我们必须显示的
    *   使用"this.变量"的方式，表明词变量是属性，而非形参。
    * 
    *   2.2在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，
    *   通常情况下，我们选择省略"this"。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显示的
    *   使用"this.变量"的方式，表明词变量是属性，而非形参。
    * 
    * 3.this调用构造器
    *       我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
    *       构造器不能通过"this(形参列表)"方式调用自己
    *       如果一个类中有n个构造器，则最多有n-1个构造器中使用了"this(形参列表)"
    *       规定："this(形参列表)"必须声明在构造器的首行
    *       构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器

    * 类的结构之三：构造器（或构造方法、constructor）的使用
    * construct：建设、建造   construction：建造者
    * 
    * 一、构造器的作用：
    * 1.创建对象
    * 2.初始化对象的属性
    * 
    * 二、说明：
    * 1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
    * 2.定义构造器的格式：权限修饰符 类名(形参列表){}
    * 3.一个类中定义的多个构造器，彼此构成重载
    * 4.一旦我们显式的定义了类的构造器之后，系统就不在提供默认的空参构造器

    * 一、继承性的好处
    * 1.减少了代码的冗余，提高了代码的复用性
    * 2.便于功能的扩展
    * 3.为之后多态性的使用，提供了前提
    * 
    * 二、继承性的式格式：
    *       class A extends B{}
    *       A:子类、派生类、subclass
    *       B:父类、超类、基类、superclass
    * 
    *       2.1体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的结构属性方法
    *       特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。
    *       只有因为封装性的影响，使得子类不能直接调用父类的结构而已。
    *       2.2字类继承父类之后，还可以声明自己特有的属性或方法，实现功能的拓展。
    *       子类和父类的关系，不同于子集和集合的关系
    *       extends:延展、拓展
    * 
    * 三、Java中关于继承性的规定：
    *       1.一个类可以被多个子类继承。
    *       2.Java中类的单继承性：一个类只能有一个父类
    *       3.子父类是相对的概念
    *       4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
    *       5.子类继承父类以后，就获取了直接父类以及所有间接类类中声明的属性和方法
    * 
    * 四、    1.如果我有没有显示的声明一个类的父类的话，则此类继承于java.lang.Object类
    *       2.所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类
    *       3.意味着，所有的java类具有java.lang.Object类声明的功能

    *1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作
    * 
    * 2.应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
    * 
    * 3.重写的规定：
    *           方法的声明：权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{
    *                       //方法体
    *                   }
    *           约定俗成：子类中的叫重写的方法，父类叫被重写的方法
    *           子类重写的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
    *           子类重写的方法的权限修饰符不于于父类被重写的方法的权限符饰符
    *               >特殊情况：子类不能重写父类中声明为private权限的方法
    *           返回值类型：
    *               >父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
    *               >父类被重写的方法的返回值类型是A类型，则子类重写的法法的返回值类型可以是A类或A的子类
    *               >父类被重写的方法的返回值类型是基本数据类型，则子类重写的方法的返回值类型必须是相同的基本数据类型
    *           子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型(具体放到异常处理时候讲)
    * **************************************************************************
    * 
    *           子类和父类中的同名同参数的方法要么都声明为非static的(考虑重写)，要么都声明为static的(不是重写)。
    * 
    * 面试题：区分方法的重载与重写

    /* 1.理解多态性：可以理解为一个事物的多种形态。
     * 2.何为多态性 
     *      对象的多态性：父类的引用指向子类的对象(或子类的对象赋给父类的引用)
     * 
     * 3.多态的使用：虚拟方法调用
     *      有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法
     *      总结：编译，看左边，运行，看右边。
     *      
     * 4.多态性的使用前提:类的继承关系、方法的重写
     * 5.对象的多态性：只使用于方法，不适用于属性（编译和运行都看左边）
     * /

    // 如何才能调用子类特有的属性和方法？
    // 向下转型：使用强制类型转换符
    /*
     * instanceof关键字的使用
     * 
     * a intanceof A:判断对象a是否时类A的实例。如果是，返回true;如果不是，返回false。
     * 
     * 使用情境，为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先
     * 进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。·
     * 
     * 如果a instanceof A返回true，a instanceof B也返回true。 其中 ，类B是类A的父类。
     */