类与对象

一、面向对象简介

面向对象是最早是在七十年代的时候由IBM的Smalltalk语言最先推广的，后来C语言经过面向对象设计的修改形成了C++，后来又由C++产生了今天的Java。

面向对象是一种技术的开发模式，但是最早的时候所使用的模式是面向过程。

•  面向过程：指的是针对于某一个问题单独提出解决方案以及代码开发。
• 面向对象：以一种组件化的形式进行代码的设计。这样开发出来的代码有一个最大的好处就是可以重用。

在我们面向对象的程序里面包含有如下几个特征：

· 封装性：保护内部的定义结构的安全性；

· 继承性：在已有的程序结构上继续扩充新的功能；

· 多态性：指的是在某一个概念范围内的满足。

而对于面向对象的开发几个步骤：

OOA（面向对象分析）、OOD（面向对象设计）、OOP（面向对象编程）。

---

二、认识类与对象

类与对象是整个面向对象过程中最为基础的组成单元，如果需要给出划分定义的话，类是共性的集合，对象是某一个性的产物。

所有的类实际上都是用来描述出对象的结构，例如：每一个人姓名、年龄、身高、长相、等一系列因素。某一类的共性的集合对象，除了具备以上特征（属性）之外，实际上还包括许多的行为（功能）。所有根据此类产生出的对象都具备相同的行为，对象所能够操作的行为都是由类来决定的，超过类定义范畴的操作是不能够使用的。

类实际上是对象操作的模板，但是类不能够直接使用，必须通过实例对象来使用。

类是不能够直接使用的，对象是可以直接使用的，对象是通过类产生的。

---

三、类与对象的定义及使用

如果要在程序之中定义类可以使用“class 类名称 {}”的语法结构来完成，而类之中的组成主要有两点：

• Field（属性、成员、变量），就是一堆变量的集合；
• Method（方法、行为），之前见到的方法，但是此时的方法是由对象调用的。

范例：定义类

class Book {// 定义一个新的类
	String title;// 书的名字
	double price;// 书的价格

	public void getInfo() {// 此方法将由对象调用
		System.out.println("图书名称:" + title + "价格：" + price);
	}
}

在这个类里面定义了两个属性和一个方法，如果有需要可以定义更多的属性和方法。

类现在虽然已经产生了，但是如果想要使用类，必须要有对象，那么对象的定义格式有如下两种方式：

·声明并实例化对象：类名称 对象名称 =new 类名称（）；

·分步完成：

            |-声明对象：类名称 对象名称 = null；

            |-实例化对象：对象名称 = new 类名称。

引用数据类型与基本数据类型最大的不同在于需要内存的开辟及使用，所以关键字new的主要功能就是开辟内存空间，即：只要是引用数据类型想使用，那么就必须使用关键字new来开辟空间。

当一个对象实例化之后那么就可以按照如下的方式利用对象来操作类的结构：

· 对象.属性：表示要操作类中的属性内容；

· 对象.方法( )：表示要调用类中的方法。

范例：使用类——在主类中使用Book类

class Book {// 定义一个新的类
	String title;// 书的名字
	double price;// 书的价格

	public void getInfo() {// 此方法将由对象调用
		System.out.println("图书名称:" + title + "价格：" + price);
	}
}

public class TestDemo {
	public static void main(String args[]) {
		Book bk = new Book();// 声明并实例化对象
		bk.title = "Java开发";// 操作属性内容
		bk.price = 89.9;// 操作属性内容
		bk.getInfo();// 调用类中的getInfo()方法
	}
}

如果想要对以上程序进行内存分析，可以首先给出两块内存空间的概念：

· 堆内存：保存每一个对象的属性内容，堆内存需要使用关键字new才可以进行开辟；

· 栈内存：保存的是一块堆内存的地址，但是为了分析方便，可以简单的理解栈内存保存的是对象名字。

对象除了可以利用一行语句定义之外，也可以分步完成。

范例：分步的方式实例化对象

class Book {// 定义一个新的类
	String title;// 书的名字
	double price;// 书的价格

	public void getInfo() {// 此方法将由对象调用
		System.out.println("图书名称:" + title + "价格：" + price);
	}
}

