作业（知识总结）

第一页

一：数据类型

    1.引用数据类型：类接，口，数组;
    2.基础数据类型：
    （1）数值型：整形，浮点型；
        整型：byte,short,int,long;
        浮点型：float,double;
    (2):字符型:char;
    (3):布尔型：blllean:

二：运算符

• 算术运算符

• 赋值运算符

• 关系运算符

• 逻辑运算符

• 位运算符

• 三元运算符

1.算数运算符：

分为一元运算符和二元运算符:+， - ，*，/， %， num++，++num, num--,--num;

2.赋值运算符

赋值运算符与扩展运算符：=， +=， -=， *= ， /=，%=:

3.关系运算符

也称作比较运算符，运算结果为布尔类型：> ,<,  ==,  >=,  <=  ,  !=;

4.逻辑运算符

用于连接多个布尔值：一般与比较运算符一起用，表示与、或、非的关系：&， |，^， ！， &&，||；

5.位运算符

直接对二进制进行的计算，性能极高，很多框架都会使用位运算：<<, >>,  >>>,  &,  |,   ^,   ~;

6.三元运算符

又称三目运算符，是连接三个表达式的运算符，格式如下：

条件表达式？表达式1：表达式2；

当条件表达式为ture时，执行表达式1，否则执行表达式2；

运算符优先级：

括号    ( )　[ ] 　.    从左到右

正负号     +，-

一元运算符 ! 　~　 ++　 –    从右到左

乘除    *　 /　 %    从左到右

加减    +　 -    从左到右

移位运算  << 　>>　 >>>    从左到右

比较大小  < 　<=　 > 　>=　 instanceof    从左到右

比较是否相等== 　!=    从左到右

换位与运算&    从左到右

换位异与运算^    从左到右

换位或运算|    从左到右

逻辑与运算  &&    从左到右

逻辑或运算 ||    从左到右

三元运算符 ? :    从左到右

赋值运算符  =   从右到左

三.程序控制

1.选择结构

（1）if语句

if 条件:
    # 在条件满足时执行的代码块
else:
    # 在条件不满足时执行的代码块
 

（2）switch语句

switch (expression) {
  case value1:
    // 当expression等于value1时执行的代码
    break;
  case value2:
    // 当expression等于value2时执行的代码
    break;
  ...
  default:
    // 当expression不匹配任何case时执行的代码
    break;
}
 

两种结构对比：

两种结构都可以实现逻辑判断，但他们使用的场景不同。if语句一般用于区间值的判断，而switch语句只能用于确定值的判断。凡是switch语句能实现的，if语句都可以，反之却不行。

2.循环结构

（1）while语句

while 条件:
    # 代码块
 

（2）do.....while语句

do { // 代码块 } while (条件);

（3）break和continue语句

break用于强制退出循环，不执行剩余语句；

continue只能终止某次循环，继续下一次循环。

四.数组

1.数组概述

数组是一种容器，可以存储多个相同类型的元素。数组的元素可以通过索引来访问，索引从0开始，依次递增。

数组有以下特点：

1. 数组的长度是固定的，一旦创建后，不能再改变其大小。
2. 数组可以存储任何数据类型的元素，包括基本数据类型和对象。
3. 数组可以是一维的，也可以是多维的，例如二维数组。
4. 数组的元素在内存中是连续存储的，可以快速访问。
5. 数组可以通过循环结构来遍历所有元素。
6. 数组可以作为参数传递给方法，也可以作为方法的返回值。
7. 数组可以使用下标来修改或者获取元素的值。

数组的应用场景非常广泛，常见的应用包括存储一组数据、实现矩阵和图等数据结构、排序和搜索算法等。

2.数组常见操作

（1）通过索引操作元素：

（2）数组的遍历

foreach循环语法如下：

int[] arr = {1, 2, 3, 4, 5};
for (int num : arr) {
    System.out.println(num);
}
 

获取数组最值

int[] array = {1, 2, 3, 4, 5};
int max = array[0];
for (int i = 1; i < array.length; i++) {
    if (array[i] > max) {
        max = array[i];
    }
}
System.out.println("最大值：" + max);
 

通过值获取索引、数组元素反转..........

3.数组排序算法

（1）冒泡排序

public static void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
 

（2）选择排序

public static void selectionSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}
 

