黑马程序员——面向对象（一）

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

 

一、 面向对象概念

1、面向对象思想：

(1)概述：面向对象是相对于面向过程而言的，面向过程强调的是功能，面向对象强调的是将功能封装进对象，

          强调具备功能的对象；

         (2)思想特点：

                    A:是符合人们思考习惯的一种思想；

                    B:将复杂的事情简单化了；

                    C:将程序员从执行者变成了指挥者；

 

比如我要达到某种结果，我就寻找能帮我达到该结果的功能的对象，如我要洗衣服我就买洗衣机，

                    至于怎么洗我不管。

         (3)特征：

                   封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式

         继承:多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义

             这些属性和行为，只要继承那个类即可。

                   多态:一个对象在程序不同运行时刻代表的多种状态，父类或者接口的引用指向子

2、类和对象：

                  类：对现实世界中某类事物的描述,是抽象的，概念上的定义。

                  对象：事物具体存在的个体。

3：成员变量和局部变量的区别(重点)

                  (1)作用域

                            成员变量：针对整个类有效。

                            局部变量：只在某个范围内有效。(一般指的就是方法,语句体内)

                  (2)存储位置

                            成员变量：随着对象的创建而存在，随着对象的消失而消失，存储在堆内存中。

                            局部变量：在方法被调用，或者语句被执行的时候存在，存储在栈内存中。

                             当方法调用完，或者语句结束后，就自动释放。

                  (3)初始值

                            成员变量：有默认初始值。

                            局部变量：没有默认初始值，使用前必须赋值。

4、匿名对象

                  (1)匿名对象就是没有名字的对象。是对象的一种简写形式。

                  (2)应用场景

                            A:只调用一次类中的方法。

                            B:可以作为实际参数在方法传递中使用

二、方法

1、方法的定义

方法就是一段有名字的代码，可以完成某一特定功能。

定义格式：

[访问权限修饰符]方法返回值类型方法名（参数列表）{

方法体；

}

定义方法的3个必要条件：函数名、参数列表、返回值类型。如果不需要参数也要写小括号，如果没有返回值类型要写void。

a)方法名定义具体要完成的任务的名称

b)参数列表定义了完成该任务需要使用的外部资源

c)返回值类型定义了执行该任务最终的结果，用return返回。

d)方法体定义了该任务的具体执行过程

访问格式：

对象名.方法名（参数列表）；

2、名词解释

形参：在定义函数时小括号中的参数，用来接收数据的参数。

实参：在调用函数时真正传入的参数，传递给函数的数据。

参数类型：函数的参数的类型，一旦定义传入时必须匹配。

返回值：函数运行结束后返回的值，使用return关键字返回。

返回值类型：函数运行结束后返回的值的类型，在类型非void情况下必须返回，而且必须类型匹配。

3、方法的重载

在同一个类中多个方法的方法名相同，参数列表不同（个数、顺序、类型），这就是函数的重载。

在调用函数的时候通过传入的实参找到匹配的函数调用。

注：函数的重载和返回值类型无关。

三、构造方法

1、构造方法概念

构造方法（Constructor）是一个特殊的方法。

方法名和类名相同。

没有返回值类型。注意：没有返回值类型不等同于void，void也是一种返回值类型。不能使用return关键字返回任何值。

在使用new关键字创建对象时自动调用。

每一个类都有构造方法，即使我们没有显式定义构造方法，也会生成一个默认无参的构造方法，其中没有任何内容。

注意：这个自动生成的构造方法只在未定义任何构造方法时生成，如果我们定义了一个有参的构造方法，那么就不会生成无参的了。

2、构造方法的重载

构造方法数的重载和普通方法相同，函数名相同，参数列表不同即可。

3、构造方法的调用

构造方法在new关键字创建对象时调用。

构造方法可以在该类其他构造方法的第一个语句使用this关键字调用，this代表本类对象的引用。

4、构造方法的访问权限

在定义构造方法时，如无特殊需要，应使用public关键字修饰构造方法。

在一些特定情况下，我们不想让别人创建该类对象，那么可以使用private修饰构造方法，例如单态设计模式。

5、构造代码块

作用：给对象进行初始化。对象一建立就运行，而且优先于构造函数运行。

和构造函数的区别：

构造代码块是给所以对象进行初始化。

而构造函数是给对应的对象初始化。

构造代码块中定义的是不同对象共性的初始化内容。

四、this关键字

this关键字只能在方法内使用。

this关键字除了在构造方法中调用其他构造方法(必须放在第一行)以外，还可以当做一个引用使用。其用于方法中，哪个对象调

用该方法，this(可以省略)就引用哪个对象。例如：

方法中局部变量和成员变量重名，我们想调用成员变量时就可以使用this.变量名形式访问成员变量。

在方法中要将调用该方法的对象作为参数传递给另一个方法时，可以将this作为实参传给该方法。

