Java学习笔记-04

news2024/11/15 12:06:31

目录

静态成员

mian方法

多态

抽象类

接口

内部类

成员内部类

静态内部类

方法内部类

匿名内部类

静态成员

  • static关键字可以修饰成员方法，成员变量
  • 被static修饰的成员，成员变量就变成了静态变量，成员方法就变成了静态方法
  • static修饰的特点：被类的所有对象共享访问（只要有一个修改，则用到的都会被修改）
  • 访问静态成员，直接  类名.  就可以调用（推荐）。当然也可以通过实例化调用

Cat.class

package Animal;

public class Cat {
    // 定义静态成员变量
    public static String name;
     public static int age = 5;
    // 定义静态成员方法
    public static void eat() {
        System.out.println("猫吃鱼");
    }
}

测试类

import Animal.Cat;

public class Main {
    public static void main(String[] args) {
        Cat c = new Cat();
        // 访问静态成员变量,可以实例化调用，也可以直接 类名. 调用
        c.name = "咪咪";
        System.out.println(c.name);
        System.out.println(c.age);
        System.out.println(Cat.name);
        // 访问静态成员方法
        Cat.eat(); // 猫吃鱼
        c.eat(); // 猫吃鱼
    }
}

static修饰的静态成员访问特点

  • 静态成员只能访问静态成员。但是不能访问非静态成员
  • 非静态成员，则都可以访问，既可以访问非静态成员，也可以访问静态成员

Cat.class

package Animal;

public class Cat {
    // 静态成员变量
    public static String name = "咪咪";
    // 非静态成员变量
    int age = 5;

    // 静态成员方法
    public static void eat() {
        System.out.println("猫吃鱼");
        System.out.println("我想访问name,是可以的，name值是" + name);
        // System.out.println("但是我想访问age,发现是不可以的，因为age是非静态成员属性" + age);
    }
    // 非静态成员方法
    public void catchMouse() {
        System.out.println("猫会抓老鼠");
        System.out.println("访问静态成员变量name:" + name);
        System.out.println("访问非静态成员变量age:" + age);
    }
}

测试类

import Animal.Cat;

public class Main {
    public static void main(String[] args) {
        Cat c = new Cat();
        // 访问静态成员方法(推荐直接 类名. 调用)
        Cat.eat();
        // 访问非静态成员方法(只能通过实例化调用)
        c.catchMouse();
    }
}

定义一个完整的常量

  • 常量名一般都是大写。常量不允许被修改，而且必须赋值
  • 可以直接通过  类名.  进行调用，也可以实例化调用

public   static   final   数据类型   常量名   =  常量值；

Cat.class

package Animal;

public class Cat {
    // 常量
    public static final int SUCCESSCODE = 200;
}

测试类

import Animal.Cat;

public class Main {
    public static void main(String[] args) {
        // 访问静态常量(推荐直接 类名. 调用就行，也可以实例化调用)
        System.out.println(Cat.SUCCESSCODE); // 200
    }
}

mian方法

  • 又叫主方法，是Java虚拟机在调用

public static void main(String[] args) { ... }

  • Java虚拟机需要调用类的mian方法，所以改方法，必须使用public修饰（因为Java虚拟机和mian方法不在同一个类中）
  • Java虚拟机执行mian方法的时候不需要创建实例化，所以mian方法也必须是static修饰的静态成员方法
  • mian方法接收String类型的数组参数，该数组中保存执行Java命令时传递给所执行的类的参数

注意：

  1. mian方法可以访问本类的静态成员(变量/方法)
  2. mian方法访问本类中的非静态成员，则需要先创建实例化Mian对象，然后再进行访问

Mian.class

import Animal.Cat;

public class Main {
    // 静态成员变量
    static int num = 100;
    // 非静态成员变量
    int count = 999;

    public static void main(String[] args) {
        System.out.println(num); // 100
        Main main = new Main();
        System.out.println(main.count); // 999
    }
}

