【探索Java世界01】面向对象编程思想

一、什么是面向对象？

• 面向过程的编程思想

	解决问题的时候按照一定的过程（流程）
	钟点工--->大象装冰箱 总共分几步
	1、开门 2、大象装冰箱 3、关门
	以过程为本--复用--增加了很多冗余
	大段的过程 拆分为小段 ---到底哪一个实体来做的

• 面向对象的编程思想

	解决问题的时候按照现实生活中的规律来考虑问题
	考虑在这个问题的过程中 有几个实体参与进来
	理解为 实体动作的支配者 没有实体动作就发生不了
	人 冰箱 大象
	分析每一类个体都有什么特点 做了哪些事情
	大象 特点：大 体重很重
	冰箱 特点：有门 容积
	人   特点：能做事 做了那些事情？开冰箱门 装大象 关门

二、面向对象的方法设计

1.类和对象

类—一个抽象笼统的概念
​ 具有一组相同特征或行为

属性---静态描述类的特征
权限修饰符 [特征修饰符] 属性类型 属性名字[=值]

方法---动态描述类的行为
权限修饰符 [特征修饰符] 返回值类型 方法名字 (参数列表) [抛出异常] [{
	方法执行体
}]

2.overload—方法重载

• 概念

	一个类中的一组方法 相同的方法名字 不同的参数列表 这样的一组方法构成了方法重载
	参数列表不同：参数的个数不同 参数的类型不同 参数的顺序不同

• 作用

	为了让使用者便于记忆与调用 只需要记录一个名字 执行不同的操作

• JDK1.5版本之后出现了一个新的写法

	int... x 动态参数列表 类型固定 个数可以动态：0-n都可以
	x本质上就是一个数组 有length属性 有[index]
	动态参数列表的方法 不能 与形同意义的数组类型的方法构成方法重载 本质是一样的
	动态参数列表的方法 可以不传参数 相当于0个
	数组的方法必须传递参数
	动态参数列表在方法的参数中只能存在一份，且必须放置在方法参数的末尾

3.类中的第三个成员

• 构造方法—做事情

	a)作用：只有一个构建（构造）当前类的对象
	b)写法：权限修饰符 与类名一致的方法名（参数列表） [抛出异常]{
	 		一件事情 创建一个对象（当前类）
	 		返回对象；
	 	}
	c)用法：通过new关键字调用
	d)特点：每一个类都有构造方法，若自己在类中没有定义，系统会默认提供一个无参数的构造方法
		若类 中自己定义了构造方法，则默认无参数的构造方法即被覆盖
		存在构造方法重载
	e)每一个类都有构造方法

• 若不定义系统会默认提供构造方法

• 在创建对象时，需要初始化一些变量属性，默认构造方法是不会做，需要自己定义构造方法

4.类的第四个成员----程序块（代码块）

• 作用：跟普通方法一样 做事情
• 写法：{}
• 用法：块也需要调用才能执行，我们自己调用不到（没有名字）
  每一次我们调用构造方法之前，系统会帮我们自动调用一次程序块，让他执行一遍
• 特点：不存在重载的概念
  可以在类中定义多个程序块
• 块可以在里面写一些程序 我想要在创建对象之前做一些事情

5.this关键字的使用（在构造方法中属性与变量重名，必须需要一个代替词代替队象）

• this是一个关键字（代指）代替的是某一个对象（当前调用属性或方法时的那个对象）

• this既然代替的是一个对象

	this可以调用属性、方法，可以放置在类中的任何成员位置上
	this可以调用构造方法，在一个构造方法内可以调用另一个构造方法
	{通过this(); 调用，省略了构造方法的名字（必须在另一个构造方法中调用，必须是程序的第一行）}
	构造方法一般是有顺序的，一般构造方法早于一般方法
	在一般方法中不能调用构造方法

6.nextLine方法与nextInt方法的区别

	1) nextLine方法会以回车符作为截止，将回车符连同之前的所有字符都读取出来，将回车符扔掉，把之前的所有字符组合成一个完整的字符串交还给我们。
	2) nextInt方法会以回车符作为截止，将回车符连同之前的所有字符都读取出来，回车符留在队列中

三、Java面向对象的三大特征

• java面向对象的三大特征

	继承 封装 多态

