02 - 面向对象—基础~什么是面向对象、面向对象思想、对象的内存分析、构造方法及方法的重载

你们是否发觉自己之前写着代码有很多都是重复性的、不灵活…总之就是很累赘，这都来源于面向过程的编程思想所导致的。为了使代码复用性高、更灵活，我们就需要有一种思想——面向对象思想，接下来就详细讲解面向对象基础知识~

一、面向对象基础

1、面向对象思想

1.1 基本概述

• 面向对象(Object Oriented)是软件开发方法。
• 面向对象的概念和应用已超越了程序设计和软件开发，是一种对现 实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。
• 面向对象是相对于面向过程来讲的，指的是把 相关的数据和方法组织为一个整体 来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。

面向过程到面向对象思想层面的转变：

• 面向过程关注的是执行的过程，面向对象关注的是具备功能的对象。
• 面向过程到面向对象，是程序员思想上 从执行者到指挥者的转变

1.2 场景模拟

我们描述一个生活的场景：

场景：当我们独自生活时， 我们经常纠结一日三餐怎么吃。

• 面向过程： 每天亲力亲为： 买菜 - 做饭 - 吃饭 - 洗碗 的过程。
• 面向对象： 招聘一个保姆，每天等吃即可。

场景升级： 假设你是一个富豪， 拥有一座占地3000亩地的庄园 ，不再是只关注吃饭问题 ， 还有花草树木修剪，泳池维 护清洗，卫生打扫，洗衣做饭。。。。。。

• 面向过程： 此处省略看着就累的N字。
• 面向对象： 招聘一个管家， 然后让管家招聘 园丁、泳池维护工、保姆等等。

结论：

• 从上述的栗子中， 我们发现面向过程，我们需要关注很繁琐的过程 。
• 而面向对象不用关注具体的细节，更关注的是统筹架构的问题。
• 其实我们进行大型应用开发时， 就如上述的例子一样， 如果我们写程序只关注过程的话， 代码量达到一定 层次以后， 就很难再编写下去了。

1.3 三大思想

面向对象思想从概念上讲分为以下三种：OOA、OOD、OOP

• OOA：面向对象分析（Object Oriented Analysis）
• OOD：面向对象设计（Object Oriented Design）
• OOP：面向对象程序（Object Oriented Programming

1.4 三大特征

封装性：所有的内容对外部不可见

• 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问，常见的实现方式就是：getter、setter。

继承性：将其他的功能继承下来继续发展

• 继承是类与类的一种关系，子类拥有父类的所有属性和方法（除了private修饰的属性不能拥有）从而实现了实现代码的复用。

多态性：多种形态。方法的重载本身就是一个多态性的体现（Java中的多态主要指引用多态和方法多态。）

• 引用多态是指：父类引用可以指向本类对象，也可指向子类对象。引用多态的强大主要体现在调用属性、方法时，可以根据引用具体指向的对象去调用，例如：子类中重写了父类方法。
• 方法多态：子类中可以重写父类的方法，在调用方法时根据引用指向的子类对象决定调用哪个具体的方法。方法多态的强大主要体现在可以根据调用时参数的不同，而自主匹配调用的方法，例如：重载。

2、类与对象的关系

类表示一个共性的产物，是一个综合的特征，而对象，是一个个性的产物，是一个个体的特征。 （类似生活中的图纸【类】 与实物【对象】 的概念。）

类必须通过对象才可以使用，对象的所有操作都在类中定义。

类由属性和方法组成：

属性：就相当于人的一个个的特征 ；
方法：就相当于人的一个个的行为，例如：说话、吃饭、唱歌、睡觉；

3、类与对象的创建

3.1 类的创建

1，类的定义格式：

class 类名称{
    
     
    成员属性 
    成员方法 
}

2，注意事项

• 类必须编写在.java文件中。
• 一个.java文件中， 可以存在N个类， 但是只能存在一个public修饰的类。
• .java文件的文件名称 必须 与public修饰的类名完全一致；

3，属性与方法定义格式

属性定义格式：

 - 数据类型 属性名;  
 - 数据类型 属性名 = 初始化值;

方法定义格式：

权限修饰符 返回值类型 方法名(形式参数列表){
    
     
//方法体 
return 返回值； 
}

3.2 对象的创建

一个类要想真正的进行操作，则必须依靠对象，对象的定义格式如下:

• 类名称 对象名称 = new 类名称() ;

如果要想访问类中的属性或方法（方法的定义），则可以依靠以下的语法形式：

• 访问类中的属性： 对象名.属性 ;
• 调用类中的方法： 对象名.方法(实际参数列表) ;

3.3 具体实例

