黑马程序员—面向对象1

----------------------   JavaEE+Android、Java培训、期待与您交流！ ----------------------

简单描述什么是面向对象？

面向对象是一种思想，它能让复杂的事物简单化，能让程序员从执行者变为指挥者。开发过程 其实就是在不断地创建对象，使用对象，指挥对象做事情；设计过程其实就是在管理和维护对象之间的关系。“一切皆对象！”

面向对象的三个特征：封装性，继承性，多态性。

类和对象

类：对生活中事物的描述

对象：对类的具体实现，是实实在在存在的实体。

成员变量与局部变量

1）作用范围：

   a.成员变量：作用于整个类中

   b.局部变量：作用于函数中，或者作用于语句块中。

2）在内存中的位置：

   a.成员变量：在堆内存中，因为对象的存在才在内存中存在。

   b.局部变量：在栈内存中，随着函数的结束而消亡

3）初始化方式：

   a.成员变量：随着类的初始化而初始化，在堆内存中被加载，有默认值，可直接参与运算

   b.局部变量：随着方法的加载而加载进栈内存中，无初始化值，必须被初始化才能参与运算

匿名对象

所谓匿名对象，就是创建的对象没有名字，直接使用。是对象的一种简写形式。

使用方式：

1）使用方式一：当对对象的方法只调用一次时，可以使用匿名对象来完成，这样写比较简化。

      如果对一个对象进行多个成员调用，必须给这个对象起个名字

2）使用方式二：可以讲匿名对象作为实际参数进行传递，从而可以不用在main方法中创建一个变量，提高了编程效率，减少了代码书写。

什么时候使用匿名对象？

当对对象的方法只调用一次时可以用匿名对象，比较简化。但是简化是有局限性的。

封装

封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

封装的好处：a.将变化隔离     b.便于使用     c.提高重用性     d.提高安全性

封装原则：

a.将不需要对外提供的内容隐藏起来

b.把属性都隐藏，提供公共方法对其访问

框架，包，类，函数都是封装体

封装不是私有，私有仅仅是封装的一种表现形式。

构造函数

1、特点：

a.函数名与类名相同

b.不用定义返回类型，括号中的参数可以没有，也可以有多个。

c.不可以写return语句

d.构造函数总是伴随着new操作一起被调用。

e.细节：当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数，即：类名(){}。但当类中自定义了构造函数后，默认的构造函数就不存在了。也就是说，每一个类中一定含有一个构造函数。

2、作用：给对象进行初始化

3、构造函数与一般函数的区别：运行上不同（写法也不一样）

构造函数时在对象一建立就运行，是给对象初始化的。且一个对象建立后，构造函数只运行一次。一般函数只有在对象调用时才执行，是给对象添加对象具备的功能的。一般函数可以被该对象多次调用。

注：一般函数是不能调用构造函数的，因为一般函数中不能定义this，而构造函数中可能存在this。

4、何时定义构造函数：

当分析事物时，该事物存在具备一些特性或行为，那么将这些内容定义在构造函数中。也就是说，一类事物一出现就应该存在的特性，这就需要构造函数对其进行初始化。

5、构造代码块：

如上面的小程序，其中打印的“我来工作了”这个语句块就是构造代码块。它和构造函数作用类似，只不过仅用一对花括号括起来即可。

1）作用：给对象进行初始化，对象一建立就运行，且优于构造函数执行，即在构造函数前加载。

2）与构造函数区别：

构造代码块是给所有对象进行统一初始化，是所有对象的共性初始化方式内容。

构造函数是给对应的对象初始化，不同的对象有各自的特性，需要选择不同的构造函数初始化。

this关键字

用于区分局部变量和成员变量同名的情况。即this代表着当前对象的引用。

1、this的用法：

a.用于区分同名变量的情况。当局部已经定义了变量，当需要找成员中的变量，且变量名相同时，为了区分局部变量和成员变量的相同变量名，可以使用this加以区分。

b.用于构造函数间的调用。

2、特点：

1）this代表了本类的对象，即代表了它所在函数所属对象的引用，也就是说，哪个对象调用这个函数，this就代表哪个对象。

2）一般情况下，this都是被省略的，需要使用的时候才需加上。

3、在构造函数中的应用：

用于构造函数之间的互相引用。且只能放在构造函数的第一行，否则编译失败。原因：初始化的动作要先执行，因为自身的特性要先具备；如果初始化中还有初始化，要限制性更细节的操作，然后再执行自己所需求的初始化。

注意：不允许两个构造函数间相互调用this语句，否则会出现死循环。

      一般函数中不能定义this语句。

static关键字

1、用法：修饰成员变量或成员函数

2、特点：

