java面向对象(含内存分析图)

下一篇持续更新中… 纯手敲，如有错误欢迎指正！！！

哈喽大家！！今天来写文章讲一下java语言的核心机制，最重要的内容：面向对象，也是java语言的特色。

新来的小伙伴可以先关注一手，以后慢慢看
如果文章对你有帮助的话，可否点个赞支持一下 ~ 你的支持就是我最大的动力 ~~（手动狗头

面向过程和面向对象的区别

1. 面向过程：
   主要关注点是：实现的具体过程，因果关系【集成显卡的开发思路】

• 优点：对于业务逻辑比较简单的程序，可以达到快速开发，前期投入成本较低。
• 缺点：采用面向过程的方式开发，很难解决非常复杂的业务逻辑，另外，面向过程的方式导致软件元素之间的 “ 耦合度 ” 非常高，只要其中一环出问题，整个系统受到影响，导致最终的软件 “ 扩展力 ” 差。另外，由于没有独立体的概念，所以无法达到组件复用。

2. 面向对象：主要关注点是：主要关注对象【独立体】能完成哪些功能【独立显卡的开发思路】

• 优点：耦合度低，扩展力强，更容易解决现实世界当中更复杂的业务逻辑。组件复用性强
• 缺点：前期投入成本较高，需要进行独立体的抽取，大量的系统分析与设计

3. c语言是纯面向过程的； c++半面向对象；Java纯面向对象
4. 现在出现的一些新的编程语言，多数都是面向对象的。人在认识现实世界的时候，以面向对象的方式。
5. 面向对象更符合人的思维方式。

面向对象的三大特征

【以后说】

• 封装
• 继承
• 多态

所有面向对象的编程语言都有这三大特征

采用面向对象的方式开发一个软件生命周期当中：【整个生命周期中贯穿使用oo面向对象方式】

• 面向对象的分析：OOA
• 面向对象的设计：OOD
• 面向对象的编程：OOP

类和对象的概念

1. 什么是类？

• 类在现实世界当中是不存在的，是一个模板，是一个概念，是人类大脑思考抽象的结果
• 类，代表了一类事物
• 在现实世界当中，对象A与对象B之间具有共同特征，进行抽象，总结出一个模板，这个模板被称为类

2. 什么是对象？

• 对象是实际存在的个体。现实世界当中实际存在。

3. 描述一下整个软件开发的过程：

• 程序员先观察现实世界，从现实世界当中寻找对象

• 寻找了N多个对象之后，发现所有的对象都有共同特征

• 程序员在大脑中形成了一个模板【类】

• java程序员可以通过Java代码来表述一个类

• Java程序中有了类的定义

• 然后通过类就可以创建对象

• 有了对象之后，可以让对象直接协作起来，形成一个系统

  • 类----【实例化】---->对象

  • 对象又被称为实例 / instance

  • 对象----【抽象】---->类

  • 重点：
    类描述的是对象的共同特征，共同特征例如：身高特征

    这个身高特征在访问的时候必须先创建对象，通过对象去访问这个特征，因为这个特征具体到某个对象上之后，值不同，有的对象身高1.80，有的对象身高2.80。

	类{
			属性;//描述对象的状态信息
			方法;//描述对象的动作信息
		}

注意：状态和动作等具体到某个对象上之后，发现最终的结果可能不一样，对象和对象之间有共同特征，具体到对象之后有数据的差异。

类的定义【从这里开始编写代码】

//语法结构
[修饰符列表] class 类名{
	属性;
	方法;
}

一个类主要描述的信息是： 状态 + 动作
状态信息：名字、身高、性别、年龄
动作信息：吃、唱歌、跳舞、学习
状态---->一个类的属性
动作---->一个类的方法

---

属性通常采用一个变量的形式来完成定义的，储存数据采用变量的形式。

那么既然是变量，变量肯定有数据类型

Java语言中包括两种数据类型：
1.基本数据类型
byte
short
int
long
float
double
boolean
char
2.引用数据类型
String.class SUN提供的
System.class SUN提供的
Student.class 程序员自定义的
User.class 程序员自定义的
Product.class 程序员自定义的
Customer.class 程序员自定义的
… …
String username = “zhangsan”;
int age = 10;
Student s = ???;