• 多态

	同一个对象体现出来的多种不同形态（身份），将一种行为表现出不同的效果
		要想实现多态的效果，需要先有继承关系
	体现：
		1、父类类型的引用指向子类的对象
			Person p = new Teacher();
		2、该引用只能调用父类中定义的属性或方法
		3、如果子类中将父类的方法重写，那么调取方法后执行的结果是子类重写之后的那个果
			如果父类与子类有同名的属性，执行父类的属性
			如果父类与子类有同名的方法（重载），则执行子类重写之后的方法
		4、若想调用子类中独有的成员
			强制类型转换 造型（向上/向下转型）
		5、造型时（强制向下转型时）可能会出现一个运行时异常
			ClassCastException 造型异常
			如果想要避免造型的异常，可以使用instanceof关键字来进行判断
 			对象 instanceof 类

• 封装

	Java的封装是一种面向对象编程的特性，它通过将数据和方法封装在类中，对外部隐藏内部实现的细节，只提供公共的操作方法来访问和修改数据。封装可以确保数据的安全性和一致	性，并且可以隐藏内部实现的细节，方便代码的维护和重用。

• 继承

  1) 子类继承父类，通过关键字 extends
  2) 子类的对象可以调用父类中的（public protected）属性和方法 当做自己的来用
  3) 子类可以添加自己独有的属性和方法的
  4) 子类从父类中继承过来的方法不能满足子类需要，可以在子类中重写（覆盖）父类的方法 		
  更多指的是内容
  5) 每一个类都有继承类，如果不写extends关键字，默认继承object,如果写了extends则		
  继承后面的那个父,可以理解object类是任何一个引用类型的父类（直接或间接继承object）,object类没有父	类
  6) java中继承是单个存在（单继承）每一个类只能有一个继承类（extends关键字后面只能写一个类）
  可以通过传递的方式实现多继承的效果,后续还会有实现（接口）
  7) 继承在内存中的存储形式
  8) 关于this和super的使用
  		this和super都是指代词，代替的是对象
  		this代替的是当前执行方法时的那个对象，不一定是当前类的
  		super代替的是当前执行方法时的对象的父类对象 空间内部的那个
  		都能调用一般属性和方法
  		可以放置在类成员的任何位置（属性 方法 构造块）
  		注意调用一般方法的时候来回调用（写法 编译时可以）执行时可能产生问题			  （StackOverFlowError）
  		可以调用构造方法（放在构造方法的第一行）
  		this和super在构造方法中调用另一个类的构造方法不能同时出现在第一行
  		构造方法之间不能相互调用

四、内部类

• 概述

	指的是在java中可以将一个类定义在另一个类的内部
	内部类可以定义在：类的内部（与类成员层次一致）
	内部类可以定义在：方法/块内部（与类成员相差一个层次，方法的局部变量一个层次）

• 成员内部类

	将一个类直接定义在类的里面，作为成员，与属性或方法层次一致
	成员内部类可以与正常类一样，使用不同的修饰符来修饰
	好处：a)省略一个.java文件
	     b)成员内部类中可以访问外部类的所有成员，包括私有的
	若想要在内部类中通过对象.调用外部类成员 外部类名字.this.外部类成员

• 局部内部类

	将一个类定义在方法/块里面，作为成员的内部结构，与临时的局部变量一个层次
	局部内部类像是一个局部变量一样，不能用public,protected,private,static修饰
	只能用abstract或final修饰
	局部内部类使用的变量只能是final修饰

• 匿名内部类

	成员匿名内部类和局部匿名内部类
	public interfase Test{
		public void test();
	}
	Test t = new Test(){
		public void test(){
		}
	}
	通常接口或抽象类的具体子类这样写
	开发中为了省略一个类文件，比较常见
	匿名内部类很特殊，只要类体，没有类的所有结构（修饰符 名字 继承 实现）
	不能用任何修饰符来修饰，匿名内部类也没有构造方法
	例如：Swing 做一个按钮 绑定一个事件监听器

• 静态内部类

	成员静态内部类
	不需要外部类对象，通过正常的方式直接创建内部类
	静态元素不能访问非静态成员（自己类和外部类都不可以）

五、Java类与类之间关系

1.类与类之间的关系

