* 重写的规定：
* 方法的声明： 权限修饰符 返回值类型 方法名（形参列表）throws 异常类型{
* 方法体
* }
* ① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和参数列表相同
* ②子类重写的方法权限修饰符不小于父类方法的权限修饰符
* >特殊情况：子类方法不能重写父类中声明为private权限的方法
* ③返回值类型：
* >父类被重写的方法的返回值类型是void或基本数据类型，则子类重写方法的返回值类型也只能是void或对应的基本数据类型
* >父类被重写的方法的返回值是A类型，则子类重写方法的返回值类型可以是A类型或者是A类型的子类
* ④子类重写的方法抛出的异常不大于父类被重写的方法抛出的异常类型
* 子类和父类中同名同参数的方法要么都声明为非static（考虑重写），要么都声明为static的。
*
* 关键字super的使用：
* 1.super理解为：父类的
* 2.super可用来调用：属性、方法、构造器
*
* 3.super的使用；
* 3.1 在子类的方法或构造器中，通过“super。属性”或“super.方法”的方式，显示调用父类中声明的属性或方法。但是通常情况下，省略：“super.”
* 3.2 特殊情况：当子类和父类中定义了同名属性时，想在子类中调用父类中声明的属性，必须使用“super。属性”的方式，表明调用的是父类中声明的属性。
* 3.3特殊情况：当子类重写父类中的方法以后，想在子类方法中调用父类被重写的方法时，使用“super.方法”调用
*
* 4.super调用构造器
* 4.1在子类的构造器中显示使用“super(形参列表)”的方式，调用父类声明的指定的构造器
* 4.2 "super(参考列表)"的使用，必须声明在子类构造器的首行
* 4.3 "super(形参列表)"或"this(形参列表)"只能二选一，不能同时出现，默认是“super()”
*
* 多态性
* 1.父类的引用指向子类的对象
* 2.多态的使用
* 有了对象的多态性以后，在编译期，只能调用父类中声明的方法，在运行期，执行的是子类重写父类的方法
* 3.多态使用前提：①有继承
* ②有重写
* ③父类引用指向子类对象
*4.多态性只适于方法，不适于属性
*
*instanceof操作符
* 1.多态性相当于向上转型
* 2.使用强转时可能出现ClassCastException的异常，
* 3.instanceof关键字的使用 ：
* a instanceof A：判断对象a是否是类A的实例，如果是，返回true，否则返回false
*
*
* 包装类
* 基本数据类型 包装类
* byte Byte
* short Short
* int Integer
* long Long
* float Float
* double Double 此及以上：父类：Number
* boolean Boolean
* char Character
*
*基本数据类型、包装类、String三者相互转换
* 1.基本数据类型---》包装类：调用对应包装类的构造器
* 如：int num1 = 10;
* Integer in1 = new Integer(num1);
* System.out.println(num1.toString());
*
* 或 Integer in2 = new Integer("123")
*
* boolean 包装类在忽略大小写的情况下，只要内容是true ，返回 true，其他内容返回false
*
* 2.包装类--->基本数据类型：调用包装类的xxxValue()
* 如: Integer in1 = new Integer(12);
* int i1 = in1.intValue();
*
* 自动装箱和自动拆箱
* 1.自动装箱
* Integer num1 = 10;
* Integer in1 = num1;
*
* 2.自动拆箱
* i nt num2 = in1;
*
* 基本数据类型、包装类----》String类型：调用String重载的valueOf(Xxx xxx);
* 如：int num1 = 10;
* String str1 = num1 + "" ; 连接运算
*
* float f1 = 12.3f;
* String str2 = String.valueOf(f1);
*
* Double d1 = new Double(12.4);
* String str3 = String.valueOf(d1);
*
* String类型--->基本数据类型、包装类：调用包装类的parseXxx(String s)方法
*
* 如：String str1 = "123";
* int num1 = Integer.parseInt(str);
*
* 关键字static
* 1.static:静态的
* 2.static可以用来修饰：属性、方法、代码块、内部类
* 3.使用static修饰属性：静态变量(或类变量)
* 3.1属性，按是否使用static修饰，分为：静态属性和非静态属性(实例变量)
* 实例变量：创建类的多个对象，每个对象都独立的拥有一套类中的非静态属性，当修改其中一个对象中的
* 非静态属性时，不会导致其他对象中同样的属性值的修改
* 静态变量：创建类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致
* 其他对象调用此静态变量时，是修改过了的。
* 3.2 static 修饰属性的其他说明：
* ①静态变量随着类的加载而加载，可以通过“类.静态变量”的方式进行调用
* ②静态变量的加载要早于对象的创建
* ③由于类只会加载一次，则静态变量在内存中也只会存在一份，存在方法区的静态域中。
* ④ 类变量 实例变量
* 类调用 可以 不可
* 对象调用 可以 可以
* 3.3 静态属性举例：System.out; Math.PI;
*
*
* 4.使用static修饰方法:静态方法
* ①随着类的加载而加载，可以通过“类.静态方法”调用
* ②静态方法中，只能调用静态的方法或属性
* 非静态方法中，既可以调用非静态的方法和属性，也可以调用静态方法和属性
*
* 5.static注意点：
* 在静态方法内，不能使用this、super关键字
*
* 6.开发中，如何确定一个属性是否要声明为static的
* 》属性是可以被多个对象所共享的，不会随着对象的不同而不同
* 》类中的常量也常常声明为static
*
* 开发中，如何确定一个方法是否需要声明为static的
* 》操作静态属性的方法，一般设置成static的
* 》工具类中的方法，习惯上声明为static的，如Math、Arrays、Collections
*
*
* 单例设计模式：
* 1.采用一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例
* 2.如何实现 ：饿汉式 懒汉式
*
* 一、饿汉式
* ①私有化类的构造器
* ②内部创建类的对象，要求此对象也必须声明为静态的
* ③提供公共的静态的方法，返回类的对象
*
* public class SingletonTest {
*
* public static void main(String[] args) {
*
* Bank bank1 = Bank.getBank();
* Bank bank2 = Bank.getBank();
* System.out.println(bank1 == bank2);//ture
* }
* }
* class Bank{
* //1.私有化构造器
* private Bank() {
* }
* //2.内部创建类的对象
* //4.要求此对象也必须声明为静态的
* private static Bank instance = new Bank();
* //3.提供公共的静态方法，返回类的对象
* public static Bank getBank() {
* return instance;
* }
* }
*
* 二、懒汉式：
* ①私有化类的构造器
* ②声明当前类对象，没有初始化
* ③声明public、static的返回当前类对象的方法
*
* public class SingletonTest2 {
* public static void main(String[] args) {
* Order order1 = Order.getOrder();
* Order order2 = Order.getOrder();
* System.out.println(order1 == order2);
* }
* }
* class Order{
* //1.私有化类的构造器
* private Order() {
* }
* //2.声明当前类对象，没有初始化
* private static Order instance = null;
* //3.声明public、static的返回当前类对象的方法
* public static Order getOrder() {
* if(instance == null) {
* instance = new Order();
* }
* return instance;
* }
* }
*3.区分饿汉式和懒汉式
* 饿汉式：坏处：创建对象，对象加载时间过长。
* 好处：线程安全
* 懒汉式：好处：延迟对象的创建。
* 坏处：目前写法 线程不安全
*
*
*代码块或初始化块：一对{}组成
* 1.作用：用来初始化类、对象
* 2.代码块如果有修饰的话，只能用static
* 3.分类：静态代码块 vs 非静态代码块
*
* 4.静态代码块
* 》内部可以有输出语句
* 》随着类的加载而执行，且执行一次
* 》作用：初始化类的信息
*
* 5.非静态代码块
* 》内部可以有输出语句
* 》随对象的加载而执行
* 》每创建一个对象，就执行一次非静态代码块
* 》作用：可以再创建对象时，对对象的属性进行初始化
*
* final:最终的
*
* 1.final可以修饰的结构：类、方法、变量
*
* 2.final 用来修饰一个类：此类就不能被其他类所继承
* 比如：String类、System类、StringBuffer类等
*
* 3.final 用来修饰方法 ：表明此方法不能被重写
* 比如：Object类中getClass() （获取当前对象所属于的类）
*
* 4.final 用来修饰变量：此时的“变量”就称为是一个常量
* 4.1 final修饰属性：可以考虑赋值的位置：显示初始化、代码块中赋值、构造器中初始化
* 4.2 final修饰局部变量：
* 尤其是是使用final修饰性时，表明此形参是一个参量。当调用此方法时，给常量形参赋值一个实参
* 一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。
*
* static final 用来修饰属性：全局常量
*
*
* abstract关键字的使用
* 1.abstract：抽象的
* 2.abstract可以修饰类、方法
*
* 3.abstract修饰类：抽象类
* abstract class A{
*
* }
* 》此类不能实例化（不能创建对象）
* 》抽象类中一定有构造器，便于子类实例化时调用（涉及，子类对象实例化的全过程）
* 》开发中，都会提供抽象类的子类，让子类对象实例化，完成相关操作
*
* 4.abstract修饰方法
* public abstract void xX();
* 》只有方法的声明，没有方法体
* 》包含抽象方法的类一定是抽象类，反之，抽象类中可以没有抽象方法
* 》若子类重写了父类中的所有的抽象方法后，此子类方可实例化
* 若在子类没有重写父类中多有的抽象方法，则此子类也是抽象类，需要使用abstract修饰
*
* 5.abstract使用上的注意点：
* 1.abstract不能用来修饰：属性、构造器等结构
* 2.abstract不能用来修饰私有方法、静态方法、final的方法、final类
*
*
* 接口的使用
* 1.接口使用interface来定义
* 2.java语言中，接口和类是并列的两个结构
*
* 3.如何定义接口，定义接口中的成员
* 3.1 JDK7及以前：只能定义全局常量和抽象方法
* 》全局常量：public static final 的，但是书写时可以省略
* 》抽象方法：public abstract的
*
* 3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法，默认方法
* 》静态方法只能通过接口直接调用，
* 》默认方法通过实现类的对象进行调用，并且可以重写，调用时，是重写以后的方法
* 》如果子类（实现类）继承了父类和实现的接口中声明了同名同参数的方法，那么 子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法 ----》类优先原则
* 》如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错，---接口冲突
* 必须要在实现类中重写此方法，
* 调用父类的同名同参方法：super.方法
* 调用接口中同名同参方法：接口名.super.方法
* * 4.接口中不能定义构造器，意味着接口不可以实例化* * 5.java开发中，接口通过让类去实现(implements)的方式使用* 如果实现类重写了接口中的所有抽象方法，则此实现类就可以实例化* 如果实现类没有重写接口中对所有的抽象方法，则此实现类仍为一个抽象类
*
* 6.java类可以实现多个接口--》弥补了类单继承的局限性
* 格式：class AA extends BB implements CC,DD{}
*
* 7.接口和接口之间可以继承，而且可以多继承
*
* 8.接口的具体使用，体现了多态
* 9.接口，实际上可以看做是一种规范
*
*
* 内部类
* Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
*
* 内部类的分类：成员内部类、局部内类(方法内、代码块内、构造器内)
*
* 成员内部类:
* 一方面作为外部类的成员:
* 》调用外部类结构
* 》可以用static修饰
* 》可以被4中不同的修饰符修饰
*
* 一方面作为一个类：
* 》类内可以定义属性、方法、构造器等
* 》可以用final修饰，表示此类不能被继承
* 》可以被abstract修饰，表示此类不能被实例化
*
* 4.内部类关注的问题
* 》1.如何实例化成员内部类的对象
* 创建 静态的成员内部类
* 外部类.内部类 实例名 = new 外部类.内部类();
*
* 创建 非静态的成员内部类
* 外部类 外部类实例 = new 外部类();
* 外部类.内部类 内部类实例 = 外部类实例.new 内部类();
*
* 》2.如何在成员内部类中区分调用外部类的结构
* 同名参数时，
* 调用内部类中的形参：直接 形参名
* 调用内部类中的属性：this.参数名
* 调用外部类中的属性：外部类.this.参数名
*
* 异常
* 1.栈溢出：java.lang.StackOverflowError
* 比如 main方法中调main方法
* main(args);
*
* 2.堆溢出：java.lang.OutOfMemoryError
* 比如：Integer[] arr = new Integer[1024*1024*1024];
*
*
* java.lang.Throwable
* ------java.lang.Error:一般不编写针对性的代码进行处理
* ------java.lang.Exception:可以进行异常的处理
* ---编译时异常(checked)
* --IOException
* -FileNotFoundException
* --ClassNotFoundException
* ---运行时异常(unchecked)
* --NullPointerExxception
* --ArrayIndexOutOfBoundsException
* --ClassCastException
* --NumberFormatException
*
* 异常的处理：抓抛模型
*
* 过程一：“抛”：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象并将此对象抛出。
* 一旦抛出对象以后，其后的代码不再执行
*
* 关于异常对象的产生：①系统自动生成的异常对象
* ②手动的生成一个异常对象，并抛出(throw)
* throw new Exception()/throw new RuntimeException()
*
*
* 过程二：“抓”：可以理解为异常的处理方式：①try-catch-fianlly
* ②throws
* try-catch-finally的使用
* try{
* //可能出现异常的代码；
* }catch(异常类型1 变量名1){
* //处理异常的方式1
* }catch(异常类型2 变量名2){
* //处理异常的方式2
* }
* ……、
* finally{
* //一定会执行的代码
* }
*
* 说明：
* 1.finally是可选的
* 2.使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据对象的类型，去catch中进行匹配。
* 3.一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出try-catch结构(在没有写finally的情况下)继续执行其后的代码。
*
* 4.catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。
* catch中的异常类型如果满足类关系，则要求子类声明在上，父类声明在下，否则报错
* 5.常用的异常对象处理的方式：①String message = e.getMessage();
* ②e.printStackTrace()
* 6.在try结构中声明的变量，再出了try结构后就不能再调用，若需要使用，可将变量声明在结构外并初始化，在结构中赋值
* 7.try-catch-finally结构可以嵌套
*
*
*
* 体会1：使用try-catch-finally处理编译时异常，使得程序在编译时就不在报错，但在运行时仍可能报错
* 相当于try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现
*
* 体会2：开发中，由于运行时异常比较常见，通常就不针对运行时异常编写try-catch-finally结构
* 针对编译时异常，一定要考虑异常的处理
*
*finally的使用
* 1. finally是可选的
* 2. finally中声明的是一定会被执行的代码，即使catch中又出现异常，try中有return语句，或catch中也有return语句等。
* 3. 数据库连接、输入输出流、 网络编程socket等资源，JVM是不能自动的回收的，我们需要自己手动的资源释放，此时的资源释放，就要声明在finally中。
*
*
* 异常处理的方式二：throws +异常类型
* 1."throws +异常类型" 写在方法的声明处。指明此方法执行时，可能会抛出的异常类型
* 一旦当方法体执行时，出现异常，仍然会在异常代码处生成一个异常累的对象，此对象满足throws后异常类型时，就会被抛出。
* 异常代码后续的代码，就不再执行
* 2.体会：try-catch-finally：真正的将异常给处理掉了
* throws的方式，只是将异常抛给了方法的调用者，并没有真正将异常处理掉
* 3.开发中如何选择使用try-catch-finally 还是 throws
* 》3.1 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，如果子类有异常，必须使用try-catch-finally方式处理
* 》3.2 执行的方法中，先后调用了另外的几个方法，这几个方法是递进关系执行的，建议该几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用try-catch-finally进行处理
*
*
* 方法重写的规则之一：
* 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
*
* 如何自定义异常
* 1.继承于现有的异常结构：RuntimeException、Exception
* 2.提供全局常量：serialVersionUID
* 3.提供重载的构造器
B站 尚硅谷视频跟学