面向对象 之封装、构造函数

------- android培训、java培训、期待与您交流！ ----------

面向对象概念

类与对象的关系

封装

构造函数

1、面向对象概念

1.1如何理解面向对象

a)         面向对象是相对面向过程而言，面向对象和面向过程都是一种思想。

b)        面向过程强调的是功能行为。

c)         面向对象将功能封装进对象，强调具备了功能的对象。面向对象是基于面向过程的。

如

人开门：名词提炼法

人

{ 开门(门)

  {门.开()；

}

}

门

{  开()

{操作门}

}

那么过程和对象在我们的程序中是如何体现的呢？过程其实就是函数；对象是将函数等一些内容进行了封装。

1.2面向对象的特点

特点：1：将复杂的事情简单化。

2：面向对象将以前的过程中的执行者，变成了指挥者。

3：面向对象这种思想是符合现在人们思考习惯的一种思想。

完成需求时：

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

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

1.3面向对象发开，设计，特征

开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。

设计的过程：其实就是在管理和维护对象之间的关系

总之在以后的开发中：其实就是找对象使用，没有对象，就创建一个对象

找对象，建立对象，使用对象，维护对象的关系。

面向对象的特征：

封装（encapsulation）

继承（inheritance）

多态（polymorphism）

2.类与对象

2.1类的定义

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

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

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

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

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

总之，在类中定义其实都称之为成员。成员有两种：

1：成员变量：其实对应的就是事物的属性。

2：成员函数：其实对应的就是事物的行为。

所以，其实定义类，就是在定义成员变量和成员函数。但是在定义前，必须先要对事物进行属性和行为的分析，才可以用代码来体现。

 

2.2关系：

a)         使用计算机语言就是不断的在描述现实生活中的事物。

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

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

2.3类与对象（图例）

可以理解为：

类就是图纸

汽车就是堆内存中的对象

2.4成员变量和局部变量的区别

a)      定义的位置：

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

局部变量只定义在局部范围内，如定义在方法中，参数上，语句中。

b)      作用范围：

成员变量作用于整个类中。有默认初始化值。

局部变量变量作用于函数中，或者语句中。作用范围结束，变量空间会自动释放。没有默认初始化值。

c)      在内存中的位置：

成员变量：在堆内存中，随着对象的产生而存在，消失而消失。存在于对象所在的堆内存中。因为对象的存在，才在内存中存在。

局部变量：存在栈内存中。随着所属区域的运行而存在，结束而释放。

2.5创建对象，使用对象

需求：描述汽车(颜色，轮胎数)。描述事物其实就是在描述事物的属性和行为。

属性对应是类中变量，行为对应的类中的函数(方法)。

其实定义类，就是在描述事物，就是在定义属性和行为。属性和行为共同成为类中的成员(成员变量和成员方法)。

 

以后开发：其实就是找对象使用。没有对象，就创建一个对象，找对象，建立对象，使用对象。维护对象的关系。

类和对象的关系。

如：现实生活中的对象：张三李四。

想要描述：提取对象中共性内容。对具体的抽象。

描述时：这些对象的共性有：姓名，年龄，性别，学习java功能。

 

映射到java中，描述就是class定义的类。

具体对象就是对应java在堆内存中用new建立实体。

 

类就是：对现实生活中事物的描述。

对象：就是这类事物，实实在在存在个体。

class Car //对Car这类事物进行描述
{
	//描述颜色
	String color = "红色";
	//描述轮胎数
	int num = 4;
	//运行行为。
	void run()
	{
		System.out.println(color+".."+num);
	}
}
class  CarDemo
{
	public static void main(String[] args) 
	{
		//生产汽车。在java中通过new操作符来完成。
		//其实就是在堆内存产生一个实体。
	Car c = new Car();//建立对象
//c就是一个类类型变量。记住：类类型变量指向对象。
		//需求：将已有车的颜色改成蓝色。指挥该对象做使用。在java指挥方式是：对象.对象成员
		c.color = "blue";//对对象的属性进行修改
		c.run();//使用对象的功能
		Car c1 = new Car();
		c1.run();//red 4;
//		Car c = new Car();
//		c.num = 5;
		/*
		new Car().num = 5;
		new Car().color = "blue";
		new Car().run();
		Car c = new Car();
		c.run();
		c.num = 4;
		new Car().run();
		*/
		Car q = new Car();
		show(q);
		//show(new Car());
	}
	//需求：汽车修配厂。对汽车进行改装，将来的车够改成黑车，三个轮胎。
	public static void show(Car c)
	{
		c.num = 3;
		c.color = "black";
		c.run();
	}
}

对上述示例进行部分图解，以便更好的了解其对象内存结构形式：

2.6匿名对象

a)        匿名对象是对象的简化形式

b)       匿名对象使用场景：

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

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

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

new Car();调用方法有意义，调用属性没有意义。

class  CarDemo
{
	public static void main(String[] args) 
	{
		Car q = new Car();
		show(q);
		//相当于 show(new Car());匿名对象可以作为实际参数。
	}
}

内存结构如下：

需求：汽车修配厂。对汽车进行改装，将来的车够改成黑车，三个轮胎。

public static void show(Car c)
	{
		c.num = 3;
		c.color = "black";
		c.run();
	}

内存结构如下：

 

 

 

 

堆内存有默认值。

3.封装（Encapsulation）(面向对象的特征之一)

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