​ A is-a B 泛化（继承 实现）
​ A has-a B 包含（组合 聚合 关联）
​ A use-a B 依赖（need-a）

• has-a 包含关系（组合 聚合 关联）

	组合-->人和大脑 人和心脏
		整体和部分的关系，不可分割，要出现都出现，要消亡都消亡
	聚合-->汽车和轮子 电脑和主板
		整体和部分的关系，创建时有可能是分开的
	关联-->人有汽车 人有电脑
		整体和部分的关系，可以分割，后来形成一起的
	
	从java程序来描述这样的关系：通过一个类的对象当做另一个类的属性来存储

• use-a（need-a） 依赖关系 （最常见最常用）

	屠夫 杀 猪
		不是整体和部分关系，某一件事情产生了关系
		临时组合在一起的，这件事一旦做完关系即解散

	java程序体现的形式：一个类的方法中使用到了另一个类的对象
	第一个可以在方法中传递参数
	第二个可以在方法中自己创建

	注意：设计类的关系遵循的原则：高内聚低耦合
		 耦合度：紧密 继承（实现）>组合>依赖

2.Object类中方法

• object类中的常用方法

		hashCode()	将对象在内存中的地址经过计算得到一个int整数
		equals()	用来比较两个对象的内容 Object默认效果是==
		toString()	打印输出时将对象变成string字符串
		getClass()	获取对象对应类的类映射（反射）
		wait()		线程进入挂起等待状态 存在方法重载
		notify()	线程唤醒
		notifyAll()	唤醒所有
		finalize()	权限修饰符protected 在对象被GC回收的时候，默认调用执行方法
		clone()		权限修饰符protected 为了克隆对象

3.重写（override）与重载（overload）

			 方法重写override		  方法重载overload
	1、类	    产生两个继承关系的类	     一个类中的一组方法
			 子类重写父类的方法
	2、权限   子类可以大于等于父类	    没有要求
	3、特征   final static abstract   没有要求
		父类方法是final	子类不能重写
		父类方法是static 子类不存在
		父类方法是abstract 子类必须重写（子类是具体必须重写 否则子类是抽象类 可以不重写）
	4、返回值  子类小于等于父类	         没有要求
	5、名字	子类与父类一致		      一个类中的好多方法名必须一致	
	6、参数	子类与父类一致		      每一个方法的参数必须不一致
	7、异常	运行时 编译时		       没有要求
		a)父类方法抛出运行时异常
		  子类可以不予理会
		b)父类方法抛出编译时异常
		  子类抛出异常的个数少于等于父类
		  子类抛出异常的类型小于等于父类
	8、方法体 子类的方法内容与父类不一致	  每一个重载的方法执行过程不一致

六、类的修饰符

1.描述一个类

	修饰符 特征 class 类名{
		属性	  权限 特征 类型 名字
		方法	  权限 特征 返回值 名字 参数 异常 执行体
		构造方法  权限 名字 参数 异常 执行体
		程序块	  执行体
	}

2.修饰符

• ​ 权限修饰符：
• ​ public: 公共的
• ​ protected: 受保护的
• ​ 默认不写:默认的
• ​ private:私有的

3.特征修饰符

• ​ final：最终的 不可更改的
• ​ static：静态的
• ​ abstract:抽象的
• ​ native:本地的
• ​ transient:瞬时的 短暂的—>序列化
• ​ synchronized:同步的 线程问题
• ​ volatile:不稳定的

4.权限修饰符

• ​ public: 公共的 同类 同包 子类 当前项目中任意位置只要有对象都可以访问

• ​ protected: 受保护的 同类 同包 子类（通过子类对象在子类范围内部访问）

• ​ 默认不写: 默认的 同类 同包

• ​ private: 私有的 同类

	a)权限修饰符可以修饰 类本身 类中的成员（程序块除外）
	b)权限修饰符用来修饰类的时候只有两个可以用（public 默认不写）
	c)权限修饰符都可以用来修饰类中的其他成员

5.特征修饰符

