黑马程序员--java基础复习之面向对象

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

    以前在学校的时候，学C语言基础的时候还没有接触到这个概念。直到由C转到学习C#的时候，才第一次接触它。但那时候理解得还是不清楚，迷迷糊糊的，后来在工作中，也一直没放在心上。直到这段时间学习java 基础的时候，才算真正理解了这个概念，也发现以前的工作中其实也用到了对象，只是自己一直没有真正理解这个概念，所以不认得它而已。

    原来前几天一直写的if、for 、while语句等都是面向过程的，毕老师的视频里很形象的将面向过程比喻成将大象装冰箱这个笑话。将大象将冰箱分三步，将冰箱门打开，将大象装进去，将冰箱门关上。这是三个过程，在这个里，我们看到的是这三个动作。而面向对象则是将这三个功能都赋给冰箱这个对象，这样，我们看到的就不再这三个动作，而是冰箱。我们只需要调用冰箱的功能，同样能实现将大象装冰箱。与我们直接接触的是冰箱了，冰箱就是这个对象。

     用我自己的理解来举例说明。我饿了，要吃饭，于是，我去菜场买菜，然后回来洗菜，切菜，煮饭，炒菜，然后才能吃饭。吃完饭还要善后：刷盘子洗碗。 一通下来，人也累得不行。这个就是面向过程。我们向对一大堆功能：买菜、洗菜、切菜、煮饭、炒菜，吃饭、善后。

      现在我觉得自己做饭太累了，我出去吃，我去找个餐馆。“服务员，点菜”，点了盘宫爆鸡丁，一会儿菜上来了，上饭，开吃，吃完了一抹嘴，结账，走人。。。。这个就是面向对象。对象就是餐馆，我先是调用餐馆的点菜功能，将参数="宫爆鸡丁"传进去，然后餐馆这个对象就调用内部的买菜，洗菜、切菜，炒菜功能，这些功能我们一般都是看不到了，这个就是私有。最后菜好了，服务员把我要的菜返回给我。我吃完结账走人，然后善后功能都交给了对象。在这个过程中，我只需要找到这个对象（餐馆），使用这个对象的点菜功能，然后就开吃，最后再调用对象的结账功能。

     很轻松的就吃了顿饭，从面向过程：买菜，洗菜，切菜，炒菜，煮饭，善后，一大堆功能都得自己执行。到面向对象：找个餐馆对象，然后调用对象的点菜，结账功能，就可以了。

面向对象的概念：

面向对象是相对面向过程而言的

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

面向过程强调的是功能

面向对象则是将功能封装进对象，强调的是具备了功能的对象。

面向对象的好处：将复杂的事情简单化,从以前的执行者，过渡到现在的指挥者

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

在java的开发过程中，其实就是不断的创建对象，使用对象，指挥对象，以及维护对象之间的关系。

类和对象的关系

类就是对现实生活中事物的描述。

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

如

/*需求：描述汽车(颜色，轮胎数)。描述事物其实就是在描述事物的属性和行为而属性对应的就是类中的变量，行为对应的是类中的函数(方法)*///其实定义类，就是在描述事物，就是在定义属性和行为。//属性和行为共同成为类中的成员(成员变量、成员函数)class Car{ //描述颜色 String color="red"; //描述轮胎数 int num=4;  //描述行为 void run() { System.out.pritnln("Car run:"+color+".."+num); }}

