static、 静态导入、成员变量的初始化、单例模式、final 常量（Content）、嵌套类、局部类、抽象类、接口、Lambda、方法引用

static

static 常用来修饰类的成员：成员变量、方法、嵌套类

成员变量

  • 被static修饰：类变量、成员变量、静态字段
    • 在程序中只占用一段固定的内存（存储在方法区），所有对象共享
    • 可以通过实例、类访问 (一般用类名访问和修改，不建议用实例修改)，但是不能通过类名访问实例变量和实例方法
  • 没有被static修饰:实例变量
    • 每个实例都有一份内存
package com.hxw.demo4;public class Person {public static  int count = 0;public int age;
}
package com.hxw.demo4;
public class Main {public static void main(String[] args) {Person.count = 20;Person p1 = new Person();p1.age = 20;System.out.println(p1.count);Person p2 = new Person();p2.age = 30;System.out.println(p2.count);}
}

控制台输出

20
20

方法

  • 被static修饰：类方法、静态方法
    • 可以通过实例、类访问
    • 内部不可以使用this
    • 可以直接访问类变量、类方法
    • 不可以直接访问实例变量和实例方法
  • 没有被static修饰：实例方法
    • 只能通过实例访问，不可以通过类访问
    • 内部可以使用this
    • 可以直接访问实例变量和实例方法
package com.hxw.demo4;public class Person {public static int count = 0;public int age;// 实例方法public void run1(){// 实例方法中可以使用this调用其他实例方法this.run2();//实例方法可以直接访问类变量和类方法System.out.println(count);test1();System.out.println(this.age);}public void run2(){System.out.println("void run2");}public static void test1(){System.out.println("static void test1");test2();System.out.println(count);}public static void test2(){System.out.println("static void test2");}
}
package com.hxw.demo4;public class Main {public static void main(String[] args) {Person person = new Person();person.age = 18;person.run1();Person.test1();}
}

总结：
在这里插入图片描述

静态导入

使用了静态导入之后，就可以省略类名来访问静态成员（成员变量、方法、嵌套类）

在这里插入图片描述

静态导入的经典应用

为了避免每一次都是用Math.PI,可以考虑使用静态导入，其他的Math方法也是一样的道理。
在这里插入图片描述

成员变量的初始化

  • 编译器会自动为未初始化的成员变量设置初始值
  • 如何手动给实例变量提供初始值
    • 在声明中：定义变量的时候直接给其设置初始值
    • 在构造方法中：在构造方法内部利用this进行初始化
    • 在初始化中 ：这个情况看下面代码，了解一下,
package com.hxw.dmeo6;public class Person {public static int count;public int age = 1; //申明中public Person(){age = 20;// 在构造方法中，但是先执行初始化中的代码}//在初始化中{age = 18;}
}

一般很少使用初始化代码,方法如下 公共初始化代码一般放到参数最多的构造方法中

package com.hxw.dmeo6;public class Person {public static int count;public int age = 1; //申明中public Person(){this(0, 0);}public Person(int age){this(age, 0);}public Person(int age, int no){// 公共初始化代码一般放到参数最多的构造方法中}//    //在初始化中
//    {
//        age = 18;
//    }
}
  • 如何手动给类变量提供初始值
    • 在声明中
    • 在静态初始化代码块中：当一个类初始化的时候（也就是一个类第一次被主动使用时，JVM会对类进行初始化），就会执行静态初始化代码块，且只会执行一次。
      • 可以有多个静态初始化块，按照在源码中出现的顺序被执行

在这里插入图片描述

初始化块和静态初始化块

这里实际的执行顺序和自己想的不一样，要先初始化完父类，再初始化子类
在这里插入图片描述

单例模式

如果一个类设计为单例模式，那么程序运行过程，这个类只能创建一个实例

  • 饿汉单例模式：一开始就创建了对象
  • 懒汉单例模式：等到该创建对象的时候创建对象，懒汉单例模式会有线程安全问题如果三个对象同时构建实例，那么会创建多个对象，但是最终创建的才会赋值给instance，所以总的说来还是单例模式

Rocket.class

package com.hxw.demo7;/*** 饿汉式单例模式：一上来就new了一个对象*/
//public class Rocket {
//    //私有的静态(唯一内存)实例变量
//    private static Rocket instance = new Rocket();
//
//    // 构造方法私有化 在Main中就不能new Rocket()
//    private Rocket(){
//
//    }
//
//    //公共的静态方法，返回唯一的静态实例
//    public static Rocket getInstance(){
//        return instance;
//    }
//}/*** 懒汉式单例模式*/public class Rocket {public static Rocket instace = null;private Rocket(){}public static Rocket getInstance(){//用到的时候再new对象if(instace == null){instace = new Rocket();}return instace;}
}

