黑马程序员──面向对象（一）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

面向对象

面向对象是相对面向过程而言

面向对象和面向过程都是一种 思想

面向过程

强调的是功能行为

比如（打开电脑，运行电脑，关闭电脑）

面向对象

将功能封装进对象，强调具备了功能的对象。 

比如（电脑具备了打开，运行，关闭的功能，强调的是电脑对象，我们只要找到电脑对象，就可以调用它的功能。）还有汽车例子

面向对象是基于面向过程的。

面向过程——>面向对象

复杂的事情变得简单化。

执行者   ——>指挥者

面向对象有三大特征：封装    继承   多态

开发：找对象   创建对象  用对象    维护对象之间的关系。

类

java中描述事物通过类的形式体现，类是具体事 物的抽象，概念上的定义。 

对象即是该类事物实实在在存在的个体 。

生活中描述事物无非就是描述事物的属性和行为。

•  如：人有身高，体重等属性，有说话，打球等行为。

Java中用类class来描述事物也是如此

•  属性：对应类中的成员变量。

•  行为：对应类中的成员函数。

定义类其实在定义类中的成员(成员变量和成员函 数)

成员变量：

•  成员变量定义在类中，在整个类中都可以被访问。

•  成员变量随着对象的建立而建立，存在于对象所在的堆内 存中。 

•  成员变量有默认初始化值。

局部变量：

•  局部变量只定义在局部范围内，如：函数内，语句内等。

•  局部变量存在于栈内存中。

•  作用的范围结束，变量空间会自动释放。

•  局部变量没有默认初始化值。

匿名对象 new Person( )

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

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

匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。

面向对象三大特征之一 封装

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

封装好处：

1、将变化隔离，我不需要知道该调用方法内部是怎么变化的，我只要知道用这个方法能解决问题就行了（工具类）

2、便于使用，封装之后，我在遇到同样的问题就可以多次使用该方法，快捷便利

3、提高重用性

4、提高安全性，封装之后，内部的变化外人是无法修改的，可以有效的防止外人的破坏

封装原则：

•  将不需要对外提供的内容都隐藏起来。

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

private关键字：

是一个权限修饰符。

•  用于修饰成员(成员变量和成员函数)

•  被私有化的成员只在本类中有效。

常用之一：

•  将成员变量私有化，对外提供对应的set ，get 方法（JavaBean）对其进行访问。

提高对数据访问的安全 性。

注意：私有仅仅是封装的一种表现形式。

构造函数

特点：

1.  函数名与类名相同

2.  不用定义返回值类型

3.  不可以写return语句

作用：

给对象进行初始化。

构造函数的小细节：

当一个类中没有定义构造函数时，那么系统会默认给该类加入一个 空参数的构造函数。

当在类中自定义了构造函数后，默认的构造函数就没有了。

这个默认的构造函数的权限和所属类一致。

如果类被public修饰，那么默认的构造函数也带public修饰符。

如果类没有被public修饰，那么默认的构造函数，也没有public修饰。

默认构造构造函数的权限是随着的类的变化而变化的。

注意：

1.  默认构造函数的特点。

2.  多个构造函数是以重载的形式存在的。

class Person
{
	private int age;
	private String name;
	Person(){}
	Person(int age)
	{
		this.age=age;
	}
	Person(int age,String name)
	{
		this.age=age;
		this.name=name;
	}

}

构造代码块。

作用：给对象进行初始化。

对象一建立就运行，而且优先于构造函数执行。

和构造函数的区别：

构造代码块是给所有对象进行统一初始化，

而构造函数是给对应的对象初始化。

 构造代码快中定义的是不同对象共性的初始化内容。

class Person
{
	private int age;
	private String name;
	{
		System.out.println("hello heima");//构造代码块
	}
	Person(){}
	Person(int age)
	{
		this.age=age;
	}
	Person(int age,String name)
	{
		this.age=age;
		this.name=name;
	}

}

this关键字

this代本类对象的引用。

当在函数内需要用到调用该函数的对象时，就用this。compare方法

class Person
{
	private int age;
	private String name;
	{
		System.out.println("hello heima");//构造代码块
	}
	Person(){}
	Person(int age)
	{	this();//this语句 只能放于构造函数第一行  用于构造函数间调用  其他函数无此用法。
		this.age=age;
	}
	Person(int age,String name)
	{
		this.age=age;
		this.name=name;
	}
	
	public void show()
	{
		System.out.println(age);//this.age
	}

static关键字

用于修饰成员（成员变量和成员函数）

修饰后特点：

随着类的加载而加载
优先于对象存在
被所有对象所共享
可以直接被类名调用

注意:

静态方法只能访问静态成员
静态方法中不可以写this，super关键字
主函数是静态的

public static void main(String[] args) {

}

设计模式：解决某一类问题最行之有效的方法。

java中23种设计模式：

单例设计模式：解决一个类在内存只存在一个对象。

想要保证对象唯一。 

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

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

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

步骤：

1，将构造函数私有化。

2，在类中创建一个本类对象。

3，提供一个方法可以获取到该对象。

用法：

对于事物该怎么描述，还怎么描述。 

当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。

饿汉式：

Single类一进内存，就已经创建好了对象。

class Single
{


	private  Single(){}//私有构造方法

	private static Single s = new Single();//建立私有本类对象

	public static  Single getInstance()//对外提供访问方式。
	{
		return s;
	}
}

懒汉式：

对象是方法被调用时，才初始化，也叫做对象的延时加载。

Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。

synchronized 用于解决多线程并发访问时安全问题。

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;
	}
}

以上内容为本人笔记，仅供参考。