public class TestDemo {
	public static void main(String args[]) {
		Book bk = null;// 声明对象
		bk = new Book();// 实例化对象
		bk.title = "Java开发";// 操作属性内容
		bk.price = 89.9;// 操作属性内容
		bk.getInfo();// 调用类中的getInfo()方法
	}
}

结果没有区别，通过内存图来分析：

任何情况下只要看见了关键字new，都表示要开辟新的堆内存空间，一旦堆内存空间开辟了，里面就一定会有所有类中定义的属性，当然所有的属性内容都是其对应数据类型的默认值。

以上代码是分为两步的方式实现了对象的实例化（开辟了堆内存的对象称为实例化对象），那么如果说现在使用了没有实例化的对象。

public class TestDemo {
	public static void main(String args[]) {
		Book bk = null;// 声明对象
		//bk = new Book();// 实例化对象
		bk.title = "Java开发";// 操作属性内容
		bk.price = 89.9;// 操作属性内容
		bk.getInfo();// 调用类中的getInfo()方法
	}
}

此时由于使用了没有实例化的Book对象，所以程序在运行的时候出现了“NullPointException（空指向异常）”，此类异常只要是引用数据类型都有可能出现。

---

四、对象引用分析

引用是整个Java开发之中的核心精髓所在。引用类似于c++之中的指针概念，但是要比指针的概念更加的简单。

在所有的引用分析里面，最关键的还是在关键字“new”上，一定要注意，每一次使用关键字“new”都一定会开辟新的堆内存空间，所以如果你的代码里面声明了两个对象，并且使用了关键字new为两个对象分别进行对象的实例化操作，那么一定是各自占有各自的堆内存空间，并且不会互相影响。

范例：声明两个对象

class Book {// 定义一个新的类
	String title;// 书的名字
	double price;// 书的价格

	public void getInfo() {// 此方法将由对象调用
		System.out.println("图书名称:" + title + "价格：" + price);
	}
}

public class TestDemo {
	public static void main(String args[]) {
		Book bookA = new Book();
		Book bookB = new Book();
		bookA.title = "Java开发";
		bookA.price = 89.8;
		bookB.title = "JSP开发";
		bookB.price = 69.8;
		bookA.getInfo();
		bookB.getInfo();

	}
}

这个时候的代码是声明并实例化对象，用一行语句完成，那么接下来观察引用类型的使用。

范例：对象引用传递

class Book {// 定义一个新的类
	String title;// 书的名字
	double price;// 书的价格

	public void getInfo() {// 此方法将由对象调用
		System.out.println("图书名称:" + title + "价格：" + price);
	}
}

public class TestDemo {
	public static void main(String args[]) {
		Book bookA = new Book();// 声明并实例化对象
		Book bookB = null;// 声明对象
		bookA.title = "Java开发";
		bookA.price = 89.8;
		bookB = bookA;// 引用传递
		bookB.price = 69.8;
		bookA.getInfo();

	}
}

严格来讲bookA和bookB里面保存的是对象的地址信息，所以以上的引用过程就属于将bookA的地址赋给了bookB。

由于此时两个对象指向的是同一块堆内存空间，所以任何一个对象修改了堆内存中的数据后，那么都会影响其他对象。在引用的操作过程之中，一块堆内存可以被多个栈内存所指向，但是反过来，一块栈内存只能够保存一块堆内存空间的地址。

范例：继续观察引用传递

class Book {// 定义一个新的类
	String title;// 书的名字
	double price;// 书的价格

	public void getInfo() {// 此方法将由对象调用
		System.out.println("图书名称:" + title + "价格：" + price);
	}
}

public class TestDemo {
	public static void main(String args[]) {
		Book bookA = new Book();
		Book bookB = new Book();
		bookA.title = "Java开发";
		bookA.price = 89.8;
		bookB.title = "JSP开发";
		bookB.price = 69.8;
		bookB = bookA;
		bookB.price = 100.1;
		bookA.getInfo();

	}
}

通过内存的分析可以发现，在引用数据类型关系里面，一块没有栈内存指向的堆内存空间就将成为垃圾，所有的垃圾会不定期的被垃圾收集器（GC）进行回收，回收之后会释放掉其所占用的空间。

虽然在Java里面支持了自动的垃圾收集处理，但是在代码的开放过程中应该尽量减少垃圾空间的产生。