2024年网络安全最全JavaSE 万字总结知识点（期末复习指南），2024年最新讲的真透彻

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

• 小于等于运算符（<=）：检查一个值是否小于或等于另一个值。

4. 逻辑运算符：

• 与运算符（&&）：当两个条件都为true时，返回true。
• 或运算符（||）：当至少有一个条件为true时，返回true。
• 非运算符（!）：用于取反一个条件的值。

5. 赋值运算符：

• 等号运算符（=）：将右边的值赋给左边的变量。
• 加等运算符（+=）：将右边的值与左边的变量相加，并将结果赋给左边的变量。

6. 位运算符：

• 与运算符（&）：将两个值的对应位进行逻辑与操作。
• 或运算符（|）：将两个值的对应位进行逻辑或操作。
• 异或运算符（^）：将两个值的对应位进行逻辑异或操作。

7. 条件运算符：

• 三元运算符（? :）：根据一个条件的真假选择两个表达式之一。

8. 移位运算符：

• 左移运算符（<）：将数按照二进制往左移动一位
• 右移运算符（>）：将数按照二进制往右移动一位
• 无符号右移（>>>）：将数按照二进制往右移动一位，但是空缺的数值位补0

---

五.逻辑控制

选择语句

switch 语句

其中float double boolean long类型不能作为switch语句的参数

switch (表达式) {
   case 值1:
       // 如果表达式的值等于值1，执行这里的代码
       break;
   case 值2:
       // 如果表达式的值等于值2，执行这里的代码
       break;
   // 可以继续添加更多的case语句
   default:
       // 如果表达式的值不等于任何一个case的值，执行这里的代码
       break;
}

if 语句

其中条件必须为boolean类型，这点和c语言并不一样，c语言中我们可以将0当作false作为if语句的参数，但是再Java里面是不可以的

if (条件) {
   // 如果条件为真，执行这里的代码
} else {
   // 如果条件为假，执行这里的代码
}

循环语句

while 循环

while (条件) {
    // 循环执行的代码块
}

for 循环

for (初始值; 条件; 操作) {
    // 循环执行的代码块
}

do…while 循环

do {
    // 循环执行的代码块
} while (条件);

增强for循环

用于遍历数组或集合中的元素，不需要指定索引或迭代器，简化了代码的书写。

for (元素类型 元素变量 : 数组名或集合名) {
    // 循环执行的代码块
}

break语句

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break; // 在i等于5时跳出循环
    }
}

continue语句

for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue; // 在i为偶数时跳过当前迭代
    }
    System.out.println(i);
}

---

六.数组

在Java中，数组是一种容器，用于存储多个相同类型的元素。数组在声明时需要指定数组的类型和长度。在使用数组时，可以通过索引访问和修改数组中的元素。

申明数组：

int[] numbers; // 声明一个整型数组
double[] grades; // 声明一个双精度浮点型数组
String[] names; // 声明一个字符串数组

创建数组：

int[] numbers = new int[5]; // 创建一个长度为5的整型数组
double[] grades = new double[10]; // 创建一个长度为10的双精度浮点型数组
String[] names = new String[3]; // 创建一个长度为3的字符串数组

初始化数组：

int[] numbers = {1, 2, 3, 4, 5}; // 初始化整型数组
double[] grades = {98.5, 87.2, 93.7}; // 初始化双精度浮点型数组
String[] names = {"Alice", "Bob", "Charlie"}; // 初始化字符串数组

需要注意的是二维数组的使用，在创建的时候，可以直接声明二维数组的具体大小，也可以缺省申明，但是只能缺省列数，不能缺省行数，这一点上是与c语言不一样的

    int[][] nums = new int[10][10];//正确
    int[][] nums = new int[10][];//正确
    int[][] nums = new int[][10];//错误
    int[][] nums = new int[][];//错误

---

七.方法

在Java中，方法是一段可执行的代码块，用于完成特定的任务。方法可以定义在类中或者在类外部，它可以接受输入参数并返回结果。以下是Java中定义方法的一般语法：

[可见性修饰符] [static] [返回类型] [方法名]([参数列表]) {
    // 方法体
}

其中，各部分的含义如下：

• 可见性修饰符：指定方法可以被哪些类访问，例如 public,private,protected 或者不使用任何修饰符。
• static：表示该方法属于类而不是类的实例，可以通过类名直接调用，不需要创建对象。
• 返回类型：指定方法返回的数据类型，可以是任何合法的Java数据类型，或者void表示不返回任何值。
• 方法名：方法的唯一标识符，用于在其他地方调用该方法。
• 参数列表：指定方法接受的输入参数的类型和名称，多个参数之间使用逗号分隔。
• 方法体：方法的实际执行代码，用于完成特定的任务。

