Java面向对象OOP复习

编程语言分类:

低级语言:对机器:汇编,编译器
高级语言:自带编译器
	C语言-->面向过程的语言
	Java-->面向对象
		OOP面向对象编程/只懂技术-->IT民工
		OOA面向对象分析方法/懂很多业务,了解一些技术-->市场人员,销售人员-(需求分析-->模具)
		OOD面向对象程序设计/主要懂技术,懂一些业务-->产品工程师,系统工程师,架构师
	Python-->面向对象
	
	diy-->手枪-->一整块木头刻出来(多个功能在一整块中)
		把手.扳机,枪管...
	diy-->板凳-->一个盖板四条腿组装(模块化开发,标准不统一)
	乐高积木-->手枪-->多块拼接-->修理方便(模块化开发,标准统一)
		把手可变化,扳机可变,枪管可变-->灵活度比较高
		-->一套模具-->生产千千万万统一标准的零件
		各个模块分散组装(把各个功能分别实现)

职业规划:

大数据:数据收集
	数据仓库	-->hive spark
		流式处理 streaming kafka
	ETL	-->可视化开发工具
		做得又快又好13-15K
		干活	10K
	数据清洗	-->定制规则的
		干活
	数据分析	-->涉及一定的算法...对数据结构掌握度高...	20K
		干活
	数据挖掘	-->要求很高算法基础 线性回归,决策树,随机森林

世界是由:静态特征和动态特征组成

抽象—>具体
如:一个人–> 王思聪
分类:本身是具体到抽象的过程(把特征模糊化提取公共特征)
对象:把某个类从抽象到具体的过程(特征清晰化把个性独有的特征赋值)
类与对象的关系:
类是对象的抽象
对象是类的具体实现
静态特征:属性
动态特征:方法
对象由属性和方法组成
例子–>
类名:
书
属性
长20cm
宽12cm
厚1.5cm
名字:从你的全世界路过
作者:张嘉佳
方法
给予知识
//定义对象分配空间
类名 对象名 = new 类名();
//对象属性赋值
对象名.属性= value;
//调用方法
对象名.方法名();
方法调用方法
同一个类内部:void a(){
b();
}
void b(){}
本类可直接调用

 不同类:	
		新建一个类对象,再调用

类图(+代表public访问修饰符)–>可用excel画图
1)类–>类名
2)属性–>+属性名:属性类型
3)方法–>+方法名():方法返回值类型
定义方法
public 返回值类型 方法名(){ -->方法名遵循驼峰命名规则
–>无返回值类型为void
//方法主体 -->若有实际类型,需返回且只能返回一个值–>调用时需要相同类型接收
return ***;
}
例子:

public void show(){
		//代码	-->关心的是方法的内容,里面的代码的执行
	}
	//可直接调用
	public String change(){
		//代码	-->关心的是返回的结果:return之后的东西
		return String类型的数据;
	}
	String a= 对象名.change();	//接收返回值

return 用法

1)return;-->流程控制,直接跳出方法
2)return 值;-->返回值作用

方法的结构:

访问修饰符–>public 公共的
返回值类型–>void 无
具体类型 需要用return返回对应类型数据
方法名(){
方法主体
}

–>方法与方法重载

1.带参方法
<访问修饰符> 返回类型 方法名(类型 形参1,...类型n 形参n){
	//方法主体
		-->参数类型限定传入数据类型,传入参数名不需要一致,但是类型必须一致
			传参时实参不能带类型,且顺序与形参保持一致
}
2.方法重载
	同一个类中方法名相同参数列表不同(参数的个数,类型,顺序),与修饰符和返回类型无关
-->this.代表本类,跟的是成员变量
引用类型传参传递的是地址(注意String上锁了,值一旦被确定不可被改变,只能改变地址的指向 -->public final class String),基本数据类型传值

3.构造方法
	1)无参构造	this()调用无参必须在第一条语句
		作用是在new 对象的时候使用构造方法在内存中开辟空间
		-->每个类都有一个默认无参构造-->继承自Object
		public 类名(){}
	2)带参构造-->若有带参构造,无参构造不再默认,一般情况需手动写出来
		public 类名(属性类型1 属性名1,...,属性类型n 属性名n){
			//用this.属性名1...n=属性名1...n
		}

成员变量与局部变量:

变量声明的位置决定变量作用域
变量作用域(大括号)确定可在程序中按变量名访问该变量的区域
区别:
	1)局部变量的作用域仅限于定义它的方法,成员变量的作用域在整个类内部都是可见的
	2)Java会给成员变量一个初始值,不会给局部变量赋予初始值
	3)同一个类中成员变量和局部变量同名时局部变量具有更高优先级别-->就近原则
	4)同方法中不可有同名局部变量,不同方法中可以有

面向对象的三特性:封装,继承,多态

访问权限控制
private 私有的,本类可访问 //
默认 包级私有,本包可访问
protected 包级私有+子类,本包可访问+非本包子类
public 公共的,整个工程都可访问 //

