深入理解Java中的三个修饰符（抽象（abstract）、静态（static）和最终的，不可变（final））【配视频】

news2024/11/16 12:05:58

🍅程序员小王的博客：程序员小王的博客
🍅 欢迎点赞 👍 收藏 ⭐留言 📝
🍅 如有编辑错误联系作者，如果有比较好的文章欢迎分享给我，我会取其精华去其糟粕
🍅java自学的学习路线：java自学的学习路线

一、abstract

  • 抽象的配套视频

深入理解Java抽象类

  • 概念：

    abstract （抽象的）
可以修饰类、方法，使程序设计的更加合理

  • 例：Shape类不合理的设计

    class Shape{//图形类
  public double area(){//计算面积
    return 0.0;//为了满足语法，给出无意义的实现
  }
  public  double girth(){//计算周长
    return 0.0;//为了满足语法，给出无意义的实现
  }
}

  • 例：Animal类不合理的设计

    class Animal{
  String name;
  int age;
  public Animal(){}
  public Animal(String name, int age){
    this.name = name;
    this.age = age;
  }
  
  public void eat(){ }//无法描述Animal的吃行为
  public void sleep(){ }//无法描述Animal的吃行为
}

  • 这些不合理的方法不能移除，因为如果父类中没有声明则影响多态的使用（参考多态特点第二条）

（一）抽象类

  • 概念：被abstract修饰的类称为抽象类
    例：

    abstract class MyClass{

}

  • 特点：抽象类只能声明引用不能创建对象
    例：

    abstract class MyClass{
 
}
MyClass mc; //
mc = new MyClass();//Error 不能创建对象

（二）抽象方法

  • 概念：被abstract修饰的方法，称之为抽象方法
    例：

    abstract void m1();

  • 特点：

    1. 抽象方法只能有声明，不能有实现
      例：

      public abstract void m1();//抽象方法
public abstract void m2();//抽象方法
public void m3(){//非抽象方法
   //方法的实现
}

    2. 抽象方法只能定义在抽象类中
      例：

      abstract class MyClass{//抽象类
    public abstract void m1();//抽象方法
}

    3. 当父类存在抽象方法时，子类必须覆盖父类的抽象方法，否则子类还是抽象类
      例：子类没有覆盖父类的抽象方法

      abstract class Super{//抽象类
  public abstract void m1();//抽象方法
}
abstract class Sub extends Super{//因为没有覆盖MyClass中的抽象方法，所以子类必须也是抽象类

}

      例：子类覆盖父类的抽象方法

      abstract class Super{//抽象类
    public abstract void m1();//抽象方法
}
class Sub extends Super{
    public void m1(){//覆盖父类中的抽象方法 添加实现{  }
    
    }
}

       子类覆盖父类的抽象方法，并添加方法的实现{ }，这种特殊的覆盖语法称之为实现。
       注意：由于继承关系可以多级继承，当继承到多个抽象方法时，子类如果不想成为抽象类，必须都予以实现。

（三）应用案例

  • 使用抽象类、抽象方法将父类设计的更加合理，抛弃无意义方法实现，保留声明部分，既不影响多态的使用，也不影响原有继承体系
    例：Shape类

    abstract class Shape{//图形类
  public abstract double area();//计算面积  
  public  abstract double girth()//计算周长
}

    例：Animal类

    abstract class Animal{
    String name;
    int age;
    public Animal(){}
    public Animal(String name, int age){
      this.name = name;
      this.age = age;
    }
  
    public abstract void eat();//无法描述Animal的吃行为
    public abstract void sleep();//无法描述Animal的吃行为
}

二、static

  • 静态和final配套视频

static和final关键字可以用来修饰什么，分别起什么作用

  • 概念

    static（静态）
可以修饰类、属性、方法、动态初始化代码块、import

（一）静态属性（类变量）

  • 概念：被static修饰的属性，称之为静态属性或类变量

  • 特点：静态属性与对象无关，有独立的存储区域，可以通过类名直接访问，可以被所有对象共享
    例：

