面向对象一封装，面向对象思想介绍

一、面向对象思想介绍

1、面向对象：编程思想

2、面向过程和面向对象的比较：

(1)面向过程：强调做事情的基本步骤，强调解决问题的方式，面向对象是基于面向过程的
(2)面向对象：强调的是做事情的主题，更强调谁来解决问题，更强调的是数据，强调的是谁拥有数据和操作数据的权利

3、面向对象和面向过程举例：
(1)面向过程：洗衣服：拿盆，放脏衣服，加水，倒洗衣粉，泡，揉一揉，漂一漂，拧干，晾晒，穿
(2)面向对象：找到洗衣机，洗衣机洗衣服，穿衣服

4、面向对象的好处：
(1)更符合现代人类的习惯：方便，凡事儿喜欢找对象、找人，而不是找方法
(2)复杂问题简单化
(3)由执行者变成了指挥者

5、面向对象的特点：
(1)封装
(2)继承
(3)多态

二、类和对象

（一）类和对象的比较

1、类：类型，对具体事物的一些抽象认识，概括的是一类事物共性的属性和行为。类：是一个抽象的概念，并非实际存在。

2、对象：一个真实存在的事物，是属性和行为的具体体现，是属性的载体，是行为的执行者。

（二）类的说明

1、类就是定义了一组属性和行为的集合

2、属性：对事物特征的描述，一般是变量
Java中，属性其实就是一个变量，只不过定义的位置发生了变化，现在定义在类中方法外，又叫做成员变量

3、行为：对事物功能的描述，是方法
Java中，功能实际上就是方法，和以前定义的位置一样，只是曾经写为public static，现在去掉static

4、举例：
人类
属性（成员变量）：姓名、年龄、性别
行为（成员方法）：吃饭、睡觉、学习

5、说明：
(1)自定义类型编译后，会生成一个独立的.class文件
(2)在一个.java源文件中，可以定义多个类，每个类编译过后都会是一个独立的.class文件
代码示例

package com.offcn.demos;

/**
*  2、属性：对事物特征的描述，一般是变量
	Java中，属性其实就是一个变量，只不过定义的位置发生了变化，现在定义在类中方法外，又叫做成员变量
3、行为：对事物功能的描述，是方法
	Java中，功能实际上就是方法，和以前定义的位置一样，只是曾经写为public static，现在去掉static

	
	public class Demo01_Class {


}

/*
* 在Java中，类使用关键字class来定义
 * 定义格式：
* class 类名 {
 * 
 * }
 * 
 * java中，每一个类都会编译生成一个独立的字节码文件(.class文件)
* 注意：在定义类的时候，类与类之间的关系一般情况下是平行的
 * 
* */
class Person {
/*
 * 属性：对事物特征的描述，一般是变量
	Java中，属性其实就是一个变量，只不过定义的位置发生了变化，现在定义在类中方法外，又叫做成员变量
 * */
//成员变量
String name;//姓名
int age;//年龄
String gender;//性别

/*
 * 3、行为：对事物功能的描述，是方法
	Java中，功能实际上就是方法，和以前定义的位置一样，只是曾经写为public static，现在去掉static
 * 
 * */
//成员方法
//吃饭
public void eat() {
	System.out.println("吃饭");
}

//睡觉
public void sleep() {
	System.out.println("睡觉");
}

//学习
	public void study() {
		System.out.println("学习");
	}
}

（三）对象的创建和使用

1、对象：是一个实实在在存在的个体，是属性的载体，是行为的执行者

2、创建对象的格式：类名 对象名 = new 类名(); Scanner sc = new Scanner(System.in);

3、说明：
(1)类名：创建的是哪个类的对象，就写哪个类的类名
(2)对象名：就是一个变量名，遵循见名知意和小驼峰原则
(3)=：对象是引用数据类型，所以=将右侧对象的地址值赋值给左侧的变量名称的空间内
(4)new：只要一看到new，就要到堆中开辟空间。创建对象时，是在堆中开辟空间，创建真正的对象
(5)注意：目前为止（多态学习之前），=前后的类名保持一致
(6)()：在封装中学习构造方法时讲解