封装与继承

封装:	将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
	把尽可能多的东西藏起来，对外提供便捷的接口
	原则:隐藏属性,提供对外公共接口
	
	实现封装:
		1)隐藏属性:设为私有化,访问修饰符private
		2)公共接口:
			存:public void setName(String name){this.name=name;}	//不合法输入可在这里判断设为默认值
				可在参数构造中调用该方法判断非法值
			取: public String getName() {  return this.name;}
包
	-->作用:与文件夹类似存放文件方便管理,防止命名冲突,有助于实施权限访问
	
	创建包	1)直接创建包2)创建类时包名.类名
	包名必须声明在第一行(除注释),且只允许有一句
		
	命名规范:
		包名由小写字母组成，不能以圆点开头或结尾
		包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名
		包名后续部分依不同机构内部的规范不同而不同 
	导入包	import 包名.*;

static关键字

static属性:在内存中只有一个拷贝,在类内部可在任何方法内直接访问静态变量,其他类中，可以直接通过类名.变量名访问
	-->作用
		（1）能被类的所有实例共享，可作为实例之间进行交流的共享数据
		（2）如果类的所有实例都包含一个相同的常量属性，可把这个属性定义为静态常量类型，从而节省内存空间
static方法:在其它类中可以通过类名.方法名调用
	静态方法中不能使用this和super-->因为this和super都是对象相关,而静态方法只与类相关
	不能直接访问所属类的实例变量和实例方法
	可直接访问类的静态变量和静态方法
	普通方法可直接调用静态方法
	静态方法必须被实现
实例方法:
	可直接访问所属类的静态变量、静态方法、实例变量和实例方法
	
static代码块:-->会在程序运行该类的时候直接调用,顺序先于对象创建,往往用于加载配置文件	???单例模式
	static{ }	
	如果有多个静态块，按顺序加载,每个静态代码块只会被执行一次

继承–>java中只支持单根继承,一个类只能有一个直接父类

关键字extends
访问父类关键字super	super();调用父类构造方法,必须在第一行
			super只能出现在子类的方法和构造方法中
			super不能访问父类的private成员	
使用继承-->需要满足所属关系!
	1)编写父类-->抽取公共属性与方法
		[访问修饰符] class 父类名{ 
			  //公共的属性和方法
		}
	2)编写子类，继承父类

		[访问修饰符] class 子类名 extends 父类名 { 
			  //子类特有的属性和方法
		}
		无参构造创建子类对象时,会先走父类构造,再走子类构造
		//继承可见属性方法
		//不可见属性和方法被继承但不能被使用

继承条件下构造方法的调用规则

			子类构造方法没有通过super显式调用父类的有参构造方法，也没通过this显式调用自身其他构造方法,系统默认调用父类的无参构造方法
			子类构造方法通过super显式调用父类的有参构造方法,执行父类相应构造方法，而不执行父类无参构造方法
			子类构造方法通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则

IDEA快捷键

alt+ins快速生成构造,setter和getter,重写Object类的基本方法,父类抽象方法和接口抽象方法等

方法的重写或方法的覆盖（overriding）

子类根据需求对从父类继承的方法进行重新编写
重写时，可以用super.方法的方式来保留父类的方法
构造方法不能被重写

方法重写规则

有继承关系,方法名相同,参数列表相同,返回值类型相同或者是其子类,访问权限不能严于父类
父类的静态方法不能被子类覆盖为非静态方法,父类的非静态方法不能被子类覆盖为静态方法,即static关键字需保持一致
子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法(注：静态方法中无法使用super),即父类静态方法不再生效
父类的私有方法不能被子类覆盖
不能抛出比父类方法更多的异常

Object类–>Object类是所有类的父类
常用方法
toString()–>返回当前对象本身的有关信息，按字符串对象返回 //重写时用json格式往往只用于程序员开发看数据值的时候使用
equals()–>比较两个对象是否是同一个对象，是则返回true->>本质就是双等,较常用,若有自己需求需要重写
hashCode()–>返回该对象的哈希代码值–>Java虚拟机安排内存地址
getClass()–>获取当前对象所属的类信息，返回Class对象–>>用来做反射

instanceof运算符 判断是否为某类型
使用instanceof时，对象的类型必须和instanceof后面的参数所指定的类在继承上有上下级关系
多态的基础是方法重写,前提是有继承关系

使用父类作为方法的形参，是Java中实现和使用多态的主要方式
使用父类作为方法的返回值，也是Java中实现和使用多态的主要方式
步骤
父类引用子类对象