给mian方法传入参数

 Mian.class

public class Main {
    public static void main(String[] args) {
        for(int i = 0;i < args.length;i++) {
            System.out.println(args[i]); // 1 2 3
        }
    }
}

多态

多态的前提与体现

  1. 有继承，实现关系（extends，）
  2. 存在方法重写
  3. 有父类引用指向子类对象（左父右子）

Animal.class

package Animal;

public class Animal {
    private String name;
    private int age;
    public String type = "分类";

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void eat() {
        System.out.println("东西都需要吃");
    }
}

Cat.class

package Animal;
// 1. 首先有继承或者实现关系
public class Cat extends Animal {
    String skill = "抓老鼠";
    // 2. 存在方法重写
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

测试类

  • 访问成员变量，规则是编译看左，执行看左
  • 访问成员方法，规则是编译看左，执行看右
import Animal.Animal;
import Animal.Cat;

public class Main {
    public static void main(String[] args) {
        // 3. 有父类引用指向子类对象(左父右子)
        Animal c =  new Cat();
        // 访问成员变量，规则是 编译(就是写代码阶段，编辑器会报错)看左，执行看左
        // c.skill // 编译阶段就会报错
        c.setName("动物名");
        System.out.println(c.getName()); // 动物
        System.out.println(c.type); // 分类
        // 访问成员方法，规则是 编译看左，执行看右
        c.eat(); // 猫吃鱼
    }
}

多态优缺点

  • 优点：可以提高程序的扩展性。定义方法的时候，使用父类作为参数，在使用的时候，使用具体的类型参与操作
  • 缺点：不能使用子类特有的成员

Animal.class

package Demo;

public class Animal {

    public void eat() {
        System.out.println("动物都需要吃");
    }
    
    public void UseEat(Animal animal) {
        animal.eat();
    }
}

Dog.class

package Demo;

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗狗吃骨头");
    }
}

Cat.class

package Demo;

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

测试类

import Demo.Animal;
import Demo.Cat;
import Demo.Dog;

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.UseEat(new Cat()); // 猫吃鱼
        animal.UseEat(new Dog()); // 狗狗吃骨头
    }
}

多态转型

  • 分为向上转型和向下转型
  • 向上转型，就是正常的多态
  • 向下转型，因为多态之后，就不能访问子类特有的成员，所以就需要向下转型成子类，这样就可以调用子类特有的成员了

Animal.class

package Demo;

public class Animal {
    public void eat() {
        System.out.println("动物都需要吃");
    }
}

Cat.class

package Demo;

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    // 猫类自己特有的成员方法
    public void catchMouse() {
        System.out.println("猫咪会抓老鼠");
    }
}

测试类

import Demo.Animal;
import Demo.Cat;

public class Main {
    public static void main(String[] args) {
        Animal animal = new Cat(); // 多态
        animal.eat(); // 可以访问重写的成员方法
        // animal.catchMouse(); // 但是访问不了子类特有的成员方法。就需要向下转型成Cat，这样才能调用子类特有的成员
        Cat c = (Cat) animal;
        c.catchMouse(); // 猫咪会抓老鼠 向下转型后就可以访问了
    }
}

抽象类

  • 在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类
  • 抽象类和抽象方法用  abstract  关键字来修饰

public  abstract  void  抽象方法名()；  // 抽象方法没有方法体，抽象方法只能在抽象类中

abstract  class  抽象类名  {  }；  // 抽象类

举例

Animal.class

package Demo;

// 抽象类，用 abstract 关键字修饰
public abstract class Animal {
    // 抽象方法，用 abstract 关键字修饰，且没有方法体。实现类必须重写抽象方法
    public abstract void eat();
}

Cat.class

package Demo;

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    // 猫类自己特有的成员方法
    public void catchMouse() {
        System.out.println("猫咪会抓老鼠");
    }
}

测试类