好处：将变化隔离；便于使用；提高重用性；安全性。

封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。

4.private(私有)关键字

private关键字:

a)     私有，是一个权限修饰符；

b)       用于修饰类中的成员(成员变量，成员函数)；

c)        私有只在本类中有效。

如：privateintage;//私有的访问权限最低，只有在本类中的访问有效。

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

私有的成员：其他类不能直接创建对象访问，所以只有通过本类对外提供具体的访问方式来完成对私有的访问，可以通过对外提供函数的形式对其进行访问。

常用之一：将成员变量私有化，对外提供对应的set,get方法对其进行访问，提高对数据访问的安全性。

class Person
{
	private int age;
// 将age私有化以后，类以外即使建立了对象也不能直接访问。
但是人应该有年龄，就需要在Person类中提供对应访问age的方式。
	public void setAge(int a)
	{
//之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句。
对访问的数据进行操作。提高代码健壮性。
		if(a>0 && a<130)
		{
			age = a;
			speak();
		}
		else
			System.out.println("feifa age");
	}
	public int getAge()
	{
		return age;
	}
	private void speak()
	{
		System.out.println("age="+age);
	}
}

class PersonDemo
{
	public static void  main(String[] args)
	{
		Person p = new Person();
		//p.age = -20;
		p.setAge(-40);
		p.speak();	
}
}

上述小小例子在内存存放结构：

总结：开发时，记住，属性是用于存储数据的，直接被访问，容易出现安全隐患，所以，类中的属性通常被私有化，并对外提供公共的访问方法。

这个方法一般有两个，规范写法：对于属性 xxx，可以使用setXXX(),getXXX()对其进行操作。

 

类中怎么没有定义主函数呢？

注意：主函数的存在，仅为该类是否需要独立运行，如果不需要，主函数是不用定义的。

主函数的解释：保证所在类的独立运行，是程序的入口，被JVM调用。

 

5.构造函数

5.1 构造函数：用于给对象进行初始化，是给与之对应的对象进行初始化，它具有针对性，函数中的一种。

5.2 特点：

1：该函数的名称和所在类的名称相同。

2：不需要定义返回值类型。

3：该函数没有具体的返回值。不可以写return语句。

5.3构造函数的作用：可以用于给对象进行初始化。

5.4构造函数的小细节：

a)        当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。为了方便该类创建对象，完成初始化。

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

c)       一个类中，可以有多个构造函数，因为它们的函数名称都相同，所以只能通过参数列表来区分。所以，一个类中如果出现多个构造函数。它们的存在是以重载体现的。

记住：所有对象创建时，都需要初始化才可以使用。对象一建立就会调用与之对应的构造函数

5.5 构造函数和一般函数有什么区别？

a)        构造函数和一般函数在写法上有不同。

b)       在运行上也有不同。

构造函数是在对象创建时就被调用。用于给对象初始化。而且初始化动作只执行一次。

而一般方法是对象创建后，需要调用才执行，给对象添加对象具备的功能。可以被该对象调用多次。

5.6 什么时候定义构造函数呢？

当分析事物时，发现具体事物一出现，就具备了一些特征，那就将这些特征定义到构造函数内。

5.7构造代码块和构造函数有什么区别？

构造代码块：是给所有的对象进行初始化。也就是说，所有的对象都会调用一个代码块。只要对象一建立就运行。而且优先于构造函数执行。

构造代码块和构造函数的区别：      

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

构造函数：是给与之对应的对象进行初始化。它具有针对性。

构造代码快的作用：是给所有的对象进行初始化。

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

class Person
{
	private String name;
	private int age;
	{
		cry();//让所有的对象都具备哭的功能
	}
	Person()
	{
		System.out.println("A: name="+name+",,age="+age);
	}
	Person(String n)//构造函数的重载
	{
		name = n;
		System.out.println("B: name="+name+",,age="+age);
		cry();
	}
	public void setName(String n)
	{
		name  = n;
	}
	public String getName()
	{
		return name;
	}
	Person(String n,int a)
	{
		name = n;
		age = a;
		System.out.println("C: name="+name+",,age="+age);
		//cry();
	}
	public void cry()
	{
		System.out.println("cry......");
	}
}
class  PersonDemo2
{
	public static void main(String[] args) 
	{
		Person p1 = new Person();
		Person p2 = new Person("lisi");
	System.out.println(p2.getName());	
	}
}

Person p1 = new Person();

创建一个对象都在内存中做了什么事情？

1：先将硬盘上指定位置的Person.class文件加载进内存。

2：执行main方法时，在栈内存中开辟了main方法的空间(压栈-进栈)，然后在main方法的栈区分配了一个变量p。

3：在堆内存中开辟一个实体空间，分配了一个内存首地址值。new

4：在该实体空间中进行属性的空间分配，并进行了默认初始化。

5：对空间中的属性进行显示初始化。

6：进行实体的构造代码块初始化。

7：调用该实体对应的构造函数，进行构造函数初始化。（）

8：将首地址赋值给p，p变量就引用了该实体。(指向了该对象)

 

———寄语：当我们还在迷茫时，多想想爱你的人和你爱的人，当他们受伤时，你是否有能力去保护他们，那样我们会重新找到自己的方向，因为他们永远是我们不变的后盾，和我们最爱的人！加油！濛濛，你会做到的。———     ——濛濛

------- android培训、java培训、期待与您交流！ ----------