黑马程序员——Java基础——面向对象概述

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、什么是面向对象

1、概念理解

面向对象是相对面向过程而言，我们知道c语言就是一门面向过程的语言。面向过程是分析出解决问题的步骤，然后用一个一个函数实现，然后使用的时候拿来调用。而面向对象是把解决的问题根据一定的规则划分为多个独立的对象，然后调用对象的方法来实现问题的求解。

举例：如把大象装进冰箱，对于C语言来说，解决问题分三步：打开冰箱，把大象塞进冰箱，关闭冰箱。而面向对象的思想，是这样，打开冰箱，关闭冰箱，是冰箱具备的特性，因此，把冰箱封装对象，打开和关闭是它的方法，要把大象塞进冰箱，只需调用冰箱的打开和关闭方法即可。我们是冰箱的指挥者。

面向对象是一种思想，能让复杂的东西简单化，能让我们的角色转变，由执行者变为指挥者。

那么怎么才能知道一件事情中有几个对象呢，并且对它们封装呢，可以用名字提炼法。
名词提炼法：把名词提炼出来封装成对象。
如：人开门，人和门是对象，开是一个行为。开的动作应该定义在哪个对象里呢？谁最清楚这个动作的原理，就定义在谁里面。
门是怎么开的，只有门最清楚。通过门轴和弹簧的物理作用，这在制造门的时候，就已经具备了。所以应该定义在门里面。
人
{
开门（门）
{

门.开();
}
}
门
{
开（）
{操作门轴等;}
}

2、面向对象的特点
1） 是一种符合人们思考习惯的思想

2）可以将复杂的事情简单化

3）将程序员从执行者转换成了指挥者

4） 代码复用性很高

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

二、类与对象
1、类与对象的关系
类的定义：类是用来创建对象的模版，它包含被创建对象的属性和行为的定义。
如：我们印刷时，用的模版，字体都被描述在模版上。
类是具体事物的抽象。定义类，就是在定义对象的属性和行为。而对象是类的一个个实体。
具体对象就是对应java在堆内存中用new建立实体。创建对象就是通过new操作符来完成，就是在堆内存中产生一个实体。
Person类的定义：
class Person
{
String name;
int age;
public String getName()
{

return name;
}
}
而在主函数中，我们只要创建一个Person类的对象，就可以操作对象。
public static void main(String[]args)
{
Person person=new Person();
person.name="zhangsan;//对对象的age属性进行修改操作
String name=person.getName();//获取person对象的name属性
}
2、成员变量和局部变量的区别：
不同一：作用范围不同
成员变量作用于整个类中
而局部变量只作用在函数中，或者语句中
不同二：在内存中的位置不同
成员变量：在堆内存中，因为对象的建立，才在内存中被建立
局部变量：存在栈内存中。
不同三：成员变量有默认初始化值，整型变量默认初始化值为0，字符串初始化值为null，double变量初始化值为0.0
而局部变量没有初始化值，要参与运算必须进行手动赋值。
例如
class Car
{
String color;
int num;
}
类中的color变量是成员变量，作用在类中，
类对象car c=new car(); c.color=“red”;

存在栈内存中。
也可以在类中写个主函数，主函数中创建一个类对象。这个叫做在本类中创建本类对象。

3、匿名对象
匿名对象是对象的简化形式
匿名对象两种使用情况
1） 当对对象的方法仅进行一次调用的时候
2） 匿名对象可以作为实际参数进行传递。
例如主函数中
new car();
这就是一个匿名对象。也可以写
new car().num=5;
这个匿名对象一执行完就已经变为垃圾了。因为没有人会调用它。
调用方法，匿名对象有意义，而调用属性，匿名对象没有任何意义。
匿名对象使用方式一，当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化，如果对一个对象进行多个成员调用，必须给这个对象起名字。
匿名对象使用方式二，可以将匿名对象作为实参进行传递。
三、封装