import Demo.Cat;

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat(); // 猫吃鱼
    }
}

抽象类的特点

  • 抽象类中不一定有抽象方法，也可以定义非抽象方法。但是抽象方法必须在抽象类中

Animal.class

package Demo;

// 抽象类，用 abstract 关键字修饰
public abstract class Animal {
    // 抽象方法，用 abstract 关键字修饰，且没有方法体。实现类必须重写抽象方法
    public abstract void eat();
    // 抽象类中也可以有非抽象方法
    public void run() {
        System.out.println("动物都会奔跑");
    }
}

Cat.class

package Demo;

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

测试类

import Demo.Cat;

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat(); // 猫吃鱼
        cat.run(); // 动物都会奔跑
    }
}
  • 抽象类不能实例化
  • 抽象类由具体的子类进行实例化（也就是子类继承抽象类并重写抽象类中的抽象方法，实例化子类既可使用）
  • 子类必须对父类（抽象类）中的所有抽象方法进行重写
  • 子类如果不重写父类（抽象类）中的抽象方法，则该子类也必须是抽象类（会继承父类的抽象方法），子类此时也是抽象类了。但是子类的子类如果想实例化使用，则还是要继承子类并且重写子类的抽象方法，总之就是只要想实例化使用，必须要继承抽象类并且重写抽象方法

Animal.class

package Demo;

// 抽象类，用 abstract 关键字修饰
public abstract class Animal {
    // 抽象方法，用 abstract 关键字修饰，且没有方法体。实现类必须重写抽象方法
    public abstract void eat();
    // 抽象类中也可以有非抽象方法
    public void run() {
        System.out.println("动物都会奔跑");
    }
}

Cat.class

package Demo;

public abstract class Cat extends Animal {

}

LiHuaMao.class

package Demo;

public class LiHuaMao extends Cat {
    @Override
    public void eat() {
        System.out.println("小狸花吃老鼠");
    }
}

测试类

import Demo.LiHuaMao;

public class Main {
    public static void main(String[] args) {
        LiHuaMao liHuaMao = new LiHuaMao();
        liHuaMao.eat(); // 小狸花吃老鼠
        liHuaMao.run(); // 动物都会奔跑
    }
}
  • 抽象类可以有构造方法，用于子类访问父类时的数据初始化

Animal.class

package Demo;

// 抽象类，用 abstract 关键字修饰
public abstract class Animal {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // 抽象方法，用 abstract 关键字修饰，且没有方法体。实现类必须重写抽象方法
    public abstract void eat();
    // 抽象类中也可以有非抽象方法
    public void run() {
        System.out.println("动物都会奔跑");
    }

    // 抽象类也可以有构造方法，用于子类数据初始化
    public Animal() {}
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Cat.class

package Demo;

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }
}

测试类

import Demo.Cat;

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat("咪咪",5);
        System.out.println(cat.getName()); // 咪咪
        System.out.println(cat.getAge()); // 5
    }
}

abstract关键字注意点(记结论就行，原因不用记)

  • abstract 关键字不能与 private 关键字同用，冲突（因为抽象方法必须被子类重写，但是private修饰的方法不能被子类继承）
  • abstract 关键字不能与 final 关键字同用，冲突（final修饰的变量，方法都不能被修改，继承）
  • abstract 关键字不能与 static 关键字同用，无意义（static是静态的，抽象方法中无方法体，无法调用）

接口

  • 接口就是一种公共的规范标准，只要符合规范标准，都可以通用。Java中的接口更多体现在对行为的抽象上
  • 接口，用 interface 修饰 

public  interface  接口名  {  }

  • 类实现接口用  implements  表示

public  class  类名  implements  接口名  {  }

创建接口

 举例：

Animal.class（这个是接口）

package Demo;

public interface Animal {
    // 接口中只能有常量，前面默认添加 public static final。因为加了 static ，所以可以直接 类名. 调用
    String name = "动物名";
    public static final int age = 5; // 跟上面写是一样的，可以看出前面的都是灰色的，可写可不写

