类和对象(4)——多态：方法重写与动态绑定、向上转型和向下转型、多态的实现条件

目录

1. 向上转型和向下转型

1.1 向上转型

1.2 向下转型

1.3 instanceof关键字

2. 重写（overidde）

2.1 方法重写的规则

2.1.1 基础规则

2.1.2 深层规则

2.2 三种不能重写的方法

final修饰

private修饰 

static修饰

3. 动态绑定

3.1 动态绑定的概念

3.2 动态绑定与静态绑定

4. 多态

4.1 多态的实现场景

1. 基类形参方法 

2. 基数组

4.2 多态缺陷

1. 属性(字段)没有多态性 

2. 向上转型不能使用子类特有的方法

3. 构造方法没有多态性

上一篇文章中，我们深度学习了继承的概念与实现。在继承篇中，我们最重要的就是“弄清楚通过子类实例变量来访问与父类相同的成员会怎么样”；而在多态篇中，最核心的内容就是“弄清楚通过父类实例变量来访问与子类相同的方法会怎么样”。

1. 向上转型和向下转型

在了解多态之前，我们还要补充几个知识点，这首先就是向上转型和向下转型。

1.1 向上转型

向上转型是指将一个子类对象的引用赋值给一个父类类型的实例变量。

语法格式：

父类类型 对象名 = new 子类类型()；

//例如 Animal animal = new Cat("小咪", 2);

animal是父类类型的实例变量，但引用的是一个子类Cat对象，因为这是从小范围向大范围的转换。类似基础数据类型中的隐式类型转换（例如长整形long接收整形int的数据）

向上转型的3种使用场景：

  1. 直接赋值：子类对象的引用直接赋值给父类类型的实例变量。
  2. 方法传参：子类对象的引用作为参数，传递给方法中的父类类型的形参。
  3. 方法返回：方法的返回类型是父类类型，返回的值是子类类型。

例如：

public class TestAnimal {
    // 2. 方法传参：形参为父类型引用，可以接收任意子类的对象
    public static void eatFood(Animal a){
        a.eat();
    }
 
    // 3. 作返回值：返回任意子类对象
    public static Animal buyAnimal(String var){
        if("狗".equals(var) ){
            return new Dog("狗狗",1);
        }else if("猫" .equals(var)){
            return new Cat("猫猫", 1);
        }else{
            return null;
        }
    }
 
    public static void main(String[] args) {
        Animal cat = new Cat("元宝",2);   // 1. 直接赋值：子类对象赋值给父类对象
        Dog dog = new Dog("小七", 1);
 
        eatFood(cat);
        eatFood(dog);
 
        Animal animal = buyAnimal("狗");
        animal.eat();
 
        animal = buyAnimal("猫");
        animal.eat();
    }
 }

1.2 向下转型

向下转型是将父类对象强制转换为子类对象的过程，需要用到类型转换运算符( ) 。

【注意】

  • 只能对已向上转型的对象进行向下转型：不能直接将一个父类对象强制转换为子类对象，除非这个父类对象实际上是子类对象的向上转型。也就是说，必须先创建一个子类对象，然后将其向上转型为父类对象，最后再进行向下转换。
  • 向上转型的子类类型 与 向下接收的子类类型必须一致。

例如：

先看父类和子类的具体代码：

public class Animal {
    public String name;

    public Animal(String name){
        this.name = name;
    }

    public void eat(){
        System.out.println(name+"在吃东西");
    }
}

public class Dog extends Animal{
    public Dog(String name){
        super(name);
    }

    public void eat(){
        System.out.println(name+"在吃狗粮");
    }
    //Dog类的专属方法
    public void bark(){
        System.out.println(name+"在汪汪叫");
    }
}

public class Cat extends Animal{
    public Cat(String name){
        super(name);
    }

    public void eat(){
        System.out.println(name+"在吃猫粮");
    }
    //Cat类的专属方法
    public void mew(){
        System.out.println(name+"在喵喵叫");
    }
}

测试1：父类实例animal是Dag类的向上转型，再让animal向下转型传给子类实例dog。

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog("旺财");
        Dog dog;

        dog = (Dog) animal;
        dog.bark();
    }
}

运行成功

测试2：父类实例animal是Dag类的向上转型，再让animal向下转型传给子类实例cat。（向上转型的子类与向下接收的子类不一致）

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog("旺财");
        
        Cat cat;
        cat = (Cat) animal;//抛出异常
    }
}

