面向对象【核心】

lwj_07

已于 2022-02-28 18:00:44 修改

阅读量220

点赞数

分类专栏：笔记文章标签： java

于 2022-02-20 19:06:35 首次发布

本文链接：https://blog.csdn.net/lwj_07/article/details/122879433

版权

笔记专栏收录该内容

144 篇文章 18 订阅

订阅专栏

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

-面向对象：主要关注点是：主要关注对象【独立体】能完成哪些功能。
   *优点：耦合度低，扩展力强，更容易解决现实世界中更复杂的业务逻辑，组件复用性强。
   *缺点：前期投入成本较高，需要进行独立的抽取，大量的系统分析与设计。

面向对象的三大特征【先背会】：
- 封装
- 继承
- 多态

采用面向对象的方式开发一个软件，生命周期当中：
   *面向对象的分析 OOA
   *面向对象的设计 OOD
   *面向对象的编程 OOP

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

   *什么是对象：
   -对象是实际存在的个体，现实世界当中实际存在。

   *描述以下整个软件开发的过程：
       *程序员先观察现实世界，从现实世界当中寻找对象。
       *寻找N的对象后，发现所有的对象都具有相同特征。
       *程序员在大脑中形成一个模板【类】
       *java程序员可以通过java代码来表示一个类。
       *java程序中有了类的定义
       *然后通过类就可以创建对象
       *有了对象后，可以让对象直接协作起来形成一个系统。

       *类-----【实例化】----->对象
       *对象又被称为实例
       *对象-----【抽象】----->类

   *重点：
   类描述的是对象的共同特征。
   共同特征如：身高特征。
   这个身高特征在访问的时候，必须先创建对象，通过对象去访问这个特征。【因为特征在具体的对象上值不同】

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

       状态=====> 一个类的属性
       动作=====> 一个类的方法

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

一、类的定义

类的定义
   语法结构：
   【修饰符列表】 class 类名{
       属性;
       方法;
   }

   学生类,描述所有学生对象的共同特征：
       学生对象有哪些状态信息：
           *学号【int】
           *年龄【int】【年龄是一个属性、年龄是一个数据、是数据就会有数据类型】
           *性别【boolean】
           *地址【String】
           *姓名【String】
           ...

       学生对象有哪些动作信息：
           *吃饭
           *睡觉
           *学习
           *玩
           *唱歌
           ...

       重点：属性通常是采用一个变量的形式来完成定义的。
           int no;
           int age;
           boolean sex;
           String addr;
           String name;

       *java语言中包括两种数据类型：
           -基本数据类型
           byte
           short
           int
           long
           float
           double
           boolean
           char
           -引用数据类型
               String.class//SUN公司提供
               System.class//SUN公司提供

               student.class//程序员自定义的
               User.class//程序员自定义的
               Product.class//程序员自定义的
               Customer.class//程序员自定义的
               ...
       -java语言当中所有的class都属于引用数据类型。

代码演示：

//引用数据类型

// 定义一个类，类名student
//student是一个类，代表了所有学生对象，是一个学生模板。
public class student
{	// 定义一个公开的类 起名student

	//     属性【描述对象的状态信息】
	//属性通常采用状态的形式来定义
	//在类体当中，方法体之外定义的变量被称为"成员变量"
	//成员变量没有赋值，系统默认赋值：一切向0看齐
    

	//姓名
	String name;
	//年龄
	int age;
	//学号
	int no;
	//性别
	boolean sex;
	//地址
	String addr;

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

二、对象的创建和使用

//学生类
//学生类是一个模板
//描述了所有学生的共同特征【状态+动作】
//当前类只描述学生的状态信息【属性】

public class Student
{
	//类体 =属性+方法

