5 循环 、数组

5.1 循环

1. while循环：先判断，在执行
2. do … while循环：先执行，在判断
3. for循环：有起始条件时经常使用

while(执行条件){
	循环体；
}

do{
	循环体；
}while（执行条件）；

for（初始条件；判断条件；改变条件）{
	执行循环语句
}

for、while、do …while区别

1. for用于知道循环次数的循环，其余两者用于不确定次数的循环
2. while为先判断在执行，do…while先执行，在判断条件，是否终止执行
3. 三种循环之间是可以相互替代的

5.2 数组

简介：数组Array，标志是[ ] ,用于储存多个相同类型数据的集合
想要获取数组中的元素值，可以通过脚标（下标）来获取
数组下标是从0开始的,下标的最大值是数组的长度减1

5.2.1 数组创建

动态初始化：

int[]a=new int[5];
a[0]=1;
a[1]=2;
a[2]=3;
a[3]=4;
a[4]=5;

静态初始化

int[] b={1,2,3,4,5};
int[] c=new int[]{1,2,3,4,5};

注意：数组名保存的是数组的地址值，不是数组中的每一个元素，数组名是一个引用类型的变量

5.2.2 数组工具类Arrays

使用.length来体现，数组一旦创建，长度不可改变

• 1.Arrays.toString 把数据组输出
• 2.Arrays.sort 对数组中数据排序
• 3.Arrays.copyOf 复制数组数据
• 4.Arrays.copyOfRange 范围复制截取数组数据

注：

1. toString:除了char类型以外均需要用此方法查看具体元素
2. copyOf （用来复制原数组，新数组长度）
   如果新数组的长度大于原数组，数组的扩容，不够的位置为默认值
   如果新数组的长度小于原数组，数组的缩容，类似原数组的截取
   如果新数组的长度等于原数组，数组的普通复制
   不管哪一种，都是通过复制，创建一个新数组
3. sort利用优化后的快速排序对数组进行排序

5.2.3 数组的遍历

若仅仅需要查看，使用Arrays.toString打印出即可
遍历即把数组中的元素均过一遍
通过循环遍历数组，所以循环中循环变量代表的就是数组的下标

5.2.4 冒泡排序

排序算法的一种，每一轮比较均得出一个最大值
其他算法：二分查找、快速排序、全排序、归并排序
排序思路
1.多轮比较，若果有n个数，比较n-1轮
2.相邻位置比大小，进行互换
注意：前面轮中的最大值，不需要参与本轮比较
3.嵌套for循环完成
外层循环变量代表轮数【数组长度-1】
内层循环变量代表数组下标【轮数往后，比较次数减少，j随着i的增大而减小】
4.优化思路
可对其进行优化，优化后的算法，对于后续比较前者小于后者的不需要执行互换代码，提升效率。具体方案参见如下代码

package example;

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] a = {12, 77, 11, 56, 34};
//        数组排序Arrays.sort
//        Arrays.sort(a);
//        System.out.println(Arrays.toString(a));

        method(a);//冒泡排序方法原理
    }

    private static void method(int[] a) {
        for (int i = 1; i <= a.length - 1; i++) {
            boolean flag = false;
            System.out.println("第" + i + "轮");
            for (int j = 0; j < a.length - i; j++) {
                if (a[j] > a[j + 1]) {
                    int t;
                    t = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = t;
                    flag = true;
                }
            }
            if (flag == false) {
                break;
            }
            System.out.println("第" + i + "轮排序后的效果：" + Arrays.toString(a));
        }
        System.out.println("排序完成后的数组" + Arrays.toString(a));
    }
}

6 面向对象

6.1 类、对象、封装

6.1.1 面向过程

面向过程是一种编程思想，这种思想强调过程

6.1.2 面向对象

java是一门面向对象的语言
面向对象oop也是一种编程思想，这种思想强调的是结果，其过程是怎么样的并不重要。

6.1.3 类

类指的是类型type，用java中的关键字class描述，一类事物抽象的特征与行为
可以把类看做是一类事物的模板/图纸