1、定义
封装是面向对象编程的核心思想，将对象的属性和行为封装起来，而将对象的属性和行为封装起来的就是类，类会对用户隐藏它的实现细节。
实际开发我们要做的就是找对象用，没有对象，就创建对象并且维护对象之间的关系。类就是对具体抽象的描述，而对象就是这个类的实体，具体实现。 映射到java中，描述就是class定义的类。具体对象就是对应java在堆内存中用new建立实体。属性和行为共同成为类中的成员（成员变量和成员方法或成员函数）。创建对象就是通过new操作符来完成，就是在堆内存中产生一个实体。
2、 封装的优点：
a.将变化隔离
b.便于使用
c.提高重用性
d.提高安全性
3、 封装的原则：
a.不要对外要提供的内容都隐藏起来。
b.把属性都隐藏，对外提供公共方法对其访问。
很简单，比如一个电脑机箱，把cpu，硬盘，主板都封装在机箱内，可以方便我们使用，但是如果对外不提供任何接口，我们也同样无法使用。
函数就是代码中最小的封装体。
4、封装方法

private：私有。是一种权限修饰符，用于修饰类中的成员，包括成员变量和成员方法。是最常用的一种封装方式。
class Person
{
private int age;
}
注解：私有只在本类中有效。
将age私有化以后，类以外的程序中，即使建立了对象，也无法直接访问到age成员，必须通过公共接口才能访问。私有成员只能被类中的方法直接访问。
如：电脑机箱的公共访问接口。
一般，实际开发中，几乎所有的成员变量都被私有化，对外提供get和set方法来对成员变量进行获取和设置。

但是，我们谨记，封装不是私有，私有只是封装的一种表现形式而已，什么是封装呢？就是只要访问权限不在你的访问范围之内，都叫做封装，而私有只是封装权限的最小权限。
四、构造函数
1、特点：
函数名与类名相同；
不用定义返回值类型；
不可以写return语句；
2、作用
给对象进行初始化操作。
3、当我们没有定义构造函数时，系统默认会定义个空参数的构造函数，里面什么也不执行。形如：Person（）｛｝。但当我们自定义一个构造函数时，系统就不会帮我们定义默认构造函数了。多个构造函数被定义时，是以重载的形式出现的。

4、构造函数与一般函数的区别：
1）构造函数和一般函数在写法上有不同，在运行上也有不同。
2）构造函数是在对象一建立就运行，给对象初始化。而一般方法是对象调用才执行，是给对象添加对象的功能。
3）一个对象一旦建立，构造函数只运行一次。而一般方法可以被对象调用多次。
5、什么时候定义构造函数呢？
当分析事物时，该事物具备一些特性和行为，那么就将这些内容定义在构造函数内。
6、构造代码块
作用：给对象进行初始化。
运行时间：对象一旦建立，就运行，而且优先于构造函数运行。

与构造函数的区别：
构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。
构造代码块中

定义的是不同对象共性初始化的内容。
构造代码块定义格式
class Person
{
private String name;
private int age;
/*构造代码块举例如下*/
{
System.out.println(“person code run”)
}
Person() //构造函数
{

}
.......

}
7、构造函数是可以私有化的，因为构造函数也是成员函数中的一员。但是，
给构造函数私有化以后，会产生一个现象，就是外界对象是不可能通过这个构造函数建立成功的。
举一反三：如果把一个类中的所有的构造函数都私有化，就说明这个类是不可能被创建对象的。

五、This关键字
class Person
{
private String name;
private int age;
Person(String name)//局部变量定义为name是为了方便阅读
{name=name;}
}
这时，运行程序会发现，创建对象，name=null，没有被赋值为实参变量
因为构造函数会先去找本函数中的局部变量。该怎么标识成员变量name呢?用 关键字this,写为 this.name=name;



1、this的基本应用：

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

2） 用于构造函数之间进行互相调用



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

this的两种用法：1、用于区分同名变量的情况，说的成员和局部同名的时候；2、用于构造函数间调用。

this语句不能用在一般函数中，只能用在构造函数间。

六、static关键字

static是一个修饰符，用于修饰成员（成员变量和成员函数）。当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。格式：类名.静态成员。

当内存中存在多个对象，具有相同的数据时，
例如
class Person
{
String name;
static String country=”CN”;
}
每一个进入公司的人，姓名可以不同，但国籍都是相同的，这样建立每一个对象，在内存中都存储国籍，相同的数据，会出现很多重复。
我们可以把country单独取出来，放在一个地方，谁用，谁就取出来。这时，就用到static修饰的共享变量。
当变量被修饰为static变量时，就不在堆内存中存储了，而是被提取到方法区，这样每个对象都可以访问。
1、 static特点：

