黑马程序员_面向对象

------- android培训、java培训、期待与您交流！ ----------

一   面向对象的理解

1、面向对象：就是将功能封装起来，强调的是具备了功能的对象。

       面向过程：强调的是功能的行为。

       所以说：面向对象是基于面向过程的。

       面向对象的三大特征：封装性、继承、多态。

       开发其实就是找对象、建立对象、适用对象和维护对象。

2、类和对象的关系

      类：对现实生活中事物的描述；（类中有成员变量和成员函数）

      对象：现实生活中事物的具体个体。

3、成员变量和局部变量

   （1）作用域不同

      成员变量作用于整个类中；局部变量作用于函数中。

    （2）在内存中的位置不同

      成员变量存在于堆内存中，只有对象建立时才能在内存中存在；局部变量则是存在于栈内存中。

4、匿名对象

      （1）匿名对象是对象的简写形式

                 对象: Person p=new Person（）;

                           p.name=chy;                                         

                       匿名对象: new Person().name=chy;

        （2）匿名对象的使用

               当对象的方法只被调用一次时，可以使用匿名对象，这样写比较简单；

               可以将匿名对象作为实际参数进行传递；

5、封装

         （1）定义：隐藏对象的属性和实现细节，仅对外提供公共的访问方式。

         （2）好处：将变化隔离；便于使用；提高复用性；提高安全性。

          （3）private：私有，权限修饰符，用于修饰类中的成员，只有在本类中有效。

            注意：私有仅仅只是封装的一种表现形式。

6、构造函数

            （1）特点：函数名和类名相同；没有返回值；

            （2）作用：对象一建立就会调用构造函数，所以构造函数可以用来进行对对象初始化。

            （3）和一般函数的区别

                和一般函数的写法不同；

                和一般函数的运行不同，构造函数在对象建立时就会运行，一般函数则是被对象调用时才能运行；

                一个对象的建立构造函数只运行一次，而一般函数则可以被多次调用；

             注意：

            

            上段程序中的构造函数和设置函数的区别：它俩的功能不相同，虽然都可以给对象赋值，但构造函数所赋的值不能改变，而设置函数可以随时改变。

            （4）什么时候定义构造函数：事物一存在就具备一些属性。

            （5）构造代码块

              作用：给对象进行初始化，给所有对象一起进行初始化。（运行时比构造函数先运行）

7、this关键字

             （1）区别局部变量和成员变量。

             （2）特点：this代表的是所在函数所属对象的引用

             （3）应用：当定义类中的功能时，该函数内部要调用到该函数的对象时，这时用this表示这个功能。

             （4）this语句（this（））用于构造函数之间的调用。（this语句只能放在构造函数的第一行）  

8、static关键字

             （1）用法：static是一个修饰符，用来修饰成员（成员函数和成员变量）。

             （2）static的特点：随着类的加载而加载，同时也会随着类的消失而消失（生命周期最长）；静态成员比对象先存在于内存  中；静态成员可以被所有对象共享；静态成员可以被类名直接调用。（注意：静态成员变量也叫做类变量，非静态变量也称为实例变量）

             （3）静态变量和非静态变量的区别

                存放位置不同：静态变量存放在方法区；非静态变量存在于堆内存中。

                生命周期不同：静态变量随着类的消失而消失；非静态变量随着对象的消失而消失

             （4）静态使用的注意事项：静态方法只能调用静态成员，不能调用非静态成员；而非静态方法都可以调用。静态方法中不可以定义this，super关键字（因为静态是先于对象而存在的）。

             （5）Person p=new Person (haha ,45)运行的过程:

                   因为new用到了Person.class,所以会先调用此文件并加载到内存中;

                   执行该类中的静态代码块；（用来给类进行初始化）

                   在堆内存中开辟空间，分配内存地址；

                   在堆内存中建立对向特有的属性，并进行默认初始化；

                  对对象进行显示初始化；（成员变量上的赋值）

                  对对象进行构造代码块初始化；

                  对对象进行对应构造函数初始化；

                  将对内存中的地址值给内村中的p变量。

