黑马程序员——Java面向对象部分（面向对象概述）

面向对象

面向对象是相对面向过程而言的。面向对象和面向过程都是一种思想。面向过程：强调的是功能行为。面向对象：将功能封装进对象，强调具备了功能的对象。面向对象是基于面向过程衍变而来的。

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

在开发中其实就是寻找对象使用，没有对象就创建一个对象。（找对象，建对象，用对象，并维护对象之间的关系）

类和对象的关系：类就是对现实生活中事物的描述。对象就是这类事物实实在在存在的个体。类与对象的关系可以理解为图纸与汽车的关系。类就是图纸，汽车就是堆内存中的对象。

想要描述现实生活中的对象就是提取对象中的共性内容，对具体的抽象描述。描述在java当中是用类的形式体现的。

而对象在java当中是通过new操作符而产生的一个实体，该实体在堆内存中。

映射到java中：描述就是class定义的类。 具体的对象就是所对应java在堆内存中用new建立的实体。

描述事物就是描述它的属性和行为。属性对应的是类中的变量，行为对应的是类中的函数。定义类就是在描述事物，就是在定义属性和行为，属性和行为统称为类中的成员（成员变量和成员函数）。

需求：定义一个Car类描述汽车的颜色为red，轮胎数为4个，具备run的行为。代码演示：

class Car  
{
	String color = "红色";  //描述颜色

	int num = 4;  //描述轮胎数

	void run()  //运行行为
	{
		System.out.println(color+".."+num);
	}
}

在java中通过new操作符在堆内存中产生对象。  类类型变量指向该类所产生的对象。

在java中指挥对象做事情的方式是： 对象.对象成员 。例如改变c车的颜色即 c.color = "blue"

请看如下代码示例：

class Car  
{
	String color = "红色";  //描述颜色

	int num = 4;  //描述轮胎数

	void run()  //运行行为
	{
		System.out.println(color+".."+num);
	}
}
class  CarDemo
{
	public static void main(String[] args) 
	{
		//生产汽车，在java中通过new操作符来完成，就是在堆内存中产生一个实体。
		Car c = new Car(); //c 就是一个类类型变量。类类型变量指向对象。

		//需求：将已有车的颜色改成蓝色。指挥该对象做事情在java中的方式是：对象.对象成员
		c.color = "blue";
		c.num = 6;
		c.run();
	}
}

在一个类中写主函数的目的是为了让该类能有正常独立的运行。当定义一个类只为了让它描述事物而不打算让它独立运行的时候，可以不写主函数。

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

1.作用范围不同：成员变量作用于整个类中，而局部变量作用于函数中或者语句中。

在内存中的位置不同：成员变量在堆内存中，因为对象的存在才在内存中存在。而局部变量在栈内存中。

匿名对象：

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

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

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。好处：将变化隔离。便于使用。提高重用性。提高安全性。封装原则：将不需要对外提供的内容都隐藏起来。把属性都隐藏，提供公共方法对其访问。

private 是修饰符，私有的意思；用于修饰类中的成员（成员变量和成员函数），私有仅仅是封装的一种表现形式。私有只在本类中有效。将age私有化以后，类以外即使建立了对象也不能直接访问，需要在用于描述的类中提供对应访问age的方式。一个成员变量通常会对应两个访问方式，一个是设置（set），一个是获取（get）。之所以对外提供访问方式是因为可以在访问方式中加入逻辑判断等语句。对访问的数据进行操作，提高代码的健壮性。

请看如下代码演示：

class Person
{
	private int age; //将成员变量私有化，类以外即使建立了对象也不能直接访问

	public void setAge(int a) //对外提供设置年龄的方式。
	{
		if(a>0 && a<130)
		{
			age = a;
			speak();
		}
		else
			System.out.println("非法年龄");
		
	}
	public int getAge() //对外提供获取该属性的方式。
	{
		return age;
	}
	void speak()
	{
		System.out.println("age="+age);
	}
}
class PersonDemo 
{
	public static void main(String[] args) 
	{
		Person p = new Person();

		p.setAge (25);
		p.getAge();
		//p.speak();
	}
}

构造函数：

特点：1.函数名与类名相同。2.不用定义返回值类型。3.不可以写return语句。  作用：给对象进行初始化。

对象一建立就会调用与之对应的构造函数。

注意：1.默认构造函数的特点。2.多个构造函数是以重载的形式存在的。

构造函数代码示例：

class Person 
{
	private String name;
	private int age;

	Person() //空参数的构造函数。
	{
		System.out.println("A:name="+name+",age="+age);
		//cry();
	}
	Person(String n) //有一个参数的构造函数。
	{
		name = n;
		System.out.println("B:name="+name+",age="+age);
	}
	Person(String n, int a) //够两个参数的构造函数。
	{
		name = n;
		age = a;
		System.out.println("C:name="+name+",age="+age);
	}
	public void cry()
	{
		System.out.println("cry...cry....");
	}

	public void setName(String x)
	{
		name = x;
	}
	public String getName()
	{
		return name;
	}
}
class PersonDemo1
{
	public static void main(String[] args)
	{
		//Person p1 = new Person();
		Person p2 = new Person("lisi");
		Person p3 = new Person("wangwu",10);
		p2.setName("liwu");
		p2.setName("liqi");
		System.out.println(p2.getName());
	}
}

当一个类中没有定义构造函数时，系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后默认的构造函数就没有了。
构造函数和一般函数在写法上有不同。在运行上也有不同，构造函数是在对象一建立就运行，给对象初始化。而一般函数是对象调用才运行，给对象添加对象具备的功能。一个对象建立构造函数只运行一次，而一般函数可以被该对象调用多次。
什么时候定义构造函数呢？当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。定义构造函数的时候要分析是否有未知内容参与运算，如果有就需要定义参数列表。 

构造代码块：

就是在单独的大括号区间里面有一些代码；{System.out.println(...);或者调用函数等等 cry();} 在开发中不多见，但在面试题中容易见到。很多面试题问这个程序的执行顺序、打印结果等等。

构造代码块示例：

class Person 
{
	private String name;
	private int age;

	{			//构造代码块：就是在单独的大括号区间里面有一些代码，开发中不多见。
		cry();		//作用：给对象进行初始化。 对象一建立就运行，而且优先于构造函数执行。
	}			//构造代码块中定义的是不同对象共性的初始化内容。

	Person()
	{
		System.out.println("A:name="+name+",age="+age);
		//cry();
	}
	public void cry()
	{
		System.out.println("cry...cry....");
	}
}

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

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

构造代码块中定义的是不同对象共性的初始化内容。