• final 最终的 不可更改的

  - 	修饰变量
  - 		如果在定义变量时没有赋初始值
  - 		给变量一次机会（因为变量在栈内存空间内没有默认值，如果不给机会，就没法用了）
  - 		一旦变量被存储了一个值，若用final修饰后，则不让再次改变--->相当于常量
  - 		如果修饰的变量是基本数据类型，则变量内的值不让更改---常量
  - 		如果修饰的变量是引用数据类型，则变量内的地址引用不让更改---对象唯一
  - 	修饰属性
  - 		全局变量存储在堆内存的对象空间内一个空间
  - 		属性如果没有赋值，就有默认值存在
  - 		属性用final修饰后，必须给属性赋初值，否则编译报错
  - 		特点与修饰变量一致
  - 		如果修饰的变量是基本数据类型，则变量内的值不让更改---常量
  - 		如果修饰的变量是引用数据类型，则变量内的地址引用不让更改---对象唯一
  - 	修饰方法
  - 		方法是最终的方法，不可更改
  - 		子类继承父类的方法，将父类的方法重写（覆盖）
  - 		final修饰后，要求不可以被子类重写（覆盖）
  - 	修饰类本身
  - 		类是最终的，不可以更改
  - 		此类不可以被其他子类继承
  - 		通常都是一些定义好的工具类（例如：Math Scanner Integer String）

• static 静态的

  - 1、可以修饰：修饰属性 修饰方法 修饰块 修饰类（内部类）
  - 2、特点：
  - ​	静态元素在类加载时就初始化了，创建的非常早，此时没有创建对象
  - ​	静态元素存储在静态元素区中，每一个类有一个自己的区域，与别的类不冲突
  - ​	静态元素只加载一次（只有一份），全部类对象及类本身共享
  - ​	由于静态元素区加载的时候，有可能没有创建对象，可以通过类名字直接访问
  - ​	可以理解为静态元素不属于任何一个对象，属于类的
  - ​	静态元素区GC(Garbage Collectuon)无法管理,可以认为常驻内存
  - ​	非静态成员（堆内存对象里）中可以访问静态成员（静态区里）
  - ​	静态成员中可以访问静态成员（都存在静态区中）
  - ​	静态成员中不可以访问非静态成员（一个出发访问一堆名字相同的东西）
  - ​	静态元素中不可以出现this或super关键字（静态元素属于类的）

• native本地的

  - ​	java源代码中看到native就已经再也看不见后续代码
  - ​	后续会调用其他编程语言c++ c执行内存的操作，帮我们操作内存
  - ​	例如：object类中的一个方法 hashCode

• abstract抽象的----很不具体，没有具体的执行，只是一个概念

  - a)可以修饰
  - 	修饰方法：
  - 	用abstract修饰符修饰的方法，只有方法结构没有方法执行体叫做抽象方法
  - 	修饰类：
  - 	用abstract修饰符修饰的类叫做抽象类
  - b)修饰后有什么特点
  - 	抽象类中不一定必须含有抽象方法
  - 	抽象方法可以放在抽象类中或者接口中
  - c)抽象类的特点
  - 	创建对象：
  - 	抽象类含有构造方法，但是不能通过调用构造方法直接创建对象
  - 	抽象类只能通过子类单继承来做事
  - 	类与类之间的关系：
  - 	抽象类可以直接单继承抽象类
  - 	抽象类可以直接单继承具体类（通常不会出现）
  - 	具体类不可以直接单继承抽象类（必须将父类的抽象方法具体化或子类也变成抽象类才可以）
  - d)当抽象类中只有抽象方法时，类的结构可以将class改为interface修饰叫做接口了
  - 接口（通常是为了定义规则）也是一个类的结构，只不过用interface修饰，替换原有的class
  - 	1、有什么成员：
  - 	属性	不能含有一般属性，只能含有公有的静态的常量 public static final
  - 	方法	不能含有一般方法，只能含有公有的抽象的方法
  - 	块	不能含有一般程序块，也不能含有静态的程序块（块本身就是具体的）
  - 	构造方法 不能含有构造方法
  - 	2、如何使用创建对象:
  - 	不能创建对象，只能通过子类多实现（implements）来做事
  - 	例如：public class A implements B,C{
  - 	
  - 	}
  -  	3.与别的类结构关系
  -  	接口不能继承别的类
  -  	抽象类可以直接多实现接口
  - 	具体类不能直接多实现接口（需要将接口中的抽象方法具体化）
  - 	接口可以直接多继承接口