抛出异常

1.3 instanceof关键字

向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了instanceof关键字。

语法：

        Object  instanceof  ClassName

其中，object 是要测试的对象或实例变量，ClassName 是要测试的类名。

作用和返回值：

如果 object 是 ClassName 的实例或其子类的实例，则表达式返回 true；否则返回 false。

有了instanceof，我们向下转型就可以更安全了：

public class TestAnimal {
    public static void main(String[] args) {
        Cat cat = new Cat("元宝",2);
        Dog dog = new Dog("小七", 1);
 
        // 向上转型
        Animal animal = cat;
        animal.eat();
        animal = dog;
        animal.eat();
 
        if(animal instanceof Cat){    //检查类型
            cat = (Cat)animal;
            cat.mew();
        }
 
        if(animal instanceof Dog){    //检查类型
            dog = (Dog)animal;
            dog.bark();
        }
    }
 }

animal最后是Dog类的引用，所以通过了第2个检查，由dog接收animal的向下转型。

2. 重写（overidde）

2.1 方法重写的规则

2.1.1 基础规则

方法重写：也称为方法覆盖，即外壳不变，核心重写。

  1. 子类在重写父类的方法时，一般必须与父类的方法原型一致【返回值类型、方法名、参数列表要完全一致】。 
  2. 重写的方法，可以在子类方法头的上一行使用“ @Override ”注解来显式指定。有了这个注解能帮我们进行一些合法性校验。（例如不小心将方法名字拼写错了，比如eat写成 aet，那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写）

例如：

如果显示指定@overidde，但方法与父类原型不一致的话，系统会报错：

2.1.2 深层规则

  1. 返回值类型：其实子类重写的方法返回类型也可以与父类不一样，但是必须是具有父子关系的。       
    1.  该要求其实隐藏了一个情况，那就是此时的方法返回值类型是类类型的。
    2.  对于这种情况的方法重写，父类方法的返回值类型 必须是 子类方法的返回值类型的 基类。
  2. 访问限定符：访问权限不能比父类中被重写的方法的访问权限更低。(即子类重写的方法访问权限可以更宽松，不能更严格)

对于“返回值类型”要求的举例：

​class Parent {
    public Number display() {
        return 42; // 返回一个Integer类型的值
    }
}

class Child extends Parent {
    // 重写父类的display方法，并改变返回类型为Double，这是允许的，因为Double是Number的子类型
    @Override
    public Double display() {
        return 42.0;
    }
}

public class Test {
    public static void main(String[] args) {
        Parent parent = new Parent();
        System.out.println(parent.display()); // 输出: 42

        Child child = new Child();
        System.out.println(child.display()); // 输出: 42.0
    }
}

Parent类的display方法的返回类型是Number类，Child类的display方法的返回类型是Double类。其中Parent类是Child类的父类，Number类又是Double类和Interger类的父类，这符合方法重写的深层规则。

如果该例子中的 方法返回值类型的父子关系反过来 会报错：

对于“访问限定符”要求的举例：

关于方法重写还有更深层更严格的规定，这些规定与异常、线程等有关。本章重点是继承与多态，所以不再具体展开。

2.2 三种不能重写的方法

如果父类方法被final、private或static修饰，则子类不能重写该方法。

final修饰

final：

final修饰成员方法时，就是用来防止该方法被子类重写 或者 不想让该方法被重写。

例如：

private修饰 

private：

当父类的方法被private修饰时，说明这个方法是父类私有的，子类也没有办法去访问该方法。

  • 如果private修饰了父类的方法，子类又写了一个与父类方法原型一样的方法，系统并不会报错。
    (因为系统检查方法重写时，会自动把父类的私有方法忽略掉)
  • 如果private修饰了子类的方法，父类又有一个与子类方法原型一样的非private方法，那么系统会报错。
    (此时系统会认为你想要让子类重写父类方法，又因为重写后的方法是私有的而父类的方法非私有，所以会提醒你“分配了更低的访问权限”并报错)

例1：

父类方法是私有的，build没有问题

例2：

子类方法是私有的，父类方法原型与子类一致。系统认为你要重写，但子类的方法权限更低，所以报错：

static修饰

static：

