黑马程序员——Java语言：面向对象

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

一、面向对象

1.1 理解面向对象：

1.面向对象是相对面向过程而言的。

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

3.面向过程强调的是功能行为，面向对象强调具备功能的对象。

4.对象对象基于面向过程。

是一种符合人们思考习惯的思想，可以将复杂的事情简单化，将程序员从执行者转换成了指挥者。

完成需求时：

1. 先要去找具有所需功能的对象来用。

2. 如果该对象不存在，那么创建一个具有所需功能的对象。这样可以简化开发并提高复用。

面向对象的特征：

封装(encapsulation)

继承(inheritance)

多态(polymorphism)

 

1.2 类与对象

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

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

1.2.1 类的定义

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

对于同一类事物可以抽取它们的共性的内容，定义在类中。 

Java中用类class来描述事物。

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

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

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

1.2.2 创建对象，使用对象

结合一下代码来认识定义类，创建对象的过程

//定义类，描述人的属性及行为（方法）
class Person
{
	//定义人的属性
	String name = "张三"; 
	int age = 15;
	//定义人的行为
	public void show() 
	{
		System.out.println("Person:"+name+age);
	}
}

class Demo
{
	public static void main(String[] args)
	{
		//通过new关键字创建对象
		Person p = new Person(); 
		//修改属性内容
		p.name = "李四";
		p.age = 20;
		//调用人的行为
		p.show();	
	}
}

注意：

对象在内存中的结构

Person p = new Person();

new Person在堆内存中创建一个Person对象，p是一个类类型的引用变量，在栈内存中生成，同时生成的Person对象地址赋给p变量。

 

1.2.3 匿名对象

匿名对象是对象的简化形式。

new Person().show();

匿名对象两种使用情况：

1. 当对对象方法仅进行一次调用时；

2. 匿名对象可以作为实际参数进行传递。

二、对象的封装

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

好处：

1. 将变化隔离。

2. 便于使用。

3. 提高重用性。

4. 提高安全性。

封装原则：

1. 将不需要对外提供的内容都隐藏起来，用private关键字

2. 把属性都隐藏，提供公共方法对其访问。 如，getXXX，setXXX。

示例：

class Person
{

	String name;
	private int age;
	public void setAge(int age)
	{
		this.age = age;
	}
	public int getAge()
	{
		return age;
	}
	public void show() 
	{
		System.out.println("Person:"+name+age);
	}
}

class Demo
{
	public static void main(String[] args)
	{
		
		Person p = new Person(); 
		p.name = "李四";
		p.setAge(20);
		p.show();	
	}
}

三、类的构造函数

特点：

1.函数名与类名相同。

2. 不用定义返回值类型。

3. 没有具体的返回值。

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

注意：在构造函数前面加上返回值就只是一般函数了。

class Person
{

	String name;
	private int age;
	Person()//构造函数
	{
		System.out.println("Perosn run");
	}
	public void setAge(int age)
	{
		this.age = age;
	}
	public int getAge()
	{
		return age;
	}
	public void show() 
	{
		System.out.println("Person:"+name+age);
	}
}

class Demo
{
	public static void main(String[] args)
	{
		
		Person p = new Person(); 
		p.name = "李四";
		p.setAge(20);
		p.show();	
	}
}

P.S

1、 一般函数和构造函数什么区别呢？

构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。

一般函数：对象创建后，需要函数功能时才调用。

构造函数：对象创建时，会调用并且只调用一次。

一般函数：对象创建后，可以被调用多次。

2、 创建对象都必须要通过构造函数初始化。

一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。

如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

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

 

四、this关键字

this代表其所在函数所属对象的引用。 换言之，this代本类对象的引用。

当成员变量和局部变量重名，可以用关键字this来区分，this就是所在函数所属对象的引用。

简单说，哪个对象调用了this所在的函数，this就代表哪个对象。 一般方法调用默认加this。

什么时候使用this关键字呢？

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

可以参考上面的代码。

五、static关键字

static关键字：用于修饰成员（成员变量和成员函数）。

被修饰后的成员具备以下特点：

1、随着类的加载而加载。

2、优先于对象存在。

3、被所有对象所共享。

4、可以直接被类名调用。

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

1. 两个变量的生命周期不同

成员变量随着对象的创建而存在，随着对象被回收而释放。

静态变量随着类的加载而存在，随着类的消失而消失。

2. 调用方式不同

成员变量只能被对象调用。

静态变量可以被对象调用，还可以被类名调用。

3. 别名不同

成员变量也称为实例变量。

静态变量也称为类变量。

4. 数据存储位置不同

成员变量存储在堆内存的对象中，所以也叫对象的特有数据。

静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

使用注意：

1、静态方法只能访问静态成员，如果访问非静态成员，就会报错！

原因：静态方法和变量存在的时候，对象还不存在，非静态变量也不存在，肯定无法访问。

2 、静态方法中不可以写this，super关键字。

原因：静态方法存在的时候，对象还不存在，this代表的就是调用方法的那个对象，既然不存在，肯定不可以写在静态方法中。

静态什么时候用？

1. 静态变量

当分析对象中所具备的成员变量的值都是相同时，这时这个成员就可以被静态修饰。

只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。

如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。

2. 静态函数

函数是否用静态修饰，就参考一点，就是该函数功能是否需要访问到对象中的特有数据。

简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。

如果不需要，就可以将该功能定义成静态的。 当然，也可以定义成非静态，但是非静态需要被对象调用。

如果没有访问特有数据的方法，该对象的创建是没有意义。

静态代码块

格式

static 
{
     执行代码
}

随着类的加载而执行，而且只执行一次，并优先于主函数。

作用：用于给类进行初始化。

 

对象的初始化过程：

定义一个新对象都做了哪些事情？

1、把类名.class文件加载到内存中。

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

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

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

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

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

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

8、将内存地址赋给栈内存中的对象名变量。

 

六、单例设计模式

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

java中有23种设计模式

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

想要保证对象唯一：

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

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

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

对于事物按需求描述，需要保证事物的对象在内存中唯一时就使用单例模式。

 

代码体现：

1.将构造函数私有化

2.在类中创建一个本类对象

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

class Single1
{
	private Single(){}
	private static Single s = new Single();
	public static Single getInstance()
	{
		return s;
	}
}
//这种方法是方法被调用时才初始化，也叫做对象的延时加载，叫做懒汉式
class Single2
{
	private static Single s = null;
	private Single(){}
	public static Single getInstance()
	{
		if(s==null)
			s = new Single();
		return s;
	}
}
class SingleDemo
{
	public static void main(String[] args)
	{
		Single  s = Single.getInstance();
	}
}