Java语言学习（五）：面向对象入门

    接下来的博客，我将着重说下面向对象的编程思想，这个是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<bookNames.length;i++){
        new Book(bookNames[i]);
    }
    System.out.println("计数器为："+Book.getCounter());
}

    运行程序打印出计数器为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接口，该接口无任何方法，仅是个标识接口。具体的使用有机会再说了。