Java中的方法重载（Overloading）与方法重写（Overriding）是两个重要的概念。

方法重载是指在一个类中，可以有多个方法拥有相同的名称，但是参数列表不同。编译器会根据调用时传入的参数类型和数量来判断调用哪个方法。方法重载可以提高代码的可读性和可维护性。需要注意，方法重载的判断与返回值并无关系。

方法重写是指在一个子类中，重新定义了父类中已经存在的方法。子类中的方法名称、参数列表和返回类型必须与父类中的方法相同。通过方法重写，子类可以根据自己的需要对继承自父类的方法进行修改或补充。方法重写是实现多态性的基础。

class Animal {
    public void makeSound() {
        System.out.println("Animal is making sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog is barking");
    }
    
    public void makeSound(String sound) {
        System.out.println(sound);
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.makeSound(); // 输出：Animal is making sound
        
        Dog dog = new Dog();
        dog.makeSound();    // 输出：Dog is barking
        dog.makeSound("Woof!"); // 输出：Woof!
    }
}

在上面的示例中，Animal类定义了一个makeSound方法，子类Dog通过方法重写重新定义了makeSound方法。另外，Dog类还定义了一个makeSound方法，在方法重载的情况下，编译器会根据传入的参数类型和数量来确定调用哪个方法。

---

八.类与对象

Java中的类是定义对象的模板，包含对象的属性和行为。类是实现面向对象编程的基本单位。在Java中，每个类都是通过class关键字来定义的。

对象是类的一个实例，具有类定义的属性和行为。在Java中，可以使用new关键字创建一个对象。创建对象后，可以访问对象的属性和调用对象的方法。

public class Car {
    // 类的属性
    private String brand;
    private String color;
    
    // 类的构造方法
    public Car(String brand, String color) {
        this.brand = brand;
        this.color = color;
    }
    
    // 类的方法
    public void drive() {
        System.out.println("Driving the " + color + " " + brand + " car.");
    }
    
    // 类的get方法和set方法
    public String getBrand() {
        return brand;
    }
    
    public void setBrand(String brand) {
        this.brand = brand;
    }
    
    public String getColor() {
        return color;
    }
    
    public void setColor(String color) {
        this.color = color;
    }
}

// 创建Car对象
Car myCar = new Car("Toyota", "red");

// 访问对象的属性
System.out.println(myCar.getBrand()); // 输出：Toyota
System.out.println(myCar.getColor()); // 输出：red

// 调用对象的方法
myCar.drive(); // 输出：Driving the red Toyota car.

构造方法

在Java中，构造方法是一种特殊的方法，用于创建和初始化对象。构造方法具有以下特点：

1. 构造方法的名称必须与类名完全相同。
2. 构造方法没有返回类型，包括void。这是因为构造方法的主要目的是创建对象，而不是返回值。
3. 构造方法在使用new关键字实例化对象时自动调用。
4. 如果一个类没有定义构造方法，Java会提供一个默认的无参构造方法。如果一个类定义了构造方法，Java将不会提供默认构造方法。
5. 构造方法可以重载，即可以定义多个具有不同参数的构造方法。
6. 构造方法可以使用this关键字来调用同一类的其他构造方法。这种方式称为构造方法的链式调用。

构造方法的作用是初始化对象的状态，可以在构造方法中为对象的实例变量赋初值。例如，以下是一个简单的例子：

public class Car {
    private String color;
    private int speed;
    
    // 无参构造方法
    public Car() {
        color = "Red";
        speed = 0;
    }
    
    // 带参构造方法
    public Car(String color, int speed) {
        this.color = color;
        this.speed = speed;
    }
    
    // 获取颜色
    public String getColor() {
        return color;
    }
    
    // 获取速度
    public int getSpeed() {
        return speed;
    }
}

// 使用构造方法创建对象
Car car1 = new Car();                // 调用无参构造方法，color为"Red"，speed为0
Car car2 = new Car("Blue", 80);      // 调用带参构造方法，color为"Blue"，speed为80

System.out.println(car1.getColor()); // 输出"Red"
System.out.println(car1.getSpeed()); // 输出0

System.out.println(car2.getColor()); // 输出"Blue"
System.out.println(car2.getSpeed()); // 输出80

内部类

Java中的内部类是指在一个类内部定义的类。内部类可以访问外部类的成员变量和方法，包括私有成员。在Java中，内部类可以分为四种类型：成员内部类、局部内部类、匿名内部类和静态内部类。