    // 接口中JDK8之前只能有抽象方法，但是JDK8之后可以有非抽象方法(但是需要使用default关键字修饰)
    public abstract void eat(); // 接口中的抽象方法，前面默认会自动添加public abstract
    void drink();
    public default void run() {
        System.out.println("动物都会奔跑");
    }
}

Cat.class

package Demo;

public class Cat implements Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    @Override
    public void drink() {
        System.out.println("猫喝水");
    }
}

实现类

import Demo.Animal;
import Demo.Cat;

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.run(); // 动物都会奔跑
        cat.eat(); // 猫吃鱼
        cat.drink(); // 猫喝水
        System.out.println(Animal.name); // 动物名
    }
}
  • 接口不能实例化，跟抽象类一样。但是接口可以参照多态的方式，通过实现类对象实例化，叫接口多态

举例：

Animal.class（这个是接口）

package Demo;

public interface Animal {
    // 接口中只能有常量，前面默认添加 public static final。因为加了 static ，所以可以直接 类名. 调用
    String name = "动物名";
    public static final int age = 5; // 跟上面写是一样的，可以看出前面的都是灰色的，可写可不写

    // 接口中JDK8之前只能有抽象方法，但是JDK8之后可以有非抽象方法(但是需要使用default关键字修饰)
    public abstract void eat(); // 接口中的抽象方法，前面默认会自动添加public abstract
    void drink();
    public default void run() {
        System.out.println("动物都会奔跑");
    }
}

Cat.class

package Demo;

public class Cat implements Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    @Override
    public void drink() {
        System.out.println("猫喝水");
    }
}

测试类

import Demo.Animal;
import Demo.Cat;

public class Main {
    public static void main(String[] args) {
        Animal cat = new Cat(); // 这个就是接口多态
        cat.eat(); // 猫吃鱼(多态访问成员方法规则：编译看左，执行看右。所以输出的是猫的吃方法)
    }
}
  • 接口中不能有构造方法
  • 接口的实现类，要不重写接口中所有的抽象方法，要不就是抽象类。但是最终只要使用接口，还是要重写所有的抽象方法。同抽象类
  • 定义了一个类，如果没有继承任何父类，则在默认情况下，就继承了Object父类，任何类的祖宗类，都是Object类

类与接口的小区别

  • 一个类只能单继承一个父类。但是接口可以继承n个不同的接口
  • 一个类可以实现n个接口

内部类

  • 就是在一个类中又定义了一个类

比如：在一个A类的内部定义一个类B，类B就称为内部类，类A相应的称为外部类

public  class  外部类名  {

        public  class  内部类名  {

                ...

        }

}

内部类访问特点

  • 内部类可以直接访问外部类的成员，包裹私有修饰的
  • 外部类要访问内部类的成员，则必须创建实例才能访问

Cat.class

package Demo;

// 外部类
public class Cat {
    private String name = "猫咪";
    private int age = 5;

    // 内部类
    public class LiHuaMao {
        private String name = "狸猫";
        public void dis() {
            System.out.println("我是一只小"+ name + "，在古代我可以换太子。今年我" + age + "岁了");
        }
    }

    // 外部类如果想使用内部类，必须实例化内部类才能使用
    public void Xxx() {
        LiHuaMao liHuaMao = new LiHuaMao();
        liHuaMao.dis();
    }
}

测试类

import Demo.Cat;

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.Xxx(); // 我是一只小狸猫，在古代我可以换太子。今年我5岁了
    }
}

内部类分类

成员内部类

  •  作为类中的一个成员。定义在类中成员方法外，跟成员方法，成员属性(又叫成员变量)同级的

package Demo;

// 外部类
public class Cat {
    // 成员属性
    private String name = "猫咪";
    private int age = 5;

    // 内部类(成员内部类，跟成员方法，成员属性同级)
    public class LiHuaMao {

    }

