接下来的博客，我将着重说下面向对象的编程思想，这个是Java编程开发的重点内容，对以后的开发有着深远的影响，必须重视起来。在使用Java语言开发时，时刻要以面向对象的思想考虑问题，面向对象的基础就是类。

    首先，说下类的定义，下面是类的一般定义模式：

    （1）任务：定义类

    （2）准备工作：类中存在的元素有成员变量和方法

    （3）编程：

    定义类，提供成员变量和方法：

public class Book {	private String bookName;//定义书名	private String author;//定义作者	private double price;//定义价格	//构造方法初始化	public Book(String bookName,String author,double price){		this.bookName = bookName;		this.author = author;		this.price = price;	}	public String getBookName(){		return bookName;	}	public String getAuthor(){		return author;	}	public double getPrice(){		return price;	}}

    测试类，创建对象：

public class TestBook {	public static void main(String[] args) {		// TODO Auto-generated method stub		//创建对象		Book book = new Book("Java语言学习","Yoki",66.66);		//通过对象调用类的方法		System.out.println("书名："+book.getBookName());		System.out.println("作者："+book.getAuthor());		System.out.println("价格："+book.getPrice());	}}

    （4）运行：输出实例化类对象的信息

    注意：在Java中，使用class关键字来定义类。一个类通常包括域和方法两部分，域表示对象的状态，方法表示对象的行为。使用new关键字创建类的对象。一般来说，变量在使用前需要对其进行初始化，Java中虚拟机会自动为其初始化，像基本数据类型，比如 byte、int、long、float、char等，而像引用类型的变量，如String类型，在使用前需要进行初始化，否则会抛出null异常。除了成员变量，还有局部变量，使用前也需初始化。

    上面是一般的类的定义，还有种方式：单例模式

    （1）任务：单例模式

    （2）准备工作：单例模式的特点在于仅能获得一个对象，需将构造方法私有化，并提供一个静态方法返回类的对象

    （3）编程：

/* * 单例模式 */public class Emperor {	//声明一个类的引用	private static Emperor emperor = null;	//将构造方法私有	private Emperor(){}	//实例化引用	public static Emperor getInstance(){		if(emperor == null)			emperor = new Emperor();		return emperor;	}	public void getName(){		System.out.println("单例模式！！！");	}}

    测试类：

public class TestEmperor {	public static void main(String[] args){		Emperor e1 = Emperor.getInstance();		e1.getName();		Emperor e2 = Emperor.getInstance();		e2.getName();	}	}

    （4）运行：输出信息

    接着，我们再通过汉诺塔的案例来进一步熟悉下：

    （1）任务：汉诺塔

    （2）准备工作：汉诺塔的思想：将N个盘子从A移到C，需要先将第N个盘子上面的N-1个盘子移到B上，这样才能将第N个盘子移到C上，同理，为了将第N-1个盘子从B移到C上，需要将N-2个盘子移到A上，这样才能将第N-1个盘子移到C上。通过递归实现汉诺塔的求解。

    （3）编程：

import java.util.Scanner;public class HanoiTower {	public static void moveDish(int level,char from,char inter,char to){		if(level == 1)			System.out.println("从"+from+"移动盘子1到"+to);		else{			moveDish(level-1,from,to,inter);			System.out.println("从"+from+"移动盘子"+level+"到"+to);			moveDish(level-1,inter,from,to);		}	}	public static void main(String[] args){		System.out.println("请输入汉诺塔的阶数：");		Scanner scan = new Scanner(System.in);		try{			int nDisks = scan.nextInt();					moveDish(nDisks,'A','B','C');		}catch(Exception e){			System.out.println("输入不合法！");		}	}}

    （4）运行：在控制台输入阶数，输出移动的操作步骤

    在方法的构造中，重载是对方法名过多的一种处理，当对象在调用方法时，可以根据方法参数的不同确定执行那个方法。方法参数的不同包括参数类型不同、参数个数不同、参数顺序不同，即这些不同能构造出相同名称的方法。构造方法是一种特殊类型的方法，声明时，遵守一些规定：

    构造方法的名称与类名相同；

    构造方法无返回值；

    构造方法总是与new操作符一起使用；

    此外，在构造方法中，可使用this来调用其他构造方法，使用super调用超类构造方法。

    对于类中的成员变量，大多通过公有public或者私有private的方式修饰。加入static修饰成员变量，则该变量时所用对象共享的，任何一个对象的修改会影响其他对象。如下

public class Book{    //定义一个计数器    private static int counter = 0;    public Book(String bookName){        System.out.println("书名："+bookName);        counter++;    }    public static int getCounter(){        return counter;    }}

    在测试类中，利用书名数组创建对象：

public static void main(String[] args){    String[] bookNames = {"Java语言学习","PHP语言学习","C语言学习"};    for(int i=0;i

    运行程序打印出计数器为3，说明创建3次对象，计数器变量共享，才能叠加而不是重新从初始值0开始。

    Java中的类都是Object类的直接或间接子类。如在Object类中定义了equals()方法，toString()方法等，我们也可以重写（加上@Override注解）该方法，使其符合我们的使用要求，如下：

public class Book{    private String bookName;    private String author;       @Override    public String toString(){        return "书名："+bookName+",作者："+author;   }}

    Java将内存空间分为两块，即堆和栈，在栈中保存基本类型和引用变量，在堆中保存对象。对于基本类型可以使用 “=” 来进行克隆，此时两个变量没有关联关系；对于引用变量使用 “=” 进行克隆，将修改引用，此时两个引用变量将指向同一个对象，则一个变量对其进行修改会改变另一个变量。克隆又分为浅克隆和深克隆，这里不做介绍了。

    最后还有个序列化的问题，进行序列化的类需要实现Serializable接口，该接口无任何方法，仅是个标识接口。具体的使用有机会再说了。