静态方法是在类加载时就绑定到类本身，而不是在运行时绑定到具体的对象实例，所以static修饰的方法不能被重写。即静态方法不能实现动态绑定，也就不能被覆盖(重写)。

例如：

虽然静态方法是可以被继承的，但如果子类定义了一个与父类相同签名的静态方法，这只是对父类静态方法的一种隐藏，而非真正意义上的重写。

  • 子类对象向上转型后，当通过父类实例变量引用调用该方法时，仍然会执行父类的静态方法，而不是子类的静态方法。

例如：

class Parent {
     static void display() {
        System.out.println("Parent display method");
     }
}

class Child extends Parent {
     static void display() {
        System.out.println("Child display method");
     }
}

public class Test {
    public static void main(String[] args) {
        Parent parent1 = new Parent();
        parent1.display();  //调用父类静态方法

        Child child = new Child();
        child.display();   //调用子类静态方法

        Parent parent2 = new Child();   //向上转型
        parent2.display();  //调用父类静态方法
    }
}

3. 动态绑定

3.1 动态绑定的概念

刚刚在解释static修饰方法时，我们提到了一个词叫动态绑定。下面让我们看看什么是动态绑定。

概念：

动态绑定也叫后期绑定，是指在运行时根据对象的实际类型来确定调用哪个方法，而不是在编译时就决定。当一个父类引用指向其子类的对象，并且通过该引用调用一个被重写的方法时，会在运行时根据对象的实际类型来调用相应的方法实现，这就是重写方法的动态绑定。

动态绑定重写方法的实现条件：

  1. 存在继承关系：必须有一个基类（父类）和至少一个派生类（子类），子类继承自父类。
  2. 方法重写：子类要实现父类中至少一个方法的重写。
  3. 向上转型：在程序中存在向上转型的情况，即把子类对象的引用赋值给父类的实例变量。

例如：

class Animal {
    public String name;

    public Animal(String name){
        this.name = name;
    }

    public void eat(){
        System.out.println(name+"在吃东西");
    }
}

public class Dog extends Animal{
    public Dog(String name){
        super(name);
    }

    public void eat(){
        System.out.println(name+"在吃狗粮");
    }
}

public class Cat extends Animal{
    public Cat(String name){
        super(name);
    }

    public void eat(){
        System.out.println(name+"在吃猫粮");
    }
}

public class Test {
    public static void main(String[] args) {
       Animal animal = new Animal("动物");//animal动态绑定到Animal类
       animal.eat();

       animal = new Dog("小狗");//animal动态绑定到Dog类
       animal.eat();

       animal = new Cat("小猫");//animal动态绑定到Cat类
       animal.eat();
    }
}

3.2 动态绑定与静态绑定

静态绑定也称为早期绑定：是指在程序编译时就已经确定了方法调用的具体对象和方法实现。与动态绑定相对应，静态绑定不需要在运行时进行额外的判断和查找来确定调用哪个方法。

静态绑定的适用情况

  • 基本数据类型的方法调用(可重载的方法)：对于基本数据类型的操作方法，如数学运算等，通常是静态绑定。例如，int a = 5; int b = 10; int c = a + b; 中 + 运算符对应的加法方法是在编译时就确定的。
  • 私有方法、静态方法和 final 方法：这些方法不能被重写或具有特殊的性质，所以它们的调用可以在编译时确定。例如，class Example { private void privateMethod() {...} static void staticMethod() {...} final void finalMethod() {...} } 中的私有方法、静态方法和 final 方法都是静态绑定的。
  • 构造方法：构造方法在创建对象时被调用，每个类都有特定的构造方法，且在编译时就可以确定是哪个类的构造方法会被调用。例如，new Example() 会调用 Example 类的构造方法，这是在编译时就已经决定的。

方法重载（静态绑定）是一个类的多态性表现【例如工具类Arrays】，而方法重写（动态绑定）是子类与父类间的多态性的表现。

4. 多态

多态的概念：

去完成某个行为时，当不同的对象去完成时会产生出不同的状态。又或者同一件事情，发生在不同对象身上，就会产生不同的结果。

打个比方，语文老师要求同学们背一首诗，同学A背了一首李白的诗、同学B背了一首杜甫的诗、同学C背了一首李清照的诗……每个同学背的诗都不同，但不管怎么说他们都完成了“背一首诗”的任务，这就是多态。

4.1 多态的实现场景