    // 成员方法
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

 在同一个类中访问成员内部类

Cat.class

package Demo;

// 外部类
public class Cat {
    // 成员属性
    private String name = "猫咪";
    private int age = 5;

    // 内部类(成员内部类，跟成员方法，成员属性同级)
    public class LiHuaMao {
        private String skill = "抓老鼠";
        public void eat() {
            System.out.println("小狸花吃老鼠");
        }
    }

    // 成员方法
    public void readInnerClass() {
        // 在同一个类中访问成员内部类(需要实例化后才能访问)
        LiHuaMao liHuaMao = new LiHuaMao();
        liHuaMao.eat(); // 小狸花吃老鼠
        System.out.println(liHuaMao.skill); // 抓老鼠
    }
}

测试类

import Demo.Cat;

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.readInnerClass(); // 小狸花吃老鼠   抓老鼠
    }
}

外界访问成员内部类

  • 实际开发中，外界是无法访问内部类的。都是通过私有形式让外界无法访问内部类。只能在该类中使用

外界类.成员内部类  xxx  =  new  外界类().new  成员内部类()；

Cat.class

package Demo;

// 外部类
public class Cat {
    // 成员属性
    private String name = "猫咪";
    private int age = 5;

    // 内部类(成员内部类，跟成员方法，成员属性同级)
    public class LiHuaMao {
        private String skill = "抓老鼠";
        public void eat() {
            System.out.println("小狸花吃老鼠");
        }
    }
}

测试类

import Demo.Cat;

public class Main {
    public static void main(String[] args) {
        Cat.LiHuaMao liHuaMao = new Cat().new LiHuaMao();
        liHuaMao.eat(); // 小狸花吃老鼠
    }
}

静态内部类

  • 定义在外部类中的成员方法外，并由static修饰的内部类（其实就是用static修饰成员内部类）

同一类中访问

  • 外部类中的静态成员方法，只能访问静态内部类

Cat.class

package Demo;

// 外部类
public class Cat {
    // 成员属性
    private String name = "猫咪";
    private int age = 5;

    // 内部类(静态内部类(我感觉叫静态成员内部类更好理解)，跟成员方法，成员属性同级)
    public static class LiHuaMao {
        private String skill = "抓老鼠";
        public void eat() {
            System.out.println("小狸花吃老鼠");
        }
    }

    // 非静态成员方法(非静态的可以访问静态)
    public void readInnerClass() {
        LiHuaMao liHuaMao = new LiHuaMao();
        liHuaMao.eat();
    }
    // 静态成员方法(静态的只能访问静态的)
    public static void readInnerClass2() {
        LiHuaMao liHuaMao = new LiHuaMao();
        liHuaMao.eat();
    }
}

测试类

import Demo.Cat;

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.readInnerClass(); // 小狸花吃老鼠
        cat.readInnerClass2(); // 小狸花吃老鼠
    }
}

外界进行访问

  • 实际开发中，外界是无法访问内部类的。都是通过私有形式让外界无法访问内部类。只能在该类中使用
  • 注意：静态内部类中，访问外部类，只能访问外部类的静态成员。静态只能访问静态

外界类.静态内部类  xxx  =  new  外界类.静态内部类()；

Cat.class

package Demo;

// 外部类
public class Cat {
    // 成员属性
    private String name = "猫咪";
    private static int age = 5;

    // 内部类(静态内部类(我感觉叫静态成员内部类更好理解)，跟成员方法，成员属性同级)
    public static class LiHuaMao {
        private String skill = "抓老鼠";
        public void showAge() {
            // 静态内部类访问外部类，只能访问外部类的静态成员
            System.out.println("小狸花今年" + age + "岁了");
        }
    }
}

测试类

import Demo.Cat;

public class Main {
    public static void main(String[] args) {
        Cat.LiHuaMao liHuaMao = new Cat.LiHuaMao();
        liHuaMao.showAge(); // 小狸花今年5岁了
    }
}