在这里插入图片描述

class MyClass{
    int a;//一般属性
    static int b;//静态属性
}

//为静态属性赋值
MyClass.a = 10;

//静态属性被所有对象共享
MyClass mc1 = new MyClass()
System.out.println( mc1.a );//10

MyClass mc2 = new MyClass();
System.out.println( mc2.a );//10

 静态属性虽然可以通过引用名.的方式使用，但是极度不推荐，容易与一般属性造成混淆

（二）静态方法

  • 概念：被static修饰的方法称为 静态方法

  • 特点：

    1. 静态方法与对象无关，可以使用类名直接调用
      例：

      class Super{
  //静态方法
  public static void m1(){
      
  }
}

//调用Super类中的静态方法
Super.m1();

    2. 静态方法与对象无关，因此不能使用非静态的成员（成员变量、成员方法），因为它们需要创建对象后才能使用。
      例：

      class Super{
  int a; //一般属性
  public void m1(){ }//一般方法
  
  public static void m2(){//静态方法
    System.out.println( a );//错误：静态方法中不能访问非静态成员
    m1();//错误：静态方法中不能访问非静态成员
  }
}

       静态方法由于与对象无关，因此也不能在静态方法中使用this或super关键字
       思考：为什么在学函数的时候，所有的函数都要加static关键字？

    3. 静态方法可以被继承
      例：

      class Super{
  public static void m1(){
  
  }
}

class Sub extends Super{ }

//调用父类中的m1方法
Sub.m1();//可以从父类中继承静态方法m1();

    4. 静态方法只能被静态方法所覆盖
      例：

      class Super{
  public static void m1(){
  
  }
}

class Sub extends Super{ 
  //覆盖父类中的静态方法
  public static void m1(){
  
  }
}

Sub.m1();//调用覆盖后的m1方法

    5. 静态方法在使用时没有多态
      例：

      class Super{
  public static void m1(){}
}
class Sub extends Super{
  public static void m1(){}
}
Super sup = new Sub();//多态语法
sup.m1();//编译后---->Super.m1();引用名替换为引用类型

  • 小结：

    static 修饰属性：静态属性，所有此类对象共享，可以直接通过类名访问
static 修饰方法：静态方法，可以直接通过类名方法，静态方法与对象无关，不能使用非静态属性或方法，也不可使用 this 或 super 关键字

（三）类加载

  • 概念：JVM将硬盘中的.class文件加载到内存中的一种行为

    在这里插入图片描述

  • 类加载的时机与过程

    1. 当虚拟机第一次遇到某个类时（new对象、调用静态成员、使用子类）某个类时，需要通过CLASSPATH查找该类的 .class 文件。
2. 将.class文件中保存的类的描述信息（属性、方法..等等）加载到内存中进行保存。
3. 加载时会初始化该类的必要信息，初始化静态属性、静态方法，调用静态初始化代码块等。
4. 类加载只会执行一次。

    例：加载时机

    class MyClass{
   static int a = 10;
   //静态初始化代码块，类加载时执行
   static{
      System.out.println("类加载...");
   }
}
class Sub extends MyClass{
   
}

//加载时机 1：访问静态成员
MyClass.a; 

//加载时机 2：创建对象
MyClass mc = new MyClass();

//加载时机 3：创建子类对象或加载子类时
Sub.a;
Sub s = new Sub();

     注意：只声明引用，不会进行类加载。

（四）静态初始化代码块

  • 概念：使用static修饰的动态初始化代码块 *，称为静态初始化代码块

  • 特点：在类加载时执行一次

  • 作用：用于初始化静态属性，执行在整个系统中只需要运行一次的代码（加载资源、构建容器等）
    例：

    class MyClass{
    static int a;
    static{//静态初始化代码块
        a = 10;
    }
}

（五）类加载的过程

  • 过程

    1. 如果有需要先加载父类
