第4讲 数组、面向对象、构造函数及代码块、继承、异常、抽象

1 数组

1.1 静态创建
int[] a = {1,2,3,4,5};
int[] a = new int[]{1,2,3,4,5};

1.2 动态创建
int[] a = new int[5];

1. 3 数组的创建过程
        1、在内存中开辟连续的空间,用来存放数据
        2、给数组完成初始化过程,给每个元素赋予默认值
        3、数组完成初始化会分配一个唯一的地址值
        4、把唯一的地址值交给引用类型的变量a去保存
        5、如果想要操作数组中的元素，可以根据变量保存的地址找到数组，然后根据下标来操作数组的具体元素
        6、数组名保存的是数组的地址值，不是数组中每一个具体的元素，数组名是一个引用类型的变量

2 数组的特性

1. 数组的长度通过 数组名.length 来获取
2. 数组一旦创建，长度无法改变
3. 数组的下标从0开始，最大下标为数组长度-1
4. 如果访问到了不存在的下标，会数组下标越界异常

3 数组的工具类Arrays

1、toString(数组名)，除了char类型以外，其他类型的数组想要查看数组的具体元素，都得使用这个方法，如果不用，打印是数组的地址值
2、sort(数组名)，给数组进行排序
3、copyOf(要复制的数组，新数组的长度)
        如果新的长度大于原数组的长度–数组的扩容
        如果新的长度小于原数组的长度–数组的缩容
        如果新的长度等于原数组的长度–普通的复制
        注意：不管是什么长度，都不是修改原数组，而是创建新数组

4 数组的遍历

如果只是想查看数组中有哪些元素，直接使用System.out.println(Arrays.toString(数组名))；就可以
如果想要拿到数组中的一个个的具体元素，或者是对数组中的元素做进一步的操作，就需要对数组进行遍历
遍历：把数组中的所有元素，从头到尾逐个“过一遍”
通过循环遍历数组，所以循环中的循环变量代表的是数组的下标

public class ReviewDemo {
    public static void main(String[] args) {
        int[] a = new int[10];
        for(int i = 0;i<a.length;i++) {
            //System.out.println(i);//打印的是数组的下标0-9
            a[i] = i+11;//a[i]代表的是数组中每一个具体的元素
        }
        System.out.println(Arrays.toString(a));
        //[11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
    }
} 

5 方法的重载

1. 我们根据方法名+参数列表确定具体调用哪个方法
2. 方法的重载:在同一个类中,存在方法名相同,但参数列表不同的方法
3. 如果在同类中,同名方法的参数个数不同,一定构成重载
4. 如果在同类中,同名方法的参数个数相同,需要查看对应位置上参数的类型,而不是参数名,与参数名无关

 6 冒泡排序

排序思路：要比较多轮，每轮两个相邻的元素做比较，位置不对就互换
代码思路：
通过嵌套for循环来完成

外层循环：控制的是轮数，如果有n个数，最多n-1轮
内层循环：控制的是每轮中比较的次数，每一轮的次数会递减，之前轮确定的最大值不应该参与后面轮的比较
        注意：外层循环的循环变量代表的是轮数1 2 3 4…
        内层循环的循环变量代表的是数组的下标[0,a.length-i)

 7 面向对象

        这种思想强调的是结果，Java就是一门面向对象的语言，不在意完成的过程，在意的是有对象可以帮我干活，比如：我们想吃饭，不在意是哪个厨师做的，也不在意是哪个骑手送的，只要有厨师做，有骑手派送就好了
        我们可以把OOP的思维理解成一种行为习惯 思维方式，比如衣服，没有办法给出一个明确的定义，但是，只要我们看到任何一件衣服，我们就自动把它归类到衣服这个分类中，因为你在过去的生活经验中已经见过太多的衣服，积累经验

8 类

类指的是类型Type，是指一类事物，使用Java中的class关键字来描述
类是抽象的，要提取这一类事物的特征与功能
可以把类理解成设计图纸，模板
注意：类在现实世界中不是真实存在，它只是一种对象的数据类型

9 对象

对象就是根据类创建出来的一个个独立且具体的实例
一个类可以创建出多个对象，我们通过对象唯一的地址值区分不同的对象
对象具有各种特征，并且每个对象的每个特征都可以有自己特定的值
对象具有各种行为，每个对象可以执行的操作

10 面向对象的特征–封装