方法内部类

  • 又叫局部内部类，定义在方法中的类
  • 只能在方法内使用，外界用不了

Cat.class

package Demo;

// 外部类
public class Cat {
    // 成员方法
    public void type() {
        // 内部类(方法内部类，定义在方法内，只能在方法中使用)
        class LiHuaMao {
             String name = "咪咪";
             int age = 5;
             void eat() {
                 System.out.println("吃老鼠");
             }
        }
        LiHuaMao liHuaMao = new LiHuaMao();
        System.out.println(liHuaMao.name); // 咪咪
        liHuaMao.eat(); // 吃老鼠
    }
}

测试类

import Demo.Cat;

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.type(); // 咪咪  吃老鼠
    }
}

匿名内部类

  • 是一个继承了某父类或者实现了某接口的匿名实例化对象

new  Animal() {

        // 重写了抽象类Animal的抽象方法

        ...

}.xxx()；

或者

new  Animal() {

        // 重写了接口Animal的抽象方法

        ...

}.xxx()；

  • 其实就是实现接口或者继承了抽象类后，没有用变量进行接收，直接开始用了

举例：

Animal.class

package Demo;
// 抽象类
public abstract class Animal {
    // 抽象方法
    public abstract void eat();
}

测试类

import Demo.Animal;

public class Main {
    public static void main(String[] args) {
        new Animal(){
            @Override
            public void eat() {
                System.out.println("动物都会吃");
            }
        }.eat(); // 动物都会吃
    }
}
  • 接口同理

思考：正常情况下，接口或者抽象类是无法实例化的，为什么匿名内部类看着却可以实例化抽象类或者接口呢？

其实不是实例化了，而是在编译阶段，内部帮我们实现了子类或者实现类。接口和抽象类是永远不能实例化的！

  • 使用匿名内部类，就不需要创建实现类或者子类了，简化了步骤，底层帮我们创建了子类

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/547566.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Java流程控制(一)

Java流程控制(一)

⭐ 控制语句⭐ 条件判断结构(选择结构)⭐ switch 语句 做任何事情事情都要遵循一定的原则&#xff0c;毕竟不以规矩&#xff0c;不成方圆&#xff0c;例如&#xff0c;到图书馆去借书&#xff0c;就必须要有借书证&#xff0c;并且借书证不能过期&#xff0c;这两个条件缺一不可…
阅读更多...
【新星计划回顾】第二篇学习计划-通过定义变量简单批量模拟数据

【新星计划回顾】第二篇学习计划-通过定义变量简单批量模拟数据

&#x1f3c6;&#x1f3c6;又到周末&#xff0c;最近这段时间非常忙&#xff0c;虽然导师首次参与新星计划活动已经在4月16日圆满结束&#xff0c;早想腾出时间来好好整理活动期间分享的知识点。 &#x1f3c6;&#x1f3c6;非常感谢大家的支持和活动期间的文章输出&#xff0…
阅读更多...
软件测试基础(V模型W模型)

软件测试基础(V模型W模型)

软件测试基础 1. 软件测试的生命周期 需求分析&#xff1a;站在用户的角度查看需求逻辑是否正确&#xff0c;是否符合用户的需求和行为习惯。站在开发的角度思考需求是否可以实现&#xff0c;或者说实现起来难度高不高测试计划&#xff1a;指定测试计划&#xff08;包括不限于…
阅读更多...
Linux用户和组管理

Linux用户和组管理

1、用户和组简介 Linux 是多用户多任务操作系统。换句话说&#xff0c;Linux 系统支持多个用户在同一时间内登陆&#xff0c;不同用户可以执行不同的任务&#xff0c;并且互不影响。不同用户具有不问的权限&#xff0c;毎个用户在权限允许的范围内完成不同的任务。 用户组是具…
阅读更多...
进攻即是最好的防御！19个练习黑客技术的在线网站

