面向对象总结

 

 

面向对象的特点：

 

      1，面向对象就是更符合人们思考习惯的一种思想。

      2，从面向过程的执行者，转变成了面向对象的指挥者。

      3，面向对象将复杂的事情简单化。

类与对象的关系：

 

     1，类：类是对具体事物的描述，描述中包含了该类事物具体的共性内容。

     2，对象：就是该类事物现实中实实在在存在的个体(对象)。

封装的特性：

    1，  易于使用

    2，  提供安全性

    3，  隔离了变化

    4，  提供复用性

构造函数的作用：

         每创建一个对象都会执行这个构造动作，所以构造函数的作用是给对象进行初始化的。

this关键字有什么含义？在哪些情况下应用？

 

         Java中为了解决变量的命名冲突和不确定性问题，引入了关键字this。this代表的是当前类的一个引用，它经常出现在函数和构造函数。

     1，  返回调用当前函数的对象的引用。

     2，  在构造函数中调用当前类中的其他构造函数。

     3，  当方法参数名和成员变量名相同时，用于区分参数名和成员变量名。

static关键字具体如何应用？能修饰构造函数？

 

     1，它是一个修饰符，只能修饰成员（成员变量和成员函数）。

     2，被static修饰的成员变量的数据，可以被对象们所共享。

     3，被静态修饰的成员多了一种调用方式，除了被对象调用以外，还可以被类名直接调用。格式：类名.类名成员。

     4，静态之所以可以被类名调用，那是因为，静态成员是随着类的加载而加载进内存的。（非静态的成员是随着对象的加载而加载进内存）。

         注意：static不能修饰构造函数。

         解决的问题包括：

                   1，当类只能有一个实例而且用户可以从一个众所周知的访问点访问它时。

                   2，当这个唯一实例应该是通过子类可扩展的，并且用户应该无需更改代码就能使用一个扩展的实例时。  

                   当一个类中只创建一个对象，并提供一个公共的访问方法。

         单例设计模式的思想：指的就是解决问题行之有效的思想。

继承的好处和弊端：

          好处：

                   1，提高了代码的复用性。

                   2，让类与类之间产生了关系，提供了多态的前提。

          弊端：

                  1，  java只支持单继承，因此继承也有局限性。

什么时候使用覆盖？以及覆盖的小细节？

         

什么时候使用覆盖？

            当对一个类中的功能的内容进行重新定义时，可以定义该类的子类，并保留父类中的功能声明。

            重新定义功能内容。并建立子类对象调用该功能。

             （定义了一个子类，保留了父类中功能的声明，但是重新定义了功能的内容，这就是覆盖的应用。）

   覆盖小细节：

        1，子类方法覆盖父类方法时，权限必须大于或等于父类的权限。

        2，静态只能覆盖静态，或者被静态覆盖。

子类的实例化过程：

         1，加载对象所属的字节码文件。

         2，通过new操作符在堆内存中开辟空间，明确首地址值。

         3，对该对象空间中的属性进行默认初始化。

         4，调用对应的本类构造函数进行初始化。

         5，本类构造函数中有隐式的super，必须到父类中进行初始化。

         6，当父类中的内容初始化完毕后，再进行属性的显示初始化。

         7，再进行构造代码块的初始化。

         8，再执行本类对应构造函数中自定义的初始化内容。

final关键字的特点：

        1，final是一个修饰符，可以修饰类，方法，变量（成员变量，局部变量）。

        2，final修饰的类不可以被继承。

        3，final修饰的方法不可以被覆盖。

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

         是为了增加阅读性，只要数据是固定的。就将这个数据用一个名称来表示，并用final修饰。

         常量名称都是大写字母，有多个单词用下划线分隔。

抽象类的特点：

       1，  没有方法体的方法，称为抽象方法，必须存放在抽象类中。

              抽象方法和抽象类必须用abstract关键字来修饰。

       2，  抽象类不可以被实例化，因为调用抽象方法没有意义。

       3，  抽象类必须由其子类将抽象类中的抽象方法都覆盖后，其子类才可以实例化。否则，该子类还是抽象类。