6.1.4 对象

对象就是根据类创建出来的一个个独立的具体事例
一个类可以创建多个对象，对象之间互不影响，可以通过对象唯一的地址来区分对象。

6.1.5 对象创建过程分析

比如：Phone p=new Phone() ; 这句话在内存中发生了什么？

1. 可以在堆内存中开辟一块空间用来存放对象
2. 这个对象需要进行初始化
3. 初始化完毕以后会为这个对象生成一个唯一的地址值
4. 在栈内存中开辟一块空间用来存放引用类型Phone类型的变量p
5. 将堆内存中的对象地址值交给引用类型的变量p来保存
6. 后续就可以根据p中保存的地址，找到堆中的对象，对对象进行操作
7. 如p.brand=”huawei”，就是根据p中保存的地址，找到对象，并对对象的属性赋值。

6.1.6 封装

1. 封装可以提高程序的安全性
2. 封装可以让资源按照我们预先规定的方式来操作

封装的属性

1. 用private修饰属性
2. 提供这个属性的get…()获取值与set…()设置值
3. 外界就可以调用公共的get与set方法操作属性了
   注意：访问控制符private修饰的资源只能在本类中使用

封装的方法

1. 用private修饰方法
2. 可以在本类中的公共方法里，调用此私有的方法
3. 外界通过调用公共的方法来使用私有的方法

6.2 构造方法、继承

6.2.1 构造方法

特点：没有返回值类型，且方法名与本类类名一致
作用：构造方法用来创建对象，每次触发，都可以创建一个对应的对象

1. 每个类默认存在一个无参构造
2. 一旦提供了其他的构造函数，默认的无参构造就会被覆盖掉，在使用无参构造需要手动创建
3. 每次创建对象都会触发一个构造方法，创建一次，触发一次，具体触发的是那个构造函数，取决于调用时的函数
4. 无参构造，没有参数的构造方法
   含参构造，包含参数的构造方法，参数可由自己决定
   全参构造，构造方法的参数与本类中所有的属性一致，全参构造除了可以创建对象，还可以给对象的属性赋值
5. 构造函数是被动触发的，不是像普通方法的调用那样
6. 全参构造必须添加给属性赋值的语句，如果不写，即便传入参数，也不会被赋值。

执行顺序：构造代码块 >构造方法>对象创建成功>普通方法>局部代码块
1.当创建对象时，会触发构造函数
2.创建对象时，会触发构造代码块，而且构造代码块优先于构造方法执行的
3.通过创建好的对象来调用普通的方法
4.如果调用的普通方法里有局部代码块，对应的局部代码块才会执行

6.2.2 This

This代表的是本类，主要作用有两个

1. 当本类的成员变量与局部变量同名的时候，指定成员变量
2. 调用本类的构造方法时，this(); 调用本类的无参构造 this(参数); 调用本类的对应参数构造方法
3. 通过this调用时，不得相互调用，并且使用this必须要在构造方法的第一行
4. 构造方法被动触发，不得主动调用，更不可创建本类的对象来调用

6.2.3 继承

1. 继承关键字为extends 格式：子类extends父类
2. 继承相当于子类把父类的功能复制一份，包括私有资源，只是私有资源不表现
3. Java只支持单继承，一个子类只有一个父类，一个父类可以有多个子类
4. 继承具有传递性
5. 子类只能使用父类的非私有资源，私有资源不可用因为不可见
6. 子类可以拥有自己的特色功能
7. 继承是is a 强耦合关系，具有很强的依赖性。

6.3 重写、重载、final、static

6.3.1 继承中变量的使用

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

6.3.2 继承中构造方法的使用

1. 每次创建对象时，都会触发构造函数
2. 创建子类对象时，会先调用父类的无参构造，子类的构造函数中默认存在一个super();
3. 如果父类没有无参构造，在子类中需要手动添加super(参数);来调用父类的含参构造
4. 构造方法不可以被继承。因为构造方法名必须是本类的类名