	//不创建对象，这些变量的内存空间是不存在的，只有创建了对象，这些变量的内存空间才会创建
	int no;
	String name;
	int age;
	String addr;
	boolean sex;
}

/*
	重点：成员变量没有手动赋值的话，系统赋默认值(如上int no... 没有赋值 系统将默认赋值)
	// 默认值
	数据类型				默认值
	-----------------------------------
	byte,short,int,long		0
	float,double			0.0
	boolean					false
	char					\u0000
	引用数据类型			 null

*/

public class OOTest01
{
	public static void main(String[] args){
		
		//int 是基本数据类型
		//i 是一个变量名
		//10 是int类型的字面值
		int i=10;

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

		//什么是对象？ new运算符在堆内存中开辟的内存空间称为对象
		//什么是引用？ 引用是一个变量(例如s),只不过这个变量中保存了另外一个java对象的内存地址
		Student s =new Student();
		
		//访问实例变量的语法格式：
		//	读取数据：引用.变量名
		//	修改数据：引用.变量名 =值
		int stuNO =s.no;
		int stuAge =s.age;
		String stuName =s.name;
		String stuAddr =s.addr;
		boolean stuSex =s.sex;
		System.out.println("学号:"+stuNO);
		System.out.println("年龄："+stuAge);
		System.out.println("姓名："+stuName);
		System.out.println("地址："+stuAddr);
		System.out.println("性别："+stuSex);

		
		// 再通过类实例化一个全新的对象
		//Student stu =new Student();
		
		

	}
}

再实例化一个对象时：

例子2：

创建用户类如下：

// 用户类
public class User
{	//属性
	


	//用户编号
	//int 是一种基本数据类型:整数型
	//no 是一个实例变量
	int no;
	//用户名
	//String 是一种引用数据类型：代表字符串[自我认为：String其实是SUN公司封装好的类名为String的类]
	//name 是一个实例变量
	//name 是一个引用
	String name;
	//用户地址
	//Address 是一个引用数据类型：代表家庭地址
	//【可以认为和String意义相同 只不过String是SUN公司封装好的而Address是自己封装的两者都是引用数据类型】
	//addr是一个实例变量
	//addr 是一个引用
	Address addr;
}

创建城市类如下：

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

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

		// 输出User对象内部实例变量的值
		System.out.println(u.name);
		System.out.println(u.no);
		System.out.println(u.addr);
        
        //修改User对象内部实例变量的值
		u.name ="junker";    //"junker"是一个java对象，属于String对象
		u.no =123;
		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 ="000";
		System.out.println(u.name+"居住在的城市为："+u.addr.city);
		System.out.println(u.name+"居住在的街道为："+u.addr.street);
		System.out.println(u.name+"居住在的邮编为："+u.addr.zipcode);

	}
}

输出结果如下：

思路图如下所示：

例子3：

public class OOTest03
{
	public static void main(String[] args){
		User u =new User();
		Address a =new Address();
		u.addr =a;
		System.out.println(u.name);
		System.out.println(u.no);
		System.out.println(u.addr);

		u.addr.street ="幸福";
		System.out.println(u.addr.street);	// 幸福
		
		a.street ="爱情";
		System.out.println(u.addr.street);	// 爱情
		
	}
}

思路图如下：

例子4：【丈夫和妻子关联关系】

创建丈夫类：

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

创建妻子类：

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

测试如下：

public class OOTest04
{
	public static void main(String[] args){
		
		// 创建一个丈夫对象
		Husband HuiTaiLang =new Husband();
		HuiTaiLang.name ="灰太狼";

		// 创建一个妻子对象
		Wife HongTaiLang =new Wife();
		HongTaiLang.name ="红太狼";

		//结婚【能通过丈夫/妻子找到妻子/丈夫】
		HuiTaiLang.w =HongTaiLang;
		HongTaiLang.h =HuiTaiLang;
		
		System.out.println(HuiTaiLang+"的妻子是："+HuiTaiLang.w.name);
	}
}

思想图如下所示：

关于JVM内存管理

例子5：

车子类：

房子类：【房子名下有主人】

妻子类：

主人类：

代码测试：

=======================================================================

随手一记

public class Husband
{	 
	 
	String idCard;
	String name;
	String birth;	 
	static boolean sex =true;// 男人类 肯定是男
	Wife wife; // 这是是妻子的内存地址  null

	public Husband(){
		
	}

	public Husband(String i,String n,String b){
		idCard =i;
		name =n;
		birth =b;		
	}
}

public class Wife
{
	String idCard;
	String name;
	String birth;
	static boolean sex =false;
	Husband husband;
	
	public Wife(){
		
	}
	public Wife(String i,String n,String b){
		idCard =i;
		name =n;
		birth =b;
	}
	
}