Main.class

package com.hxw.demo7;public class Main {public static void main(String[] args) {Rocket r1 = Rocket.getInstance();Rocket r2 = Rocket.getInstance();Rocket r3 = Rocket.getInstance();//r1 r2 r3 都是同一个instanceSystem.out.println(r1 == r2);System.out.println(r2 == r3);}
}

控制台输出

true
true

final和常量

  • 被final修饰的类不能被继承
  • 被final修饰的成员方法不能被重写
  • 被final修饰的变量，只能进行一次赋值，而且需要初始化，如果定义的时候没有初始化，那么在构造函数中一定要初始化

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

常量（Content）

  • 常量的写法： public static final double PI = 3.14159265358979323846;,一般名字全部用大写
  • 如果将基本类型或字符串定义为常量，并且在编译时就能确定值，编译器就会使用常量值代替各处的常量名（类似于C语言的宏替换），这样可以减少访问内存的次数，提高代码运行的效率

嵌套类

内部类（Inner Class，非静态嵌套类）

  • 嵌套类：定义在另一个类中的类
  • 外部类：在嵌套类外层的类
  • 顶级类：最外层的外部类
  • 内部类：没有被static修饰的嵌套类，非静态嵌套类。
    • 跟实例变量、实例方法一样，内部类与外部类的实例相关联**，必须先创建外部类实例，然后再用外部类实例创建内部类实例**。
    • 内部类不能定义除了除编译时常量以外的任何static成员
    • 内部类可以直接访问外部类中的所有成员（即使被申明为static）因为先创建了外部类实例，再创建内部类实例。
    • 外部类可以直接访问内部类实例的成员变量、方法
      外部类、内部类如下
package com.hxw.demo9;public class OuterClass {// 静态嵌套类static class StaticNestedClass {}// 非静态嵌套类（内部类）class InnerClass{}class A{class B{class C{}}}}

在这里插入图片描述
对应的内存图如下
在这里插入图片描述

静态嵌套类

  • 静态嵌套类：被static修饰的嵌套类
  • 静态嵌套类在行为上就是一个顶级类，只是定义的代码写在了另一个类中
  • 对比一般的顶级类，静态嵌套类多了一些特殊权限
    • 可以访问外部类中的成员（即使被申明为static）

在这里插入图片描述
在这里插入图片描述

什么情况使用嵌套类

情况一：如果类A只用在类C内部，可以考虑将类A嵌套到类C内部

  • 封装性更好
  • 程序包更加简化
  • 增强可读性、维护性

情况二：如果类A需要经常访问类C的非公共成员，可以考虑将类A嵌套到类C中

  • 另外也可以根据需要将类A隐藏起来，不对外暴露

情况三：如果需要经常访问非公共的实例成员（而且需要现有外层，后有内层的关系，例如现有公司Company 后有员工Employee），设计成内部类（非静态嵌套类），否则设计成静态嵌套类
- 如果必须现有C实例，才能创建A实例，那么可以将A设计为C的内部类

情况一案例：
在这里插入图片描述
在这里插入图片描述

局部类

  • 局部类：定义在代码块（包含{}，可以在里面写代码的块）中的类（可以定义在方法中，for循环中，if语句中）
  • 局部类不能定除编译时常量以外的任何static成员
  • 局部类只能访问final或者有效final（只赋值一次，没有被第二次赋值）的局部变量
  • 局部类可以直接访问外部类的所有成员
    • 局部类只有定义在实例相关的代码块中，才能直接访问外部类中的实例成员（实例变量、实例方法）

由于局部类是定义在代码块中的，所以其作用域也只局限于代码块中，因此，什么时候会用到局部类呢？当一个类是在一个代码块中使用的时候

package com.hxw.demo10;public class Person {static {class A{}}{int age = 10;class A{}}public void test(){for (int i = 0; i < 10; i++) {class A{}}if(true){class A{}}else{class A{}}{class A{}}}
}

在这里插入图片描述

抽象类

抽象方法（Abstract Method）

  • 抽象方法：被abstract修饰的方法
    • 只有方法申明，没有方法实现
    • 不能是private权限（因为定义抽象方法的目的就是为了让子类去实现）
    • 只能是实例方法，而不能是类方法
    • 只能定义在抽象类，接口中
package com.hxw.demo11;public abstract class Main {public static void main(String[] args) {}public abstract void test();
}

抽象类

  • 抽象类：被abstract修饰的类
    • 可以定义抽象方法
    • 不能实例化，但是可以自定义构造方法
    • 子类必须实现抽象父类中的所有抽象方法（除非子类也是一个抽象类）
    • 可以向非抽象类一样定义成员变量、常量、嵌套类型、初始化块、非抽象方法等，也就是，抽象类也可以完全不定义抽象方法

常见使用场景

  • 抽取子类的公共实现到抽象父类中，要求子类必须要单独实现的去定义成抽象方法

接口（Interface）

联想到日常笔记本电脑的接口，不同厂商的USB长得都是一样的，这是他们遵守相同的标准

  • API（Application Programming Interface）

    • 应用编程接口，提供给开发者调用的一组功能（无需提供源码）

  • java中的接口

    • 一系列方法申明的集合
    • 用来定义规范、标准

抽象类（abstract）是通过子类继承来实现其抽象方法，接口（Interface）是通过其他类实现该接口来实现其抽象方法

家教案例引入接口概念

有一个小孩，需要应聘家教，应聘要求：

  • 会教授编程
  • 会教踢足球
    涉及的人群可能有：在校的学生，在校的老师、出租车司机

首先看没有使用接口：

  • 定义一个孩子类
package com.hxw.demo12;public class Child {private String name;private Student jiajiao;public Child(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Student getJiajiao() {return jiajiao;}public void setJiajiao(Student jiajiao) {this.jiajiao = jiajiao;}public void study(){jiajiao.jiaoBianCheng(this);jiajiao.jiaoZuQiu(this);}}
  • 定义一个学生类
package com.hxw.demo12;public class Student {public void jiaoBianCheng(Child child){System.out.println("Student教" + child.getName() + "编程");}public void jiaoZuQiu(Child child){System.out.println("Student教" + child.getName() + "足球");}}
  • 主函数
package com.hxw.demo12;public class Main {public static void main(String[] args) {Child child = new Child("Jack");child.setJiajiao(new Student());child.study();}
}

如果希望老师教学生的话，按照这种方式就需要再创建一个Teacher类…教课的人身份众多，都需要单独修改Child类中的jiajiao属性，以及本类中的方法，这样很繁琐，但是这些类本质上都是实现了两个方法，招人的要求是满足这两个要求，但是对于这个人其他的特征，其实不用了解。此时，就可以将这两个行为定义到接口当中，各种身份的家教去实现这个接口即可。

  • 创建JiaJiaoable接口，将原来Student中的方法复制过去，并改写为抽象方法。
package com.hxw.demo12;public interface JiaJiaoable {public abstract void jiaoBianCheng(Child child);public abstract void jiaoZuQiu(Child child);
}

Student类、Teacher类分别实现JiaJiaoable接口中的方法

package com.hxw.demo12;public class Student implements JiaJiaoable{@Overridepublic void jiaoBianCheng(Child child) {System.out.println("Student教" + child.getName() + "biancheng");}@Overridepublic void jiaoZuQiu(Child child) {System.out.println("Student教" + child.getName() + "zuqiu");}
}
package com.hxw.demo12;public class Teacher implements JiaJiaoable{@Overridepublic void jiaoBianCheng(Child child) {System.out.println("Teacher教" + child.getName() + "biancheng");}@Overridepublic void jiaoZuQiu(Child child) {System.out.println("Teacher教" + child.getName() + "zuqiu");}
}

修改孩子类的家教属性为借口类型

package com.hxw.demo12;public class Child {private String name;private JiaJiaoable jiajiao;public Child(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}public JiaJiaoable getJiajiao() {return jiajiao;}public void setJiajiao(JiaJiaoable jiajiao) {this.jiajiao = jiajiao;}public void study(){jiajiao.jiaoBianCheng(this);jiajiao.jiaoZuQiu(this);}}

调用Main方法：

package com.hxw.demo12;public class Main {public static void main(String[] args) {Child child = new Child("Jack");child.setJiajiao(new Student());child.study();child.setJiajiao(new Teacher());child.study();}
}

控制台输出

Student教Jackbiancheng
Student教Jackzuqiu
Teacher教Jackbiancheng
Teacher教Jackzuqiu

接口中可以定义的内容

  • 可以定义：抽象方法、常量、嵌套类型，从java8开始定义
    • 上述可以定义的内容都是隐式public的，因此可以省略public关键字
    • 从java9开始可以定义private方法
  • 常量可以省略static、final
    • 接口中没有成员变量，写出来就是常量
  • 抽象方法可以省略abstract
  • 不能自定义构造方法、不能定义初始化块、不能实例化

接口的细节

  • 接口名称可以在任何使用类型的地方使用
  • 一个类可以通过implement关键字实现一个或者多个接口
    • 实现接口的类必须接口中定义的所有抽象方法，除非它也是一个抽象类
    • 如果一个类实现的多个接口中有相同的抽象方法，只需要实现此方法一次
    • extends和implement可以同时使用，但是implements必须写在extends后面
    • 当父类、接口中的方法签名（方法名称和参数列表）一样，那么返回值类型也必须一样

一个接口可以通过extends关键字继承一个或者多个接口

  • 当多个父接口方法签名一样的时候，那么返回值类型也必须一样

定义保姆类

package com.hxw.demo12;public interface BaoMuable {void cook(Child child);
}

学生不仅想应聘家教，也想应聘保姆

package com.hxw.demo12;public class Student implements JiaJiaoable, BaoMuable{@Overridepublic void jiaoBianCheng(Child child) {System.out.println("Student教" + child.getName() + "biancheng");}@Overridepublic void jiaoZuQiu(Child child) {System.out.println("Student教" + child.getName() + "zuqiu");}@Overridepublic void cook(Child child) {}
}

由上述案例，可以看出 一个类可以通过implement关键字实现一个或者多个接口

定义一个Animal类

package com.hxw.demo12.test;public class Animal {public void eat(String name){}
}

定义一个吃东西的接口

package com.hxw.demo12.test;public interface Eatable {void eat(String name);
}

定义了一个小狗类，这个类继承了Animal.class并且实现了Eatable接口

package com.hxw.demo12.test;public class Dog extends Animal implements Eatable{@Overridepublic void eat(String name) {}public static void main(String[] args) {Dog dog = new Dog();dog.eat("bone");}}

抽象类和接口的对比

抽象类和接口的用途有些类似，该如何选择？

抽象类：
1. 继承：A extends D (A 是 D)接口：
2.实现：A implement D（A会D中的行为）
  • 何时选择抽象类
    • 在紧密相关的类之间共享代码（例如人、老师都吃东西）
    • 需要除public以外的访问权限
    • 需要定义实例变量、非finial的静态变量（接口中只能定义常量）
  • 何时选择接口
    • 不相关的类实现相同的方法 （例如人、狗都吃东西）
class Student{public void eat(){// 代码1// 代码2}
}
class Teacher{public void eat(){// 代码1// 代码2}
}
Student和Teacher中的eat（）代码一样，就可以将其共享出来，选择抽象类

接口的升级问题

  • 如果接口需要升级，比如增加新的抽象方法
    • 会导致大幅度的代码改动，以前实现的接口类都得改动
  • 若想在不改动以前实现类的前提下进行接口升级，从java8开始有两种方案
    • 默认方法（Default Method）：将接口中新增的方法定义为默认方法，默认方法是允许有实现的
    • 静态方法（Static Method）

Lambda

Lambda Expression

  • Lambda 表达式是从java8才开始有的语法。
  • 函数式接口（Funxtional Interface）：只包含一个抽象方法的接口
    • 可以在接口上加上@FunctionalInterface注解，表示其是一个函数式接口
  • 当匿名类实现的是函数式接口时， 可以使用Lambda表达式进行简化

函数式接口

Lambda注意事项

  • Lambda只能访问finial或者有效finial的局部变量
  • Lambda没有引入新的作用域

定义一个OuterClass

package com.hxw.demo13;public class OuterClass {private int age = 1;public class InnerClass{private int age = 2;void inner(){Testable t = v -> {System.out.println(v);System.out.println(age);System.out.println(this.age);System.out.println(InnerClass.this.age);System.out.println(OuterClass.this.age);};t.test(3);}}public static void main(String[] args) {new OuterClass().new InnerClass().inner();}
}

方法引用

  • 如果Lambda中的内容仅仅是调用这个方法，可以使用方法引用（method Reference）来简化

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

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

CI/CD 的原理

CI/CD 的原理

一、CI/CD 的概念 CI/CD是一种软件开发流程&#xff0c;旨在通过自动化和持续的集成、测试和交付实现高质量的软件产品。 CI(Continuous Integration)持续集成 目前主流的开发方式是协同开发&#xff0c;即多位开发人员同事处理同意应用不同模块或功能。 如果企业在同一时间将…
阅读更多...
高效数据集成案例：从聚水潭·奇门到MySQL

高效数据集成案例：从聚水潭·奇门到MySQL

聚水潭奇门数据集成到MySQL的技术案例分享 在企业信息化建设中&#xff0c;数据集成是实现业务流程自动化和数据统一管理的关键环节。本文将分享一个具体的系统对接集成案例&#xff1a;如何将聚水潭奇门平台上的销售出库单数据高效、可靠地集成到MySQL数据库中&#xff0c;以…
阅读更多...
编译，链接，加载

编译，链接，加载

编译、链接、加载 编译、链接、加载是基础&#xff0c;十几年前从《深入理解计算机系统》等相关书籍中获得了比较全面的理解&#xff0c;现在已经变得有些模糊了。当时没有做总结的习惯&#xff0c;现在零零散散的记一些吧&#xff0c;有时间还要重温书本。 Build time 编译器…
阅读更多...
Python(pandas库3)

Python(pandas库3)

函数 随机抽样 语法&#xff1a; n&#xff1a;要抽取的行数 frac&#xff1a;抽取的比例&#xff0c;比如 frac0.5&#xff0c;代表抽取总体数据的50% axis&#xff1a;示在哪个方向上抽取数据(axis1 表示列/axis0 表示行) 案例&#xff1a; 输出结果都为随机抽取。 空…
阅读更多...
YOLOv8实战野生动物识别

YOLOv8实战野生动物识别

本文采用YOLOv8作为核心算法框架&#xff0c;结合PyQt5构建用户界面&#xff0c;使用Python3进行开发。YOLOv8以其高效的实时检测能力&#xff0c;在多个目标检测任务中展现出卓越性能。本研究针对野生动物数据集进行训练和优化&#xff0c;该数据集包含丰富的野生动物图像样本…
阅读更多...
Semantic Kernel进阶：创建和管理聊天（ChatCompletion）历史记录对象（四）

Semantic Kernel进阶：创建和管理聊天（ChatCompletion）历史记录对象（四）

一、引言 在构建基于Semantic Kernel的AI应用时&#xff0c;聊天历史记录对象&#xff08;Chat History&#xff09;是维护对话上下文和连续性的关键。本文将一步步指导你如何创建和管理聊天历史记录对象&#xff0c;从而为你的AI代理提供一个强大的对话管理工具。 二、聊天…
阅读更多...
规划控制复现：Apollo LQR横向控制（C++/simulink实现）

规划控制复现：Apollo LQR横向控制（C++/simulink实现）

本文在前文已经搭建好的ROS-C规划控制验证平台中进行LQR算法的复现&#xff0c;理论部分详见于&#xff1a; 规划控制复现&#xff1a;Apollo LQR横向控制&#xff08;算法原理推导与流程&#xff09;_apollo 规划控制-CSDN博客 Prescan-Carsim-ROS的仿真平台搭建详见于&…
阅读更多...
ASO优化秘籍！

ASO优化秘籍！

根据 App Annie 发布的报告显示&#xff0c;现全球移动设备使用时长达到新高&#xff0c;日均 4.2 小时。在这大环境下&#xff0c;App 的竞争也愈演愈烈&#xff0c;App 想让更多人看到&#xff0c;似乎越来越难。那么&#xff0c;App 可以通过哪些方式进行推广&#xff1f; …
阅读更多...
面向对象编程中类与类之间的关系(一)

面向对象编程中类与类之间的关系(一)

目录 1.引言 2."有一个"关系 3."是一个"关系(继承) 4.“有一个”与“是一个”的区别 5.not-a关系 6.层次结构 7.多重继承 8.混入类 1.引言 作为程序员&#xff0c;必然会遇到这样的情况&#xff1a;不同的类具有共同的特征&#xff0c;至少看起来彼…
阅读更多...
React写关键字高亮的三个方案

React写关键字高亮的三个方案

1.js正则replaceAlldangerouslySetInnerHTML{{ __html: xxx }}危险属性 步骤最简单,但是是危险属性,不推荐使用,项目中实在没有头绪,可以使用它应急 通过useMemo计算得到新的状态值,赋值给dangerouslySetInnerHTML属性的__html 关键代码: const [state1, setState1] useSt…
阅读更多...
Linux 生产者消费者模型

Linux 生产者消费者模型

1. 背景概念 假设现在有多个线程&#xff0c;一部分线程负责生产任务&#xff0c;称为生产者productor&#xff0c;另一部线程负责执行任务&#xff0c;称为消费者consumer&#xff0c;他们之间是一对一一对一一对一的关系。 现在生产者productor-3有任务要派发&#xff0c;但…
阅读更多...
PlantUML在IDEA中使用

PlantUML在IDEA中使用

1.打开settings,搜索PlantUML Integration并下载 2.安装并重启IDEA 3.学习相关的语法即可进行使用
阅读更多...
Java之多线程的实现(创建)（3种实现方式）(面试高频)

Java之多线程的实现(创建)（3种实现方式）(面试高频)

目录 一、多线程的3种实现方式 &#xff08;1&#xff09;继承Thread类。 &#xff08;2&#xff09;实现Runnable接口。&#xff08;void run()&#xff1a;该方法无返回值、无法抛出异常&#xff09; &#xff08;3&#xff09;实现Callable接口。&#xff08;V call() throw…
阅读更多...
企业如何吸引稀缺的高技能员工

企业如何吸引稀缺的高技能员工

高技能员工的稀缺性和招聘难度日益凸显&#xff0c;其原因主要在于技术发展迅速、人才供需失衡、企业竞争加剧。其中&#xff0c;技术发展迅速导致人才培养跟不上市场需求&#xff0c;使得高技能人才更加稀缺。以人工智能领域为例&#xff0c;新技术层出不穷&#xff0c;相关人…
阅读更多...
【MySQL】MySQL数据库中密码加密和查询的解决方案

【MySQL】MySQL数据库中密码加密和查询的解决方案

本篇博客是为了记录自己在遇到password函数无法生效时的解决方案。通过使用AES_ENCRYPT(str,key)和AES_DECRYPT(str,key)进行加密和解密。 一、问题 自己想创建一个user表&#xff0c;user表中有一个password属性列&#xff0c;自己想对密码进行加密后再存入数据库&#xff0c…
阅读更多...
java质数的判断 C语言指针变量的使用

java质数的判断 C语言指针变量的使用

1. public static void main(String[] args) {Scanner scnew Scanner(System.in);System.out.println("请输入一个值");int num sc.nextInt();boolean flagtrue;for (int i2;i<num;i){if (num%i0){flagfalse;break;}}if (flag){System.out.println(num"是一…
阅读更多...
Midjourney 3D：探索未来沉浸式体验的无限可能

Midjourney 3D：探索未来沉浸式体验的无限可能

一、Midjourney 3D：开启沉浸式新时代 最近，Midjourney宣布即将推出一款全新的3D产品，这不仅仅是一次简单的3D生成技术的升级，而是一场革命。这款新产品将基于先进的光场技术，而非传统的3D网格模型，为用户提供前所未有的沉浸式体验。用户不仅可以“跳入”生成的场景中自由…
阅读更多...
CasPL: Cascade Prompt Learning for Vision-Language Model Adaptation

CasPL: Cascade Prompt Learning for Vision-Language Model Adaptation

文章汇总 当前的问题 目前可学习的提示符号主要用于适应任务的单一阶段(即适应提示)&#xff0c;容易导致过度拟合风险。 动机 提示符将分两个阶段逐步优化。在初始阶段&#xff0c;学习增强提示&#xff0c;**通过使用大量未标记的领域图像数据对齐其预测逻辑&#xff0c;从…
阅读更多...
【文献及模型、制图分享】基于投入品减量增效视角的长江经济带农业生产绿色化演进研究

【文献及模型、制图分享】基于投入品减量增效视角的长江经济带农业生产绿色化演进研究

文献介绍 绿色化转型是农业可持续发展研究的重要议题。以农业生产绿色化转型过程的理论分析为基础&#xff0c;运用文献调查、访谈与问卷调查、脱钩分析相结合的方法&#xff0c;研究了长江经济带农业生产绿色化转型过程和投入品减量增效的趋势。 结果表明&#xff1a; 2015…
阅读更多...
记录一个容器间访问不通问题

记录一个容器间访问不通问题

docker-compose装了zookeeper和一个服务。 zk服务如下&#xff1a; szxc-zk:image: "image.sd001.cn:30003/base/zookeeper:3.8"privileged: trueenvironment:- "TZAsia/Shanghai"#- "ALLOW_ANONYMOUS_LOGINyes"- "ZOO_MY_ID1"- &qu…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023