---

举个栗子 1 ：

学生类：描述所有学生对象的共同特征：

• 学生对象有哪些状态信息
  • 学号【int】int no;
  • 名字【String】String name;
  • 性别【boolean】boolean sex;
  • 年龄【int】int age;【年龄是一个属性，年龄是一个数据，是数据就应该有数据类型】
  • 住址【String】String address;
• 学生对象有哪些动作信息
  • 吃饭
  • 睡觉
  • 学习
  • 玩儿
  • 唱歌
  • 跳舞

// Student是一个类，代表了所有的学生对象，是一个学生模板
//学生类
public class Student//定义一个公开的类起名 Student
{
	//类体 = 属性 + 方法

	//所有学生都有学号信息，但是每一个学生的学号都是不同的
	//所以要访问这个学号，必须先创建对象，通过对象去访问学号信息
	//学号信息不能直接通过类去访问，所以这种成员变量又被叫做实例变量
	//对象又被称为实例，实例变量又被称为对象变量【对象级别的变量】
	//不创建对象，这个no变量的内存空间是不存在的
	//只有创建了对象，这个no变量，内存空间才会创建。
	
	//学号
	int no;

	//姓名
	String name;
	
	//性别
	boolean sex;
	
	//年龄
	int age;
	
	//住址
	String address;

	//在类体当中，方法体之外定义的变量被称为 “ 成员变量 ” 
	//成员变量没有手动赋值的话，系统赋默认值：一切向0看齐
	//默认值
	/*
		数据类型						默认值
	------------------------------------------
		byte,short,int,long				0
		float,double					0.0
		boolean							false
		char							\u0000
		引用数据类型						null
	*/

	//方法
	//方法描述的是对象的动作信息
	//当前例子就只描述属性了，不描述方法
}

再举个栗子 2 ：

观察现实世界当中超市中的商品，发现这所有的商品都有一些共同的特征。例如每一个商品都有编号，每一个商品都有单价。所以定义以下的类来表示所有的商品。

public class Product
{
	//编号【通常是一个数字，而且该数字的通常是整数型的】
	//productNo是基本数据类型
	int productNo;

	//单价【通常是一个数字，但是数字可能带有小数，所以采用浮点型数据double表示】
	//price是基本数据类型
	double price;
}

定义一个汽车类：
* 购买的总价浮点型数据
* 品牌字符串
* 颜色，字符串
* 号牌字符串

public class Car
{
	//属性【成员变量之；实例变量】

	//总价
	//基本数据类型
	double price

	//品牌
	//引用数据类型
	String brand;
	
	//颜色
	//引用数据类型
	String color;
	
	//号牌
	//引用数据类型
	String plate;
}

对象的创建和使用

• 通过一个类可以实例化N个对象
• 实例化对象的语法：new + 空格 + 类名();

new是Java语言当中的一个运算符，new运算符的作用是创建对象，在JVM堆内存当中开辟新的内存空间

JVM中划分了三块主要的内存空间：
1.方法区内存：在类加载的时候，class字节码代码片段被加载到该内存空间当中
2.栈内存（局部变量）：方法区代码片段执行的时候会给该方法分配内存空间，在栈内存中压栈
3.堆内存：new的对象在堆内存中存储，成员变量中的实例变量在堆内存的Java对象内部存储

• 访问实例变量的语法格式
  • 读取数据：引用.变量名
  • 修改数据：引用.变量名 = 值

测试 1（含内存分析图） ：

