黑马程序员——面向对象

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

备注：主函数的格式

public static void main(String[] args) 
主函数：是一个特殊的函数。作为程序的入口，可以被jvm调用。
主函数的定义：
public：代表着该函数访问权限是最大的。
static：代表主函数随着类的加载就已经存在了。
void：主函数没有具体的返回值。
main：不是关键字，但是是一个特殊的单词，可以被jvm识别。
（String[] arr）:函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。
主函数是固定格式的：jvm识别。
jvm在调用主函数时，传入的是new String[0];

一、面向对象概念及与类的关系

面向对象概念：就是把行为属性封装成对象，使用功能通过对象；

类与对象的关系：类描述对象，对象是类的实例化

二、封装

1、关键字private（私有，用于修饰本类成员，只在本类有效）

2、对外提供访问方式：Setter（设置）、Getter（获取）

三、构造函数

1、用于对对象初始化，只在对象创建时执行

2、每个类都有一个默认的空参构造函数

3、构造函数可以重载

4、构造函数没有返回值且必须与类名一致

class Person{
    Person{}
}

5、构造代码块（优于构造函数执行，给所有对象初始化）

6、局部代码块｛｝（主要是限定变量的生命周期）

四、this关键字（就是一个本类对象的引用）

/*
当成员变量和局部变量重名，可以用关键字this来区分。

this : 代表对象。代表哪个对象呢？当前对象。
	   this就是所在函数所属对象的引用。
	   简单说：哪个对象调用了this所在的函数，this就代表哪个对象。

this也可以用于在构造函数中调用其他构造函数。
注意：只能定义在构造函数的第一行。因为初始化动作要先执行。
*/

class Person
{
	private String name;
	private int age;	
	Person()
	{		
		name = "baby";
		age = 1;
		System.out.println("person run");
	}	
	Person(String name)	
	{
		this();
		this.name = name;
	}
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;		
	}
	public void speak()
	{
		System.out.println(this.name+":"+this.age);
	}

	/*
	判断是否是同龄人。
	*/
	public boolean compare(Person p)
	{
		/*
		if(this.age==p.age)
			return true;
		else
			return false;
		*/
		return this.age==p.age;
	}

}

class ThisDemo 
{
	public static void main(String[] args) 
	{

		Person p1 = new Person("aa",30);//
		Person p2 = new Person("zz",12);

		p2.compare(p1);

	}
}

五、 static关键字

用于修饰类中成员，随着类的加载而加载，被所用对象共享，优先于对象存在，调用可直接使用类名，生命周期最长，随着类的消失而消失。

static的特点：

1、 static是一个修饰符，用于修饰成员。
2、 static修饰的成员被所有的对象所共享。
3、 static优先于对象存在，因为static的成员随着类的加载就已经存在了。 
4、 static修饰的成员多了一种调用方式，就可以直接被类名所调用 。 类名.静态成员 。
5、 static修饰的数据是共享数据，对象中的存储的是特有数据。

成员变量和静态变量的区别？

1、 两个变量的生命周期不同。
成员变量随着对象的创建而存在，随着对象的被回收而释放。
静态变量随着类的加载而存在，随着类的消失而消失。

2、 调用方式不同。
成员变量只能被对象调用。
静态变量可以被对象调用，还可以被类名调用。

3、 别名不同。
成员变量也称为实例变量。
静态变量称为类变量。 

4、 数据存储位置不同。
成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据.
静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据.

静态使用的注意事项：

1、 静态方法只能访问静态成员。(非静态既可以访问静态，又可以访问非静态)
2、 静态方法中不可以使用this或者super关键字。
3、 主函数是静态的。

静态代码块static｛｝（并优先于主函数。, 随着类的加载而执行，只执行一次）

六、单例设计模式（私有构造函数，对外提供方法获取对象，保证对象唯一性）

设计思路：想要保证对象唯一。

1、 为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2、 还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3、 为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

这三部怎么用代码体现呢？

1、 将构造函数私有化。
2、 在类中创建一个本类对象。
3、 提供一个方法可以获取到该对象。

饿汉式以及懒汉式：

//饿汉式
class Single//类一加载，对象就已经存在了。
{
	private static Single s = new Single();

	private Single(){}

	public static Single getInstance()
	{
		return s;
	}
}


//懒汉式
class Single2//类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象。
			//延迟加载形式。 
{
	private static Single2 s = null;

	private Single2(){}

	public static Single2 getInstance()
	{
		if(s==null)
			s = new Single2();
		return s;
	}
}


class  SingleDemo
{
	public static void main(String[] args) 
	{
		Single s1 = Single.getInstance();
		Single s2 = Single.getInstance();

		System.out.println(s1==s2);
		
		Test t1 = Test.getInstance();
		Test t2 = Test.getInstance();
		t1.setNum(10);
		t2.setNum(20);
		System.out.println(t1.getNum());
		System.out.println(t2.getNum());
	}
}


class Test
{
	private int num;

	private static Test t = new Test();
	private Test(){}
	public static Test getInstance()
	{
		return t;
	}
	public void setNum(int num)
	{
		this.num = num;
	}
	public int getNum()
	{
		return num;
	}

}