抽象类涉及的问题：

        1，  抽象类中是否可以定义非抽象的方法？

              是可以的。

              注意：抽象类也是用于描述事物的，只不过有些信息不具体。

              抽象类和一般类的异同点：

         相同点：

                   抽象类和一般类都用来描述事物，都可以定义成员。

         不同点：

                   抽象类可以定义抽象的成员函数，而一般类不可以。

                   抽象类不可以实例化，而一般类可以。

 

         2，  抽象类是否有构造函数

            有的。

            虽然抽象类自身不可以实例化，但是其子类覆盖了所有的抽象方法后，是可以实例化的。

            所以抽象类的构造函数，是用于给其子类对象进行初始化的。

 

         3，  抽象类通常都是一个父类？

            是的。

           因为需要子类去覆盖父类中的抽象方法。

 

         4，  抽象类中可不可以不定义抽象方法？

           可以。

           看上去没什么意义，其实有点意义，目的就是不让这个类创建对象。

 

         5，  抽象关键字不可以和那些关键字共存？

 

           final：修饰子类是一个最终类，不可以被继承。abstract修饰的是父类，必须被继承。

           static：抽象方法被static修饰，就具备了被类名直接调用的特点，但是抽象方法被调用没有意义。

           private：因为抽象方法被私有，无法被覆盖。

接口的特点：

        1，  里面的方法都是抽象的。

        2，  接口中的成员都有固定的修饰符。最常见的成员：全局常量，抽象方法。

               a)        全局常量：public static final

               b)        抽象方法：public abstract

        3，  接口中的成员都是public的。

        4，  接口是不可以建立对象的，必须由接口的子类覆盖了所有的抽象方法后，该子类才可以实例化。否则该子类是一个抽象类。

        5，  类与类之间是继承关系，类与接口之间是实现关系。

        6，  接口的出现可以多实现，避免了继承的局限性。

        7，  一个类在继承一个类的同时，还可以实现多个接口。

        8，  接口与接口之间是继承关系，而且可以多继承。

 

思想：它是个规则，对外提供一个规则，提高了功能的扩展性，降低了功能的耦合性。

多态的好处、弊端和前提：

         多态的好处：

             提高了程序的扩展性，有了多态以后，前期设计好的内容可以使用后期出现的子类内容。

             对应指挥对象做事情的这件事，如果对象很多，指挥起来很麻烦。

             抽取对象共性类型，对该类型的事物进行指挥就会变得很简单。

 

         多态的弊端：

                   前期的程序虽然可以使用后期子类出现的内容，但是只能使用子类覆盖父类的内容。

                 不能使用子类中的特有内容。

 

         多态的前提：

                1，  必须要有关系，继承（extends）和实现(implements)。

                2，  必须有覆盖的操作。

 

        Instanceof是一个关键字，用于判断对象的类型。

        当进行向下转型时，先判断对象是否符合被转成的子类类型，如果是，就可以使用instanceof关键字进行向下转型的操作。

内部类的访问规则：

        1，  内部类可以直接访问外部类中的成员。

        2，  外部类需要创建内部类对象才可以访问内部类中的成员。

什么叫异常以及特点：

         

异常就是在运行时期发生的不正常情况。

         Java发现不正常的情况都包含一些常见信息，并将这些信息进行了对象封装。

         异常的这种机制，其实就是java按照面向对象的思想，将出现的问题封装成了对象。

         异常和错误都有一个特点：其子类的名称的后缀名都是父类名。

          java将常见的问题都封装成了对象。

          对于自定义项目中出现的问题，java并未给出对应的描述。

          这时我们就需要按照面向对象的思想自己完成对问题的描述和封装。

 

throw和throws的区别：

         throw：定义在函数内，用于抛出异常对象，引起程序的跳转，后面跟的是异常对象。

         throws：定义在函数上，用于声明函数可能出现的问题。后面跟的是异常类，可以跟多个，用逗号隔开。

异常的种类及区别：

         1，  编译时被检测的异常。Exception

                这种异常通常都需要进行针对性的处理。

         2，  运行时发生的异常。RuntimeException

                对于运行时异常，一般不编写针对性的处理方式。

               如果该异常发生，就让程序停止，对程序进行修正。

               因为这种异常的出现往往已经无法让程序继续运算了。