4、对象访问属性的格式：
(1)访问：对象名.属性名
(2)修改：对象名.属性名 = 属性值;

5、访问方法：对象名.方法名(实参列表);

代码示例

package com.offcn.demos;

public class Demo02_Instance {

public static void main(String[] args) {
	//类名 对象名 = new 类名();
	Animal a = new Animal();
	
	/*
	 *  (1)访问：对象名.属性名
		(2)修改：对象名.属性名 = 属性值;
	 * */
	
	System.out.println(a.age);
	System.out.println(a.color);
	
	a.age = 3;
	a.color = "五彩斑斓的黑";
	
	System.out.println(a.age);
	System.out.println(a.color);
	
	a.eat();
	a.sleep();
	}
}

/**
 * 动物类
 *
 * 变量在方法中，必须先赋值后使用
 * 变量定义在类中，具有默认值
 */
class Animal {
int age;
String color;

public void eat() {
	System.out.println("吃");
}

public void sleep() {
	System.out.println("睡");
}

}

（四）练习
定义一个汽车类，有颜色（color），有轮胎个数（num），跑（run：输出打印“汽车跑”）
在main方法中创建汽车类对象，修改成员变量的值，并且输出成员变量修改后的值，通过对象调用方法

代码示例

package com.offcn.demos;

/**
 * 定义一个汽车类，有颜色（color），有轮胎个数（num），跑（run：输出打印“汽车跑”）
在main方法中创建汽车类对象，修改成员变量的值，并且输	出成员变量修改后的值，通过对象调用方法
 *
 */

public class Demo03_Exercise {

public static void main(String[] args) {
	Car c = new Car();
	
	c.color = "红";
	c.num = 4;
	
	System.out.println(c.color);
	System.out.println(c.num);
	
	c.run();
}
}

class Car {
String color;
int num;

public void run() {
	System.out.println("汽车跑");
}
}

三、创建对象的内存理解

（一）创建两个对象的内存图

1、图示：

2、创建对象的步骤：
(1)将要创建的对象所属的类型的字节码文件加载到方法区
(2)在栈内存中创建对象的引用，将来用于存储对象的地址值
(3)在堆内存中开辟一块空间，为成员变，并存储了默认值
(4)将对象的地址值赋值给对象名称指代的空间内

3、内存图示的说明：
(1)第一次使用某个类型的时候，会将这个类型的字节码文件加载到方法区，第二次使用的时候不用重复加载，一般情况下，一个类只加载一次
(2)在创建对象的过程中，对象内部会默认隐含一份所属类型的字节码文件的地址，将来可以通过这个地址找到所属类型
(3)每一个对象都具有一份类的成员变量
(4)每次使用new关键字，都会在堆中开辟一块全新的空间，这意味着是不同的对象，具有不同的地址值

代码示例

package com.offcn.demos;

public class Demo04_TwoInstancePicture {

public static void main(String[] args) {
	Bus b1 = new Bus();
	
	b1.color = "黑";
	b1.num = 6;
	
	Bus b2 = new Bus();
	
	b2.color = "红";
	b2.num = 3;
	
	System.out.println(b1.color);
	System.out.println(b1.num);
	
	System.out.println(b2.color);
	System.out.println(b2.num);
}
}

/*
 同包下不能出现同名类，因为在一个包下，如果出现了同名类，
编译过后就有同名的.class文件，计算机就分不清楚谁是谁了
 */

class Bus {
String color;
int num;

public void run() {
	System.out.println("汽车跑");
}
}

（二）两个引用指向同一个对象的内存图

代码示例

package com.offcn.demos;

public class 			

Demo05_TwoAddressPointerOneInstance {

public static void main(String[] args) {
	Airplane a1 = new Airplane();
	
	//地址不变：引用数据类型抓住地址
	a1.color = "white";
	a1.num = 4;
	
	Airplane a2 = a1;
	
	a2.color = "green";
	a2.num = 2;
	
	System.out.println(a1.color + "..." + a1.num);//green...2  white...4
	System.out.println(a2.color + "..." + a2.num);//green...2
	
}
}

