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

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

面向对象：

（1）概念：面向对象是相对面向过程而言，基于面向过程，面向过程强调的是功能行为

   面向对象将功能封装进对象，强调具备了功能的对象，将复杂问题简单化，从      执行者变成了指挥者

   面向对象和面向过程都是一种思想

（2）类和对象的关系：

 类：对现实生活中事物的描述

 对象：这类事物实实在在存在的个体

如：现在生活中的对象：张三、李四

想要描述：提取对象中共性内容，对具体的抽象

描述时：这些对象的共性有姓名、性别、年龄等

映射到Java中，描述就是class定义的类，具体对象就是对应Java在堆内存中用new 建立的实体

匿名对象：对象的简化形式

匿名对象两种使用情况：1）当对对象方法仅进行一次调用时

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

（3）面向对象三个特征：封装、继承、多态

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

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

原则：将不需要对外提供的内容都隐藏起来

      把属性都隐藏，提供公共方法对其访问

private：私有，权限修饰符，用于修饰类中成员（成员变量、成员函数），私有只在本类中有效

注：封装不是私有，私有仅是封装的一种表现形式

构造函数：

特点：1.函数名与类名相同

        2.不用定义返回值类型

        3.不可以写return语句

作用：给对象进行初始化

注：多个构造函数是以重载的形式存在的

小细节：当一个类中没有定义构造函数时，系统会默认给该类加入一个空参数的构造函数，方便该类初始化，否则对象建立不出来，因为对象没办法初始化，当在类中自定义构造函数后，默认的构造函数就没了，默认构造函数的权限是随着类的变化而变化的

构造函数和一般函数在写法上有不同，在运行时也有不同：构造函数是在对象一建立就运行，给对象初始化，而一般方法是对象调用才执行，是给对象添加对象具备的功能，一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次。

构造函数什么时候定义呢？

当分析事物时，该事物存在就具备一些特性或行为，那么将这些内容定义在构造函数中

构造函数是可以被私有化的，私有化是修饰成员的，构造函数也是成员，私有化后，对象是不可能建立成功的，若一个类中所有的构造函数都被私有化，即代表该类是不可能创建对象的，因为对象都不能进行初始化动作

构造代码块：

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

和构造函数的区别：构造代码块是给所以对象进行统一初始化，而构造函数是给对应的对象初始化，构造代码块中定义的是不同对象共性的初识化内容

this关键字:

this就代表本类的对象，代表它所在函数所属对象的引用，简单地说，哪个对象在调用this所在的函数，this就代表哪个对象

this的应用：当定义类中功能（函数）时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象，但凡本类功能内部使用了本类对象，都用this表示

this语句：用于构造函数之间进行相互调用，只能在构造函数间

注：this语句只能定义在构造函数的第一行，因为初始化要先执行

static关键字：静态，是一个修饰符，用于修饰成员（成员变量和成员函数）

特点：随着类的加载而加载

      优先于对象存在

      被所有对象所共享

      可以直接被类名调用

使用注意事项：静态方法只能访问静态成员（方法和变量）

  静态方法中不可以写this、super关键字

特有内容随着对象存储，共有内容静态

被静态化后的成员都存放在哪里呢？方法区（共享区、数据区）

静态有利有弊：

利：对对象的共享数据进行单独空间的存储，节省空间，没有必要每一个对象中都存储一份，可以直接被类名调用

弊：生命周期过长，访问出现局限性（静态虽好，只能访问静态）

什么时候使用静态？

要从两方面下手：因为静态修饰的内容有成员变量和成员函数，所以从成员变量和函数下手

什么时候定义静态变量呢？

当对象中出现共享数据时，该数据被静态所修饰，对象中的特有数据要定义成非静态存在于堆内存中

什么时候定义静态函数呢？

当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的

静态的应用：每一个类中都有共性的功能，可以将这些功能进行抽取，独立封装，以便复用

静态代码块：

格式：

static

{

静态代码块中的执行语句;

}

特点：随着类的加载而执行，只执行一次，并优先于主函数，用于给类进行初始化的

静态代码块是静态的，随着类的加载只能访问静态的

单例设计模式：解决一个类在内存中只存在一个对象

想要保证对象唯一：

1.为了避免其它程序过多建立该类对象，先禁止其它程序建立该类对象

2.还为了让其它程序可以访问到该类对象，只好在本类中，自定义一个对象

3.为了方便其它程序对自定义对象的访问，可以对外提供一些访问方式

这三步怎么用代码体现呢？

1.将构造函数私有化

2.在类中创建一个本类对象

3.提供一个方法可以获取到该对象

<pre name="code" class="java">class Single{//第一步private Single(){}//第二步private static Single s=new Single();//第三步public static single getinstance(){return  s;}}

单例设计模式有两种体现：第二种方式

class Single{private Single(){}private static Single s=null;public static Single getInstance(){if(s==null)s=new Single();return  s;}}

第一种方式是先初始化对象，称为饿汉式，Single类一进内存就已经创建好了对象

第二种方式是对象是方法被调用时才初始化，也叫做对象的延迟加载，称为懒汉式，，Single类一进内存，对象还没存在，只有调用了getInstance方法时才建立对象

原则：定义单例，建议使用饿汉式