面向对象初步

1. 面向对象概念

早期的计算机编程是基于面向过程的，随着计算机技术的不断提高，计算机被用于解决越来越复杂的问题。面向对象，是将现实世界的事物抽象成对象，将现实世界中的关系抽象成类、继承。Wikipedia是这样定义的：

“Object-oriented programming (OOP) is a programming paradigm based on the concept of “objects”, which are data structures that contain data, in the form of fields, often known as attributes; and code, in the form of procedures, often known as methods. A distinguishing feature of objects is that an object’s procedures can access and often modify the data fields of the object with which they are associated (objects have a notion of “this” or “self”). In OO programming, computer programs are designed by making them out of objects that interact with one another.”

面向过程的编程语言：C
　　面向对象的编程语言：Python, C++, Objective-C, Smalltalk, Delphi, Java, Swift, C#, Perl, Ruby and PHP.
　　面向对象的三大特征：封装(Encapsulation)、继承(Inheritance)、多态。(Polymorphism)。

2. 类与对象的关系

类是一组具有相同特性(属性)与行为(方法)的事物集合。对象是人们要研究的具体事物。“objects are instances of classes”. —— From Wiki
　　
　　成员变量：
　　　　a.定义在类中，在整个类中都可以被访问；
　　　　b.随着对象的建立而建立，随着对象的消失而消失，存在于对象的堆内存中；
　　　　c.有默认初始化值。
　　局部变量：
　　　　a.只定义在局部范围内，如函数内、语句内等；
　　　　b.存在于栈内存中，作用的范围结束，变量空间会自动释放；
　　　　c.没有默认初始化值。
　　匿名对象: 没有被其他对象所引用，使用一次就变成垃圾，被垃圾回收系统回收。可以作为实际参数进行传递。

/*
 描述小汽车。属性： 颜色，轮胎数； 行为：run
 打印结果是： 4
			 black..10
			 black..10
			 6...yellow
 */
//对Car这类食物进行描述
class Car {
	//成员变量
	static String color ="red";
	int num = 4;
	//成员方法
	public static void run()
	{
		//临时变量
		int num = 10;
		//输出临时变量的值
		System.out.println(color+".."+num);
	}
}
class CarDemo
{
	public static void main(String[] args)
	{
		//通过new关键字，建立对象
		//c就是一个类类型的引用变量，指向了该类的对象
		Car c = new Car();
		//对对象的属性进行修改
		c.color = "black";
		//输出成员变量的默认值
		System.out.println(c.num);
		//通过对象.成员的形式来使用对象的功能
		c.run();
		//使用匿名对象
		new Car().run();
		//匿名对象作为实际参数进行传递
		show(new Car());
	}
	private static void show(Car c) {
		c.num = 6;
		c.color = "yellow";
		System.out.println(c.num+"..."+c.color);
	}
}

在Java中，方法参数的传递永远都是传值，而这个值，对于基本数据类型，值就是你赋给变量的那个值。而对于引用数据类型，这个值是对象的引用，而不是这个对象本身。

3. 封装（Encapsulation）

封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式。这样不仅便于修改内部代码，而且提高了重用性和安全性。
　　封装的实现——private。将成员变量私有化，对外提供get和set方法。

4. 构造方法（Constructor）

作用：给对象初始化（new）。
　　特点：函数名与类名同；不写返回数据类型。
　　一个类中如果没有定义构造函数，系统会给一个默认的空参数构造函数（default constructor）；如果有定义构造函数，则类中没有默认的构造函数。多个构造函数以重载的形式存在。

5. this关键字

this代表本类对象的引用。
　　两种用法：a.当成员变量和局部变量重名时，可用this区分。
　　　　　　　b.构造函数间的调用。只能定义在构造函数第一行。

class Person{
	private String name;
	private int age;
	//构造函数
	Person(){
	}
	Person(String name){
		this.name = name;
	}
	Person(String name, int age){
		this(name); // this用于在构造函数中调用其他构造函数，只能定义在构造函数的第一行。
		this.age = age;
	}
	//成员变量name,age的set和get方法
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		if (age >0 && age <130)
			this.age = age;
		else
			System.out.println("Wrong data");
	}
	public int getAge(){
		return age;
	}
	void speak(){
		System.out.println(name+" is "+age+" years old");
	}
}
class PersonDemo{
	public static void main(String[] args){
		Person p1 = new Person("Charley", 15);
		p1.speak();
		Person p2 = new Person("Beth");
		p2.speak();
		Person p3 = new Person();
		p3.speak();
		p3.setAge(-1);
	}
}

