疯狂java 面向对象~~~

Java面向对象的回顾

    Java源程序的定义规则：

    package 包名; （全部字母都是小写）          0～1次

            一旦在Java源文件中定义了该语句，该源文件中所有Java类，都位于该包下。

    import 包.*（星号只能代表类）  0～N次

            用于导入指定包下的类。这样就允许在该源代码中使用这些类时，省略包名。

    import static 包....类.**（星号只能代表静态Field和静态方法）  0～N次

            用于导入指定类下所有静态成员（包括静态Field和静态方法）。

    [public final abstract] class 类名

    {

         // 0～N个Field

         [private|protected|public static final] 类型 Field名 [= 默认值];

         // 0～N个方法

         [private|protected|public static final|abstract] 返回值类型 方法名(形参列表)

         {

              // 可执行性的代码

              // 如果方法声明了返回值类型，这里就需要一条有效的return语句。

         }

         // 0～N个构造器

         [private|protected|public] 构造器名(形参列表)

         {

              // 可执行性的代码

         }

    }

    一旦有了类之后，做的最多的3件事情：

    （1）直接通过类名来访问类Field，调用类方法。

    （2）创建对象。  

             类名 变量名 = new 构造器();  // 让引用变量，指向new所创建的实例。

    （3）通过引用变量来访问对象的实例Field、或调用它的实例方法。

    ===================傻瓜级================

    定义类  → A。可以通过类调用类Field、调用类方法。

               B。创建对象

               C。通过引用变量来访问对象的实例Field、或调用它的实例方法。

    方法：

        1. 方法传参模式。         值传递。

        2. 方法重载。             两同， 一个不同。

        3. 形参个数可变的参数。

        4. 递归方法。

    变量的分类：

                             ↗   实例变量（没有static）

                  成员变量

             ↗              ↘   类变量（有static）

        变量

             ↘              ↗   形参

                  局部变量   →   代码块的局部变量（仅在该代码块内有效）

                             ↘   方法中的局部变量

    private(当前类访问权限) → 默认（包访问权限） → protected（子类访问权限）

                 → public（公共访问权限）

      封装,继承,多态. ╮(╯▽╰)╭

面向对象的3大特征：

     － 封装。 合理隐藏（private）、合理暴露（protected，public）

     － 继承

     － 多态

Java的继承 － 一个类与另一个类的关系。

              extends － 扩展。

              “is a”

              类与类之间的关系：从“一般到特殊”的关系。 

              人 → 老师 → IT老师 → 较Java的老师

            

      现实中继承 － 一个实例与另一个实例的关系。

                   “捞到”财富。 

   

      Java的继承，单继承， extends后只有一个父类。

      

      子类继承了父类，  就可以获得父类的Field和方法。

      如果你定义的Java类没有显式指定父类，系统会默认会让它继承Object类。

      “一切类，都是Object类的子类！”

方法重载（Overload）  ： 两同，一个不同。          

方法重写（Override，也叫覆盖）  ： 两同、两小、一大。

         两同： 方法名相同

                形参列表相同。

         两小： 子类重写的方法的返回值类型必须比父类方法的返回值类型更小、或相等。

                子类重写的方法的声明抛出的异常必须比父类方法的声明抛出的异常更小、或相等。                

         一大： 子类重写的方法的访问权限必须比父类方法的访问权限更大，或相等。

        @Override  让编译器执行更严格的检查，要求被修饰的方法，必须是重写父类的方法。

        super

             － super限定：强制去父类的方法。

             － super调用：用于显式调用父类的构造器。

              规则：子类的构造器【总会】调用父类的构造器【一次】

                    默认情况下，子类构造器会自动调用父类无参数的构造器。

                    如果希望明确指定子类构造器调用父类的哪个构造器，

                    可用super(参数)来调用。

                super调用必须出现在构造器第一行。

       super调用、this调用都必须出现在构造器的第一行。

          super调用、this调用不能同时出现。

       P146

        1。 如果既没有super调用，也没有this调用。

             子类构造器会自动先调用父类无参数的构造器。

        2.  如果有super调用。

             子类构造器会根据super调用传入的参数去调用父类对应的构造器。

        3.  如果有this调用。

             子类构造器A会先找this调用所对应子类中被重载的构造器B。

多态（Ploymorphism）

 

      由于有如下所示关系：

         

           父类到子类的关系：  从一般到特殊的关系。

           Animal a = new Wolf();

      A。 第一个结论： 【子类的实例，完全可以当成父类对象使用。】

                        父类的引用变量，完全可以指向子类的实例。

      多态：  同一个类型的变量，在执行同一个方法时，表现出多种行为特征

              ——这就是多态。

              多态增加了Java语言的灵活性，也是和设计模式紧密相连的。

      Java的引用变量，有两个类型：

              编译时类型： 由声明它的类型来决定。

              运行时类型： 由该引用实际所指向的对象来决定。

             

         当我们调用引用变量时，它总是呈现它的运行时类型的行为特征。

         在编译阶段，编译器并不知道引用变量实际所引用的对象的类型。

                     编译器只知道它的编译时类型。

      强制类型转换的运算符是 (类型)

      1. 基本类型之间（除了boolean之外），都可以进行转换。

      2. 引用类型之间，只能在具有继承关系的两个类型之间才能转换，否则编译时就报错了。

 

     instanceof － 判断前面的变量所引用的对象，是否为后面类型的实例。

         P151 ，注意点：instanceof前面操作数的类型要么与后面的类相同，要么与后面的类有继承关系，否则会引起编译错误。

留着随时回顾~~~