JavaSE学习笔记第二弹——对象和多态（下）
今天我们继续复习与JavaSE相关的知识，使用的编译器仍然是IDEA2022，大家伙使用eclipse或其他编译环境是一样的，都可以。
目录
数组
定义
一维数组
编辑
二维数组
多维数组
数组的遍历
for循环遍历
编辑
foreach遍历
封装、继承和多态
封装
继承
多态
重写
instanceof关键字
final关键字
抽象类
接口
总结
数组
定义
数组是相同类型数据的有序集合。数组可以代表任何相同类型的一组内容（包括引用类型和基本类型）其中存放的每一个数据称为数组的一个元素，数组的下标是从0开始，也就是第一个元素的索引是0，不是基本数据类型。
一维数组
一维数组中，元素是依次排列的（线性），每个数组元素可以通过下标来访问。声明方式如下：
- 类型[] 变量名称 = new 类型[数组大小];
- 类型[] 变量名称 = new 类型[数组大小];
- 类型[] 变量名称 = new 类型[]{...}; //静态初始化（直接指定值和大小）
- 类型[] 变量名称 = {...};
public class Main {public static void main(String[] args) {int[] arr_1 = new int[10];float[] arr_2 = new float[10];int[] arr_3 = new int[]{1,1,4,5,1,4};double[] arr_4 = {1.0,2.3,4.9};}
}创建出来的数组每个元素都有默认值，我们可以通过下标去访问。
public class Main {public static void main(String[] args) {int[] arr = new int[10];arr[0] = 626;System.out.println(arr[0]);System.out.println(arr[1]);}
}
我们可以通过数组变量名称.length来获取当前数组长度：
public class Main {public static void main(String[] args) {int[] arr_3 = new int[]{1,1,4,5,1,4};System.out.println(arr_3.length);}
} 
数组在创建时，就固定长度，不可更改。访问超出数组长度的内容，会出现错误。例如在Java当中，如果你尝试访问超出数组长度的内容，程序会抛出ArrayIndexOutOfBoundsException异常。
public class Main {public static void main(String[] args) {int[] arr_3 = new int[]{1,1,4,5,1,4};System.out.println("length of arr_3" + "=" + arr_3.length);System.out.println(arr_3[10]);}
}
二维数组
二维数组是存放数组的数组，每一个元素都存放一个数组的引用，等于在数组当中嵌套一个数组，套娃中的套娃，可以类比线性代数当中的矩阵或行列式来理解。以下就是一个典型的二维数组：
int[][] arr = { {1, 2},{3, 4},{5, 6}};
System.out.println(arr[2][1]);二维数组的定义方式与一维数组几乎完全一致，如下所示：
- 类型[][] 变量名称 = new 类型[数组大小][数组大小];
- 类型[][] 变量名称 = new 类型[数组大小][数组大小];
- 类型[][] 变量名称 = new 类型[][]{...}; //静态初始化（直接指定值和大小）
- 类型[][] 变量名称 = {...};
public class Main {public static void main(String[] args) {int[][] arr_1 = new int[10][10];float[][] arr_2 = new float[10][10];int[][] arr_3 = new int[][]{{1,1},{4,5},{1,4}};double[][] arr_4 = {{1.0,2.3},{4.9,5.2}};}
}当然，这里我们也可以用length来查看数组的长度，方法与一维数组一样。
多维数组
多维数组与二维数组类似，只是不断的套娃而已，可以借鉴二维数组的原理来理解。
数组的遍历
for循环遍历
for循环是我们马上就能想到的一种遍历方法，从我们学习C语言开始，我们就知道想要遍历一个数组，最直接的方法就是使用for循环来遍历。同样，在Java当中，for循环他也是存在的，格式也一样，for循环直呼：没想到吧！下面是一个常规的for循环：
public class Main {public static void main(String[] args) {int[] arr = new int[]{1,1,4,5,1,4};for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}}
}
foreach遍历
foreach属于增强型的for循环，它使得代码更简洁，同时我们能直接拿到数组中的每一个数字。它隐藏了迭代器和索引的细节，使得遍历数组或集合更加直观。但是，它不允许你直接访问元素的索引。
public class Main {public static void main(String[] args) {int[] arr = new int[]{1,1,4,5,1,4};for (int i : arr) {System.out.println(i);}}
}
封装、继承和多态
封装、继承和多态是面向对象编程的三大特性。
封装
封装的主要目的是保护对象的内部状态，防止外部代码直接访问对象的内部属性，并通过定义公共的方法来访问这些属性。这样做的好处包括提高代码的安全性、可维护性和灵活性。封装的作用主要可以概括为以下五点：数据隐藏、提高代码的安全性、提高代码的可维护性、灵活性、促进模块化。
如下我为大家展示了一段经过封装的代码：
public class PleaSure {private String name;private int age;public PleaSure(String name, int age) {this.name = name;this.age = age;}public int getAge() {return age;}public String getName() {return name;}
}
要调用已经封装好的代码中的 getAge 方法，我们需要首先创建一个 PleaSure 类的实例，然后使用这个实例来调用 getAge 方法。具体代码如下：
public class Main {public static void main(String[] args) {// 创建一个Student对象，并通过构造函数初始化它的name和age属性PleaSure pleasure = new PleaSure("Pleasure", 18);// 使用student对象调用getAge方法，并打印返回的年龄int age = pleasure.getAge();System.out.println("age is: " + age);}
}
那么如果现在我想要更改姓名name，那么我们需要新增加一个方法在封装的类内部：
public class Main {public static void main(String[] args) {// 创建一个Student对象，并通过构造函数初始化它的name和age属性PleaSure pleasure = new PleaSure("Pleasure", 18);// 使用student对象调用getAge方法，并打印返回的年龄int age = pleasure.getAge();System.out.println("age is: " + age);pleasure.setAge(20);age = pleasure.getAge();System.out.println("age is: " + age);}
}
public class PleaSure {private String name;private int age;public PleaSure(String name, int age) {this.name = name;this.age = age;}public int getAge() {return age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public void setAge(int age) {if (age >= 0) {this.age = age;} else {throw new IllegalArgumentException("Age cannot be negative.");}}
}
此时如果我们想要更改年龄，就会得出如下结果：
当然这段代码当中，我已经通过直接在代码片段当中调用setAge来修改年龄，如果想要通过键盘输入，减少每次查找到这段setAge代码再进行修改的麻烦，我们可以通过new一个Scanner来进行键盘输入，这样就可以每次通过键盘输入，而非反复查找相关代码，节约时间。
继承
继承允许我们基于一个已存在的类（称为父类或基类）来创建一个新的类（称为子类或派生类），子类会继承父类的属性和方法，可以减少代码的重复定义。封装的作用主要可以概括为以下七点：代码重用、扩展功能、建立类之间的层次关系、多态性的基础、模板化设计、访问控制、实现接口的一种替代方式。
现在PleaSure分为两种，A和B，他们都是PleaSure的分支，但是他们都有自己的方法：
public class APleaSure extends PleaSure{public APleaSure(String name, int age) {super(name, age);}public void guanzhu(){System.out.println("关注");}
}
//CSDN的PleaSure乐事水印
public class BPleaSure extends PleaSure{public BPleaSure(String name, int age) {super(name, age);}public void dianzan(){System.out.println("点赞");}
}需要一定注意的是，在继承后我们必须先通过super关键字（指代父类），实现父类的构造方法。当我们已经像上面这样完成了两个继承完毕的子类，我们可以通过如下方法完成调用方法：
public class Main {public static void main(String[] args) {// 创建APleaSure实例APleaSure apleaSure = new APleaSure("Alice", 30);// 调用APleaSure的guanzhu方法apleaSure.guanzhu();// 创建BPleaSure实例BPleaSure bpleaSure = new BPleaSure("Bob", 25);// 调用BPleaSure的dianzan方法bpleaSure.dianzan();}
}
需要注意的是，每一个子类必须定义一个实现父类构造方法的构造方法，也就是需要在构造方法开始使用super，如果父类使用的是默认构造方法，那么子类不用手动指明。
所有类都默认继承自Object类，除非手动指定类型，但是依然改变不了最顶层的父类是Object类。所有类都包含Object类中的方法。
多态
多态允许一个引用变量在运行时指向多种实际类型的对象，并且这些对象可以执行相同的方法但表现出不同的行为。多态的作用主要包含以下几点：增加程序的扩展性和可维护性、接口和抽象类的实现、动态绑定、提高代码复用性和灵活性。
重写
方法的重写和重载是不一样的，重载是原有的方法逻辑不变的情况下，支持更多参数的实现，而重写是直接覆盖原有方法。
假设我们在父类中有这样一个方法：
public void study(){System.out.println("点赞");
}在子类中我们通过重写后的代码如下：
@Override
public void study(){System.out.println("关注");
}那么我们在主函数中调用study方法后我们会得到如下结果：
public class Main {public static void main(String[] args) {// 创建APleaSure实例APleaSure apleaSure = new APleaSure("Alice", 30);// 调用APleaSure的guanzhu方法apleaSure.study();}
}
当我们在重写方法时，不仅想使用我们自己的逻辑，同时还希望执行父类的逻辑（也就是调用父类的方法）时我们可以写如下代码：
public void study(){super.study();System.out.println("给你看点好康的");
}同理，如果想访问父类的成员变量，也可以使用super关键字来访问，例如：
public void setTest(int test){test = 1;this.test = 1;super.test = 1;
}instanceof关键字
我们如果只是得到一个父类引用，但是不知道它到底是哪一个子类的实现时，我们可以使用instanceof关键字来帮助我们进行类型判断。
final关键字
final关键字能够使得一个变量的值不可更改，那么如果在类前面声明final，则该类无法再被继承，不允许子类的存在。如果类的成员属性被声明为final，那么必须在构造方法中或是在定义时赋初始值。
private final String name; //引用类型不允许再指向其他对象
private final int age; //基本类型值不允许发生改变public Student(String name, int age) {this.name = name;this.age = age;
}抽象类
类本身就是一种抽象，而抽象类，把类还要抽象，也就是说抽象类可以只保留特征，而不保留具体呈现形态，比如方法可以定义好，但是我可以不去实现它，而是交由子类来进行实现。例如：
public abstract class Student { //抽象类public abstract void test(); //抽象方法
}通过使用abstract关键字来表明一个类是一个抽象类，抽象类可以使用abstract关键字来表明一个方法为抽象方法，也可以定义普通方法，抽象方法不需要编写具体实现，但是必须由子类实现（除非子类也是一个抽象类）
但是需要注意的是，抽象类由于不是具体的类定义，因此无法直接通过new关键字来创建对象。
接口
在Java当中，接口只代表某个确切的功能，也就是只包含方法的定义，接口包含了一些列方法的具体定义，类可以实现这个接口，表示类支持接口代表的功能。使用interface实现。
public interface Eat {void eat();
}一个类可以实现很多个接口，类通过implements关键字来声明实现的接口，每个接口之间用逗号隔开。比如：
public class SportsStudent extends Student implements Eat, ...{@Overridepublic void eat() {}
}总结
至此，我们大致浏览和学习了JavaSE当中有关数组、封装、继承、多态、抽象类和接口相关的知识，希望对大家有所帮助，也希望大家可以为我留下点赞、关注和收藏，这对我真的很重要，谢谢！也希望能与大家一起努力，获得更好的未来。