4.二分查找法

public class BinarySearch {
    public static int binarySearch(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;

        while (left <= right) {
            int mid = left + (right - left) / 2;

            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }

        return -1; // 目标元素不存在
    }

    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        int target = 5;

        int index = binarySearch(nums, target);
        if (index != -1) {
            System.out.println("目标元素的索引为：" + index);
        } else {
            System.out.println("目标元素不存在");
        }
    }
}
 

5.二维数组

数据类型[  ][  ]数组名=new 数据类型[  ][  ]；

6.Arrays工具类

常用的方法包括：

1. sort()：对数组进行排序。

2. binarySearch()：在排序后的数组中查找指定元素。

3. equals()：比较两个数组是否相等。

4. fill()：将数组的所有元素都设置为指定的值。

5. copyOf()：复制数组。

6. toString()：将数组转换为字符串。

第二页

类与对象（封装、继承、多态、接口）

一、封装

1）定义：隐藏对象的属性和实现细节，仅对外公开接口,控制在程序中属性的读和修改的访问级别。
2）封装的目的是：增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员。

 就像现在在用电脑或手机看这篇文章，你使用电脑或手机的时候并不需要理解电脑或手机内部是怎么样构成的，你只需要对点开浏览就可以了。

二、继承

1、

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

java中使用extends 关键字表示继承，如下：

class 父类 {}

class 子类 extends 父类{ }

2、

重写：表示子类中的方法名、返回值、参数列表和父类当中的方法是一模一样（子类继承了父类的所有方法，包括父类中的方法。子类可以直接使用父类的方法，也可以重写父类的方法来实现自己的功能。在子类中可以通过super关键字来调用父类的方法。）

三、多态

多态是面向对象程序设计中的一个重要概念，指的是同一个方法调用可以根据对象的不同而表现出不同的行为。简单来说，多态就是通过子类重写父类的方法，实现对同一方法的不同实现。

引用数据类型：

（1）向上转型：父类引用指向子类对象，属于自动类型转换。

父类类型  变量名 =  子类对象；

（2）向下转型：子类引用指向父类对象。属于强制类型转换。

子类类型  变量名  =  （子类类型）父类对象；

四、抽象类

所谓接口就是对操作规范的说明。接口只是说明操作应该做什么( What)，但没有定义操作如何做( How)。接口可以理解成为类的一个特例，它只规定实现此接口的类的操作方法，而把真正的实现细节交由实现该接口的类去完成。

接口在面向对象分析和设计过程中起到了至关重要的桥梁作用，系统分析员通常先把有待实现的功能封装并定义成接口，而后期程序员依据此接口进行编码实现。

定义接口用interface修饰：

interface 接口名[ extends 父接口 1，父接口 2，···]{

//常量定义

//方法定义

}

接口的继承：

// 定义一个父接口
interface Animal {
    void eat();
    void sleep();
}

// 定义一个子接口，继承自父接口，并添加了一个新方法
interface Dog extends Animal {
    void bark();
}

// 实现子接口
class Labrador implements Dog {

    @Override
    public void eat() {
        System.out.println("Labrador is eating");
    }

    @Override
    public void sleep() {
        System.out.println("Labrador is sleeping");
    }

    @Override
    public void bark() {
        System.out.println("Labrador is barking");
    }
}

public class InterfaceInheritanceExample {

    public static void main(String[] args) {
        Labrador labrador = new Labrador();
        labrador.eat(); // 输出：Labrador is eating
        labrador.sleep(); // 输出：Labrador is sleeping
        labrador.bark(); // 输出：Labrador is barking
    }
}
 

抽象类与接口的区别：

1、接口是行为的抽象，是一种行为的规范，接口是like a 的关系；抽象是对类的抽象，是一种模板设计，抽象类是is a 的关系。
2、接口没有构造方法，而抽象类有构造方法，其方法一般给子类使用
3、接口只有定义，不能有方法的实现，java 1.8中可以定义default方法体，而抽象类可以有定义与实现，方法可在抽象类中实现。
4、抽象体现出了继承关系，继承只能单继承。接口提现出来了实现的关系，实现可以多实现。接口强调特定功能的实现，而抽象类强调所属关系。