黑马程序员_Java基础Day05_面向对象之封装(Done)

本文链接：https://blog.csdn.net/gkgosh/article/details/8968047

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

Day05开始接触到了Java核心部分——“面向对象”。

面向对象是一种思考思想，是相对于早期的“面向过程”而言的。

比如：把大象放进冰箱需要哪些步骤？

①打开冰箱；②把大象放进去；③关闭冰箱。

在这个描述中，我们强调的是“过程”，注重的是过程中所涉及到的行为、功能(打开==>存储==>关闭)。所以这是一个面向过程的方法。

但是，我们发现，无论是“打开”、“存储”、“关闭”，我们操作的都是“冰箱”，这些都是“冰箱”这类事物所具备的行为。换句话说，有了冰箱，就有了这一系列的功能。即这些功能被封装在了冰箱这个事物当中。因此，我们只要得到了冰箱这类事物，就自然能够得到“打开”、“存储”、“关闭”这些功能。这样就是面向对象的思想。

由此可见面向过程强调的是功能，而面向对象强调的具有(封装了)一系列功能的一类事物。

面向对象思想是符合人们思考习惯的一种思想，它将复杂的问题简单化，将程序员从执行者变为指挥者。

开发的过程就是找对象、创建对象、适用对象，并维护对象之间的关系。如果没有对象，那么就自己创造一个对象来使用。

类与对象的关系：类是对现实生活中事物的描述，而对象就是这类事物实实在在存在的个体。

描述对象就是提取对象中共性内容的过程，在Java中是以“类”的形式体现的；对象是通过new操作符产生的一个实体，这个实体在堆内存中。

以通过图纸生产汽车为例，理解类与对象的关系，如下图：

这里图纸就相当于Java中的类，通过图纸生产出来的汽车，就是Java中的对象。

描述事物的过程能够就是定义类的过程。而描述事物就是在描述事物的属性和行为。属性对应的是类中的变量；行为对应的是类中的方法(函数)。属性和行为又共同称为类中的成员，即：成员变量和成员方法(函数)。

class Car//定义一个Car类(描述汽车)，相当于图纸
{
	String color = "red";//定义汽车颜色并初始化
	int num = 4;//定义汽车轮胎数并初始化
	void run()//定义汽车功能，展示颜色和轮胎数
	{
		System.out.println("color="+color+"...num="+num);
	}
}
class  CarDemo
{
	public static void main(String[] args) 
	{
		Car c = new Car();//生产汽车。使用new操作符，将汽车从抽象的图纸(类)变为具体的实体(对象)
		c.color = "green";//更改汽车颜色。更改的是实物(对象)而不是图纸(类)
		c.run();//调用run();方法
	}
}

成员变量与局部变量的区别：

①作用范围：

成员变量===>整个类中有效；

局部变量===>函数中或者语句中；

②内存中存储位置：

成员变量===>堆内存中，随着对象的建立而存在，随着对象的消失而消失；

局部变量===>栈内存中，方法被调用或语句执行用时存在，当方法调用完，或语句执行结束后，自动释放；

③初始化值：

成员变量有默认初始值；

局部变量没有默认初始值，使用前必须赋值；

匿名对象就是“没有名字的对象”，是对象的一种简写形式。

匿名对象使用方式：

①当匿名对象的方法仅调用一次时，可使用匿名对象来完成，这样写比较简化。但是，当需要对对象进行多次/多个成员调用时，必须使用new操作符创建对象后使用；

②匿名对象可以调用属性，但是这样毫无意义；

③可以将匿名对象作为实际参数进行传递。

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

封装(Encapsulation)

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

封装带来的好处：将变化隔离，方便使用，提高重用性，提高安全性。

举个生活中的例子：

我们去汽车修理厂修汽车，我们需要做的仅仅是把汽车交给修理人员；过几天后过去取回修理好的汽车并付钱即可。而具体汽车如何修理的，整个修理的过程是什么样子，修理用到了什么材料、什么零件...这些我们都没有必要知道。

这就是汽车修理厂把修理汽车的过程给封装隐藏了起来，仅仅提供了一个收费口，人们把车开来付钱即可。

封装原则：

①把不需要对外提供的部分隐藏起来；

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

(函数就是Java中最小的封装体)

private关键字

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

私有仅在本类中有效；将类中的成员私有后，类以外即便建立了对象，也不能直接访问。

私有仅仅是封装的一种表现形式，封装！=私有。

private修饰成员变量，将其私有化，对外提供set*** 和 get*** 方法对其访问。

并且，通过使用语句，可以限制set***的条件，从而实现对访问的数据进行控制(使其符合实际情况)提高代码的安全性、健壮性。

class Person//定义Person类
{
	private int age;//定义int型成员变量age，并将其封装在类中，让外界不能直接访问。
	public void setAge(int age)//对外提供访问方法，并根据实际情况对age的取值进行限制
	{
		if (age>=0 && age<=130)
		{
			this.age = age;
			show();
		}
		else
			System.out.println("输入了非法age");
	}
	public int getAge()//对外提供访问方法
	{
		return this.age;
	}
	void show()
	{
		System.out.println("age="+age);
	}
}

class PersonDemo
{
	public static void main(String[] args) 
	{
		Person p = new Person();//创建Person对象
		p.setAge(200);//使用Person类提供的方法，对age进行操作
	}
}

运行结果：

构造函数

构造函数也是函数，是有特殊功能的函数。所以，具备函数的一般性质。

构造函数特点：

1.函数名与所在类类名一致；

2.没有返回值类型；（是没有，并不是返回值为void）

3.由于第2点的存在，所以也不可以写return语句。

构造函数的作用：

给对象进行初始化。对象一建立，就会调用与之对应的构造函数。当一个类中没有定义构造函数时，系统会默认给该类加入一个空参数的构造函数。

类名(){}

当函数中自定义了构造函数后，默认的构造函数就没有了。

构造函数具备重载的特性，方便给不同的对象进行初始化。

在运行方面，构造函数与一般函数不同：

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

对象一建立，构造函数只运行一次；一般方法(函数)可被对象多次调用。

根据构造函数的作用，可知，一般将事物的特有属性，特有行为定义在构造函数中。

构造代码块

作用：给对象进行初始化。对象一建立就运行，并且，优先于构造函数执行。构造代码块中定义的是不同对象共性的初始化内容。

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

构造代码块是给所有对象统一初始化；而构造函数是给对应的对象初始化。

如下面代码，定义游戏角色，角色具备初始等级(lv)和初始装备(equip)，并且每个角色生成时，都会说同样的话。

class Player
{
	private String equip;
	private int lv;
	{
		System.out.println("银鳞胸甲5G一件。");//角色共性初始化内容，定义在构造代码块中。
	}
	Player()//①
	{
		System.out.println("equip="+equip+"---lv="+lv);
	}
	Player(String e)//②
	{
		equip = e;
		System.out.println("equip="+equip+"---lv="+lv);
	}
	Player(int l)//③
	{
		lv = l;
		System.out.println("equip="+equip+"---lv="+lv);
	}
	Player(String e,int l)//④
	{
		equip = e;
		lv = l;
		System.out.println("equip="+equip+"---lv="+lv);
	}
	//①至④定义了具备不同初始化内容的四种Player。
}
class PlayerDemo 
{
	public static void main(String[] args) 
	{
		Player p1 = new Player();
		Player p2 = new Player("霜之哀伤");
		Player p3 = new Player(70);
		Player p4 = new Player("银鳞胸甲",80);
	}
}

代码运行结果：