成员内部类：成员内部类是定义在外部类中的类。它可以访问外部类的成员，并且可以使用外部类的实例化对象来创建内部类的对象。成员内部类有自己的成员变量和方法，可以被外部类或其他类实例化使用。

public class Outer {
    private int x;
    
    public void outerMethod() {
        Inner inner = new Inner();
        inner.innerMethod();
    }
    
    public class Inner {
        private int y;
        
        public void innerMethod() {
            System.out.println("Inner method");
        }
    }
}

局部内部类：局部内部类是定义在方法体或作用域内的类。它只能在定义它的方法中使用，并且不能被其他方法或类访问。局部内部类可以访问外部类和方法的成员变量和方法。

public class Outer {
    private int x;
    
    public void outerMethod() {
        int y = 10;
        
        class Inner {
            public void innerMethod() {
                System.out.println("Inner method: " + x + " " + y);
            }
        }
        
        Inner inner = new Inner();
        inner.innerMethod();
    }
}

匿名内部类：匿名内部类是没有名字的内部类，它通常用作接口或抽象类的实现类。匿名内部类只能在创建对象时使用，并且只能使用一次。它可以访问外部类的成员变量和方法。

public class Outer {
    private int x;
    
    public void outerMethod() {
        new Interface() {
            @Override
            public void method() {
                System.out.println("Anonymous inner class");
            }
        }.method();
    }
    
    interface Interface {
        void method();
    }
}

静态内部类：静态内部类是定义在外部类中的静态类。它可以直接访问外部类的静态成员，并且可以在没有外部类对象的情况下创建内部类对象。静态内部类与外部类的关系不是紧密的，可以独立存在。

public class Outer {
    private static int x;
    
    public static void outerMethod() {
        Inner inner = new Inner();
        inner.innerMethod();
    }
    
    public static class Inner {
        private int y;
        
        public void innerMethod() {
            System.out.println("Inner method: " + x);
        }
    }
}

---

九.继承和多态

在Java中，继承是面向对象编程的一个重要概念。它允许一个类继承另一个类的属性和方法。通过继承，子类可以重用父类的代码，并且可以在不修改父类的情况下添加新的功能或修改现有功能。在这里笔者只是简单的解释一下，对于继承和多态的详细解读可以点击这篇文章：

万字详解Java的三大特性：封装 | 继承 | 多态

使用关键字"extends"可以创建一个子类，该子类继承了父类的属性和方法。子类可以访问父类的公共（public）和受保护（protected）成员，但不能访问父类的私有（private）成员。

例如，我们有一个父类Animal和一个子类Dog：

class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking");
    }
}

在上面的例子中，Dog类继承了Animal类，并添加了一个新的方法bark()。现在我们可以创建一个Dog对象并调用父类的方法和子类的方法：

Dog dog = new Dog();
dog.eat(); // 输出 "Animal is eating"
dog.bark(); // 输出 "Dog is barking"

多态是Java中另一个重要的概念，它允许使用一个父类的引用来引用子类的对象。这意味着可以使用父类类型的引用来调用子类对象中重写的方法。

例如，我们有一个Animal类和一个子类Dog：

class Animal {
    public void makeSound() {
        System.out.println("Animal is making a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog is barking");
    }
}

现在我们可以使用Animal类的引用来引用Dog对象：

Animal animal = new Dog();
animal.makeSound(); // 输出 "Dog is barking"

在上面的例子中，animal引用的是一个Dog对象，但是调用的是Dog类中重写的makeSound()方法。这就是多态的效果。

---

十.抽象类与接口

抽象类

在Java中，抽象类是一种不能被实例化的类，只能被子类继承的类。抽象类不能创建对象，但可以被用作其他类的父类。

抽象类通过关键字"abstract"来声明，可以包含抽象方法和具体方法。抽象方法是没有具体实现的方法，必须由子类来实现。具体方法是有具体实现的方法。

还有兄弟不知道网络安全面试可以提前刷题吗？费时一周整理的160+网络安全面试题，金九银十，做网络安全面试里的显眼包！

王岚嵚工程师面试题（附答案），只能帮兄弟们到这儿了！如果你能答对70%，找一个安全工作，问题不大。

对于有1-3年工作经验，想要跳槽的朋友来说，也是很好的温习资料！

【完整版领取方式在文末！！】

93道网络安全面试题

内容实在太多，不一一截图了

黑客学习资源推荐

最后给大家分享一份全套的网络安全学习资料，给那些想学习 网络安全的小伙伴们一点帮助！

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

1️⃣零基础入门

① 学习路线

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

② 路线对应学习视频

同时每个成长路线对应的板块都有配套的视频提供：

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！