黑马程序员—面向对象(一)

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

一、面向对象与面向过程

1.面向对象是相对面向过程而言

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

面向过程：

强调的是功能行为

面向对象：

将功能封装进对象，强调具备了功能的对象

3.面向对象是基于面向过程

4.面向对象的三个特征：抽象、继承、封装、多态性。

a.抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不    用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

b.继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新    类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增    加新的方法使之更适合特殊的需要。

c.封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，    这些对象通过一个受保护的接口访问其他对象。

d.多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的      解决了应用程序函数同名问题。

在开发的过程中就是找对象使用，没有对象，就创建对象，找对象，建立对象，使用对象，维护对象的关系。

二、成员变量和局部变量区别

1.作用范围

1. 1. 成员变量作用于整个类中。
   2. 局部变量作用于函数中，或者语句中。

2.在内存中的位置不同

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

局部变量：存在栈内存中。

三、匿名对象的使用

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

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

四、封装（Encapsulation）

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

1.将变化隔离

2.便于使用

3.提高重用性

4.提高安全性

封装原则：

将不需要对外提供的内容都隐藏起来。把属性都隐藏，提供公共方法对其访问。

private：私有，权限修饰符：用于修饰类中的成员（成员变量，成员函数）。私有只在本类中有效。私有仅仅是封装的一种变现形式。

class Person
{
	private int age;
	public void setAge(a)
	{
		if(a <= 0)
		{
			System.out.println("数据错误！");
			return;
		}
		else
		{
			age = a;
			talk();
		}
	}
	public int getAge()
	{
		return age;
	}
	void talk()
	{
		System.out.println("age="+age);
	}
}

class PersonDemo
{
	public static void main(String[] args)
	{
		Person p = new Person();
		p.setAge(20);
	}
}

五、构造函数

特点：

1. 1. 函数名与类名相同
   2. 不用定义返回值类型
   3. 不可以写return语句
   4. 对象一建立就会调用与之对应的构造函数。
   5. 当一个类中没有定义构造函数时，那么系统会自动在类中定义一个与类名相同且参数为空的构造函数。

作用：给对象进行初始化

默认构造函数的特点：

1. 1. 多个构造函数重载的形式存在的。
   2. 构造函数和一般函数写法上有不同。
   3. 在运行上也有不同

a.构造函数是对象一建立就运行，给对象初始化。

b.而一般方法是对象调用时才执行，给对象添加对象具备的功能。

c.一个对象建立，构造函数值运行一次。

d.而一般方法可以被调用多次。

什么时候调用构造函数呢？

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

构造代码块：

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

和构造函数的区别：

构造代码块I是给所有对象进行统一初始化而构造函数是给对应的对象初始化。构造代码块中定义的是不同对象共性的初始化内容。

表现形式：

class Person
{
	private String name;
	private int age;
	//构造代码块
	{
		age = 3;
	}
}

六、this关键字

功能：用于区分局部变量与成员变量重名的情况。
this到底代表的是什么呢？

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

this关键字的特点：

1.this关键字的使用:当定义类中的功能时，该函数内部要用到调用该函数的对象时，使用this调用当前对象。

2.this语句:用于构造函数之间互相调用。

3.this语句只能定义在构造函数的第一行。

代码示例：

class Person
{
	private int age;
	person(int age)
	{
		this.age = age;
	}
}

七、静态（static）

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

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

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

2，优先于对象存在。

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

3，被所有对象所共用

4，可以直接被类名调用

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

1，存放位置

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

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

2，生命周期

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

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

3，主函数是静态的

public static void main(String[] args)
主函数：是一个特殊函数，作为程序的入口，可以被JVM调用。
主函数的定义：

public：代表着该函数访问权限是无限大的。

static：代表主函数随着类的健在就已经存在了。

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

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

(Stringp[] args):函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型数组。

主函数是固定格式的。
JVM在调用主函数时，传入的是new String[0]
静态使用注意事项：

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

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

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

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

静态有利有弊：

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

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

什么时候使用静态

要从两个方面下手：

因为静态修饰的内容有成员变量和函数。

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

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

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

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

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

静态的应用：

/*
将方法都静态后，可以方便调用，但是该类还是可以被其他程序建立对象。
为了更严谨，强制让该类不能建立对象。
可以通过私有化构造函数完成。
*/

/**
这是一个可以对数组进行操作的工具类，该类中提供了获取最大值、最小值、选择排序、冒泡排序功能。
@author DuckOne
@verson V1.1

*/

public class ArrayTool
{
	/**
	空参数构造函数
	*/
	private ArrayTool(){}
	/**
	获取一个整形数组中的最大值
	@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];
	}
	/**
	获取一个整形数组中的最小值
	@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型数组进行选择排序
	*/
	public static void selectSort(int[] arr)
	{
		for(int x = 0; x<arr.length ;x++)
			for(int y = x+1; y<arr.length; y++)
				if(arr[x]>arr[y])
					swap(arr,x,y);
	}
	/**
	给一个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,x,y+1);
	}
	/**
	用于打印数组中的元素。
	*/
	public static void printArray(int[] arr)
	{
		System.out.print("[");
		for(int x = 0; x<arr.length ;x++)
			if(x != arr.length-1)
				System.out.print(arr[x]+",");
			else
				System.out.print(arr[x]+"]");
	}
	/**
	给数组中的元素进行置换
	@param arr 接收一个int类型的数组
	@param a 要置换的位置
	@param b 要置换的位置
	*/
	private static void swap(int[] arr,int a,int b)
	{
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
}

最终用Javadoc文档工具提取说明文档产生如下网页：

内容如下：