a、随着类的加载而加载，在类中生命周期最长(说明静态成员在对象的建立之前就已经存在于内存中，此块内存称为方法区，共享区或数据区)

b、优先于对象而存在

c、可以被所有对象共享

d、可以直接被类名调用

注：对象建立后存放于堆内存中，与之一起存放的只有对象特有的成员变量。共享成员变量和方法都存在方法区中

实例变量和类变量的区别：

1，存放位置：类变量随着类的加载而存在于方法区中。实例变量随着对象的建立而存在于堆内存中。

2，生命周期：类变量生命周期最长，随着类的消失而消失。实例变量生命周期随着对象的消失而消失。

3、静态是用注意事项：

1）静态方法只能访问静态成员，非静态方法既能访问静态也可以访问非静态

2）静态方法中不可定义this，super等关键字，因为静态优先于对象存在，所以静态方法中不可以出现this

3）主函数是静态的。

4、什么时候定义静态变量（类变量）和静态函数？

a、当对象中出现共享数据时，该数据可以定义为静态的

b、当函数内部功能没有访问到非静态数据（即对象中特有的数据），此时该函数可以定义为静态的

5、静态有利有弊

利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。可以直接被类名调用。

弊端：生命周期过长。访问出现局限性。(静态虽好，只能访问静态。)

主函数

主函数是一个特殊的函数，作为程序的入口，可以被jvm调用，它的格式是固定的

格式：public static void main(String[] args)     args——字符串数组名，可以被自由定义（arguments是参数的意思）

public：代表该函数的访问权限是最大的

static：代表主函数随着类的加载已经存在了

void：主函数没有具体的返回值

main：不是关键字，但它是一个特殊的单词，可以被jvm识别

(String[] args)：函数的参数，参数类型是一个数组，字符串数组

注：jvm在调用主函数时传入的是 new Sring[0],该字符串数组没有元素

工具类

将每个应用程序中共性的功能抽取，独立封装以便复用，这样的类称为工具类

为了严谨，需要将该类的构造函数（包括默认构造函数）私有化，为了避免建立该类的对象，因为工具类中并没有用到对象中的特有数据。不需对外显示函数也要定义为私有的。

工具类中的方法都是静态的

Person p = new Person("zhangsan",20);该句话都做了什么事情？

1，因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。

2，执行该类中的static代码块，如果有的话，给Person.class类进行初始化。

3，在堆内存中开辟空间，分配内存地址。

4，在堆内存中建立对象的特有属性。并进行默认初始化。

5，对属性进行显示初始化。

6，对对象进行构造代码块初始化。

7，对对象进行对应的构造函数初始化。

8，将内存地址付给栈内存中的p变量。

静态代码块

静态代码块随着类的加载而执行，只执行一次，且优先于主函数执行。

静态代码块用于给类进行初始化

类A  b= full;  类A不要加载，没有具体指向

单例设计模式

解决一个类在内存只存在一个对象

如何保证对象的唯一性？

1、为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象

2、还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象

3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式

单例设计模式的两种具体表现形式：

1、饿汉式：先初始化对象，类一进内存就加载

<span style="font-family:Arial;font-size:12px;">//饿汉式
class Single 
{
	private Single(){}
	private static Single s = new Single();
	public static  Single getSingle()
	{
		return s;
	}
}

class SingleText
{
	public static void main(String [] args)
	{
		Single s1 = Single.getSingle();
		Single s2 = Single.getSingle();
		if (s1==s2)
			System.out.println(true);
		else
			System.out.println(false);		
	}
}</span>

2、懒汉式：类进内存，对象还没有存在，只有调用了getSingle方法时，才建立对象class Single

<span style="font-family:Arial;font-size:12px;">//懒汉式
class Single 
{
	private Single(){}
	private static Single s = null;
	public static Single getSingle()
	{
		if (s==null) 
			s = new Single();
		return s;
	}
}

class SingleText
{
	public static void main(String [] args)
	{
		Single s1 = Single.getSingle();
		Single s2 = Single.getSingle();
		if (s1==s2)
			System.out.println(true);
		else
			System.out.println(false);		
	}
}</span>

注：对于第二种懒汉式的单例设计模式，会出现一些小小的问题，当一个线程调用时，是没什么问题的，如果多个线程调用此种方式，那么就会出现问题。解决方案如下代码：

<span style="font-family:Arial;font-size:12px;">class Single
{
	private static Single s = null;
	private Single(){}
	public static Single getInstance()
	{
		if (s == null)
		{
			synchronized(Single.class)
			{
				if (s == null)
					s = new Single();
			}
		}
		return s;
	}
}</span>

----------------------   JavaEE+Android、Java培训、期待与您交流！ ----------------------

详细请查看： http://edu.csdn.net