9、main

             （1）main是一个特殊的主函数，可以作为程序的入口，被jvm调用。

             （2）public static void main（String[] args）的意义

                  public：代表的是该函数的访问权限是最大的；

                  static： 代表着主函数随着类的加载就已经存在了；

                  void：   主函数没有具体的返回值；

               （String[] args）：函数的参数，参数的类型是一个字符串类型的数组。相当于new String[]  

10、单例设计模式

            （1）定义：解决一个类中只有一个对象的方法。

            （2）怎样保证对象的唯一？

               为了避免其他程序多次建立该类的对象，禁止其他程序建立该类的对象；（私有化构造函数）

               同时为了让其他程序访问到该类的对象,可以在类中建立自己的对象;

               对外提供访问该对象的访问方法;

              下面是单例设计的两种方法饿汉式和懒汉式:

              饿汉式:

                  

                懒汉式；

             

             这两种设计的区别：饿汉式是类一加载就会建立对象，而懒汉式则是在调用getInstance（）方法是才建立对象，因此懒汉式又叫作延迟加载。

二  类的继成

1、继承的概述

          （1） 简单的说，继承就是在一个现有类型的基础上，通过增加新的方法或者重定义已有方法的方式，产生一个新的类。继承是面向对象的三个基本特征--封装、继承、多态的其中之一。  

             （2）   继承 的好处 ：提高了代码的复用性；让类和类之间产生了关系，有了这个关系，才有了多态的特性 。

             注意：java只支持但继承，不支持多继承（存在安全隐患，继承多个父类时，若是父类中有相同的方法，子类就不知道该继承谁。）但是java支持多层继承和多实现。

 2、继承中的构造函数

          （1）子类的所有构造函数，默认都会访问父类中的空参数构造函数。（子类的构造函数第一行都有一个super语句，隐藏了）

          （2）当父类中没有空参数的构造函数时，子类必须通过super或者this语句来指定要访问的构造函数。

3、final关键字

          （1）final是一个修饰符，表示最终的意思；就可以修饰类、函数和变量。

          （2）final修饰过的类不可以再被继承。（避免此类中功能主体被破坏）

          （3）final修饰过的方法不可以再被复写。

          （4）final修饰过的变量是一个常量。

4、抽象类

          （1）定义：当多个类中出现功能相同，但主体不同的方法时，只抽取类中的功能定义，而不抽取功能主体

          （2）特点：抽象方法一定在抽象类中；抽象方法和抽象类必须用abstract关键字修饰；抽象类不可以建立对象（空方法被调用没有意义）；抽象类想建立对象必须让其子类复写其全部抽象方法。

5、模板方法设计模式

           定义：定义功能时，功能的一部分是确定的，一部分是不确定的，确定的要使用不确定的，所以要将不确定的给暴露出去，由该类的子类去完成。

6、接口（interface）

           （1）接口；可以理解为一个特殊的抽象类（接口中的方法都是抽象的）（类是用class表示；接口是用interface表示）

           （2）接口格式的特点：接口中常见的定义有方法和常量；

                     方法的格式：public abstract

                     常量的格式：public static final（记住：接口中的成员都是public，常量可以被对象，类名和接口名调用）

           （3）类extends类；类implements接口；接口extends接口

           （4）类可以多实现的原因在于接口中的方法都是抽象的（只有功能没有主体）。

三、多态性

1、多态的理解

          （1）定义：一种事物的多种表现形态（比如：一个对象既可以用它自己的类来引用，也可以用父类来引用）

          （2）多态的体现

            父类的引用指向子类的对象（例：原本： 子 z=new 子（）；现在：父 f=new 父（）；子是继承父的）

          （3）多态的前提

            必须是类与类（接口）之间有关系（继承或是实现）；另外还有一个前提是必须覆盖其父类的方法。

          （4）多态的优点

           多态提高了代码的扩展性（看下面的代码）                        

             （5）多态的弊端：只能使用父类的引用去访问父类的成员。

            相应的解决办法：其实：父 f=new 父（）这是一种类型转化，向上转型；相应的我们可以进行向下的强制转化（强制将父类的引用转化成子类的引用。其格式是 子 z=(子)f;）

         （6）多态的注意事项（多态成员的应用）

             多态成员函数（非静态）：在编译时期：参阅的是引用型变量的类中（父类中）是否有调用方法，如果有则编译通过，反之失败。在运行时期：参阅的是对象所属的类型是否有方法调用。（编译看左边，运行看右边）

            多态成员变量：在编译和运行时期都看左边。（静态函数也相同）

            总结:根据静态的特性可以知道,静态函数是随着类的加载而存在的(不需要对象),所以在父类引用指向子类对象之前,父类的静态函数值已经确定了.

            小知识点：1.基本数据类型赋值用=；应用数据类型赋值用instanceof。

                                2.多态的出现不但简化了代码，而且使对象的调用变简单了。以前是指挥每一个对象做事情，现在是指挥一批对象做事情（将这些对象所属的共同类型向上提取）。

