JAVA学习第六课（面向对象）

面向对象首先要先了解什么是面向对象？

面向对象：就是不断的和对象打交道。

早期解决问题，都是面向过程（简单来说就是一步一步怎么做，面对的是过程，即强调动作），如C语言，利用函数，进行函数的调用。

思想：

面向对象：强调的是对象，对象即指实体。c++，java，c#

例子：把大象装进冰箱

面向过程实现：1.打开冰箱  2.存储大象  3.关上冰箱

面向对象实现：（找到实体，实体封装着这些功能，也就是找到冰箱，冰箱具备打开、存储、关闭功能）
1.冰箱打开  2.冰箱存储   3.冰箱关闭

面向对象的特点：

1.符合人们的思考习惯。  2.将复杂的问题简单化

3.角色转变，针对的是对象，即面向过程中的执行者，变为面向对象的指挥者。

（土一点的说，就是对象有你需求的功能，具体它怎么做，不关我们的事）

所以解决一个问题，先找有没有解决这个问题对象，如果没有，自己编写一个对象。

面向对象思考问题举例：

   面试官招聘人员，就是面向对象的很好例子，企业接受一个项目，设计、编写、测试，面试官一个人可以完成，但是浪费大量的时间和精力，
所以他就需要招聘一些人员来帮助完成，而对象就指的是被招聘的人员，他们具备了设计、编写、测试等功能，但具体怎么实现的，面试官不
需要知道。面试官要做的，只需要找到这个对象，并指挥他来解决这个问题即可。

JAVA里面，什么都可以成为对象。
有对象找对象用对象，没对象造对象用对象，并不断的维护对象之间的关系。

面向对象的特征：

1.封装  2.继承  3.多态

规则：哪个对象，对某一动作最清楚，就把动作定义在该对象中。搬家公司搬东西，他们只需要告诉，搬运工人搬到哪即可，至于怎么搬，搬运工人最清楚，自然把搬运这个动作定义在搬运工人这个对象中。

（指挥对象做事情）

代码理解：

/*定义类就是在定义类中的成员，即组成部分
 * 成员函数：对应的就是事物功能
 * 成员变量：对应的就是属性
 * 
 */

//具体体现

/*描述搬运过程
 * 搬运工人 这一名次由属性和功能组成
 * 属性：1.人数 2.性别
 * 功能：搬运
 */
class Man
{
	int num ; //成员
	String sex;//成员
	void function()//成员
	{
		System.out.println(num+" .... "+sex);
	}
	/*public static void main(String[] args)
	{
		//Man这个类只是描述某一事物，当要用到它时，才运行，并不需要其独立运行，当然也可以
		//所以，要用到这个事物时，只需要在一个类中，进行其对象的创建并调用即可
	}*/
}
/*描述汽车
 * 属性：数量、颜色
 * 功能，启动
 */
class Car
{
	int num = 3;
	String color = "blue";
	void run()
	{
		System.out.println(num+" ... "+color);
	}
	
}
public class Main 
{
	public static void main(String[] args)
	{
		/*完成对象的创建，并定义该对象的名称*/
		//创建一个Man的实体，通过new关键字实现
		Man BLF1 = new Man();//定义一个Man类型的变量BLF2，Man是类，BLF2是变量名
		//用类来定义的变量，就是一个 类 类型的变量，指向了该类的对象
		
		BLF1.function();//使用对象中的内容，形式：对象.成员，来完成调用	
		
		Car BLF2 = new Car();
		BLF2.run();//对象.组成部分
	}
}

趁热打铁：

class Man
{
	int num ; //成员
	String sex;//成员
	void function()//成员
	{
		System.out.println(num+" .... "+sex);
	}

}

//堆中储存的是对象
public class Main 
{
	public static void main(String[] args)
	{
		Man BLF = new Man();
		Man BLF2 = BLF;
		//Man BLF2 = new Man();
		// BLF2 = BLF;
		BLF.num = 4;
		BLF2.sex = "man";
		System.out.println(Integer.toBinaryString(BLF.num));
		BLF.function();
		/*
		 * 100
		 *	4 .... man
		 */
		//PS:一旦产生对象，那么这个对象一定具备着这个类中所描述的内容
	}
	
}

/**
 * 成员变量和局部变量的区别
 *1. 局部变量定义在函数、语句、代码块中，并且只在所属区域中有效
 * 成员变量定义在类中，且整个类中都可以访问
 * 2.成员变量存在于堆内存的对象中
 * 局部变量存在栈内存的方法中
 * 3.成员变量随着对象的创建而存在，随着对象的消失而消失
 * 局部变量随着所属区域的执行而存在，随着所属区域的结束而释放
 * 4.成员变量都有默认初始化值，局部变量没有初始化值
 */

类 类型参数：

class Man
{
	int num = 4; //成员
	String sex;//成员
	void function()//成员
	{
		
		System.out.println(num+" .... "+sex);
	}

}
public class Main 
{
	public static void main(String[] args)
	{
		/*Man a = new Man();
		a.num = 4;
		a.sex = "man";
		Man b = new Man();
		b.num = 4;
		b.sex = "man";*///代码冗杂,进行调用
		Man a = new Man();
		Man b = new Man();
		show(a);
		show(b);
		a.function();
		b.function();
		/*
		 * 4 .... man
		 * 4 .... man
		 */
	}
	public static void show(Man b) //类类型的变量一定指向对象，否则就是null
	{
		b.num = 4;
		b.sex = "man";
	}
	
}

了解：匿名对象


栈内存存储的是局部变量，所以匿名变量储存在堆中

class Car
{
	int num ;//成员
	String color;//成员
	void function()//成员
	{
		
		System.out.println(num+" .... "+color);
	}

}
public class Main 
{
	public static void main(String[] args)
	{
		/*
		 * 匿名对象
		 * new Man();
		 * 也就是定义对象时的简写格式
		 * */
		new Car();
		
		//使用方法一：当对象对方法仅进行一次调用，即可简化为匿名对象
		/*
		 * new Car().num = 4;
		 * new Car().color = "man";
		 * new Car().function;
		 * 打印结果：0....null
		 * 理由如下图：
		 * new Car().num = 4;执行完后，自动变成堆中的垃圾
		 * */
		//使用方法二：匿名对象可以做实际参数进行传递
		show(new Car());
	}
	public static void show(Car a)
	{
		a.num = 4;
		a.color = "MAN";
		a.function();
	}

}

数据类型参数传递问题：

//基本数据类型参数传递
public class Main
{
	public static void main(String[] args)
	{
		int x = 3;
		show(x);
		System.out.println(x);
	}
	public  static void show(int x) 
	{
		x = 9;
		//return ;
	}
}
//打印 3
改变的只是show中x的值，执行完后弹栈，释放，但是本来的x的值并为改变。

/引用数据类型参数传递
public class Main 
{
	int  x = 3;
	public static void main(String[] args)
	{
		Main d = new Main();
		d.x = 9;
		show(d);
		System.out.println(d.x);
	}
	public  static void  show(Main b) 
	{
		b.x = 1;
	}
}
//打印 1 ，栈 和 堆
//执行如图

图示：很清晰，引用数据类型变量，在栈和堆中执行，栈中show也引用了类d的地址，所以可以改变其中x的值