在java中要实现多态，必须要满足如下几个条件，缺一不可：

  1. 必须在继承体系下 
  2. 子类必须要对父类中方法进行重写 
  3. 通过父类的引用调用

下面我来介绍两种常见的多态实现。

1. 基类形参方法 

基类形参方法：指的是形参数据类型为基类类型的方法。

该方法的形参的类型是父类类型，我们一般在该方法中使用被重写的方法。不同的子类实例变量传参进去并发生向上转型，该基类形参方法就能够通过动态绑定来调用不同的重写方法，从而实现多态。

例如：

//有继承关系的类
public class Animal {
    public String name;
    public Animal(String name){
        this.name = name;
    }
    public void eat(){
        System.out.println(name+"在吃东西");
    }
}

public class Dog extends Animal{
    public Dog(String name){
        super(name);
    }

    public void eat(){
        System.out.println(name+"在吃狗粮");
    }
}

public class Cat extends Animal{
    public Cat(String name){
        super(name);
    }

    public void eat(){
        System.out.println(name+"在吃猫粮");
    }
}
————————————————————————————————————————————————————————
————————————————————————————————————————————————————————
//含基类形参方法的类
public class Test {
    public void eat(Animal animal){ //基类形参方法
        animal.eat();
    }

    public static void main(String[] args) {
        Test test = new Test();    //如果Test的eat方法是静态方法，那么可以不用new一个Test对象
        test.eat(new Animal("小动物"));
        test.eat(new Dog("小狗"));
        test.eat(new Cat("小猫"));
    }
}

这种方法有点类似C语言中的函数指针和回调函数的用法。详细请看《指针之旅（4）—— 指针与函数：函数指针、转移表、回调函数》

2. 基数组

基数组：指的是数组元素的类型都是基类类型。

由于可以向上转型，在基数组中可以存放子类对象，从而实现多态。

（有点类似C语言中的函数指针数组）

例如：

​//Animal类、Dog类和Cat类的内容如上面的一致
public class Test {
    public static void main(String[] args) {
        //基数组animals
        Animal[] animals = {new Animal("小动物"), new Dog("小狗"), new Cat("小猫")};
        
        for(Animal x: animals){
            x.eat();    //临时变量x通过动态绑定实现多态
        }
    }
}

如果有新的动物增加，我们可以在基数组animals中添加，这就是多态的好处，十分便捷。

如果不基于多态来实现刚刚的代码内容，我们需要多个if-else语句，如下：

在这种情况下，如果要增加一个动物，不仅字符串数组animals要变，而且在for-each循环中还要加多一条else-if语句，十分不便。

4.2 多态缺陷

1. 属性(字段)没有多态性 

当父类和子类都有同名属性的时候，通过父类实例变量引用，只能引用父类自己的成员属性。

例如：

public class Parent {
    public String str = "parent";
}

public class Child extends Parent{
    public String str = "child";
}

public class Test {
    public static void main(String[] args) {
        Parent parent = new Parent();
        System.out.println(parent.str);//打印parent

        Child child = new Child();
        System.out.println(child.str);//打印child

        parent = child;     //向上转型
        System.out.println(parent.str);//属性没有多态性，打印的还是父类的str
    }
}

2. 向上转型不能使用子类特有的方法

方法调用在编译时进行类型检查，编译器只检查引用变量类型中定义的方法，而不考虑实际对象的类型。

例如，这里子类Dog比父类Animal类多了一个特殊方法bark()。如果用Animal类型的实例变量来接收Dog类的对象，我们会发现无法通过该实例变量调用bark方法：

3. 构造方法没有多态性

当父类的构造方法中调用一个被重写的方法时，实际执行的是子类中的实现。然而，此时子类可能还未完成初始化，其成员变量尚未赋值或处于默认状态，这就可能导致程序行为不确定，甚至引发错误。

父类构造方法中如果调用了被重写的方法，那么该重写的方法使用的是子类的方法。

我们创建两个类, B 是父类, D 是子类. D 中重写 func 方法. 并且在 B 的构造方法中调用 func：

​
class B {
    public B() {
        // do nothing
        func();
    }

    public void func() {
        System.out.println("B.func()");
    }
}

class D extends B {
    private int num = 10;
    @Override
    public void func() {
        System.out.println("D.func() " + num);
    }
}

public class Test {
    public static void main(String[] args) {
        D d = new D();
    }
}