6. static关键字

static用于修饰成员。被修饰的成员具备以下特点：a.随着类的加载而加载；b.优先于对象存在；c.被所有对象所共享；d.可直接被类名调用。

区别	成员变量（实例变量）	静态变量（类变量）
生命周期	随对象	随类
调用方式	只能被对象调用	可被对象和类调用
数据存储位置	堆内存	方法区（共享数据区）的静态区

注：a.静态方法只能访问静态成员，即静态方法只能处理本类中的static域或调用static方法；非静态方法静态和非静态都可访问；
　　b.静态方法中不能访问实例变量，不能使用this，super关键字，因为静态先于对象存在；
　　c.主函数是静态的。

主函数解析：
　public：权限必须是最大的，被jvm调用。
　static：不需要对象调用，直接用主函数所属类名调用即可。命令行窗口中输入：java StaticDemo，实际上就是在执行StaticDemo.main();。
　void：主函数不需要具体的返回值。
　main：函数名，不是关键字，只是一个jvm识别的固定的名字。
　String[] args：这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。

什么时候使用静态呢？
　　a.静态变量：不同对象具有相同的值时
　　b.静态函数：无需访问非静态成员时
　　静态代码块：给类初始化。随着类的加载而执行，且只执行一次。
　　格式：
　　　　static
　　　　{
　　　　　　静态代码块中的语句。
　　　　}
　　构造代码块：给所有对象初始化。
　　格式：
　　　　{
　　　　　　构造代码块中的语句。
　　　　}

7.类的API文档创建

现在网络上已经有了很不错的API文档生成工具，百度一下就出现了下面这篇，博主还木有用过，不知道效果如何，这里附上链接仅供大家参考一下。 http://www.youkuaiyun.com/article/2013-02-20/2814189-API_DOC_TOOLS
　　下面还是着重介绍一下如何手动创建类的API文档。
　　前提：该类必须是public的。
　　方法：
　　1)首先在我们的java类中加好注释，包括类的说明、@author、@version等，每个方法最好也写清楚方法实现的功能、@param、@return等等。
　　2)在dos命令行中输入命令：javadoc -d Myhelp -author-version 类名.java

8. 单例设计模式

设计模式(Design pattern)是一套可以反复使用的代码设计经验的总结。使用设计模式是为了提高代码的可读性、可维护性。
　　经典的23种模式
　　

下面来详细说一说单例设计模式（Singleton pattern）。
　　单例设计模式：一个类有且仅有一个实例，并且自行实例化向整个系统提供。
　　如何保证对象唯一性呢？
　　　　a.不允许其他程序用new创建该类对象。——> 私有化该类构造函数
　　　　b.在该类创建一个本类实例。——> 通过new在本类中创建一个本类对象。
　　　　c.对外提供一个方法让其他程序可以获取该对象。——> 定义一个公有的方法，将创建的对象返回。
　　单例设计模式的静态结构图：
　　
　　下面程序演示了单例设计模式的两种类型：饿汉式和懒汉式。其中懒汉式较为常用。

/*
 饿汉式：在程序启动或单例模式类被加载的时候,单例模式实例就已经被创建。
 */
 
class Singleton{
	//通过new在本类中创建一个本类对象。
	private static Singleton s = new Singleton();
	//私有化该类构造函数。
	private Singleton(){}
	//定义一个公有的方法，将创建的对象返回。
	public static Singleton getInstance(){
		return s;
	}
}
public class SingletonDemo {
	public static void main(String[] args){
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		System.out.println(s1 == s2);
	}
}

/*
懒汉式：当程序第一次访问单例模式实例时才创建实例。
*/ 
class Singleton{
	private static Singleton s = null;
	//私有化该类构造函数。
	private Singleton(){}
	//定义一个公有的方法，将创建的对象返回。
	public static Singleton getInstance(){
		//如果s为空，通过new在本类中创建一个本类对象。
		if (s == null)
			s = new Singleton();
		return s;
	}
}
public class SingletonDemo {
	public static void main(String[] args){
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		System.out.println(s1 == s2);
	}
}