/*
对象的创建和使用？
*/
public class OOTest01
{
	public static void main(String[] args){
	
		//Student是一个引用数据类型
		//s是一个变量名//s是一个局部变量【在栈内存中存储】
		//new Student()是一个学生对象
		//什么是对象？ new运算符在堆内存中开辟的内存空间称为对象
		//什么是引用？引用是一个变量，只不过这个变量中保存了另一个Java对象的内存地址
		//Java语言当中，程序员不能直接操作堆内存。Java中没有指针，不像C语言。
		//java语言当中，程序员只能通过 “ 引用 ” 去访问堆内存当中的对象内部的实例变量
		
		Student s = new Student();

		int stuNo = s.no;
		String stuName = s.name;
		int stuAge = s.age;
		boolean stuSex = s.sex;
		String stuAddr = s.addr;

		System.out.println("学号 = " + stuNo);//0
		System.out.println("姓名 = " + stuName);//null
		System.out.println("年龄 = " + stuAge);//0
		System.out.println("性别 = " + stuSex);//false
		System.out.println("地址 = " + stuAddr);//null

		System.out.println("学号 = " + s.no);//0
		System.out.println("姓名 = " + s.name);//null
		System.out.println("年龄 = " + s.age);//0
		System.out.println("性别 = " + s.sex);//false
		System.out.println("地址 = " + s.addr);//null

		s.no = 10;
		s.name = "jack";
		s.age = 20;
		s.sex = true;
		s.addr = "BeiJing";
		
		System.out.println("学号 = " + s.no);//10
		System.out.println("姓名 = " + s.name);//jack
		System.out.println("年龄 = " + s.age);//20
		System.out.println("性别 = " + s.sex);//true
		System.out.println("地址 = " + s.addr);//BeiJing

		//再通过类实例画一个全新的对象
		//stu这是一个引用，同时也是一个局部变量
		//Student是变量的数据类型
		Student stu = new Student();
		
		//实例变量是一个对象一份，100个对象有100份
		System.out.println("学号 = " + s.no);//0
		System.out.println("姓名 = " + s.name);//null
		System.out.println("年龄 = " + s.age);//0
		System.out.println("性别 = " + s.sex);//false
		System.out.println("地址 = " + s.addr);//null

		//编译报错。no这个实例变量不能直接采用 “ 类名 ” 的方式访问
		//因为是no实例变量，对象级别的变量，变量存储在java对象的内部必须先有对象
		//通过对象才能访问no这个实例变量不能直接通过 “ 类名 ” 访问
		//System.out.println(Student.no);
	}
}

测试 2 （含内存分析图）：

//家庭住址类
public class Address
{
	//属性【成员变量之实例变量】
	//城市
	// String是一种引用数据类型，city是一个变量名，属于实例变量
	//city是一个引用：保存内存地址的一个变量，该变量保存内存地址指向了堆内存当中的对象
	
	//城市
	String city;

	//街道
	String street;
	
	//邮编
	String zipcode;
}

//用户类
public class User
{
	//属性
	
	//用户编号
	// int是一种基本数据类型：整数型
	//no是一个实例变量
	int no;
	
	//用户名
	// String是一种引用数据类型：代表字符串
	//name是一个实例变量
	//name是一个引用
	String name;
	
	//家庭住址
	// Address是一种引用数据类型：代表家庭住址
	//addr是一个实例变量
	//addr是一个引用
	String addr;
}

//测试类
public class OOTest02
{
	public static void main(String[] args){
		
		//创建User对象
		//u是局部变量，u是一个引用
		//u保存的内存地址指向堆内存的User对象		
		User u = new User();

		//输出User对象内部实例变量的值
		System.out.println(u.no);//0
		System.out.println(u.name);//null
		System.out.println(u.addr);//null

		//修改User对象内部实例变量的值
		u.no = 110;
		u.name = "jack";//"jack"是一个Java对象，属于String对象
		u.addr = new Address();

		//在main方法当中，目前只能看到一个引用 “ u ”
		//一切都是只能通过 “ u ” 来进行访问
		System.out.println(u.name + "居住在哪个城市" + u.addr.city);
		System.out.println(u.name + "居住在哪个街道" + u.addr.street);
		System.out.println(u.name + "邮编" + u.addr.zipcode);

		u.addr.city = "北京";
		u.addr.street = "朝阳";
		u.addr.zipcode = "111111";
	}
}

测试 3 （含内存分析图）：

public class OOTest03
{
	public static void main(String[] args){
		
		//引用
		//u是局部变量
		User u = new User();

		//上一个版本中编写的
		//u.addr = new Address();

		//a是引用
		//a是局部变量
		Address a = new Address();
		u.addr = a;

		System.out.println(u.addr.city);//null

		a.city = "天津";

		System.out.println(a.addr.city);//天津		
	}
}

测试 4 （含内存分析图）：

