1. /*
2. * abstract关键字的使用
3. * 1.abstract：抽象的
4. * 2.abstract可以用来修饰的结构：类、方法
5. *
6. * 3.abstract修饰类：抽象类
7. * > 此类不能实例化
8. * > 抽象类中一定有构造器：便于子类实例化时调用(涉及：子类对象实例化的全过程)
9. * > 开发中，都会提供抽象类的子类，让子类对象实例化
10. *
11. * 4.abstract修饰方法：抽象方法
12. * > 抽象方法只有方法的声明，没有方法体
13. * > 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
14. * > 若子类重写了父类中的所有抽象方法后，此子类方可实例化
15. * 若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰
16. */


/*
* abstract使用上的注意：
* 1.abstract不能用来修饰：属性、构造器等结构
*
* 2.abstract不能用来修饰私有方法、静态方法、final的方法、final的类
*
*
*/


1. /*
2. * static关键字的使用
3. * 1. static：静态的
4. * 2. static可以用来修饰：属性、方法、代码块、内部类
5. *
6. * 3. 使用static修饰属性：静态变量(或类变量)
7. * 3.1 属性，按是否使用static修饰，又分为：静态属性 vs 非静态属性(实例变量)
8. * 实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的
9. * 非静态属性时，不会导致其他对象中同样的属性值的修改。
10. * 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致
11. * 其他对象调用此静态变量时，是修改过了的。
12. * 3.2 static修饰属性的其他说明：
13. * ①静态变量随类的加载而加载。可以通过"类.静态变量的方式进行调用
14. * ②静态变量的加载要早于对象的创建。
15. * ③由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
16. *
17. * ④ 类变量 实例变量
18. * 类 yes no
19. * 对象 yes yes
20. *
21. * 3.3 静态属性举例：System.out;Math.PI
22. * 4. 使用static修饰方法：静态方法
23. * ① 随着类的加载而加载，可以通过"类.静态变量"的方法进行调用
24. * ② 静态方法 非静态方法
25. * 类 yes no
26. * 对象 yes yes
27. * ③ 静态方法中，只能调用静态的方法或属性
28. * 非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
29. *
30. * 5. static注意点：
31. * 5.1 在静态方法内，不能使用this关键字、super关键字

    /* 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的父类。
     */

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

    * 一、继承性的好处
    * 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类声明的功能

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

    * 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(形参列表)"，用来调用其他的构造器

一、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 :导入指定类或接口中的静态结构:属性或方法