​

  • 构造 D 对象的同时，会调用 B 的构造方法.
  • B 的构造方法中调用了 func 方法， 此时会触发动态绑定，会调用到 D 中的 func 。此时 D 对象自身还没有构造，此时 num 处在未初始化的状态，值为 0.
  • 如果具备多态性，num的值应该是10.

结论: "用尽量简单的方式使对象进入可工作状态", 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触 发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题。

本期分享完毕，感谢大家的支持Thanks♪(･ω･)ﾉ

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

JavaScript使用toFixed保留一位小数的踩坑记录：TypeError: xxx.toFixed is not a function

JavaScript使用toFixed保留一位小数的踩坑记录：TypeError: xxx.toFixed is not a function

JavaScript的toFixed函数是用于将一个数字格式化为指定的小数位数的字符串。其语法如下： numObj.toFixed([digits]) 其中，numObj是需要格式化的数字，digits是保留的小数位数。digits参数是一个可选参数，默认值为0，表示不保留小数位。 计算后需要保留一位小数，于是使用…
阅读更多...
网络仿真工具Core环境搭建

网络仿真工具Core环境搭建

目录 安装依赖包 源码下载 Core安装 FAQ 下载源码TLS出错误 问题 解决方案 找不到dbus-launch 问题 解决方案 安装依赖包 调用以下命令安装依赖包 apt-get install -y ca-certificates git sudo wget tzdata libpcap-dev libpcre3-dev \ libprotobuf-dev libxml2-de…
阅读更多...
深入 Rollup：从入门到精通（三）Rollup CLI命令行实战

深入 Rollup：从入门到精通（三）Rollup CLI命令行实战

准备阶段：初始化项目 初始化项目，这里使用的是pnpm，也可以使用yarn或者npm # npm npm init -y # yarn yarn init -y # pnpm pnpm init安装rollup # npm npm install rollup -D # yarn yarn add rollup -D # pnpm pnpm install rollup -D在…
阅读更多...
volatile之四类内存屏障指令 内存屏障 面试重点 底层源码

volatile之四类内存屏障指令 内存屏障 面试重点 底层源码

目录 volatile 两大特性 可见性 有序性 总结 什么是内存屏障 四个 CPU 指令 四大屏障 重排 重排的类型 为什么会有重排？ 线程中的重排和可见性问题 如何防止重排引发的问题？ 总结 happens-before 和 volatile 变量规则 内存屏障指令 写操作…
阅读更多...
力扣算法题——11.盛最多水的容器

力扣算法题——11.盛最多水的容器

目录 💕1.题目 💕2.解析思路 本题思路总览 借助双指针探索规律 从规律到代码实现的转化 双指针的具体实现 代码整体流程 💕3.代码实现 💕4.完结 二十七步也能走完逆流河吗 💕1.题目 💕2.解析思路…
阅读更多...
RK3568 adb使用

RK3568 adb使用

文章目录 一、adb介绍**ADB 主要功能****常用 ADB 命令****如何使用 ADB****总结** 二、Linux下载adb**方法 1：使用包管理器（适用于 Ubuntu/Debian 系统）****方法 2：通过 Snap 安装（适用于支持 Snap 的系统&#xff09…
阅读更多...
【ES实战】治理项之索引模板相关治理

【ES实战】治理项之索引模板相关治理

索引模板治理 文章目录 索引模板治理问题现象分析思路操作步骤问题程序化方案索引与索引模板增加分片数校验管理 彩蛋如何查询Flink on Yarn 模式下的Task Manager日志相关配置查询已停止的Flink任务查询未停止的Flink任务 问题现象 在集群索引新建时，索引的分片比…
阅读更多...
网络工程师 （2）计算机体系结构

网络工程师 （2）计算机体系结构

一、冯诺依曼体系结构 （一）简介 冯诺依曼结构也称普林斯顿结构，是一种将程序指令存储器和数据存储器合并在一起的存储器结构。程序指令存储地址和数据存储地址指向同一个存储器的不同物理位置，因此程序指令和数据的宽度相同。数学…
阅读更多...
Android Studio:视图绑定的岁月变迁(2/100)

Android Studio:视图绑定的岁月变迁(2/100)

一、博文导读 本文是基于Android Studio真实项目，通过解析源码了解真实应用场景，写文的视角和读者是同步的，想到看到写到，没有上帝视角。 前期回顾，本文是第二期。 private Unbinder mUnbinder; 只是声明了一个 接口…
阅读更多...
LeetCode | 不同路径