class CarDemo{public static void main(String[] args){//生产汽车。在java中通过new操作符来完成。//其实就是在堆内在中产生一个实体Car c=new Car();  //c就是一个类类型的变量。类类型变量指向对象//需求：将已有车的颜色改成蓝色。指挥该对象做使用//在java中指挥的方式是：对象.对象成员c.color="blue";}}

在内存中是这样的

其实定义类，就是在描述事物，就是在定义属性和行为。

属性和行为共同成为类中的成员(成员变量、成员函数)

属性：对应类中的成员变量

行为：对应类中的成员函数

而对象则是事物的实实在在的个体

成员变量和局部变量

作用范围：

成员变量作用于整个类中，局部变量作用于函数中或语句中

存储位置：

成员变量在堆内存中。因为对象的存在，才在内存中存在。

局部变量存在于栈内存中.

初始值：

局部变量没有默认初始化值，而成员变量有默认初始化值

匿名对象

匿名对象是对象的简化形式。

使用方式一：当对对象的方法只调用一次时，可以使用匿名对象来完成，这样写比较简化,如果对对象的多个成员进行调用的时候，必须给给这个对象起一个名字

使用方式二：可以将匿名对象作为实际参数进行传递。

如:

new Car().run()

例子：

class CarDemo{public static void main(String[] args){show(new Car());}public static void show(Car c){c.num=6;c.color="black";c.run();}}

封装(Encapsulation)

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

好处：1、将变化隔离   2、便于使用    3、提高重用性    4、提高安全性

封装原则：

A、将不需要对外提供的内容都隐藏起来

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

注：函数就是程序中最小的封装体

封装的表现形式之一：private 私有

private ：私有，权限修饰符：用于修饰类中的成员(成员变量、成员函数)

注：私有只在本类中有效

如：

<span style="color:#999999;">//定义一个Person类class Person{//定义一个私有的成员变量private int age;//成员函数void speak(){System.out.println("age="+age);}}class PersonDemo{public static void main(String[] args){//创建Person的一个对象Person p=new Person();//调用对象的私有成员变量，这里是编译失败的p.age=-20;p.speak();}}</span>

结果：

如上，将age私有化以后，类以外即使建立了对象也不能直接访问。但是人应该有年龄，就需要在Person类中提供对应访问age的方式。如下:

/定义一个Person类class Person{//定义一个私有的成员变量private int age;public void setAge(int a){age=a;}public int getAge(){return age;}//成员函数void speak(){System.out.println("age="+age);}}class PersonDemo{public static void main(String[] args){//创建Person的一个对象Person p=new Person();//调用对象的私有成员变量，这里是编译失败的//p.age=-20;p.setAge(20);p.speak();}}

结果：

之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句，对访问的数据进行操作，提高代码健壮性。

如：

public void setAge(int a){if(a>0&&a<130){age=a;speak();}elseSystem.out.println("年龄不合法");}

构造函数

构造函数特点：

A、函数名与类名相同

B、不用定义返回值类型

C、不可以写return语句

作用：给对象进行初始化

注意：

1、默认构造函数的特点。

2、多个构造函数是以重载的形式存在的

如：

<span style="font-size:14px;">class Person{//定义一个构造函数Person(){System.out.println("我是构造函数");}}class PersonDemo{public static void main(String[] args){Person p=new Person();}}</span>

运行结果：

上述结果说明，对象一建立就会调用与之对应的构造函数。

构造函数的作用：可以用于给对象进行初始化

构造函数的小细节：

当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。

其格式如下:Person(){};  而当类中自定义了构造函数后，默认的构造函数就没有了。

构造函数和一般函数在写法上的区别：

运行：构造函数是在对象一建立就运行，给对象初始化。而一般方法是对象调用才执行，是给对象添加对象具备的功能。

一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次。

什么时候定义构造函数？

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

构造代码块

格式：

{  //执行语句;}

作用：给对象进行初始化。

对象一建立就运行，而且优先于构造函数执行。

构造代码块和构造函数的区别：

构造代码块是给所有的对象进行统一初始化，而构造函数是给对应的对象初始化.

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

this关键字

this代表什么？

this代表本类的对象

this  代表它所在函数所属对象的引用

通俗地说，哪个对象在调用this所在的函数，this就代表哪个对象

this 的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来

表示这个对象。但凡本类功能内部使用了本类对象，都用this表示

如下代码：

<span style="font-size:14px;">class Person{private String name;private int age;Person(int age){this.age=age;}Person(String name,int age){this.age=age;//this(age)，即调用上面那个构造函数 即new Person(age);this.name=name;}}class PersonDemo1{public static void main(String[] args){Person p1=new Person(20);Person p2=new Person(25);}}</span>

从上述代码中可以看出，this代表本类的对象，代表了它所在函数所属对象的引用，通俗地说，哪个对象在调用this所在的

函数，this就代表哪个对象

对this的概括总结：
        this的两种用法：1、用于区分同名变量的情况，成员和局部同名的时候；

2、用于构造函数间调用。
注：一般函数不能直接调用构造函数，因为this语句不能用在一般函数中，只能用在构造函数间。

如：

class Person{private String name;private int age;Person(int age){this.age=age;}Person(String name,int age){this(age);//即调用上面那个构造函数 即new Person(age);this.name=name;}}

static关键字（静态）

用法：是一个修饰符，用于修饰成员(成员变量、成员函数)

当成员被静态修饰后，就多了一种调用方式，除了可以被对象调用外，还可以被类名.静态成员

被修饰后的成员具备以下特点：

A、随着类的加载而加载

也就是说：静态会随着类的消失而消失。说明它的生命周期最长。

B、优先于对象存在

明确一点：静态是先存在的，对象是后存在的

C、被所有对象所共享

D、可以直接被类名调用

代码：

<span style="font-size:14px;">class Person{String name;//成员变量，实例变量static String country="CN";//静态的成员变量，类变量public void show(){System.out.println(name+"::"+country);}}class StaticDemo{public static void main(String[] args){System.out.println(Person.country);}}</span>

运行结果：

其中，类中的非静态变量称为实例变量（即对象的变量，随着对象而存在），而静态变量称为类变量(随着类的加载而加载)

实例变量和类变量的区别：

1、存放位置

类变量随着类的加载而存在于方法区中

实例变量随着对象的建立而存在于堆内在中

2、生命周期

类变量生命周期最长，随着类的消失而消失

实例变量生命周期随着对象的消失而消息。

静态的使用注意事项：

代码如下：

class Person{String name;//成员变量，实例变量static String country="CN";//静态的成员变量，类变量public static void show(){System.out.println(name+"::"+country);}}class StaticDemo{public static void main(String[] args){System.out.println(Person.country);}}

运行结果：

从上述代码中可以得出：

1、静态方法只能访问静态成员  上述代码中，在主函数中调用Person中的静态方法show（）,但是show()

方法访问了非静态成员name，所以报错。

而非静态方法既可以访问静态也可以访问非静态

2、静态方法中不可以定义this,super关键字

因为静态优先于对象存在。所以静态方法中不可以出现this （this代表对象）

3、主函数是静态的

静态的利弊
利：A、对对象的共享数据进行单独空间的存储，节省空间。
没有必要每个对象中都存储一份。
B、可以直接被类名调用。
弊：A、生命周期过长
B、访问出现局限性。(静态只能访问静态)

主函数

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

public static void main(String[] args)

主函数的定义

public:代表着该函数访问权限是最大的

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

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

main:不是关键字，但是是一个特殊的单词，可以被jvm识别

(String[] args):主函数的参数，参数类型是一个数组，该数组中的元素是

字符串。即字符串类型的数组

主函数是固定格式的，以便虚拟机识别

主函数的重载，如下：

<span style="font-size:14px;color:#666666;">class MainDemo{public static void main(String[] args){System.out.println("A");main(1);}//主函数的重载public static void main(int x){System.out.println("B");}}</span>

jvm调用主函数时传递了一个String类型的数组过来，那么，这个参数的内容是什么呢？如下：

class MainDemo{public static void main(String[] args){System.out.println(args.length);System.out.println(args);}}

结果：  参数是一个长度为0的String类型的数组。

当我们手动传递参数时：

class MainDemo{public static void main(String[] args){System.out.println(args.length);for(int i=0;i<args.length;i++){System.out.println(i+":"+args[i]);}}}

运行：  

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

当对象中出现共享数据时，该数据被静态所修饰。

对象中的特有数据要定义成非静态存在于堆内存中。

什么时候定义静态函数？

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

静态代码块

格式：

static

{

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

}

特点：随着类的加载而执行，只执行一次。

用于给类进行初始化。

例子：

<span style="font-size:14px;">class StaticCode{//静态代码块static{System.out.println("a");}}class StaticCodeDemo{//静态代码块static{System.out.println("b");}public static void main(String[] args){new StaticCode();new StaticCode();  //类初始化后只执行一次System.out.println("over");}//静态代码块static{System.out.println("c");}}</span>

执行结果  b c a  over

注：

Person p=new Person("zhangsan",20);

该句话做了什么事情？

1、因为new用到了 Person.class。所以会先找到Person.class文件并加载到内存中。

2、执行该类中的static代码块，如是有的话，给Person.class类进行初始化。

3、在堆内存中开辟空间，分配内存地址。

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

5、对属性进行显示初始化(赋值)

6、对对象进行构造代码块初始化。

7、对对象进行对应的构造函数初始化

8、将内存地址赋给栈内存中的p变量

设计模式

设计模式：解决某一类问题最行之有效的方法

java中有23种设计模式

下面说下单例设计模式

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

想要保证对象唯一，有三步

1、为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象。

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

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

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

1、将构造函数私有化。

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

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

单例设计模式有两种方式

一，饿汉式  特点是先初始化对象。在实际开发中，出于安全考虑，建议使用饿汉式，其具体代码如下：

class Single{private Single(){};//将构造函数私有化，这样，在其他类中就不能创建该类的对象private static Single s=new Single();//在本类中自定义一个对象//提供一个方法可以获取到该类对象public static Single getInstance()  {return s;}}

二、懒汉式  特点是对象在方法被调用时，才进行初始化，也叫对象的延时加载

在代码中，Single类进内存，对象还没有存在，只有调用了getInstance方法时，才创建对象。代码如下：

/*懒汉式*///对象是方法被调用时，才初始化，也叫做对象的延时加载。称为：懒汉式//Single 类进内存时，对象还没有存在，只有调用了getInstance方法时，才建议对象。class Single1{private Single1(){};private static Single1 s=null;public static Single1 getInstance(){if(s==null)s=new Single1();return s;}}