/**
* 飞机类
 *
*/
class Airplane {
String color;
int num;//翅膀个数

public void fly() {
	System.out.println("飞");
}
}

四、面向对象中的其他内容

（一）成员变量和局部变量的区别

1、成员变量：是一个变量，定义在类中，属于类的成员，这种变量就叫做成员变量。

2、局部变量：是一个变量，定义在方法中，属于方法的成员，对于类而言，方法只是一个部分，所以是局部。

3、不同点：

(1)代码层面：定义位置不同
1)成员变量：定义在类中
2)局部变量：定义在方法中
(2)内存层面：内存空间不同
1)成员变量：随着对象创建在堆内存中
2)局部变量：随着方法创建在栈中方法内
(3)内存层面：内存时间不同，生命周期不同
1)成员变量：属于对象，随着对象的创建而创建，随着对象的消亡而消亡
2)局部变量：属于方法，随着方法的进栈而创建，随着方法的出栈而消亡
(4)初始化状态不同：
1)局部变量：不具有初始值，必须先赋值后使用
2)成员变量：具有默认初始化值
a.基本数据类型：
a)整数类型：0
b)浮点类型：0.0
c)字符类型：’\u0000’ NaN
d)布尔类型：false
3)引用数据类型：null

代码示例

package com.offcn.demos;

public class Demo06_InitValueForVariable {

public static void main(String[] args) {
	Test t = new Test();
	
	/*System.out.println(t.b);
	System.out.println(t.s);
	System.out.println(t.i);
	System.out.println(t.l);*/
	
	/*System.out.println(t.f);
	System.out.println(t.dou);*/
	
	//System.out.println(t.c);
	
	//System.out.println(t.bo);
}
}

class Test {
/*byte b;
short s;
int i;
long l;*/

/*float f;
double dou;*/

//char c;
boolean bo;
}

（二）方法的形式参数是引用数据类型

1、变量访问的就近原则：
(1)变量的定义（声明）：变量名称带有数据类型
(2)变量的访问（调用）：只有变量名称没有数据类型
(3)就近原则：当变量被访问的时候，会现在最近的范围内寻找（最近的范围：被访问的位置所属的大括号），如果没有找到，就从大括号中出来，跑去更大的范围——类中去寻找。

2、方法的形式参数，既可以是基本数据类型，也可以是引用数据类型

3、当方法的形式参数是引用数据类型时，传递到实际上引用数据类型的地址值，就变成了多个引用指向同一个对象，当有一个引用修改了对象中的属性值，其他引用读取到的也是被修改后的内容

4、引用数据类型传递的本质，是传递地址值！
5、图示：

代码示例

package com.offcn.demos;

public class Demo07_MethodParamIsAddress {

public static void main(String[] args) {
	Cell c = new Cell();
	
	c.show();
	
	updateCell(c);
	
	c.show();
}

/**
 * 更新手机：为手机贴牌，定价
 */
public static void updateCell(Cell c) {//Cell c = new Cell();
	c.brand = "华为";
	c.price = 8999;
}


}

/**
 * 手机类型
 *
 */
class Cell {
String brand;
int price;

public void show() {
	System.out.println(brand + "..." + price);
}
}

（三）方法的返回值是引用数据类型

1、方法的返回值，既可以是基本数据类型，也可以是引用数据类型

2、方法返回值是基本数据类型时，返回的是数值；方法返回值是引用数据类型时，返回的是地址值
3、图示：

代码示例

package com.offcn.demos;

public class Demo08_ReturnAddress {

public static void main(String[] args) {
	Phone p = getPhone();//Phone p = new Phone();
	
	p.show();
}

//生产手机
//对象的来源不唯一：可以通过new手动创建，也可以通过方法进行返回
public static Phone getPhone() {
	Phone p = new Phone();
	
	p.brand = "红米K30S";
	p.price = 1999;
	
	return p;
}
}

class Phone {
String brand;
int price;

public void show() {
	System.out.println(brand + "..." + price);
}
}