package com.kaikeba.demo2;
/**
 * class 类名{
 * 	成员属性;
 * 	成员方法;
 * }
 * 
 * 类必须编写在.java文件中。
 * 一个.java文件中， 可以存在N个类， 但是只能存在一个public修饰的类。
 * .java文件的文件名称 必须 与public修饰的类名 完全一致；
 *
 */
public class Demo {
    
    
 
	public static void main(String[] args) {
    
    
		//创建对象的格式：
		//类名 对象名 = new 类名();
		Person p = new Person();
		//对象属性赋值
		//格式：	对象名.属性名=值;
		p.name = "张三";
		p.age = 18;
		p.sex = '男';
		p.say();
		
		
		int s = p.sum(100, 200);
		System.out.println(s);
	}
}
/**
 * 类就像是图纸
 */
class Person{
    
    
	//属性 - 特征
	String name;
	int age;
	char sex;
	//方法 - 行为
	/**
	 * 定义格式：
	 * 返回值类型 方法名称(形式参数列表){
	 * 	方法体
	 * 	return 返回值;
	 * }
	 * 
	 * 调用格式：
	 * 对象名.方法名称(实际参数列表);
	 */
	
	void say() {
    
    
		System.out.println("自我介绍：我是"+name+" , 我的年龄："+age+"，我的性别："+sex);
	}
	
	int sum(int x,int y) {
    
    
		int z = x+y;
		return z;
	}
	
	/*
	void xxx() {
		if(true) {
			return;    // 这里的return表示方法的结束
		}
		System.out.println("哈哈");
	}
	*/
	
}

4、对象创建内存

4.1 栈（stack）

1，栈(Stack):
Java中一个线程一个栈区。每一个栈中的元素都是私有的,不被其他栈所访问。
栈有先进后出的特点，栈中的数据大小与生存期都是确定的,缺乏灵活性,但是,存取速度比堆要快，仅次于CPU中的高存器…
Java栈的区域很小 , 大概2m左右 , 特点是存取的速度特别快 ；

2，存储速度快的原因:

• 栈内存, 通过 ‘栈指针’ 来创建空间与释放空间 !
• 指针向下移动, 会创建新的内存, 向上移动, 会释放这些内存 !
• 这种方式速度特别快 , 仅次于PC寄存器 !

3，但是这种移动的方式, 必须要明确移动的大小与范围 , 明确大小与范围是为了方便指针的移动 , 这是一个对于数据存储的限制, 存储的数据大小是固定的 , 影响了程序 的灵活性 ~ 。所以我们把更大部分的数据 存储到了堆内存中 。

4，栈中存储的是:

基本数据类型的数据（比如局部变量） 以及 引用数据类型的引用（比如数组的引用名，对象的引用名）!

例如:

• int a =10;
• Person p = new Person();
• 10存储在栈内存中 , 第二句代码创建的对象的引用( p )存在栈内存中

4.2 堆（heap）

存放的是类的对象（new出来的东西，成员变量/属性） . （大小不固定）

• Java是一个纯面向对象语言, 限制了对象的创建方式: 所有类的对象都是通过new关键字创建
• new关键字, 是指告诉JVM ,需要明确的去创建一个新的对象 , 去开辟一块新的堆内存空间；
• 堆内存与栈内存不同, 优点在于我们创建对象时 ,不必关注堆内存中需要开辟多少存储空间 , 也不需要关注内存占用 时长 !
• 堆内存中内存的释放是由 GC(垃圾回收器) 完成的。

垃圾回收器 回收堆内存的规则:

• 当栈内存中不存在此对象的引用 时,则视其为垃圾 , 等待垃圾回收器回收。

4.3 方法区（method）

存放的是

• 类信息
• 静态的变量
• 常量
• 成员方法

方法区中包含了一个特殊的区域 ( 常量池 )(存储的是使用static修饰的成员)

4.4 PC寄存器

PC寄存器保存的是 当前正在执行的 JVM指令 的 地址 !
在Java程序中, 每个线程启动时, 都会创建一个PC寄存器 !

4.5 本地方法栈

保存本地(native)方法的地址 !

4.6 实例过程1

1，分配内存（地址），并且修改属性的值；

2，创建新的对象b2，指向旧对象b1，并且更新属性name的值

3，程序执行完毕，引用数据从栈中弹出，栈内存中不存在此对象的引用时，等待垃圾回收器回收；

4.7 实例过程2

1，创建两个新对象

2，引用数据b2指向b1，b2原先指向的对象被当作垃圾释放；

5、构造方法

5.1 概述

回顾对象的创建

• Person p = new Person(); 在右侧Person后面出现的小括号, 其实就是在调用构造方法 !

作用：

• 用于对象初始化。

执行时机：

• 在创建对象时,自动调用

特点：