进攻即是最好的防御！19个练习黑客技术的在线网站

前言 进攻即是最好的防御&#xff0c;这句话同样适用于信息安全的世界。这里罗列了19个合法的来练习黑客技术的网站&#xff0c;不管你是一名开发人员、安全工程师、代码审计师、渗透测试人员&#xff0c;通过不断的练习才能让你成为一个优秀安全研究人员。以下网站希望能给各…
阅读更多...
智能排班系统 【技术选型与工具版本】

智能排班系统 【技术选型与工具版本】

技术架构图 前端工具及环境 名称版本介绍NodeJS16.13.2开源、跨平台的 JavaScript 运行时环境Npm8.1.2npm包管理工具可以快速引入别人开发好的工具包进行使用Webpack4.0.0打包工具Vue2.6.14Vue 的核心库只关注视图层&#xff0c;易于上手&#xff0c;便于与第三方库或既有项目…
阅读更多...
每日学术速递5.17

每日学术速递5.17

CV - 计算机视觉 | ML - 机器学习 | RL - 强化学习 | NLP 自然语言处理 Subjects: cs.CV 1.HACK: Learning a Parametric Head and Neck Model for High-fidelity Animation 标题&#xff1a;HACK&#xff1a;学习用于高保真动画的参数化头颈模型 作者&#xff1a;Longwe…
阅读更多...
FEC功能在40G和100G光模块中的应用和注意事项

FEC功能在40G和100G光模块中的应用和注意事项

FEC&#xff08;Forward Error Correction&#xff0c;前向纠错&#xff09;功能是一种在数字通信中用于纠正传输过程中产生的误码的技术。在100G和40G光模块中&#xff0c;FEC功能被广泛应用于光纤传输过程中&#xff0c;以提高传输的可靠性和抗干扰能力。 本期文章我们主要介…
阅读更多...
Twitter架构决策

Twitter架构决策

技术决策需要在不同限制条件下做出权衡&#xff0c;本文介绍了Twitter早期应对用户大规模增长所做出的技术架构决策。原文&#xff1a;Twitter’s Tough Architectural Decision[1] Jeremy BezangerUnsplash 研究大规模互联网应用可以学到很多东西&#xff0c;像Netflix这样的公…
阅读更多...
强大而可靠的DiskQ：持久化队列的解决方案

强大而可靠的DiskQ：持久化队列的解决方案

强大而可靠的DiskQ&#xff1a;持久化队列的解决方案 简介: 在软件开发中&#xff0c;处理大量数据和任务调度是常见的挑战。为了有效地处理这些问题&#xff0c;开发人员需要一种可靠的队列解决方案&#xff0c;以确保数据和任务在处理过程中不会丢失。DiskQ作为一种持久化队…
阅读更多...
浏览器如果免费安装ChatGPT插件？

浏览器如果免费安装ChatGPT插件？

一、什么是ChatGPT&#xff1f; ​ ChatGPT是一种基于自然语言处理的机器学习算法&#xff0c;通过大规模的训练数据和优化算法来生成自然语言响应。目前&#xff0c;它在聊天机器人&#xff0c;自动回答问题&#xff0c;自动文本生成等方面有广泛的应用。ChatGPT是由OpenAI公…
阅读更多...
[组合数学] 排列组合

[组合数学] 排列组合

文章目录 加法法则 --每一类都能够独立的完成任务乘法法则 --集合论 任务分步骤1000和9999之间有多个具有不同数位的奇数n 7 3 1 1 2 1 3 4 ^311^213^4 3112134 求除尽n的整数个数0到10000之间有多少个整数恰好是有一位数字是5两位数字可以组成多少两位互异且非零的两位数 减…
阅读更多...
suricata中command的实现分析和自定义命令方法

suricata中command的实现分析和自定义命令方法

