黑马程序员-Java基础学习第五天总结

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

3-1 面向对象概括

3-1-1 理解面向对象

面向对象是相对面向过程而言，面向对象和面向过程都是一种思想。

面向过程
强调的是功能行为。
代表语言：C语言。

例子：把大象装进冰箱
1、打开冰箱。
2、存储大象。
3、关上冰箱。
"打开"、"存储"、"关上"都是功能行为，在代码中的直观体现就是函数或者方法，这就是一种面向过程的以功能行为为主体的思想体现。

面向对象
将功能封装进对象，强调具备了功能的对象。
代表语言：Java、C++、C#。

注意：
面向对象是基于面向过程的。

例子：把大象装进冰箱
1、冰箱打开。
2、冰箱存储。
3、冰箱关闭。
可以看到，所有的操作都是以"冰箱"为主体，而不是功能行为。
也就是说冰箱自己已经具备"打开"、"存储"、"关上"的行为功能，我们只需要让冰箱执行它具备的功能就可以了。
这就是一种面向对象的以执行功能的对象为主体的思想体现。

3-1-2 面向对象的特点

是一种符合人们思考习惯的思想，可以将复杂的事情简单化，将程序员从执行者转换成了指挥者。

完成需求时：
1、先要去找具有所需的功能的对象来用。
2、如果该对象不存在，那么创建一个具有所需功能的对象。
这样可以简化开发并提高复用。

3-1-3 面向对象开发，设计，特征
开发的过程：
其实就是不断的创建对象，使用对象，指挥对象做事情。

设计的过程：
其实就是在管理和维护对象之间的关系。

面向对象的特征：
封装(encapsulation)
继承(inheritance)
多态(polymorphism)

3-2 类与对象的关系 
使用计算机语言就是不断地在描述现实生活中的事物。
java中描述事物通过类的形式体现，类是具体事物的抽象，概忥上的定义。
对象即是该类事物实实在在存在的个体。

3.2.1 类与对象(图例)

类与对象的关系如图：



可以理解为：类就是图纸，汽车就是堆内存中的对象。

对于同一类事物可以抽取它们的共性的内容，定义在类中。如：生活中的汽车，每一台车都有轮胎数和颜色。

那么在通过java描述汽车这类事物时，就可以将这两个共性属性作为类中的属性进行定义。

通过该类建立的每一个汽车实体都具有该属性，并可以有对象特有的属性值。

3.2.2 类的定义

生活中描述事物无非就是描述事物的属性和行为。
如：人有身高，体重等属性，有说话，打球等行为。

Java中用类class来描述事物也是如此。
属性：对应类中的成员变量。
行为：对应类中的成员函数。
定义类其实在定义类中的成员(成员变量和成员函数)。

3.2.3 成员变量和局部变量的区别？

成员变量：
①成员变量定义在类中，在整个类中都可以被访问。
②成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。
③成员变量有默认初始化值。

局部变量：
①局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。
②局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。
③局部变量没有默认初始化值。

3.2.4 匿名对象

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

匿名对象两种使用情况：①当对对象方法仅进行一次调用时；②匿名对象可以作为实际参数进行传递。

class Car
{
String color = "red";
int num = 4;

public static void run()
{
System. out.println("function run is running!" );
}
}

class CarDemo{
public static void main(String[] args){
//对对象方法仅进行一次调用时，就可以使用匿名对象
new Car().run();
//匿名对象可以作为实际参数进行传递
show(new Car());
}

public static void show(Car c){
c. num = 3;
c. color = "black" ;
System. out.println("function show is running!" );
System. out.println(c.num + "..." + c. color);
}
}

3-3 封装（Encapsulation）

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

2、好处：

①将变化隔离。

②便于使用。

③提高重用性。

④提高安全性。

3、 原则

a) 将不需要对外提供的内容都隐藏起来。

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

4、 封装的表现形式之一——private（私有）

private关键字：权限修饰符；用于修饰类中的成员（成员变量，成员函数）；私有只在本类中有效。

常用之一：

将成员变量私有化，对外提供对应的set，get方法对其进行访问。提高对数据访问的安全性。

如：我有一个人对象，而年龄这一属性我不想被对象访问，我就可以将其设为private。

注意：

1、私有仅仅是封装的一种体现而已。

2、private关键字：是一个权限修饰符，用于修饰成员(成员变量和成员函数)，被私有化的成员只在本类中有效。

常用场景之一：将成员变量私有化，对外提供对应的set、get方法对其进行访问，提高对数据访问的安全性。

3-4 构造函数