抽象方法–>若一个方法必定被重写,就要考虑改成抽象的方法
抽象方法没有方法体
抽象方法必须在抽象类里–>抽象类不能被实例化
抽象方法必须在子类中被实现，除非子类是抽象类
向上转型
<父类型> <引用变量名> = new <子类型>();
此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法
此时通过父类引用变量无法调用子类特有的方法
向下转型
将一个指向子类对象的父类引用赋给一个子类的引用，即：父类类型转换为子类类型。需强制类型转换
<子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;
在向下转型的过程中，如果没有转换为真实子类类型，会出现类型转换异常
由父类向子类进行强制转换,若不能完全确定能不能转型成功,必须要用instanceof关键字判断类型

抽象类和接口

1)抽象类与抽象方法的使用
抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类
如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类
没有抽象构造方法，也没有抽象静态方法
抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用
2)接口interface–>是Java中多继承的体现
类图中实线加箭头子类继承父类,虚线加箭头实现接口
标准
系统标准由Java虚拟机提供
自定义标准:定义的时候需要详细注释
特性
接口中的变量都是静态常量（public static final）
接口中的方法默认公共抽象方法(public abstract)
接口不可以被实例化,实现类必须实现接口的所有方法,实现类可以实现多个接口,一个类必须实现接口抽象方法（implements），除非这个类也是抽象类
接口没有构造方法，不能被实例化
一个接口不能实现另一个接口，但可以继承多个其他接口

接口是一种能力,体现在接口的方法
面向接口编程
	程序设计时,关心实现类有何能力,而不关心实现细节,面向接口的约定而不考虑接口的具体实现

抽象类VS接口

相同点
	代表系统的抽象层,都不能被实例化,都能包含抽象方法,用于描述系统提供的服务，不必提供具体实现
不同点
	在抽象类中可以为部分方法(可以是普通方法)提供默认实现，抽象类中也可以没有抽象方法,而接口中只能包含抽象方法
	抽象类便于复用，接口便于代码维护
	一个类只能继承一个直接的父类，但可以实现多个接口
使用原则
	接口做系统与外界交互的窗口
	接口提供服务
	接口本身一旦制定，就不允许随意修改
	抽象类可完成部分功能实现，还有部分功能可作为系统的扩展点

面向对象设计原则
多用组合，少用继承
针对接口编程,不建议过多接口
针对扩展开放，针对改变关闭

异常Exception

概念:是指在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序
异常分为Checked异常和运行时异常,Checked异常必须捕获或者声明抛出,运行时异常不要求必须捕获或者声明抛出
异常处理:Java编程语言使用异常处理机制为程序提供了错误处理的能力
	Java的异常处理是通过5个关键字来实现的：try、catch、 finally、throw、throws
	try一定要有,catch和finally至少要有一个	
	try-->执行可能产生异常的代码
	catch-->捕获异常
	finally-->无论是否异常代码块总会执行
	throws-->声明异常,声明某个方法可能抛出(其实是转移)的各种异常，多个异常用逗号隔开跟在参数列表后面
		通知调用者方式:
			方式1：调用者处理异常
			方式2：调用者继续声明异常
			main()方法声明的异常由Java虚拟机处理
	throw-->抛出异常
		throws与throw的区别
				throw				throws相当于甩锅
			生成并抛出异常				声明方法内抛出了异常
			位于方法体内部，可作为单独语句使用		必须跟在方法参数列表后面，不能单独使用
			抛出一个异常对象，且只能是一个		声明抛出异常类型，可以跟多个异常
	try-catch-->分三种情况
			1)程序正常没有异常跳过catch块继续执行
			2)有异常,被捕获会继续执行后面代码,但是try里面异常代码后面的代码不会执行
			3)有异常,异常类型不匹配未捕获,程序中断
	多重catch块-->相当于if()else{}
		排列catch 语句的顺序：先子类后父类 
		发生异常时按顺序逐个匹配
		只执行第一个与异常类型匹配的catch语句
	try-catch- finally块中， finally块唯一不执行的情况是什么？
		System.exit(num);num为非零数,强制退出Java虚拟机
	try-catch块中存在return语句，是否还执行finally块? 如果执行，说出执行顺序
		方法无返回值	会优先执行finally中的代码块	try--> catch-->finally代码块-->catch中的return跳出方法
		方法有返回值且catch和finally都有return		try-->catch return-->finally return
常见异常类型
	Exception				-->所有异常父类
	ArithmeticExceprion		-->算数异常
	ArrayIndexOutOfBoundsException	-->数组下标越界异常
	NullPointerException		-->空指针异常
	ClassNotFoundException		-->不能加载所需的类
	IllegalArgumentException		-->非法参数异常
	ClassCastException			-->对象强制类型转换异常
	NumberFormatException		-->数字格式转换异常
自定义异常
	定义异常类-->继承父类实现,编写构造方法-->实例化自定义异常对象-->使用throw抛出
异常链
	异常链创建了新的异常但却保留了原有的异常信息
异常处理原则
	异常处理与性能
	异常只能用于非正常情况
	不要将过于庞大的代码块放在try中
	在catch中指定具体的异常类型
	需要对捕获的异常做处理