suricata提供了suricatasc这个工具用来与其进行通信&#xff0c;比如修改规则文件后&#xff0c;通知suricata重新加载规则&#xff0c;就可以通过suricatasc下发重新加载规则命令&#xff0c;suricatasc和suricata通过unix socket进行通信&#xff0c;unix socke好处就是不占用…
阅读更多...
libevent高并发网络编程 - 06_基于libevent的C++线程池实现

libevent高并发网络编程 - 06_基于libevent的C++线程池实现

文章目录 1 功能简介线程池的初始化线程池执行流程 2 线程池类的设计线程类XThreadXThread.hXThread.cpp 线程池类XThreadPoolXThreadPool.hXThreadPool.cpp 任务基类taskXTask.h 3 自定义任务的例子自定义任务类ServerCMDServerCMD.hServerCMD.cpp 测试程序运行效果 1 功能简介…
阅读更多...
华为机试（JAVA）真题Od【A卷+B卷】2023

华为机试（JAVA）真题Od【A卷+B卷】2023

目录 华为OD机试是什么&#xff1f;华为OD面试流程&#xff1f;华为OD机试通过率高吗&#xff1f;华为OD薪资待遇&#xff1f;华为OD晋升空间&#xff1f; 大家好&#xff0c;我是哪吒。 本专栏包含了最新最全的华为OD机试真题&#xff0c;有详细的分析和Java代码解答。已帮助…
阅读更多...
【信息安全案例】——信息内容安全（学习笔记）

【信息安全案例】——信息内容安全（学习笔记）

&#x1f4d6; 前言&#xff1a;在数字化时代&#xff0c;信息内容安全问题越来越引起人们的关注。信息内容安全主要包括对数据的机密性、完整性和可用性的保护&#xff0c;以及对用户隐私的保护等方面。针对信息内容安全的威胁&#xff0c;采取科学有效的安全措施和技术手段至…
阅读更多...
每日学术速递5.20

每日学术速递5.20

CV - 计算机视觉 | ML - 机器学习 | RL - 强化学习 | NLP 自然语言处理 Subjects: cs.CV 1.Improved baselines for vision-language pre-training 标题&#xff1a;改进视觉语言预训练的基线 作者&#xff1a;Enrico Fini, Pietro Astolfi, Adriana Romero-Soriano, Jak…
阅读更多...
10-《简单算法》

10-《简单算法》

10-《简单算法》 一、时间复杂度二、空间复杂度三、排序算法1.比较排序1.1冒泡排序&#xff1a;1.2选择排序&#xff1a;1.3插入排序&#xff1a;1.4归并排序(非常重要)1.5快速排序&#xff08;非常重要&#xff09;1.6堆排序1.7排序算法稳定性 2.线性排序2.1桶排序2.2计数排序…
阅读更多...
数据结构初阶（3）（链表：链表的基本概念、链表的类型、单向不带头非循环链表的实现、链表的优缺点 ）

数据结构初阶（3）（链表：链表的基本概念、链表的类型、单向不带头非循环链表的实现、链表的优缺点 ）

接上次博客&#xff1a;和数组处理有关的一些OJ题&#xff1b;ArrayList 实现简单的洗牌算法&#xff08;JAVA)(ArrayList&#xff09;_di-Dora的博客-CSDN博客 目录 链表的基本概念 链表的类型 单向、不带头、非循环链表的实现 遍历链表并打印节点值&#xff1a; 在链…
阅读更多...
uni-app小程序uni.navigateBack返回上一个页面并传递参数.返回上个页面并刷新

uni-app小程序uni.navigateBack返回上一个页面并传递参数.返回上个页面并刷新

返回上一个打开的页面并传递一个参数。有种办法就是使用 假如从B页面返回A页面&#xff1a; var pages getCurrentPages(); var prevPage pages[pages.length - 2]; //上一个页面 prevPage.setData({ mdata:1 })经过测试&#xff0c;在uni.app中使用B页面使用setData设置A页…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023