//丈夫类
public class Husband
{
	//姓名
	String name;
	
	//丈夫对象当中含有妻子引用
	Wife w;
}

//妻子类
public class Wife
{
	//姓名
	String name;

	//妻子对象当中含有丈夫引用
	Huaband b;	
}

public class OOTest04
{
	public static void main(String[] args){
		//创建一个丈夫对象
		Husband xiaoming = new Husband();
		xiaoming.name = "小明";
		
		//创建一个妻子对象
		Wife baby = new Wife();
		baby.name = "小红";
		
		//结婚【能通过丈夫找到妻子，通过妻子也可以找到丈夫】

		xiaoming.w = baby;
		baby.h = xiaoming;

		//得到以上小明的妻子的名字
		System.out.println(xiaoming + "的妻子的名字是：" + xiaoming.w.name);
		System.out.println(xiaoming + "的妻子的名字是：" + baby.name);
	}
}

对象创建和使用----JVM内存分析总结图

测试 5 （含内存分析图）：

//顾客类
public class Customer
{
	//id
	int id;
}

//测试程序
public class OOTest05
{
	public static void main(String[] args){
		
		Customer c = new Customer();
		System.out.println(c.id);//0

		c = null;

		//以下程序编译可以通过，因为符合语法
		//运行时出现空指针异常
		//空引用访问 “ 实例 ” 相关的数据一定会出现空指针异常
		//java.lang.NullPointerException
		System.out.println(c.id);
	}
}
// " 实例 " 相关的数据表示：这个数据访问的时候，必须有对象的参与。这种数据就是实例相关的数据。

练习题（附答案）：

/*
	需求：
	
	定义一个计算机类【电脑/笔记本】，计算机类有以下属性：
		* 品牌
		* 型号
		* 颜色
	
	定义一个学生类，学生类有以下属性：
		* 学号
		* 姓名
		* 学生有一台笔记本电脑
	
	请编写程序来表示以上的类，然后分别将类创建为对象。
	对象数量不变，然后让其中的一个学生去使用其中的一台笔记本电脑

	然后编译并运行，并且将整个执行过程采用图形的方式描述出来

	所有的代码全部写到当前java源文件当中
	
*/

//计算机类
public class Computer
{
	String brand;
	String style;
	String color;
}

//学生类
public class Student
{
	int no;
	String name;
	Computer laptop;
}

//测试类
public class OOTest06
{
	public static void main(String[] args){
		
		//创建笔记本电脑对象
		Computer notepad = new Computer;
		
		//不采用系统默认值，手动赋值
		notepad.brand = "联想";
		notepad.style = "C023";
		notepad.color = "black";
		
		//创建学生对象
		Student zhangsan = new Student();
		
		//不采用系统默认值，手动赋值
		zhangsan.no = 123;
		zhangsan.name = "张三";
		
		//让这个学生和笔记本对象产生关系【通过学生能找到他的笔记本电脑】
		zhangsan.laptop = notepad;
		
		//想知道张三的笔记本的品牌
		System.out.println(zhangsan.name + "的笔记本的品牌" + zhangsan.laptop.brand);//联想

		//修改品牌
		zhangsan.laptop.brand = "Apple";

		System.out.println(zhangsan.notepad.brand);//Apple

		//张三又买了一台新的电脑，原先的电脑扔了
		zhangsan.laptop = new Computer();
		System.out.println(zhangsan.notepad.brand);//null
	}
}

注意：

每一个类中都可以编写主方法。但是一般情况下，一个系统只有一个入口，所以主方法一般写一个。

public class Product
{
	//实例变量
	int productNo;
	double price;
}

public class ProductTest
{
	//程序入口
	public static void main(String[] args){
		
		//创建对象，商品对象
		//ipnone15变量中保存内存地址。指向堆内存当中的商品对象
		Product iphone15 = new Product();

		//访问实例变量的语法：引用.变量名
		System.out.println("商品的编号：" + iphone15.productNo);
		System.out.println("商品的编号：" + iphone15.price);
	}
}

持续更新中！！
如果对你有帮助的话，可以点个大大的赞支持楼主以下吗~~（手动狗头
你的支持就是我最大的动力！~