2、内部类

           （1）内部类定义：将一个类定义在另一个类里面，称里面类为内部类（内置类或嵌套类）

           （2）内部类的特点：可以直接访问外部类的成员（包括私有）；而外部类访问内部类则必须建立内部类的对象。

                     直接访问内部类的格式：外部类名.内部类名  名称=new 外部类名（）.new 内部类名（）；

           （3）功能内部要调用某一变量时（此同名变量可能同时存在于方法中，内部类中或外部类中），有局部变量就取局部变量，若想访问内部的变量，则用this.变量名来调用；想访问外部的变量，则用外部类名.this.变量名。

           （4）内部类可以被直接调用的原因：内部类持有一个外部类的引用，格式是：外部类名.this。

           （5）内部类可以被static修饰，被static修饰过的内部类只能访问外部类的静态成员。内部类成员有静态成员时此内部类也为静态内部类。

           （6）访问内部类非静态成员格式：new  Outer.Inner（）.function（）。

                     访问内部类静态成员格式： Outer.Inner.function（）。

           （7）内部类定义在局部时：不可以被静态修饰（局部变量不可以被静态修饰）；可以直接访问外部类中的成员，但不可以访问它所在局部中的变量（只可以访问被fianl修饰的局部变变量）。

3、异常

          （1）定义：程序在运行时出现不正常的情况。

          （2）异常的由来：问题也是现实生活中的一个具体的事物，可以通过java形式进行描述，并封装成对象。

          （3）异常分为两类：一类是严重的，用Error类进行描述，对于这类类java一般不编写针对性的代码进行描述；另一类是非严重的，用Exception来描述，对于这类类可以使用针对性的方式进行处理。Error和Exception有个父类Throwable。

         （4）异常的处理：try处理的格式：try{可能发生异常的代码}catch（异常类 变量）{处理方式}finally{一定会执行的代码}。 throws处理方式 ：在函数名上将此函数可能出现的异常类的类名抛给调用者，格式:函数名（）throws 异常类名.

         （5）throws处理的好处：提高了代码的安全性，让调用者处理，调用者不处理则编译失败。

         （6）多异常的处理：一个函数可能出现多个异常，可以同时将几个异常同时抛出，这几个异常用逗号隔开（注：几个异常就有几个相对应的catch语句。多个异常之间存在继承关系时父类的catch语句要放在子类下面）

         （7）自定义异常类：有些异常是开发中特有的，这些类必须继承Exception类（原因就在于不是所有的类和对象都是可抛的，这是异常体系特有的。）  

         （8）throw和throws的区别：throw使用在函数内，throws使用在函数上；throw后面跟的是类对象，throws后面跟的是类名。

         （9）RuntimeException类

              特点：是一个特殊的Exception类，如果在函数内处理了异常，可以不在函数上声明，编译一样可一同过；对应的在函数上声明了，在函数内可以不进行处理。原因就在于当RuntimeException异常发生时，需要的是程序停止，以便对代码进行修正，而处理了，程序就不会停止，问题就会被隐藏。

         （10）finally：最后一定会执行的代码（通常用于关闭资源）

         （11）try、catch和finally的组合方式有三种：try和catch；try和finally；try，catch和finally。

         （12）异常中的覆盖：子类只能抛父类的异常或是父类的子异常，其他的异常只能try。

         （13）异常的运行过程：建立具有异常的类的对象时：在类中jvm会建立一个此异常的对象，将这个异常对象抛给try语句，若是在try中发现此异常（正常语句不会再执行），继续抛给catch语句，让catch来处理。若是没有发现异常就会执行正常语句。

 ------- android培训、java培训、期待与您交流！ ----------