6.3.3 方法重写

重写：子类对父类的方法不满意时，可以重写父类的方法，对其功能做修改
重写的语法规则：两同 两小 一大
1. 一大：子类方法的修饰符权限>=父类方法的修饰权限
2. 两同：方法名相同，参数列表相同
3. 两小：子类方法的返回值类型<=父类方法的返回值类型
子类方法抛出的异常类型<=父类方法抛出的异常类型
注意：如果父类方法的返回值类型为void，那么子类方法的返回值类型也是void
注意：我们这里说的返回值的类型大小，不是值得大小，而是 继承关系

6.3.4 方法重载：

如果在同一个类中，存在多个重名的方法，单参数列表不同的现象
作用：重载使我们的代码更灵活，传入不同的参数，都可以有不同的方法被调用
注意：方法是否勾成重载，与方法参数的类型有关，与方法的名字无关
前提：同一个类中，同名的方法，
1.方法的参数个数不同，一定勾成重载
2.方法的参数个数相同，需要查看相应对应位置的类型

6.3.5 重载与重写的比较

重载：在一个类中的现象：同一个类中，存在方法名相同，参数列表不同的方法。
重载意义：是为了外界调用时的方便，不管传入什么样的参数，都可以匹配到对应同名的方法

重写：指建立了继承关系以后，子类对父类的方法不满意，可以重写，遵循两同两小一大原则
重写的意义：在不修改源代码的情况下，进行功能的修改与拓展（OCP原则：面向修改时关闭，面向拓展时开放）

6.3.6 this与super

1. this代表对本类同名对象的引用/super代表的是对父类同名对象的引用
2. 本类成员变量与局部变量重名，this.变量名
   本类成员变量与父类成员变量重名，super.变量名
3. This(); 调用本类无参构造 this（参数）调用本类的含参构造
   Super()；调用父类无参构造，super（参数）调用父类对应含参构造
4. 注：super的使用基于继承的前提，没有父子关系继承就没有super
   This与super的使用都需要在构造方法的第一行
   子类重写了父类的方法之后，需要使用super.方法名（参数列表）来调用

6.3.7 final

fina表示最终，用来修饰的类为最终类，不可被继承；用来修饰的方法为最终实现，不可重写；用来修饰的常量，值不可被修改，常量定义时必须赋值。

6.3.8 关键字static

被static修饰的资源称为静态资源，可以修饰变量，方法，代码块。

1. 静态资源属于类资源，随类的加载而加载，优先于对象进行加载
2. 静态资源被全局对象共享
3. 静态只能调用静态

6.3.9 静态代码块

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

6.4 多态、异常、抽象

6.4.1 多态

1. 多态的前提：继承、有方法的重写
2. 父类引用指向子类对象,如：Animal a = new Cat();
3. 多态中，编译看左边，运行看右边

注意：多态对象把自己看做是父类类型
成员变量: 使用的是父类的
成员方法: 由于存在重写现象,所以使用的是子类的
静态成员: 随着类的加载而加载,谁调用就返回谁的

6.4.2 异常

异常处理只有两种方式: catch 和 throws,所以必须二选一

1.捕获

try {
…
} catch(Exception e) {
}
底层异常，应该向前抛出处理

2.抛出

throws 异常类型
经验少时，不知道该在什么位置捕获处理，应该选择 throws
例如：void method1 throws Exception1,Exception2,Exception3{ }

6.4.3 抽象

1. abstract可以用来修饰方法，叫做抽象方法；可以用来修饰类，叫做抽象类；
2. 子类继承了抽象类以后,要么还是一个抽象类,要么就把父类的所有抽象方法都重写
3. 多用于多态中
4. 抽象类不可以被实例化
5. 抽象方法要求子类继承后必须重写。

注：abstract关键字在抽象类中和以下关键字共同使用时是没有意义的：

1. private：被私有化后，子类无法重写，与abstract相违背。
2. static：静态优先于对象存在，存在加载顺序问题。
3. final：被final修饰后，无法重写，与abstract相违背。