java基础之：面向对象

面向过程和面向对象：

     面向过程：程序=算法+数据结构；首先确定如何操作数据，然后再决定如何组织数据。

     面向对象（OOP）：程序=数据结构+算法；首先确定操作那些数据，然后决定如何操作这些数据。其思想类似于CSS：将HTML各标签的格式提取出来，作为一段独立的代码，文件，然后对该代码和文件进行操作。

       

面向对象三大特性

一、封装：数据隐藏，黑盒化

     定义：隐藏对象的属性和实现细节，只对外提供访问方式。

     好处：将变化隔离，便于使用，提高重用性，安全性。

     封装原则：对于属性，都将其隐藏（用private私有化），并提供公共访问方法（setXyz和getXyz)。其他不需要对外提供的内容也都隐藏，需要对外提供的则公有化。

     典型的封装：

          1、单例设计模式：

                用途：保证内存中存在的该类对象只有一个，

                      比如配置文件的读写：需要保证多个程序读取同一个配置文件时，在内存中操作的是同一个文件对象。

                思路和步骤：

                   （1）不让其他程序创建对象：将构造函数私有化：

                   （2）在本类中自行创建一个对象：同时用private私有该对象，

                   （3）对外提供访问本类这唯一对象的方法：定义公有且静态的方法来获取该对象，使外部（public）

                         能使用“类名.方法名”获得该对象（static修饰的方法可通过类名直接调用）。

               两种方式：

                  // 饿汉式  ：类一加载进内存立即创建对象并存储于静态区，供其他程序随时调用

class Single

{ 

private Single(){}                                         // 私有化构造函数

private static Single s = new Single();      // 创建私有并静态的本类对象。

         public static Single getInstance()              // 定义公有并静态的方法，返回该对象。

         {  

     return s; 

 } 

   } 

           // 懒汉式 : 延迟加载方式：该类 getInstance()方法被第一次调用后才创建对象，后续调用返回该对象。

     class Single2

    { 

    private Single2(){} 

    private static Single2 s = null; 

             public static Single2 getInstance()

            { 

          if(s==null) 

          s = new Single2(); 

          return s;

                                   }

                            }

          2、javaBeans

          JavaBean是符合某种规范的Java类。 

           它必须满足如下规范： 

             1）必须有一个零参数的默认构造函数 

             2）必须有get和set方法，类的字段（即成员变量，拥有此两方法的成员变量可称为类的一个属性，且为可读写的）必须通过get和set 方法来访问 ，且格式符合： 属性名为xyx，则方法为getXyz（），set Xyz （参数）。

 

二、继承：类的扩展，数据的复用

     好处：提高了代码的复用性。让类与类之间产生了关系，是多态的前提。

     知识点：

        1、子类继承的内容：非私有的成员变量和成员方法，protected修饰的内容能且只能被子类访问。

        2、成员函数的重写（override），也叫复写、覆盖。当子类继承了父类的成员函数并需要对其函数功能进行修改时，此过程就叫重写。

             与重载（overload）的区别：

               override：子类对继承自父类的方法进行修改，重写需要相同的方法名、返回类型和参数表；子类函数的访问修饰权限不能少于父类的；

               overload：同一个类中，多个同名函数同时存在：输入的参数类型和/或个数不同，是让类以统一的方式处理不同类型数据的一种手段。。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这也是函数的多态性的体现。

                                        

       3、构造函数的继承：

           子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super();

           如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。

           如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。

       4、final关键字：

          这个关键字是一个修饰符，可以修饰类，方法，变量。

          被final修饰的类是一个最终类，不可以被继承。 

          被final修饰的方法是一个最终方法，不可以被覆盖。

          被final修饰的变量是一个常量，只能赋值一次。 

   5、抽象类：

          1：抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。 

 2：抽象方法只定义方法声明，并不定义方法实现。 

 3：抽象类不可以被创建对象(实例化)。 

 4：只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。 

 5: 抽象类只能单继承。

 6：抽象类中有构造函数：用于给子类对象进行初始化，常用于创建匿名内部类。

 7：抽象类中可以定义非抽象方法： 

     抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。 

 8：抽象关键字abstract和final , private , static不能共存。  

 9：抽象类中可以不定义抽象方法，此时直接在类名前加abstract关键字。

    6、接口：当一个抽象类中只有抽象方法，也就是只提供某一些特性的描述时，该抽象类就成了接口。

          抽象类与接口的不同：

          1：抽象类只能被继承，而且只能单继承。 

   接口需要被实现，而且可以多实现。  

2：抽象类中可以定义非抽象方法，子类可以直接继承使用。 

   接口中都有抽象方法，需要子类去实现。

3：抽象类使用的是  is a 关系。 

   接口使用的 like a 关系。 

4：抽象类的成员修饰符可以自定义。 

   接口中的成员修饰符是固定的。全都是public的。 

三、多态

          函数本身就具备多态性，某一种事物有不同的具体的体现。

          体现：父类引用或者接口的引用指向了自己的子类对象。//Animal a = new Cat(); 

          好处：提高了程序的扩展性，降低了程序之间的耦合性。 

          弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性) 

          匿名内部类：

               没有名字的内部类。就是内部类的简化形式。一般只用一次就可以用。这种形式。匿名内部类其实就是一个匿名子类对象。

               前提：内部类必须继承一个类或者实现接口。 

          格式：new 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }.方法。

          使用场景： 

当函数的参数是接口类型引用时，如果接口中的方法不超过3个。可以通过匿名内部类来完成参数的传递。 

其实就是在创建匿名内部类时，该类中的封装的方法不要过多，最好两个或者两个以内。