1、为啥要用封装？
        封装可以提高程序的安全性
        封装可以让资源按照我们预先规定的方式来操作
2、属性的封装
        用private修饰属性，一旦属性被private修饰，就只能在本类中使用，外界无法访问
        所以为了让外界能够按照我们提供的方式来调用，需要根据属性生成公共的getXxx()与setXxx()方法

3、方法的封装
        方法的封装也是使用private来修饰方法
        如果想要调用私有方法的功能，就需要在本类的公共方法里调用这个私有方法

11 构造函数

1、格式：与本类类名同名，且没有返回值类型
2、作用：创建对象
3、执行时机:每次创建对象时都会执行构造方法
4、分类：
1）无参构造：默认存在，如果添加了其他构造，默认的构造函数会被覆盖,所以要记得手动提供
2）含参构造：对于参数没有任何要求，有参数就行
3）全参构造：全参构造的参数必须与本类属性一致
全参构造不仅可以创建对象，还可以给对象的所有属性赋值

12 方法的重载

1、在同一个类中，存在多个方法名相同，但参数列表不同的方法
2、如果在同类中，多个同名方法的参数个数不同，一定构成重载
3、如果在同类中，多个同名方法的参数个数相同：需要查看对应位置上的参数的类型，而不是参数名，与参数名无关
4、如：

        (int a ,String b)与(int b,String a)–不构成重载
        (int a,String b)与(String a,int b)–构成重载

13 构造代码块

1、位置：类里方法外

2、执行时机：每次创建对象时执行，并且优先于构造方法执行

3、作用：用于提取所有构造方法的共性功能

 14 局部代码块

1、位置：方法里

2、执行时机：调用本局部代码块所处的方法时执行

3、作用：用于控制变量的作用范围

4、执行顺序:

        构造代码块->构造方法->普通方法->局部代码块

15 this的用法

1.当成员变量与局部变量同名时，使用this指定成员变量
2.使用this在构造方法的第一行调用构造方法的功能
this();–调用的是本类的无参构造
this(参数);–调用的是本类对应参数的构造方法

16 super的用法

1.当父类的成员变量与子类的变量同名时，使用super指定父类的成员变量
2.使用super在子类构造方法的第一行调用父类构造方法的功能
super();–调用的是父类的无参构造
super(参数);–调用的是父类对应参数的构造方法

17 继承

1. 继承的关键字extends 格式： 子类 extends 父类
2. 继承相当于子类把父类的功能复制了一份
3. Java只支持单继承：一个子类只能有一个父类，一个父类可以有多个子类
4. 继承具有传递性：爷爷的功能会传给爸爸，爸爸的功能会传给孙子
5. 子类只可以使用父类的非私有资源，私有资源由于private限制,不可用
6. 子类可以拥有自己的特有功能
7. 继承是is a 强耦合的关系，依赖性非常强，比如我们看到”熊孩子”，就知道他有一个”熊父母”

18 继承中的构造方法

1、子类在创建对象时,默认会先调用父类的构造方法
2、原因是子类构造函数中的第1行默认存在super();–表示调用父类的无参构造
3、当父类没有无参构造时,可以通过super(参数);调用父类的其他含参构造
      注意:子类必须调用父类的一个构造函数,不论是无参还是含参,选一个即可
4、构造方法不可以被继承!因为语法的原因,要求构造方法的名字必须是本类类名
      不能在子类中出现一个父类名字的构造方法

19 继承中变量的使用

父类成员变量与子类成员变量同名时，使用super.变量名指定父类的成员变量

20 继承中构造方法的使用 

1. 创建子类对象时，会先调用父类的无参构造，因为子类的构造函数中默认存在一个super();
2. 如果父类没有无参构造的话，我们就需要手动指定子类去调用父类的含参构造super(参数)；
3. 构造方法不可以被继承，原因是：构造方法名必须是本类的类名，不可能在子类中存在一个父类名字的构造方法

21 方法的重写

重写：子类对父类的方法不满意时，可以重写父类的方法
注意：重写是在不改变父类方法的前提下，实现功能的修改，重写后子类对象调用的就是重写后的功能
原则：两同 两小 一大
两同：方法名+参数列表相同
一大：子类方法的修饰符权限 >= 父类方法的修饰符权限
两小：子类方法的返回值类型，有两种选择：
1）子类方法的返回值类型与父类方法的返回值类型相同
2）子类方法的返回值类型是父类方法的返回值类型的子类
比如：父：void 子：void
父：int 子：int 但是：byte short long都不行！没有继承关系
父：Animal 子：Animal/Cat都可以，但不可以是Car

