JavaSE学习----（四）面向对象 深度解析

面向对象

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

（Java语言的核心机制，最重要的内容，Java语言的特色就是面向对象编程）

• 面向过程:主要关注的点是，实现具体过程，因果关系。
  优点：对于业务逻辑比较简单的程序，可以达到快速开发，前期投入成本低。
  缺点：采用面向过程的方式开发很难解决非常复杂的业务逻辑，另外面向过程的方式导致软件元素之间“耦合度”非常高，只要其中一环出问题，整个系统受到影响，导致最终软件扩展力差。另外，由于没有独立体的概念，所以无法达到组件复用。
• 面向对象：主要关注对象【独立体】能完成哪些功能
  优点：耦合度低，扩展力强，更容易解决现实世界当中更复杂的业务逻辑，组件复用能力强。
  缺点：前期投入成本较高，需要进行独立体的抽取，大量的系统分析设计。
  注：c语言是纯面向对象的，c++是半面向对象，java是纯面向对象。
  现在出现的新一些编程语言多数是面向对象的，人在认识世界的时候以面向对象得到方式，因为面向对象更符合人的思维方式。

2.面向对象的三大特征

• 封装
• 继承
• 多态
  所有面向对象编程的语言都具有这三大特性。
   
  采用面向对象的方式开发一个软件，生命周期中：
  面向对象的分析：OOA
  面向对象的设计：OOD
  面向对象的编程：OOP
  【整个生命周期中贯穿使用OO面向对象的方式】

3.类和对象的概念

(1)什么是类？

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

(2)什么是对象？

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

(3)描述一下整个软件的开发过程

1.程序员先观察现实世界，从现实世界当中寻找对象。
2.寻找了N个对象之后，发现所有的对象都有共同特征。
3.程序员在大脑中形成了一个模板【类】。
4.java程序员可以通过java代码来表述一个类。
5.Java程序中有了类的定义。
6.然后通过类就可以创建对象。
7.有了对象之后就可以让对象协作起来形成一个系统。

(4)具体说明

• 类—实例化–>对象
  对象又被称为实例

• 对象—抽象–>类

• 重点：类描述的是对象的共同特征，共同特征例如：身高特征，这个身高特征在访问的时候，必须先创建对象，通过对象区访问这个特征，因为这个特征具体到某个对象上之后，值不同，有的对象身高180，有的对象身高280。

• 一个类主要描述什么信息呢？
  一个类主要描述的是： 状态加动作
  状态信息：名字、身高、体重、性别、年龄
  动作信息： 吃、唱歌、学习、跳舞

• 状态—>一个类的属性

• 动作—>一个类的方法

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

4.类的定义

【从这里开始编写代码】

• 语法结构:
  [修饰符列表]  class 类名{
       属性；
       方法；
  }

eg:学生类，描述学生对象的共同特征：

学生对象有哪些状态信息：

• 学号（int）
• 名字（string）
• 性别（boolean）
• 年龄（int）【年龄是一个属性，年龄也是一个数据，是数据就应该有数据类型】
• 住址（string）

学生对象有哪些动作信息：

• 吃饭
• 睡觉
• 学习
• 玩
• …

重点：属性通常是采用一个变量的形式来完成定义的，Java语言中所有class都是引用数据类型，不属于基本数据类型

例子一：

/*
定义一个类，类名student
student是一个类，代表了所有的学生对象，是一个学生模板
*/
public class student//定义一个公开的类，起名为student
{
		//属性【描述的是对象的状态信息】
		//属性通常采用变量的方式来定义
		//在类体中，方法体之外定义的变量被称为“成员变量”
		//成员变量没有赋值，系统默认赋值，详细见之前笔记--一切向0看齐
		//学号
		int no;
		//姓名
		string name;
		//年龄
		int age;
		//性别
		boolean sex;
		//住址
		string address;
		
		//方法
		//方法描述的是对象得的动作信息
		//当前例子就只描述属性了，不描述方法。

} 

5.对象的创建和使用

例子二：

/*
学生类
学生类是一个模板
描述了所有学生的共同特征【状态＋行为】
当前类只描述学生的状态信息
*/
public class student 
{
	int no;
	String name;
	int age;
	boolean sex;
	String addr;
}