• 所有的Java类中都会至少存在一个构造方法
• 如果一个类中没有明确的编写构造方法, 则编译器会自动生成一个无参的构造方法,构造方法中没有任何的代 码！
• 如果自行编写了任意一个构造器, 则编译器不会再自动生成无参的构造方法！

5.2 定义格式

定义的格式:

与普通方法基本相同, 区别在于: 方法名称必须与类名相同, 没有返回值类型的声明 !

案例：

 public class Demo3{ 
    public static void main(String[] args){ 
        Person p = new Person(); 
        p = new Person(); 
        p = new Person(); 
        p = new Person(); 
    }  
  } 
  class Person{ 
    public Person(){ 
        System.out.println("对象创建时,此方法调用"); 
    } 
  } 

5.3 构造方法设计

建议自定义无参构造方法，不要对编译器形成依赖，避免错误发生。

当类中有非常量成员变量时，建议提供两个版本的构造方法，一个是无参构造方法，一个是全属性做参数的构造方法。

当类中所有成员变量都是常量或者没有成员变量时，建议不提供任何版本的构造。

6、方法的重载

6.1 普通方法的重载

方法名称相同, 参数列表类型或参数列表长度不同或参数类型顺序, 可以完成方法的重载 !

方法的重载与返回值无关! 方法的重载 ,可以让我们在不同的需求下, 通过传递不同的参数调用方法来完成具体的功能

package com.kaikeba.demo2;
 
public class Demo5 {
    
    
 
	public static void main(String[] args) {
    
    
		Math m = new Math();
		int num = m.sum(100, 500);
		System.out.println(num);
		
		double num2 = m.sum(10.5, 20.6);
		System.out.println(num2);
	}
 
}
// 命名规范 见名知意
class Math{
    
    
	/**
	 * 一个类中定义的方法， 是允许重载 （相同的方法名称）
	 * 
	 * 1、方法名称相同
	 * 2、参数列表长度  或 参数列表类型 或 （参数类型顺序不同）
	 * 
	 * 注意： 与返回值类型无关
	 * 
	 */
	int sum(int x,int y) {
    
    
		int z = x+y;
		return z;
	}
	
	double sum(double x,double y) {
    
    
		double z = x+y;
		return z;
	}
	
	double sum(int x,double y) {
    
    
		double z = x+y;
		return z;
	}
	
	double sum(double y,int x) {
    
    
		double z = x+y;
		return z;
	}	
}

6.2 构造方法的重载

一个类, 可以存在多个构造方法 :

• 参数列表的长度或类型不同即可完成构造方法的重载 ~
• 构造方法的重载 ,可以让我们在不同的创建对象的需求下,调用不同的方法来完成对象的初始化!

package com.kaikeba.demo2;
 
public class Demo6 {
    
    
 
	public static void main(String[] args) {
    
    
		Person3 p = new Person3("张三",18);
		p.say();
		
		Person3 p2 = new Person3("李四");
		p2.say();
	}
 
}
class Person3{
    
    
	
	Person3(String name2,int age2){
    
    
		name = name2;
		age = age2;
	}
	
	Person3(String name2){
    
    
		name = name2;
	}
	
	String name;
	int age;
	
	void say() {
    
    
		System.out.println("自我介绍： 姓名："+name+", 年龄："+age);
	}
	
}

方法重载的注意点： 两同一不同

• ‘两同’：在同一个类，方法名相同；
• ‘一不同’：参数不同（个数、类型、类型顺序）。

7，匿名对象

没有对象名称的对象 就是匿名对象。（没有对象名、引用名，所以所以栈中无相关记录，故只能使用一次）

• 匿名对象只能使用一次，因为没有任何的对象引用，所以将称为垃圾，等待被GC回收。
• 只使用一次的对象可以通过匿名对象的方式完成，这一点在以后的开发中将经常使用到。

package com.kaikeba.demo2;
 
public class Demo7 {
    
    
 
	/**
	 * 匿名	:	没有名字(没有对象名 没有引用名，所以栈中无相关记录，故只能使用一次)
	 */
	public static void main(String[] args) {
    
    
		int num = new Math2().sum(100, 200);	// 没有给对象名称 而是直接新建对象并使用方法
		System.out.println(num);
	}
}
 
class Math2{
    
    
	
	int sum(int x,int y) {
    
    
		return x+y;
	}
}

每次new都是在堆中创建了一个新的内存区：

总结

实不相瞒，我觉得面向对象纯看文字概念有些难理解，需要在脑海里构想一幅面向对象的场景，这样就使得抽象的概念变着简单化。

总之，不管怎样都得有扎实基础才能胜任接下来面向对象进阶和高阶的学习，稳扎稳打，各位加油~

（ps：接下来还会不断更新面向对象进阶和高阶的知识，敬请期待~）