特点：
①函数名与类名相同。
②不用定义返回值类型。
③没有具体的返回值。
附：在构造函数前面加上返回值就只是一般函数了。

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

class Person{
private String name ;
private int age ;

//定义一个Person类的构造函数
//构造函数，而且是空参数的
Person(){
System. out.println("person run" );
}

public void speak(){
System. out.println(name + ":" + age);
}
}

class ConsDemo{
public static void main(String[] args){
//构造函数：构建创造对象时调用的函数
//作用：可以给对象进行初始化
Person p = new Person();
p.speak();
}
}

注意：
1、一般函数和构造函数什么区别呢？
构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
一般函数：对象创建后，需要函数功能时才调用。

构造函数：对象创建时，会调用并且只调用一次。
一般函数：对象创建后，可以被调用多次。

2、创建对象都必须要通过构造函数初始化。
一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。
如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

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

3-5 this关键字

this代表其所在函数所属对象的引用。换言之，this代本类对象的引用。
当成员变量和局部变量重名，可以用关键字this来区分，this就是所在函数所属对象的引用。
简单说，哪个对象调用了this所在的函数，this就代表哪个对象。一般方法调用默认加this。

什么时候使用this关键字呢？
当在函数内需要用到调用该函数的对象时，就用this。

class Person
{
private String name;
private int age;
Person(int age)//局部变量时age，成员变量也是age
{
this.age = age;//this能够很好区分
}
Person(String name)
{
this.name = name;//这里用this表示调用构造方法的对象
}
Person(String name,int age)
{
this.name = name;
this.age = age;
}

public void speak()
{
System.out.println("name="+name+"...age="+age);
show();
}
public void show()
{
System.out.println(this.name);
}
}

以上程序综合了构造函数和this的用法。看上去，是用于区分局部变量与成员变量同名情况。
this代表它所在函数所属对象的引用。
简单说：哪个对象在调用this所在的函数，this就代表哪个对象。

this的应用：

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

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

this语句：

用于构造函数之间进行互相调用。如：this(name);

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

对this的概括总结：

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

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

3-6 static关键字

static关键字：
用于修饰成员（成员变量和成员函数）。

被修饰后的成员具备以下特点：
①随着类的加载而加载。
②优先于对象存在。
③被所有对象所共享。
④可以直接被类名调用。

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

实例变量和类变量的区别：
1、存放位置。

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

实例变量随着对象的建立而存在于堆内存中。
2、生命周期。

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

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

静态有利有弊：

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

弊端：生命周期过长。

访问出现局限性。（静态虽好，只能访问静态）。

静态需要清楚的几个小问题：

什么时候使用静态？

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

静态使用注意事项：

1、静态方法只能访问静态成员。

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

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

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

3、主函数是静态的。

静态代码块：

格式：

static

{

静态代码块中的语句。

}

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

对象的初始化过程：

定义一个新对象都做了哪些事情？

1、把类名.class文件加载到内存中。

2、执行该类中的static代码块，如果有得话，给该类进行初始化。

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

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

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

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

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

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

静态的应用——文档说明书。

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

成员变量和静态变量的区别？

1、两个变量的生命周期不同

成员变量随着对象的创建而存在，随着对象被回收而释放。

静态变量随着类的加载而存在，随着类的消失而消失。

2、调用方式不同

成员变量只能被对象调用。

静态变量可以被对象调用，还可以被类名调用。

3、别名不同

成员变量也称为实例变量。

静态变量也称为类变量。

4、数据存储位置不同

成员变量存储在堆内存的对象中，所以也叫对象的特有数据。

静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

使用注意：

①静态方法只能访问静态成员，如果访问非静态成员，就会报错！

原因：静态方法和变量存在的时候，对象还不存在，非静态变量也不存在，肯定无法访问。

注意：

非静态方法既可以访问静态成员，又可以访问非静态成员。

②静态方法中不可以写this，super关键字。

原因：静态方法存在的时候，对象还不存在，this代表的就是调用方法的那个对象，既然不存在，肯定不可以写在静态方法中。

③主函数是静态的

主函数特殊之处：

1、格式是固定的。

2、被jvm所识别和调用。

主函数各成分解析：

public：权限必须是最大的，被jvm调用。

static：不需要对象调用，直接用主函数所属类名调用即可。 命令行窗口中输入：java StaticDemo，实际上就是在执行StaticDemo.main();。

void：主函数不需要具体的返回值。

main：函数名，不是关键字，只是一个jvm识别的固定的名字。

String[] args：这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。

静态什么时候用？

①静态变量