2. 初始化静态属性
3. 按照顺序初始化静态属性，或执行静态代码块

    验证例：

    class Super{
    static{
        System.out.println("static in Super");
    }

    public Super(){
        System.out.println("init Super");
    }
}

class Sub extends Super{
    static{
        System.out.println("static in Sub");
    }
    public Sub(){
        System.out.println("init Sub");
    }
}

    第一次创建子类对象时输出：

    static in Super
static in Sub
init Super
init Sub

（六）静态引入

  • 使用import static 引入类中的静态资源
    例：引入java.lang.System中的静态属性out

    //静态引入
import static java.lang.System.out;

public class Test {
    public static void main(String[] args) {
         //使用System.out进行输出时，不必再加入类名
         out.print("Hello");
    }
}

（七）static小结

  1. static 修饰的属性为静态属性（类变量）每个对象共用一份，可以使用 类名.属性名的方式直接访问
  2. static 修饰的方法为静态方法（类方法）每个对象共用一份，可以使用 类名.属性名的方式直接访问
  3. static 修饰的初始化代码框为静态初始化代码框，主要用于在类加载时对静态变量进行初始化工作
  4. import static 称为静态引入可以`引入静态资源，使用时不必明确类名

三、final

  • 概念：

    final （最终的）
可以修饰 变量（局部变量、属性）、方法、类

（一）常量

  • 概念：被final修饰的变量称为常量

  • 修饰局部变量特点：只能赋值一次，不可修改
    例：

    final int a = 10;//只能赋值一次
a = 10;//编译错误

final int[] as = new int[5];//只能赋值一次
as = new int[10];//编译错误

  • 修饰成员变量特点：值不可遍，必须手动初始化
    例：

    class MyClass{
  final int a;//编译错误
}

  • 初始化方式

    1. 直接初始化
      例：

      class MyClass{
  final int a = 10;
}

       由于被final修饰的属性不可变，所以为了避免内存空间的浪费，该属性还应该被static修饰

    2. 初始化代码块| 静态块初始化代码块
      例：

      class MyClass{
    final int a;
    {
      a = 10;
    }
}

    3. 构造方法赋值
      例：

      class MyClass{
    final int a;
    
    public MyClass(){
        a = 10;
    }
    public MyClass(int a){
        this.a = a;
    }
}

       注意：由于final修饰的属性必须保证能够被初始化，所以每个构造方法都要为属性初始化

（二）最终方法

  • 概念：被final修饰的方法，称为最终方法

  • 特点：此方法不能被子类覆盖
    例：

    class Super{
    public final void m1(){
    
    }
}

class Sub extends Super{
  //编译错误：父类final修饰的方法不能被覆盖
   public void m1(){
   
   }
}

（三）最终类

  • 概念：被final修饰的类，称为最终类

  • 特点：不能被继承
    例：

    final class Super{

}
//编译错误：父类为最终类，不能继承
class Sub extends Super{

}

（四）修饰符组合

  • 修饰符可以组合使用，请遵循一下规则：

    1. static、final与abstract不能连用，因为abstract为抽象的，修饰类必须由子类继承才能使用，修饰方法必须由子类覆盖才能使用，不能调用abstract修饰的方法等特点，与static final 意义冲突。
2. private 与 abstract不能一起修饰方法，否则该方法将无法被覆盖
3. static与final可以连用，意义不冲突
4. 在定义常量时通常使用public static final 进行声明，称为公开静态常量

五、三个修饰符答案

客观题

  1. 关于三个修饰符描述不正确的是( a d )

    a. static 可以修饰所有类型的变量

    b. static 可以修饰方法

    c. final 可以修饰类

    d. abstract 可以修饰类、方法、属性

  2. 下面关于 static 描述不正确的是( c d )

    a. static 修饰的属性称为静态变量，被所有的对象共享

    b. static 修饰的方法，可以直接用 类名.方法名(参数)调用

    c. static 修饰的方法中可以直接访问本类的其他方法

    d. 父类中定义了 static 修饰的方法，子类中不能再定义同名的 static 方法

  3. 关于 final 描述错误的是( a b )

    a. final 修饰的类是作用范围内常量，只允许一次赋值

    b. final 修饰的方法不能被继承

    c. final 修饰的方法不允许被覆盖

    d. final 修饰的类没有子类

  4. 关于 abstract，以下选项正确的是( a b c d )

    a. abstract 类中可以没有 abstract 方法

    b. abstract 类的子类也可以是 abstract 类

    c. abstract 类不能创建对象，但可以声明引用

    d. abstract 方法不能有方法体

  5. 仔细阅读以下程序，写出程序输出的结果。

    class Myclass{
    static int a;
    int b;
}
public class TestMain{
    public static void main(String[] args){
        MyClass mc1 = new MyClass();
        MyClass mc2 = new MyClass();
        mc1.a=100;
        mc1.b=200;
        mc2.a=300;
        mc2.b=400;
        System.out.println(mc1.a);
        System.out.println(mc1.b);
        System.out.println(mc2.a);
        System.out.println(mc2.b);
    }
}


    运行结果为：
300
200
300
400

  6. 仔细阅读以下程序，选出哪些代码会导致程序出错( e g )

    class MyClass{
    int a;
    static int b;
    void fa(){}
    static void fb(){}
    public void m1(){
        System.out.println(a);//1
        System.out.println(b);//2
        fa();//3
        fb();//4
    }
    public static void m2(){
        System.out.println(a);//5
        System.out.println(b);//6
        fa();//7
        fb();//8
    }
}

    a. //1 e. //5

    b. //2 f. //6

    c. //3 g. //7

    d. //4 h. //8

  7. 仔细阅读以下程序，写出程序运行输出的结果。

    class MyClass{
    static int i = 10;
    static{
        i = 20;
        System.out.println("In Static");
    }
    public MyClass(){
        System.out.println("MyClass()");
    }
    public MyClass(int i){
        System.out.println("MyClass(int)");
        this.i = i;
    }
}
public class TestMain{
    public static void main(String[] args){
        MyClass mc1 = new MyClass();
        System.out.println(mc1.i);
        MyClass mc2 = new MyClass(10);
        System.out.println(mc2.i);
    }
}

    运行结果为：
In Static
MyClass()
20
MyClass(int)
10

  8. 仔细阅读以下代码，关于代码描述正确的是( c )

    class MyClass{
    final int value;
    public MyClass(){}
    public MyClass(int value){
        this.value = value;
    }
}
public class TestMain{
    public static void main(String[] args){
        MyClass mc = new MyClass(10);
        System.out.println(mc.value);
    }
}

    a. 编译通过，输出 10

    b. 编译不通过，把第 2 行改为 final int value = 10;

    c. 编译不通过，把第 3 行改为 public MyClass(){ value = 10; }

    d. 以上描述都不正确

  9. 仔细阅读以下代码，关于以下程序描述正确的是( c )

    class MyValue{
    int value;
}
public class TestFinal{
    public static void main(String[] args){
        final MyValue mv = new MyValue();
        mv.value = 100;
        //1
        System.out.println(mv.value);
    }
}

    a. 编译不通过

    b. 编译通过；在//1 处加上：mv.value = 200; 则编译不通过

    c. 编译通过。如果在//1 处加上：mv = new MyValue(); 则编译不通过

    d. 以上描述都不正确

  10. 仔细阅读以下代码，选出正确选项( a )

    class MyClass{
    public void printValue(final int value){
        System.out.println(value);
    }
    public void changeValue(int value){
        value = value*2;
        System.out.println(value);
    }
}
public class TeatMain{
    public static void main(String args[]){
        MyClass mc = new MyClass();
        int value = 5;
        final int fvalue = 10;
        mc.printValue(value);//1
        mc.printValue(fvalue);//2
        mc.changeValue(value);//3
        mc.changeValue(fvalue);//4
    }
}

    a. 编译通过

    b. //1 出错

    c. //2 出错

    d. //3 出错

    e. //4 出错

  11. 仔细阅读以下代码，代码中哪些内容是错误的( b c )

    abstract class MyAbstractClass{
    public abstract void m1();//1
    abstract protected void m2(){}//2
}
class MySubClass extends MyAbstractClass{
    void m1(){}//3
    protected void m2(){}//4
}

    a. //1

    b. //2

    c. //3

    d. //4

  12. 仔细阅读以下代码，程序是否能编译通过？如果可以，输出运行结果；如果不可以，应该怎样 修改？

    class Super{
    public final void m1(){
        System.out.println("m1() in Super");
    }
    public void m1(int i){
        System.out.println("m1(int) in Super");
    }
}
class Sub extends Super{
    public void m1(int i){
        System.out.println("m1(int) in Sub");
    }
    public void m1(double d){
        System.out.println("m1(double) in Sub");
    }
}
public class TestMain{
    public static void main(String args[]){
        Sub s = new Sub();
        s.m1();
        s.m1(10);
        s.m1(1.5);
    }
}

    运行结果：
m1() in Super
m1(int) in Sub
m1(double) in Sub

  13. 仔细阅读以下程序，写出程序运行输出的结果。

    class Super{
    public static void m1(){
        System.out.println("m1 in Super");
    }
    public void m2(){
        System.out.println("m2 in Super");
    }
}
class Sub extends Super{
    public static void m1(){
        System.out.println("m1 in Sub");
    }
    public void m2(){
        System.out.println("m2 in Sub");
    }
}
public class Test2{
    public static void main(String args[]){
        Super sup = new Sub();
        sup.m1();
        sup.m2();
        Sub sub =(Sub)sup;
        sub.m1();
        sub.m2(); 
    }
}

    运行结果：
m1 in Super
m2 in Sub
m1 in Sub
m2 in Sub

  14. 下面关于方法声明正确的是( e )

    a. abstract final void m()

    b. public void final m()

    c. static abstract void m()

    d. private abstract void m()

    e. public static final void m()

  15. 判断以下描述是否正确，正确填 T；否则填 F。

    (1) abstract 可以修饰类、方法、属性（F）

    (2) 抽象类中不一定有构造方法（F）

    (3) 抽象类只能声明引用，不允许单独 new 对象（T）

    (4) 所有类中都可以定义抽象方法（F）

    (5) 子类继承抽象类必须实现抽象类中所有抽象方法（T）

    (6) static 可以修饰属性、方法、代码块（T）

    (7) 静态属性只能用 类名.静态属性名 访问 （F）

    (8) 静态方法可以被本类中的其他方法直接访问（T）

    (9) 静态代码块在创建对象时完成静态属性的初始化工作（F）

    (10)final 只能修饰属性、方法、类（F）

    (11)final 修饰的方法不能被继承（F）

    (12)final 修饰的类不能被继承，即没有子类（T）

  16. 代码填空

    abstract class Super{
    void m();
    void m2();
}
class Sub extends Super{
    //1.
}
abstract class Sub1 extends Super{
    //2.
}

    代码示例：

    abstract class Super{
    void m();
    void m2();
}
class Sub extends Super{
    //1.
    void m(){}
    void m2(){}
}
abstract class Sub1 extends Super{
    //2.
}

主观题

  1. （编码）把三大特性中的 Shape 类改为抽象类，并把其中的求周长和求面积的方法改为抽象方法。

    • 代码示例：

      abstract class Shape{
    //抽象方法
    public abstract double girth();
    public abstract double area();
}
class Circle extends Shape{
    private double radius;//子类独有的属性 半径
    public Circle(){}
    public Circle(double radius){
        this.radius = radius;
    }
    public double getR() {
        return radius;
    }
    public void setR(double radius) {
        this.radius = radius;
    }
    //子类重写实现了抽象方法
    public double girth(){
        return Math.PI*radius*2;
    }
    public double area(){
        return Math.PI*radius*radius;
    }
}
class Rect extends Shape{
    private double length,width;//长方形的属性 长和宽
    public Rect(){}
    public Rect(double length,double width){
        this.length = length;
        this.width = width;
    }
    public double getLength() {
        return length;
    }
    public void setLength(double length) {
        this.length = length;
    }
    public double getWidth() {
        return width;
    }
    public void setWidth(double width) {
        this.width = width;
    }
    //子类重写了抽象方法 完成了抽象方法的实现
    public double girth(){
        return 2*(length+width);
    }
    public double area(){
        return length*width;
    }
}
class Square extends Rect{
    public Square(){}
    public Square(double length){
        //正方形继承了长方形 长和边相等 所以四个边相等 调用父类的构造方法
        super(length,length);
    }
}

  2. （编码）设计一个类 MyClass，为 MyClass 增加一个 count 属性，用来统计总共创建了多少个对象。

    public class Test{
    public static void main(String[] args) {
        MyClass mc1 = new MyClass();
        System.out.println(mc1.count);
    }
}
class MyClass{
    static int count;//静态属性 全类成员共享
    public MyClass(){
        //在创建的时候将count自增
        count++;
    }
}

  3. （编码）定义一个类是员工,员工有id和name属性,有一个方法是eat调用eat所有员工输出吃饭,有一 个抽象方法是work,不同的员工工作的内容不同,定义3个类,程序员, 老师,网管,分别调用work 的时候”id为xx的name”写代码”,”讲课”,”拉网线”

    • 代码示例：

      //员工类-抽象父类
abstract class Employee{
    private String id;
    private String name;
    public Employee() {}
    public Employee(String id, String name) {
        this.id = id;
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void eat(){
        System.out.println("吃饭");
    }
    //抽象方法
    public abstract void work();
}
//程序员类
class Programmer extends Employee{
    public Programmer() {}
    public Programmer(String id, String name) {
        super(id, name);
    }
    //实现了员工类中的抽象方法
    public void work(){
        System.out.println("id为"+this.getId()+"的"+this.getName()+"写代码");
    }
}
//老师类
class Teacher extends Employee{
    public Teacher() {}
    public Teacher(String id, String name) {
        super(id, name);
    }
    //实现了员工类的抽象方法
    public void work(){
        System.out.println("id为"+this.getId()+"的"+this.getName()+"讲课");
    }
}
//网管类
class Webmaster extends Employee{
    public Webmaster() {}
    public Webmaster(String id, String name) {
        super(id, name);
    }
    //实现了员工类的抽象方法
    public void work(){
        System.out.println("id为"+this.getId()+"的"+this.getName()+"拉网线");
    }
}

  4. （编码）设计一个抽象类，并演示它的三级使用

    抽象类 Teacher,有两个方法teach(),add(int a,int b)

    抽象子类 MathTeacher,继承于Teacher类,有一个方法teachMath();

    第三级类 RealMathTeacher,继承于MathTeacher，有两个方法TeachHightMath(),add(int a,int b);

    在主函数中，声明Teacher类引用，并且调用add方法

    • 代码示例：

      public class Test {
    public static void main(String[] args){
        Teacher t = new RealMathTeacher();
        System.out.println(t.add(3,5));
    }
}
//抽象父类-里面有抽象方法add
abstract class Teacher{
    public void teach(){
        System.out.println("教学");
    }
    public abstract int add(int a,int b);
}
//抽象子类-没有实现抽象方法add
abstract class MathTeacher extends Teacher{
    public void teachMath(){
        System.out.println("教数学");
    }
}
//普通子类-实现了抽象方法
class RealMathTeacher extends MathTeacher{
    public void teachHighMath(){
        System.out.println("教高数");
    }
    public int add(int a,int b){
        return a+b;
    }
}

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

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

相关文章

Linux文件系统上的特殊权限

Linux文件系统上的特殊权限

Linux 的文件权限，远不止 rwx 那么简单，还有一些特殊权限是用来打破限制和默认的安全上下文规则的，除了之前介绍过的隐藏属性，还有几个显式的特殊权限。下面就来说说 Linux 文件系统上的 SUID，SGID 和 Sticky 权限。 …
阅读更多...
Vue2基础篇-20-生命周期回调函数

Vue2基础篇-20-生命周期回调函数

1.vue2的生命周期 beforeCreate ：在实例初始化之后,进行数据侦听和事件/侦听器的配置之前同步调用； created: 在实例创建完成后被立即同步调用; beforeMount: 在挂载开始之前被调用 mounted : 实例被挂载后调用; beforeUpdate： 在数据发生…
阅读更多...
2023最新SSM计算机毕业设计选题大全（附源码+LW）之java民生租赁车辆管理信息系统w29s0

2023最新SSM计算机毕业设计选题大全（附源码+LW）之java民生租赁车辆管理信息系统w29s0

如果你自己基础不好或者是小白的情况下那就建议你选择网站、系统类的去做，但是还得问问你们导师，如果你们导师没问题就可以，因为有的导师是不愿意你们选择做网站、系统的，毕竟做的人比较多，重复率调高，选择…
阅读更多...
springboot中统一日志管理

springboot中统一日志管理

Springboot中统一日志管理 一、为什么要用日志？ 一般分为两个大类：操作日志和系统日志 **操作日志：**用户在操作软件时记录下来的操作步骤，便于用户自己查看。主要针对的是用户。 **系统日志：**系统日志是记录系统…
阅读更多...
zeno封装子图

zeno封装子图

选中想要封装的节点，点击编辑->简易子图 2. 设置输入输出（可以有多个） 最后，在main图中测试
阅读更多...
CDGA|6大核心环节，详解医疗机构如何做好数据治理

CDGA|6大核心环节，详解医疗机构如何做好数据治理

医疗机构进行数据治理的过程，就是对其数据资产进行管理和控制，支撑并保障数据被安全高效地交换与应用的过程。 我们接下来主要从6个核心环节来详解医疗机构如何做好数据治理。 环节一：设立数据治理组织结构 设计健全的数据治理组织结构&…
阅读更多...
网络配置（桥接仅主机自定义网络）

网络配置（桥接仅主机自定义网络）

目录 一、网络模式简介 1.bridge模式（默认桥接模式） 总结：桥接模式的特点就在于，它所虚拟的服务器都有独立的IP 初始网络模式 2.host模式（仅主机模式） 总结：仅主机它不会分配IP&#xff0c…
阅读更多...
java计算机毕业设计ssm校园考研互助网站71747（附源码、数据库）

java计算机毕业设计ssm校园考研互助网站71747（附源码、数据库）

java计算机毕业设计ssm校园考研互助网站71747（附源码、数据库） 项目运行 环境配置： Jdk1.8 Tomcat8.5 Mysql HBuilderX（Webstorm也行） Eclispe（IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff0…
阅读更多...
基于Android的校园二手闲置物品交易系统设计与实现

基于Android的校园二手闲置物品交易系统设计与实现

一、选题背景和意义 随着商品经济的快速发展，人们的生活中出现了大量的闲置物品，这种现象在当代大学生中尤为显著。大多数学生是通过摆地摊的方式来交易闲置物品，这种交易方式效率低下并且信息滞后。还有一部分学生通过BBS论坛来交易闲置物品…
阅读更多...
springboot--web开发

springboot--web开发

使用springboot开发web项目 1）、创建SpringBoot应用，选中我们需要的模块； web 2）、SpringBoot会默认将这些场景配置好了，只需要在配置文件中指定少量配置就可以将项目运行起来 ；/ 3）、自己编…
阅读更多...
Paddle 点灯人 之 Paddle介绍

Paddle 点灯人 之 Paddle介绍

Paddle 点灯人 之 Paddle介绍 文章目录Paddle 点灯人 之 Paddle介绍选择Paddle学习的原因Paddle免费提供的强大算力资源Paddle简单介绍Paddle的优势Paddle相关资料汇总选择Paddle学习的原因 首先，我想讲一下，为什么我想学习paddle，或者说为什…
阅读更多...
【C++】STL——vector的模拟实现

【C++】STL——vector的模拟实现

vector的模拟实现 文章目录vector的模拟实现一、vector模拟实现总览二、模拟实现vector函数接口1. 默认成员函数1.1. 构造函数1.2. 析构函数1.3.拷贝构造函数（深拷贝）1.4. 赋值运算符重载函数2. 容量操作函数2.1. size和capacity2.2. resize2.3. reserve…
阅读更多...
高数 | 【数一专项】真题回顾整理及知识点总结

高数 | 【数一专项】真题回顾整理及知识点总结

本文摘录于周洋鑫2023考研数学真题刷题班串讲~ 均为自用笔记整理。 ヾ(◍∇◍)ﾉﾞ 加油！ 对密度的积分 一、空间几何 1.1、旋转面方程 ☆ 常见二次曲面
阅读更多...
MINRES（极小残差算法）求解线性系统详细解读

MINRES（极小残差算法）求解线性系统详细解读

本博客参考了添加链接描述这篇知乎 先看我这篇博客介绍添加链接描述 QkRk−1Q_k R_{k}^{-1}Qk​Rk−1​的处理 假设Dk[d1,d2,…,dk]QkRk−1D_k [d_1,d_2, \ldots, d_k] Q_k R_{k}^{-1}Dk​[d1​,d2​,…,dk​]Qk​Rk−1​，假设RkR_kRk​的第iii行第jjj列元素为ri,…
阅读更多...
在无控制点的条件下如何用RTK定线定位

在无控制点的条件下如何用RTK定线定位

作为测量人的你，是否遇到过暂时没有测区范围内的控制点资料，或者虽然有控制点资料，但没有这些点的 WGS84坐标的情况？这时候如何处理呢？ 其实在没有控制点的情况下，可以利用RTK技术提供的在任意点上地方化功…
阅读更多...
JavaSe-泛型机制详解

JavaSe-泛型机制详解

1 理解泛型的本质 JDK 1.5开始引入Java泛型（generics）这个特性，该特性提供了编译时类型安全检测机制，允许程序员在编译时检测到非法的类型。 泛型的本质是参数化类型，即给类型指定一个参数，然后在使用时再…
阅读更多...
2022最后一个月如何快速发表一篇SCI

2022最后一个月如何快速发表一篇SCI

距2022年结束仅剩不到1个月，年终考核迫在眉睫，您的年初计划是否都已完成？2023年的科研计划是否也已提上日程？想要在2023年论文发表快人一步，早安排才是关键！ 进入12月，我处EA-ISET协会重点SCI/…
阅读更多...
基于jsp+mysql+ssm手机综合类门户网站-计算机毕业设计

基于jsp+mysql+ssm手机综合类门户网站-计算机毕业设计

项目介绍 手机综合类门户网站采用ssm框架和eclipse编辑器、MySQL数据库设计并实现的,主要包括系统手机评测管理模块、文章管理模块、手机新闻管理、所有评论管理、登录模块、和退出模块等多个模块。 管理员的登录模块：管理员登录系统对本系统其他管理模块进行管理。…
阅读更多...
vue3 速成教程（上）

vue3 速成教程（上）

学 vue3 通过官方文档更详细，不过阅读本博客，可以更容易理解，且帮你速成！ 官方文档（记得将API风格偏好切换为 组合式 否则你学的是vue2） https://cn.vuejs.org/guide/introduction.html 学习前的准备 创建…
阅读更多...
HBase的读写流程

HBase的读写流程

HBase的读流程 客户端从zk获取.META.表所在的regionserver；去对应的regionserver读取.META.表，获取region所在信息（region在哪个regionserver上保存的信息）；客户端到了regionserver时，先找到region&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023