阶段性学习总结（2）

三、流程控制：

        1.分支语句：

          1>if语句: if(条件表达式){语句}//若条件表达式为ture，则执行语句

                         if(条件表达式){语句1}else{语句2}//为ture，执行语句1；为false则执行语句2

                         if(条件1){语句1}else if(条件2){语句2}else{语句n}//条件1为ture执行语句1；条件1为false,条件2为ture则执行语句2；条件全为false则执行语句n

           2>switch语句：switch(表达式){case 常量值1；语句组1；[break;] case 常量值2；语句组2；[break;]case 常量值n；语句组n；[break;][default:语句组；break;]}

        2.循环语句：

          1>whlie循环语句：while(条件表达式){语句}

          2>do-while循环语句：do{语句}whlie(条件表达式)；

          3>for循环语句：for(变量初始化；结束判断表达；修改变量值){语句}

       3.跳转语句：break; contine; return;

四、面向对象：

       1.类与对象：

          1>概念:对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
                       类：类是一个模板，它描述一类对象的行为和状态。

          2>一个类可以包含以下类型变量：

              局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
              成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
              类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。
              一个类可以拥有多个方法，在上面的例子中：barking()、hungry()和sleeping()都是Dog类的方法。

          3>构造方法:
             每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。
             在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

          4>创建对象:
              对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象,与类名一致，无返回值，在实例化的时候调用。创建对象需要以下三步：

              声明：声明一个对象，包括对象名称和对象类型。
              实例化：使用关键字new来创建一个对象。
              初始化：使用new创建对象时，会调用构造方法初始化对象。

      2.修饰符：

         1>访问修饰符的作用:用于控制类,属性和方法的访问权限和其他功能,放在语句的最前端。

             <1>分类:public,private.protected和缺省的四类

                                                                                          作用范围表

                                     修饰符                         本类            子类            同一包                   不同包

                                     public                             √                √                    √                            √

                                     private                            √                ×                    ×                            ×  

                                     缺省的                            √                ×                    √                            ×  

                                  protected                          √                √                    √                            ×  

             <2>访问控制符可以让我们很方便的控制代码的权限：
                   当需要让自己编写的类被所有的其他类访问时，就可以将类的访问控制符声明为 public。
                   当需要让自己的类只能被自己的包中的类访问时，就可以省略访问控制符。
                   当需要控制一个类中的成员数据时，可以将这个类中的成员数据访问控制符设置为 public、protected，或者省略。

         2>非访问修饰符:static    只能修饰成员变量,不能修饰构造方法,表示"静态"的     

                                       final     所修饰的数据具有“终态”的特征，表示“最终的”意思;final 修饰的类不能被继承;final 修饰的方法不能被子类重写;final 修饰的变量( 成员变量或局部变量）即成为常量，只能赋值一次。

      3.作用域:分类及其概念:

              在Java中，变量的作用域分为四个级别：类级、对象实例级、方法级、块级。

              类级变量 又称全局级变量或静态变量，需要使用static关键字修饰。类级变量在类定义后就已经存在，占用内存空间，可以通过类名来访问，不需要实例化。

              对象实例级变量 就是成员变量，实例化后才会分配内存空间，才能访问。

              方法级变量就是在方法内部定义的变量，就是局部变量。

              块级变量就是定义在一个块内部的变量，变量的生存周期就是这个块，出了这个块就消失了，比如 if、for 语句的块;块是指由大括号包围的代码。

      4.继承的概念及实现:

        1>概念:就是一个类从另一个类获取方法和属性的过程,就像现实生活中的继承关系一样。

        2>继承使用 extends 关键字来实现;继承具有单继承性：Java 允许一个类仅能继承一个其它类，即一个类只能有一个父类。

        3>注意：构造方法不能被继承，掌握这一点很重要。 一个类能得到构造方法，只有两个办法：编写构造方法，或者根本没有构造方法，类有一个默认的构造方法。

     5.类中方法的重载:

        1>概念:同一个类中的多个方法可以有相同的名字，只要它们的参数列表不同就可以(参数列表不同包括参数的类型、参数的个数和参数的顺序,其中一个不同就行)。

         2>方法的重载的规则：
             方法名称必须相同。
             参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。
             方法的返回类型可以相同也可以不相同。
             仅仅返回类型不同不足以成为方法的重载。

         3>方法重载的实现：

              方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错，这叫做重载分辨。

       6,继承中方法的重载和覆盖:

          1>方法的覆盖:   

               <1>如果在新类中定义一个方法，其名称、返回值类型和参数列表正好与父类中的相同，那么，新方法被称做覆盖旧方法。

               <2>方法覆盖的原则：
                       覆盖方法的返回类型、方法名称、参数列表必须与原方法的相同。
                       覆盖方法不能比原方法访问性差（即访问权限不允许缩小）。
                       覆盖方法不能比原方法抛出更多的异常。
                       被覆盖的方法不能是final类型，因为final修饰的方法是无法覆盖的。
                       被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
                       被覆盖的方法不能为static。如果父类中的方法为静态的，而子类中的方法不是静态的，但是两个方法除了这一点外其他都满足覆盖条件，那么会发生编译错误；反之亦然。即使父类和子类中的方法都是静态的，并且满足覆盖条件，但是仍然不会发生覆盖，因为静态方法是在编译的时候把静态方法和类的引用类型进行匹配。

            2>方法的重载:Java父类和子类中的方法都会参与重载，例如，父类中有一个方法是 func(){ … }，子类中有一个方法是 func(int i){ … }，就构成了方法的重载。

            3>覆盖和重载的区别:

                方法覆盖要求参数列表必须一致，而方法重载要求参数列表必须不一致。
                方法覆盖要求返回类型必须一致，方法重载对此没有要求。
                方法覆盖只能用于子类覆盖父类的方法，方法重载用于同一个类中的所有方法（包括从父类中继承而来的方法）。
                方法覆盖对方法的访问权限和抛出的异常有特殊的要求，而方法重载在这方面没有任何限制。
                父类的一个方法只能被子类覆盖一次，而一个方法可以在所有的类中可以被重载多次。

       7.多态：

          1>概念:一个事物有多种表现型态就叫多态。

          2>多态的体现的三个条件 : <1>继承 < 2>覆盖(重写)< 3>父类变量引用子类对象。