1）随着类的加载而加载。

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

2）优先于对象存在。明确一点：静态是先存在。对象是后存在。

3）被所有对象所共享。

4）可以直接被类名所调用。

由于静态成员可以直接被类名调用，因此静态成员变量又称为类变量。而非静态成员变量又被称为实例变量。

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

1）存放位置
类变量随着类的加载而存在于方法区中。实例变量随着对象的创建而存在堆内存中。
2） 生命周期

类变量最长，随着类的消失而消失。而实例变量生命周期随着对象消失而消失。

2、静态使用注意事项
1 静态方法只能访问静态成员变量和方法。
非静态方法既可以访问静态成员变量和方法，也可以访问非静态
2 静态方法中不可以定义this、 super关键字，因为静态优先于对象存在
3、静态的优缺点：
优点是节约内存，对共享数据，单独存储，节省了堆内存的空间。
缺点：
a.生命周期过长
b.访问出现局限性 只能访问静态成员。
4、什么时候使用静态？
从两方面下手： 因为静态修饰的内容有成员变量和函数。
1） 什么时候定义静态变量（类变量）呢？

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

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

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

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

5、静态代码块

格式：

static
{
静态代码块中的执行语句；
}
静态代码块的特点：

1）随着类的加载而执行，只执行一次，并且优先于主函数执行。

2）用于给类进行初始化。
对象在内存中的初始化过程
也就是new操作符在内存中所做的操作。



1）把类名.class文件加载到内存中。
2）执行该类中的static代码块，如果有得话，给该类进行初始化。

3）在堆内存中开辟空间，分配内存地址。给对象

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

5）对属性进行显示初始化。

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

7）对对象进行对应构造函数初始化。

8）将内存地址赋值给栈内存中的对象名变量。

6、静态的应用——制作工具类文档说明书
每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装，以便复用。
比如
定义个工具类









在dos命令行中输入命令：javadoc -d e:\myclasstool -author-version ArrayTool.java

Java中的javadoc工具就会帮我们完成说明文档也称API的制作。



到e：\myclasstool\下找到index.html文件打开



7、静态的使用——主函数

主函数是一个特殊的函数，作为程序的入口，可以被jvm调用。
主函数的定义
public 代表着该函数的访问权限是最大的，是被虚拟机访问的
static 代表着主函数随着类的加载就已经存在了
把类名告诉虚拟机，虚拟机就已经以 类名.main 来访问主函数了
void 主函数没有具体的返回值。

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

主函数的使用：
class MainDemo
{
public static void main(String []args)
{

String [] arr={“haha”,“heihei”,“hehe”,“xixi”};

MainTest.main(arr);
}
}
class MainTest
{
public static void main(string[]args)
{

for(int i=0;i<args.length;i++)
{
System.out.println(args[i]);

}

}
}

七、单例设计模式

设计模式就是解决某一类问题行之有效的方法，集合成模式，帮助开发。
几个模式综合运用，就形成复杂的框架。java共有23中通用模式。
其中有一种叫做单例设计模式：用于解决一个类在内存中只有一个对象，确保对象唯一。

思想：
1）为了避免其他程序的过多建立该类对象，先禁止其他程序建立该类对象
2）还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象。
3）为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
需要三步：
1）将构造函数私有化
2）在类中创建本类对象
3）提供一个方法可以获取到本类对象
举例
class Single
{
private single(){}
private static Single s=new Single(); //成员变量为类对象。
public static single getInstance()
{
return s;
}
}
单例设计模式的两种方法：
方法一：饿汉式。
特点是先初始化对象。是比较安全的方式。



方法二、懒汉式。
特点是当调用创建实例方法时，才初始化对象，这称之为延时加载。当在多线程中，容易出现并发问题。



当在多线程的系统中，两个线程访问该类，并在方法中被冻结了，就容易发生问题，因此，采用锁机制来解决这个问题
因此，最终的懒汉式代码为：





------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------