面向对象
OOP面向对象编程
属性+方法 = 类
本质：以类的方式组织代码，以对象的组织（封装）数据
static 方法是和类一起加载的
普通方法是在类实例化之后才存在的
new 类名，快速生成前一段代码：alt+enter
构造器
相当于构造函数
没有返回值，名字与类名相同
一旦定义了有参构造，无参构造就必须显示定义（不定义默认为无参构造）
快捷键：alt+insert 快速生成构造器
简单的内存
对象和方法放在栈中
对象实例和类模板也放在类中，有一块专门的方法区，还有静态方法区
对象是通过引用来操作的：栈-->堆
属性：字段Field 成员变量
默认初始化：数字：0 0.0
char u0000
boolean:false
引用：null
非静态函数不能使用静态函数，调用时间不同
封装
追求：高内聚，低耦合
高内聚：类的内部数据操作细节自己完成，不允许外部干涉
低耦合：仅暴露少量的方法给外部使用
属性私有，get/set
提供一些可以操作这个属性的方法
提供一些public的get、set方法
//get 获得这个数据
//set 给这个数据设置值
封装的作用
1.提高程序的安全性
2.隐藏代码的实现细节
3.统一接口
4.系统可维护增加了
继承
java中只有单继承，没有多继承
本质是对某一批类的抽象
extends 的意思是“拓展”，子类是父类的拓展
类和类之间的关系还有依赖、组合、聚合等
Ctrl + H 打开继承树
在java中，所有的类，都默认直接或者间接继承object
super
继承父类中同名的东西，跟this使用当前对象相对应
私有的东西无法继承
调用父类的构造器，必须要在子类构造器的第一行，使用格式：
public Student(){
super();//调用父类的构造函数
//必须要在子类构造器的第一行
System.out.println("Student无参执行了");
}
super注意点
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法
多态
重写都是方法的重写和属性无关
@override//注解有功能的注释
//非静态 重写
B b = new A();//子类重写了父类的方法 //B为父类，A为子类
//方法只能为public，出现向上箭头证明重载
重写：需要有继承关系，子类重写父类的方法！
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大但不能缩小：public>protected>default>private
4.抛出的异常：范围，可以被缩小，但不能扩大；
重写，子类的方法和父类必要、一致；方法体不同！
为什么需要重写：
1.父类的功能，子类不一定需要，或者不一定满足！
多态
父类的引用指向子类
子类重写了父类的方法，执行子类的方法
对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系 类型转换异常！ ClassCastException
-
存在条件：继承关系，方法需要重写，父类引用指向子类对象！
instanceof
System.out.println(X instanceof Y); //能不能编译通过，X,Y是否具有父子关系 看Y是不是在X所在的这一条线上，true or false
类型之间的转化
父（上） 子（下）
子类转换为父类，可能丢失自己本来的一些方法
1.父类引用指向子类的对象
2.把子类转换为父类，向上转型
3.把父类转换为子类，向下转型；强制转换
4.方便方法的调用，减少重复的代码
static
建议用类名.属性名使用
非静态的方法可以调用静态的方法
静态方法不能调用非静态方法，因为静态方法随着类的加载而加载
匿名代码块
static {//第一个执行，只执行一次
System.out.println("静态代码块");
}
{//匿名代码块第二个执行，赋初值
System.out.println("匿名代码块");
}
public Person{
System.out.println("构造方法");
}
静态导入包
import static java.lang.Math.random;
final class 不能有子类，即不能被继承
抽象类
抽象类，抽象方法
抽象方法，只有方法名，没有方法体，前面用abstract修饰
抽象类的所有方法，继承了它的子类，都必须要实现它的方法，除非子类也是抽象类
1.不能new这个抽象类，只能靠子类去实现它；约束
2.抽象类中可以写普通方法
3.抽象方法必须写在抽象类中
接口可以多继承
接口
只有规范！自己无法写方法~专业的约束！约束和实现分离：面向接口编程
接口都需要有实现类，用impl结尾
public class UserServiceImpl implements UserService{
//实现接口中的类
}
类 可以实现接口 implements 接口
实现了接口的类，就需要重写接口中的方法
多继承~利用接口实现多继承
作用：
1.起到约束作用
2.定义了一些方法，让不同的人实现
3.接口中所有的方法都是 public abstract
4.接口中的属性都是常量，为public static final
5.接口不能被实例化，只能被implements，接口中没有构造方法
6.implements可以实现多个接口
7.必须要重写接口中的方法
内部类
在一个类的内部再定义一个类
**一个java类中可以有多个class类，但是只能有一个public class类
局部内部类：
写在方法里的类
匿名内部类：
不用将实例保存到变量中
异常机制（Exception）
程序在运行过程中，可能遇到各种异常问题
JAVA把异常当做对象来处理，定义了一个基类java.lang.Throwable作为所有异常的超类
在java API中定义了许多异常类，这些异常分为两大类，错误Error和异常Exception
异常处理机制
try{//监控区域
new Test().a();
// System.out.println(a/b);
}catch (Throwable e){//catch 捕获异常
//catch(想要捕获的异常类型！)
System.out.println("程序出现异常，变量不能为0");
}finally {//处理善后
System.out.println("finally");
}
}
try{//监控区域
// new Test().a();
System.out.println(a/b);
}catch (Error e){
System.out.println("Error");
}catch (Exception e ){
System.out.println("Exception");
} catch (Throwable t){
System.out.println("Throw");
} finally {//处理善后
System.out.println("finally");
}
假设要捕获多个异常：从小到大
生成捕捉异常的快捷键：Ctrl+alt+t
主动抛出异常：throw
一般在方法中使用
throws一般在方法旁使用
public void test(int a,int b) throws ArithmeticException {
if(b==0){
throw new ArithmeticException();//主动抛出异常
}
//System.out.println(a/b);
}
自定义异常
1.创建自定义异常类
2.在方法中通过throw关键字抛出异常
3.如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续下一步操作
4.在出现异常方法的调用者中捕获并处理异常
实际应用中的经验总结
处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗忘的异常
对于不确定的代码，也可以加上try-catch，处理潜在的异常
尽量去处理异常，切忌只是简单地调用printStackTrack（）去打印输出
尽量添加finally语句块去释放占用的资源