当分析对象中所具备的成员变量的值都是相同时，这时这个成员就可以被静态修饰。

只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。

如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。


②静态函数

函数是否用静态修饰，就参考一点，就是该函数功能是否需要访问到对象中的特有数据。

简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。

如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，但是非静态需要被对象调用。

如果没有访问特有数据的方法，该对象的创建是没有意义。

下面我们以一个数组工具类为例，作一个文档说明书。

/**
这是一个可以对数组进行相关操作的工具类，该类提供了取数组的最值、排序等功能。
@author Godream
@version V1.0

*/
//类名权限要最大才能创建说明书文档
public class ArrayTool
{
/**
空参数构造函数
*/
private ArrayTool() //私有化构造函数是为了让其不能创建对象。
{

}

/**
这个功能用于得到int类型数组中的最大值
@param arr 接收一个int类型的数组
@return 返回接收的该数组的最大值
*/
public static int getMax(int[] arr)
{
int max=0;
for (int x=1;x<arr.length ;x++ )
{
if(arr[x]>arr[max])
max=x;
}
return arr[max];
}

/**
这个功能用于得到int类型数组中的最小值
@param arr 接收一个int类型的数组
@return 返回该数组的最小值
*/
public static int getMin(int[] arr)
{
int min=0;
for (int x=1;x<arr.length ;x++ )
{
if(arr[x]<arr[min])
min=x;
}
return arr[min];
}

/**
对int类型数组进行选择升序排列
@param arr 接收一个int类型的数组
*/
public static void selectSort(int[] arr)
{
for (int x=0;x<arr.length-1 ; x++)
{
for (int y=x+1; y<arr.length; y++)
{
if(arr[x]>arr[y])
swap(arr,x,y);
}
}
}

/**
对int类型数组进行冒泡升序排列
@param arr 接收一个int 类型数组
*/
public static void bubbleSort(int[] arr)
{
for (int x=0;x<arr.length-1;x++ )
{
for (int y=0;y<arr.length-x-1;y++ )
{
if(arr[y]>arr[y+1])
swap(arr,y,y+1);
}
}
}

/**
对数组中的两个元素进行位置交换
@param arr 接收一个int类型的数组
@param a 要置换的元素角标
@param b 要置换的元素角标
*/
private static void swap(int[] arr,int a,int b)
{
arr[a]=arr+(arr[b]=arr[a])*0;
}

/**
遍历数组：打印数组中所有元素，形式为：[elemet1,elemet2,...]
@param arr 接收一个int类型的数组
*/
public static void printArray(int[] arr)
{
System.out.print("[");
for (int x=0; x<arr.length-1; x++)
{
System.out.print(arr[x]+",");
}
System.out.println(arr[arr.length-1]+"]");
}
}

在dos命令行中输入命令：javadoc -d Myhelp -author-version ArrayTool.java
Java中的javadoc工具就会帮我们完成说明文档也称API的制作。



结果：



[b]注意：

1、如果想把一个类进行文档化，该类必须是public的。

2、私有的方法在文档中不会体现，例如ArrayTool类中的swap方法。

3-7 单例设计模式

设计模式：对问题行之有效的解决方式，其实它是一种思想。

单例设计模式解决的问题：就是可以保证一个类在内存中的对象唯一性。

比如多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。
如何保证对象唯一性呢？
①不允许其他程序用new创建该类对象。
②在该类创建一个本类实例。
③对外提供一个方法让其他程序可以获取该对象。

步骤：
①私有化该类构造函数。
②通过new在本类中创建一个本类对象。
③定义一个公有的方法，将创建的对象返回。

饿汉式：

class Single{
//类已加载，对象就已经存在了
private static Single s = new Single();

private Single(){}

public static Single getInstance(){
return s ;
}
}

class SingleDemo{
public static void main(String[] args){
Single s1 = Single.getInstance();
Single s2 = Single. getInstance();
System. out.println(s1 == s2);
}
}

注意：
之所以不用Single.s;的方式获取Single对象，而采用getInstance获取是因为在getInstance方法中我们可以做一些判断来决定是否返回Single的对象，也就是实现了对单例对象的可控。
所以，给Single的构造方法加上了private限制，禁止使用者直接采用Single.s;的方式获取。

<strong>示例（懒汉式）：</strong>
Single.java
class Single{
//类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象
//延迟加载形式
private static Single s = null;

private Single(){}

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

class SingleDemo{
public static void main(String[] args){
Single s1 = Single. getInstance();
Single s2 = Single. getInstance();
System. out .println(s1 == s2);
}
}