22 静态

1.static可以修饰成员变量和方法
2.被static修饰的资源称为静态资源
3.静态资源随着类的加载而加载，最先加载，优先于对象进行加载
4.静态资源可以通过类名直接调用，也被称作类资源
5.静态被全局所有对象共享，值只有一份
6.静态资源只能调用静态资源
7.静态区域内不允许使用this与super关键字,因为this代表本类对象,super代表父类对象,有静态时还没有对象呢

23 静态代码块static{}

1、格式：static{ }
2、位置：类里方法外
3、执行时机：随着类的加载而加载，优先于对象进行加载【只加载一次】
4、作用：用于加载那些需要第一时间就加载，并且只加载一次的资源，常用来初始化
5、顺序：静态代码块 构造代码块 构造方法 普通方法【如果普通方法里有局部代码块，执行局部代码块】
TIPS: 如果有多个静态资源，加载顺序取决于先后位置
TIPS: 静态不可以与this和super共用

 24 final 关键字

1. 修饰类：最终类，不可以被继承
2. 修饰方法：这个方法的最终实现，不可以被重写
3. 修饰常量：值不可以被更改，并且常量定义时必须赋值
   注意：常量的定义需要使用全大写，单词之间使用下划线分隔

25 面向对象-多态

1. 前提：继承+重写
2. 口诀1：父类引用指向子类对象
解释：父类类型的引用类型变量保存的是子类类型的对象的地址值

3. 口诀2：编译看左边，运行看右边
解释：编译时要看父类是否定义了这个资源，运行时使用的是子类的功能

4. 资源使用情况
成员变量使用的是父类的
成员方法使用的是父类的方法定义，子类的方法体
如果多态对象调用的是子类没有重写过的方法，方法定义与方法体使用的都是父类的，所以这个不符合多态的前提，直接使用纯纯的父类对象调用即可
静态资源属于类资源，随着类的加载而加载，只会加载一次，优先于对象进行加载，可以通过类名直接调用，被全局所有对象共享，所以静态不存在重写的现象，在哪个类定义，就属于哪个类的资源，我们现在学习的多态，把自己看作是父类类型，参考“花木兰替父从军”

26 异常的解决方案 

 1. 捕获处理try-catch

自己解决异常捕获处理的格式：

 try{
   可能会抛出异常的代码
 }catch(异常的类型 异常的名字){
    万一捕获到了异常，进行处理的解决方案
 }

1. try-catch结构可以嵌套，如果有多种异常类型需要特殊处理的话
2. 使用多态的思想，不论是什么子异常，统一看作父类型Exception
   做出更加通用的解决方案，甚至可以只写这一个

2.向上抛出throws–交给别人解决 

异常抛出的格式：
在方法的小括号与大括号之间，写：throws 异常类型
如果有多个异常，使用逗号分隔即可

private static void method3() throws ArithmeticException,InputMismatchException,Exception{ }

private static void method3() throws Exception{ }

1. 如果一个方法抛出了异常，那么谁来调用这个方法，谁就需要处理这个异常，这里的处理也有两种方案：捕获解决 或者 继续向上抛出
2. 不能直接把异常抛给main(),因为调用main()是JVM，没人解决了，该报错还报错，所以我们一般会在main()调用之前将异常解决掉

 27 抽象

1.抽象类

被abstract修饰的方法是抽象方法,抽象方法没有方法体，一旦一个类中有抽象方法,这个类必须被声明成抽象类，如果一个子类继承了一个抽象父类,有两种解决方案:
1)抽象子类:不实现/实现一部分抽象父类中的抽象方法
2)普通子类:实现抽象父类中全部的抽象方法
抽象类不能实例化
抽象类有构造函数的,但是不是为了自己使用,为了子类super()调用
抽象类可以定义成员变量/成员常量
抽象类中可以定义全普/全抽/半普半抽
如果一个类不想被外界实例化,可以把这个类声明成抽象类
abstract关键字不可以与private static final共用

2 抽象方法

1. 被关键字abstract 修饰的方法就是抽象方法
2. 抽象方法没有方法体{ }，直接以分号结束