LeetCode | 不同路径

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。 问总共有多少条不同的路径？ 示例 1…
阅读更多...
低代码系统-产品架构案例介绍、得帆云（八）

低代码系统-产品架构案例介绍、得帆云（八）

产品名称 得帆云DeCode低代码平台-私有化 得帆云DeMDM主数据管理平台 得帆云DeCode低代码平台-公有云 得帆云DePortal企业门户 得帆云DeFusion融合集成平台 得帆云DeHoop数据中台 名词 概念 云原生 指自己搭建的运维平台，区别于阿里云、腾讯云 Dehoop 指…
阅读更多...
使用ensp进行ppp协议综合实验

使用ensp进行ppp协议综合实验

实验拓扑 实验划分 AR1的Serial3/0/0接口：192.168.1.1/24； AR2的Serial3/0/0接口：192.168.1.2/24； AR2的Serial3/0/1和4/0/0的聚合接口：192.168.2.2/24； AR3的Serial3/0/0和3/0/1的聚合接口：192…
阅读更多...
【Python・机器学习】多元回归模型（原理及代码）

【Python・机器学习】多元回归模型（原理及代码）

前言 自学笔记，分享给语言学/语言教育学方向的，但对语言数据处理感兴趣但是尚未入门，却需要在论文中用到的小伙伴，欢迎大佬们补充或绕道。ps：本文最少限度涉及公式讲解（文科生小白友好体质）&am…
阅读更多...
unity免费资源2025-1-26

unity免费资源2025-1-26

https://assetstore.unity.com/packages/tools/animation/motion-warping-climb-interact-270046 兑换码KINEMATION2025
阅读更多...
Kitchen Racks 2

Kitchen Racks 2

Kitchen Racks 2 吸盘置物架 Kitchen Racks-CSDN博客
阅读更多...
ESMC-600M蛋白质语言模型本地部署攻略

ESMC-600M蛋白质语言模型本地部署攻略

前言 之前介绍了ESMC-6B模型的网络接口调用方法，但申请token比较慢，有网友问能不能出一个本地部署ESMC小模型的攻略，遂有本文。 其实本地部署并不复杂，官方github上面也比较清楚了。 操作过程 环境配置：CUDA 12.1、…
阅读更多...
JAVA设计模式：依赖倒转原则（DIP）在Spring框架中的实践体现

JAVA设计模式：依赖倒转原则（DIP）在Spring框架中的实践体现

文章目录 一、DIP原则深度解析1.1 核心定义1.2 现实比喻 二、Spring中的DIP实现机制2.1 传统实现 vs Spring实现对比 三、Spring中DIP的完整示例3.1 领域模型定义3.2 具体实现3.3 高层业务类3.4 配置类 四、Spring实现DIP的关键技术4.1 依赖注入方式对比4.2 自动装配注解 五、D…
阅读更多...
JVM栈溢出线上环境排查

JVM栈溢出线上环境排查

#查看当前Linux系统进程ID、线程ID、CPU占用率（-eo后面跟想要展示的列） ps H -eo pid,tid,%cpups H -eo pid,tid,%cpu |grep tid #使用java jstack 查看进程id下所有线程id的情况 jstack pid 案例2 通过jstack 排查死锁问题 #启动java代码 jstack 进…
阅读更多...
Langchain+讯飞星火大模型Spark Max调用

Langchain+讯飞星火大模型Spark Max调用

1、安装langchain #安装langchain环境 pip install langchain0.3.3 openai -i https://mirrors.aliyun.com/pypi/simple #灵积模型服务 pip install dashscope -i https://mirrors.aliyun.com/pypi/simple #安装第三方集成,就是各种大语言模型 pip install langchain-comm…
阅读更多...
Gradle配置指南：深入解析settings.gradle.kts（Kotlin DSL版）

Gradle配置指南：深入解析settings.gradle.kts（Kotlin DSL版）

文章目录 Gradle配置指南：深入解析settings.gradle.kts（Kotlin DSL版）settings.gradle.kts 基础配置选项单项目配置多项目配置 高级配置选项插件管理（Plugin Management）基础配置模板案例：Android项目标准配…
阅读更多...
最新文章

Copyright @ 2022~2023