当一个方法需要返回当前对象的引用时，在return后面跟this.

在内部类中访问外部类的成员时，需要使用外部类名.this.成员名形式访问。

五、方法的参数传递

1、基本数据类型的变量作为实参传入函数之后，在函数中将形参改变，调用处的实参不变。

因为基本数据类型的值是直接存在变量中，传入函数之后函数中的形参也同样存了一个值，这两个值是没有联系的，所以函数中

将形参改变时修改的只是函数中的变量的值，和调用处的实参无关。

2、引用数据类型的变量作为实参传入函数之后，在函数中将形参改变，调用处的实参改变。

因为引用数据类型变量中存储的是地址，传入函数之后函数中的形参存储的也是同样一个地址，函数中将这个形参改变时改变的

都是同一个地址上的对象，所以一边改变两边都变。

六、static关键字

static关键字用来修饰类的成员，被这个关键字修饰的成员都和类加载有关。

JVM运行时不会将所有类加载到内存，因为无法确定程序中要使用哪些。

类在第一次使用时加载，只加载一次。

1、静态变量

·        用static修饰的变量就是静态变量。

·        静态变量在类加载后就初始化。

·        静态变量被类的所有实例所共享。

·        静态变量可以使用类名.变量名形式访问。

·        如果在定义一个类的时候，发现一个成员变量需要被所有实例所共享，那么这个成员变量就需要定义为static的。

2、静态方法

用static修饰的方法就是静态方法。

静态方法在类加载后就可以使用。

静态方法可以使用 类名.方法名形式访问。

静态方法不能直接访问外部非静态成员。

因为外部非静态成员必须在类创建对象之后才能使用，而静态方法可以在没创建对象时就使用。

如果要在静态方法内部访问外部非静态成员，需要先创建该类对象，通过对象访问。

静态方法中不能使用this关键字。

因为this是个引用，哪个对象调用方法就引用哪个对象。而静态方法有可能不是被对象调用的，this无从引用。

如果一个方法不用访问对象的非静态成员，那么就可以定义为静态的，这样使用者就不需要创建对象，直接用类名调用。

静态方法通常是作为工具方法或者一个可以产生对象的方法被声明，目的是为了让调用者更方便的使用，不必创建对象。

3、静态代码块

用static修饰的代码块就是静态代码块，随类加载，只加载一次。

静态代码块在类加载后执行。

静态代码块和静态方法相同，不能使用外部非静态成员。

静态代码块执行和静态变量的初始化顺序由代码从上到下顺序决定。

七、垃圾回收

对象在没有任何引用可以到达时，生命周期结束，成为垃圾。

所有对象在被回收之前都会自动调用finalize()方法。

一个对象在成为垃圾之后不会被马上回收，JVM会检测内存中的垃圾堆积到一定程度时才会回收，如果我们不想等到这个时候才

回收，可以使用System.gc()方法来通知虚拟机回收垃圾。调用该方法之后JVM会开启新线程做处理垃圾的工作，这需要一定时间。

单例设计模式：

                  (1)设计模式：

                            解决某类问题行之有效的方法，是一种思想，是规律的总结

                  (2)用来保证某个类在内存中只有一个对象

                  (3)保证唯一性的思想及步骤

**为了避免其他程序建立该类对象，先禁止其他程序建立该类对象，即将构造函数私有化

                   **为了其他程序访问到该类对象，须在本类中创建一个该类私有对象

                   **为了方便其他程序访问到该类对象，可对外提供一个公共访问方式

 

         比如API中的Runtime类就是单例设计模式。

 

         (4)单例设计模式的两种方式

                   A:饿汉式当类加载的时候，就创建对象。       

                   classStudent

                   {

                            privateStudent(){}

                           

                            privatestatic final Student s = new Student();

                           

                            publicstatic Student getInstance()

                            {

                                     returns;

                            }

                   }

                   B:懒汉式当使用的使用，才去创建对象。

                   classStudent

                   {

                            privateStudent(){}

 

                            privatestatic final Student s = null;

                           

                            publicstatic Student getInstance()

                            {

                                     if(s==null)

                                     {

                                               //线程1就进来了，线程2就进来了。

                                               s= new Student();

                                     }

                                     returns;

                            }

                   }

         饿汉式和懒汉式的区别：

                   **

                   饿汉式是类一加载进内存就创建好了对象；

                   懒汉式则是类才加载进内存的时候，对象还没有存在，只有调用了getInstance()方法时，

                   对象才开始创建。

                   **

                   懒汉式是延迟加载，如果多个线程同时操作懒汉式时就有可能出现线程安全问题，解决线程安全问题

                   可以加同步来解决。但是加了同步之后，每一次都要比较锁，效率就变慢了，

                   所以可以加双重判断来提高程序效率。

                   注：开发常用饿汉式，因为饿汉式简单安全。懒汉式多线程的时候容易发生问题