/*
对象的创建与使用
*/
public class Test01
{
	public static void main (String[] args)
	{
		//int 是基本数据类型
		//i 是一个变量名
		//10是一个int类型的字面值
		int i = 10;

		//通过一个类可以实例化N个对象
		//实例化对象的语法： new 类名（）；
		//new是java语言中的一个运算符
		//new运算符的作用是创建对象，在JVM堆内存中开辟新的内存空间
		//方法区内存：在类加载的时候，class字节码代码片段被加载到该内存空间中
		//栈内存（局部变量）：方法代码片段执行的时候，会给该方法分配内存空间，在栈内存中压栈
		//堆内存：new对象在堆内存中存储
		//student是一个引用数据类型
		//s是一个变量名
		//new Student（）是一个学生对象
		//s是一个局部变量【在栈内存中存储】
		student s = new Student();
	}
}

注意：什么是对象？ new运算符在堆内存中开辟的内存空间
   什么是引用？ 引用是一个变量，只不过这个变量中保存了另一个java对象的内存地址
java语言中，程序员不能直接操作堆内存，java中没有指针，不像c语言。
java语言中，程序员只能通过“引用”去访问堆内存中对象内部的实例变量
访问实例变量的语法格式：
  读取数据：引用.变量名；
  修改数据：引用.变量名 = 值；

 
例子三：(接例二)
（1）读取数据

      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); 
	System.out.println("学号="+s.name); 
	System.out.println("学号="+s.age); 
	System.out.println("学号="+s.sex); 
	System.out.println("学号="+s.addr); 

(2)修改数据

			s.no = 10;
			s.name = "jack";
			s.age = 20;
			s.sex = true;
			s.addr = "福建";


	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); //北京

例子四：

//用户类
public class User
{
		int no;
		String name;
		//Address是一种引用数据类型：代表家庭住址
		//addr是一个实例变量
		//addr是一个引用
		Address addr;
}

//家庭住址类
public class Address
{
	//String 是一种数据类型，city是一个变量名，属于实例变量
	//city是一个引用：保存内存地址的一个变量，该变量保存内存地址指向了堆内存当中的对象
	String city;
	//街道
	String street;
	//邮编
	String zipocde;
	 
}

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

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

				//修改User对象内部实例变量的值
				u.no = 110;
				u.name = "jack";
				u.addr = new Address();
		}
}

例子五：夫妻

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

}

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

//测试类
public  class Test03
{
		public static void main(String[] args)
		{
				Husband xiaoming  = new Husband();
				xiaming.name = "小明";
				
				//创建一个妻子对象
				Wife.xiaohong  = Wife();
				xiaohong.name = "小红";
				
				//结婚【能通过丈夫找到妻子，也能通过妻子找到丈夫】
				xiaoming.w = xiaohong;
				xiaohong.h = xiaoming;
				
				//得到以上小明的妻子的名字
				//这种方式只能证明是妻子，只找到名字
				System.out.println(xiaoming.name +"的妻子叫做："+xiaohong.name);
				//与关系对应
				System.out.println(xiaoming.name +"的妻子叫做：" +xiaoming.w.name);

		}


}

6.JVM详解

1.JVM（java虚拟机）主要包括三块内存空间，分别是：栈内存、堆内存、方法区内存
2.堆内存和方法区内存各有一个，一个线程一个栈内存。
3.方法调用的时候，该方法所需要的内存空间在栈内存中分配，称为压栈。方法执行结束后，该方法所属的内存空间释放，称为弹栈。
4.栈中主要储存的是方法体中的局部变量。
5.方法的代码片段以及整个类的代码片段都被储存到方法区内存中，在类加载的时候这些代码片段会载入。
6.在程序执行过程中使用new运算符创建的java对象，存储在堆内存当中，对象内部有实例变量，所以实例变量存储在堆内存当中。
7.变量分类：

• 局部变量【方法体中声明】

• 成员变量【方法体外声明】

  • 实例变量【前面修饰符没有static】
  • 静态变量【前面修饰符有static】

8.静态变量存储在方法区内存当中
9.三块内存当中变化最频繁的是栈内存，最先有数据的是方法区内存，垃圾回收器主要针对的是堆内存。
10.垃圾回收器（自动垃圾回收机制，GC机制）什么时候会考虑将某个java对象的内存回收呢？

• 当堆内存当中的java对象成为垃圾的时候，垃圾回收器回收

什么时候堆内存中的java对象会变成垃圾呢？

• 没有更多引用指向它的时候
• 这个对象无法被访问，因为访问对象只能通过引用的方式访问

著名异常：空指针异常

//测试程序
public class Test04
{
		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);
		}
}

实例相关的数据表示：这个数据访问的时候必须有对象的参与，数据就是实例相关的数据