二、常用操作
1 public class TestArray {
2 public static void main(String[] args) {
3 /**
4 * 1. 数组的初始化
5 /
6 // 1.1 数组的静态初始化
7 int[] array1 = { 1, 3, 5, 6, 7, 2, 4, 10 };
8
9 // 1.2 数组的动态初始化
10 int[] array2 = new int[5];
11 array2[0] = 1;
12 array2[1] = 2;
13 array2[2] = 7;
14 array2[3] = 3;
15 array2[4] = 4;
16
17 /*
18 * 2. 数组的遍历
19 /
20 // 2.1 for循环打印数组
21 for (int i = 0; i < array2.length; i++) {
22 System.out.print(array2[i]);
23 }
24
25 // 2.2 foreach打印数组
26 for (int i : array2) {
27 System.out.print(i);
28 }
29
30 /*
31 * 3. 数组排序
32 */
33
34 // 3.1 冒泡排序
35 for (int i = 0; i < array2.length; i++) {
36 for (int j = i + 1; j < array2.length; j++) {
37 // 1. 比较相邻元素，将较大的数冒泡
38 if (array2[i] > array2[j]) {
39 // 2. 交换
40 int temp = array2[i];
41 array2[i] = array2[j];
42 array2[j] = temp;
43 }
44 }
45 }
46 for (int i : array2) {
47 System.out.println(i);
48 }
49
50 // 3.2 选择排序
51 for (int i = 0; i < array2.length; i++) {
52 int min = i;
53 for (int j = i; j < array2.length; j++) {
54 // 1. 找到最小的数
55 if (array2[j] < array2[min]) {
56 // 2. 将最小的数赋值给min
57 min = j;
58 }
59 }
60 // 3. 交换两个数的位置
61 int temp = array2[i];
62 array2[i] = array2[min];
63 array2[min] = temp;
64 }
65 for (int i : array2) {
66 System.out.println(i);
67 }
68
69 // 3.3 反转排序
70 for (int i = 0; i < array2.length / 2; i++) {
71 // 将第i位元素与array2.length-1-i位元素交换
72 int temp = array2[i];
73 array2[i] = array2[array2.length - 1 - i];
74 array2[array2.length - 1 - i] = temp;
75 }
76 for (int i : array2) {
77 System.out.println(i);
78 }
79
80 // 3.4 插入排序
81 for (int i = 0; i < array2.length; i++) {
82 int j = i;
83 int tmp = array2[i];
84 for (; j > 0 && tmp < array2[j - 1]; j–) {
85 // 1. 将大于待排序的数向后移
86 array2[j] = array2[j - 1];
87 }
88 // 2. 交换
89 array2[j] = tmp;
90 }
91 for (int i : array2) {
92 System.out.println(i);
93 }
94 }
95 }
三、Arrays工具类
1 package pers.mj;
2
3 import static org.hamcrest.CoreMatchers.instanceOf;
4
5 import java.util.Arrays;
6 import java.util.List;
7
8 import org.junit.Test;
9
10 public class Demo {
11 @Test
12 public void test() {
13
14 int[] array1 = { 1, 3, 5, 2, 4 };
15 int[] array2 = { 3, 2 };
16
17 // 1. 排序
18 Arrays.sort(array2);
19 for (int i : array2) {
20 System.out.print(i);
21 }
22
23 // 2. 二分法查找
24 System.out.print(Arrays.binarySearch(array2, 3));
25
26 // 3. 数组元素比较
27 System.out.println(Arrays.equals(array1, array2));
28
29 // 4. 数组元素填充
30 Arrays.fill(array2, 1);
31 for (int j : array2) {
32 System.out.println(j);
33 }
34
35 /**
36 * aslist详解
37 * 1. 该方法适用于对象型数据的数组（String、Integer…）
38 * 2. 该方法不建议使用于基本数据类型的数组（byte,short,int,long,float,double,boolean）
39 * 3. 该方法将数组与List列表链接起来：当更新其一个时，另一个自动更新
40 * 4. 不支持add()、remove()、clear()等方法
41 */
42
43 // 1、对象类型(String型)的数组数组使用asList()，正常
44 String[] strings = { “aa”, “bb”, “cc” };
45 List stringList = Arrays.asList(strings);
46 System.out.print("1、String类型数组使用asList()，正常： ");
47 for (String str : stringList) {
48 System.out.print(str + " ");
49 }
50 System.out.println();
51
52 // 2、对象类型(Integer)的数组使用asList()，正常
53 Integer[] integers = new Integer[] { 1, 2, 3 };
54 List integerList = Arrays.asList(integers);
55 System.out.print("2、对象类型的数组使用asList()，正常： ");
56 for (int i : integerList) {
57 System.out.print(i + " “);
58 }
59 System.out.println();
60
61 // 3、基本数据类型的数组使用asList()，出错
62 int[] ints = new int[] { 1, 2, 3 };
63 List intList = Arrays.asList(ints);
64 System.out.print(“3、基本数据类型的数组使用asList()，出错(输出的是一个引用，把ints当成一个元素了)：”);
65 for (Object o : intList) {
66 System.out.print(o.toString());
67 }
68 System.out.println();
69
70 System.out.print(” " + “这样遍历才能正确输出：”);
71 int[] ints1 = (int[]) intList.get(0);
72 for (int i : ints1) {
73 System.out.print(i + " ");
74 }
75 System.out.println();
76
77 // 4、当更新数组或者List,另一个将自动获得更新
78 System.out.print("4、当更新数组或者List,另一个将自动获得更新： ");
79 integerList.set(0, 5);
80 for (Object o : integerList) {
81 System.out.print(o + " ");
82 }
83 for (Object o : integers) {
84 System.out.print(o + " ");
85 }
86 System.out.println();
87
88 }
89 }
四：面向对象
一、简介
1. 概念：面向对象也即OOP(Object Oriented Programming)，是一种编程思想，它以对象作为基本的单元来构建系统，具有三大特征和五大原则。
2. 三大特征：
1. 封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式，提高安全性。
2. 继承：提高代码复用性，是实现多态的前提。
3. 多态：父类或接口定义的引用变量指向子类或具体实现类的实例对象，提高了代码的拓展性。
3. 五大原则
1. 单一职责原则SRP(Single Responsibility Principle)：类的功能要单一。
2. 开放封闭原则OCP(Open－Close Principle)：扩展开放，修改关闭。
3. 里式替换原则LSP(the Liskov Substitution Principle LSP)：子类可以替换父类出现在父类能够出现的任何地方。
4. 依赖倒置原则DIP(the Dependency Inversion Principle DIP)：高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。抽象不应该依赖于具体实现，具体实现应该依赖于抽象。
5. 接口分离原则ISP(the Interface Segregation Principle ISP)：设计时采用多个与特定客户类有关的接口比采用一个通用的接口要好。
二、封装
1. 核心思想：隐藏细节，保护数据安全。
2. 访问权限
3. 封装代码实现
1 public class Encapsulation {
2 // 1.成员属性私有化
3 private String name;
4 private String pwd;
5
6 // 2.提供getter和setter方法来访问
7 public String getName() {
8 return name;
9 }
10
11 public void setName(String name) {
12 this.name = name;
13 }
14
15 public String getPwd() {
16 return pwd;
17 }
18
19 public void setPwd(String pwd) {
20 this.pwd = pwd;
21 }
22 }
23
24 class TestEncapsulation {
25 public static void main(String[] args) {
26 Encapsulation test = new Encapsulation();
27 // 3.通过setter方法设置属性值
28 test.setName(“封装”);
29 test.setPwd(“666”);
30 // 4.通过getter方法获取值
31 System.out.println(“姓名：” + test.getName() + " – 密码：" + test.getPwd());
32
33 }
34 }
三、方法的重载和重写
1. 方法的重载：方法名相同，参数列表不同
2. 方法的重写：方法名、返回值类型、参数列表都相同，构造方法和使用final、static修饰的方法不能被重写。对于新手小白想更轻松的学好Java提升，Java架构，web开发、大数据，数据分析,人工智能等技术，这里给大家分享系统教学资源，扩列下我尉（同英）：CGMX9880 【教程/工具/方法/解疑】
3. 方法重载和重写代码实现
1 package pers.mj;
2
3 public interface Override {
4 /**
5 * 方法的重载：方法名相同，参数列表不同
6 /
7 public void query(int id);
8
9 public int query(int id, String username);
10
11 }
12
13 class Test implements Override {
14 /*
15 * 方法的重写：方法的所有东西都一样，只有方法实体不同。
16 */
17 public void query(int id) {
18 System.out.println(“我重写了接口的方法”);
19
20 }
21
22 public int query(int id, String username) {
23 System.out.println(“我也可以重写父类的方法”);
24 return 0;
25 }
26
27 }
四、继承
1. 核心思想：解决代码冗余，提高代码的复用性
2. 继承关系：满足is-a的关系，父类更通用，子类更具体。
3. 继承代码实现
1 /**
2 * 1. 将类中重复的部分提取成为父类
3 /
4 public class Animal {
5 private String name;
6 private String food;
7
8 public Animal(String name, String food) {
9 this.name = name;
10 this.food = food;
11 }
12
13 public void eat() {
14 System.out.println(name + “正在吃” + food);
15 }
16 }
17
18 /*
19 * 2. 子类继承父类，对父类进行扩展
20 /
21 public class Cat extends Animal {
22
23 public Cat(String name, String food) {
24 super(name, food);
25 }
26 }
27 public class Dog extends Animal{
28
29 public Dog(String name, String food) {
30 super(name, food);
31 }
32 }
33
34 /*
35 * 3. 测试
36 */
37 public class TestExtends{
38 public static void main(String[] args) {
39 Animal cat = new Cat(“三三”, “鱼”);
40 cat.eat();
41 Animal dog = new Dog(“二哈”, “香肠”);
42 cat.eat();
43 }
44 }
五、多态
1. 核心思想：提高代码可维护性和可扩展性
2. 实现多态的三个必要条件：继承、重写、父类引用指向子类对象(向下转型)
3. 多态的实现方式：重写、接口、抽象类和抽象方法
4. 多态代码实现
1 /**
2 * 1. 创建动物类，定义动物吃什么的方法
3 /
4 class Animals {
5 private String name;
6 private String food;
7
8 public Animals(String name, String food) {
9 super();
10 this.name = name;
11 this.food = food;
12 }
13
14 public void eat() {
15 System.out.println(this.name + “会吃” + this.food);
16 }
17 }
18
20 /*
21 * 2. 创建Cat类来实现吃的功能
22 /
23 class Cat extends Animals{
24 public Cat(String name, String food) {
25 super(name, food);
26 }
27
28 @Override
29 public void eat() {
30 super.eat();
31 }
32 }
33
35 /*
36 * 3. 通过向上转型和向下转型实现多态
37 */
38 public class Test01 {
39 public static void main(String[] args) {
40 // 向下转型
41 Animals animals = new Cat(“三三”, “鱼”);
42 animals.eat();
43 // 向上转型
44 Cat cat = (Cat) animals;
45 cat.eat();
46 }
47 }
六、抽象类
1. 核心思想：让代码有更强的可扩展性
2. 特点
1. 抽象类不能实例化对象。
2. 如果一个类包含抽象方法，那么该类必须是抽象类
3. 任何子类必须重写父类的抽象方法(具体实现)，或者声明自身为抽象类
4. 抽象类中的抽象方法只有方法声明，没有方法体
5. 构造方法和static修饰的方法不能声明为抽象方法
3. 抽象类代码实现
1 /**
2 * 1. 创建员工抽象类
3 */
4 abstract class Employees {
5 // 成员变量
6 private String name;
7 private String address;
8 private Integer number;
9
10 // 构造方法
11 public Employees(String name, String address, Integer number) {
12 System.out.println(“Employees.Employees()”);
13 this.name = name;
14 this.address = address;
15 this.number = number;
16 }
17
18 // 定义信息抽象函数
19 public abstract void call();
20
21 // 省略getter 和 setter方法
22 …
23 }
24 }
25
26 class Salary extends Employees {
27 private Double salary;
28
29 public Salary(String name, String address, Integer number, Double salary) {
30 super(name, address, number);
31 this.salary = salary;
32 System.out.println(“Salary.Salary()”);
33 }
34
35 // 2. 重写父类的抽象方法
36 @Override
37 public void call() {
38 System.out.println(super.getNumber() + “是” + super.getName() + “的电话，他住在” +
39 super.getAddress() + “他现在的工资是” + this.salary);
40 }
41 }
42
43 public class Test {
44 public static void main(String[] args) {
45 // 3. 抽象类的对象必须由子类去实例化
46 Employees emp = new Salary(“孙悟空”, “花果山”, 1234, 222.66);
47 emp.call();
48 }
49 }
