初识Java 18-4 泛型

目录

泛型存在的问题

在泛型中使用基本类型

实现参数化接口

类型转换和警告

无法实现的重载

基类会劫持接口

自限定类型

奇异递归类型

自限定

自限定提供的参数协变性

本笔记参考自： 《On Java 中文版》

泛型存在的问题

        接下来讨论的，是在泛型中经常可能遇到的一些问题。

在泛型中使用基本类型

        Java的泛型并不支持基本类型，因此我们无法将其用作泛型的类型参数。一个替代的方法是使用基本类型的包装类：

【例子：通过包装类使用泛型】

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class ListOfInt {
    public static void main(String[] args) {
        List<Integer> li = IntStream.range(38, 48)
                .boxed() // 将基本类型转换成其对应的包装类
                .collect(Collectors.toList());
        System.out.println(li);
    }
}

        程序执行的结果是：

        这足以应付大部分的情况。但如果真的需要追求性能，可以使用专门适配基本类型的集合，例如org.apache.commons.collections.primitives。

        或者，可以使用泛型集合来装载基本类型：

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class ByteSet {
    Byte[] possibles = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    Set<Byte> mySet1 =
            new HashSet<>(Arrays.asList(possibles));

    // 不可行的方式：
    /* Set<Byte> mySet2 =
            new HashSet<>(Arrays.<Byte>asList(
                    1, 2, 3, 4, 5, 6, 7, 8, 9)); */
}

        在这里，自动装箱机制为我们解决了转换问题。但它不会总是有效，例如：

【例子：向数组中填充对象】

import java.util.*;
import java.util.function.*;

interface FillArray {
    static <T> T[] fill(T[] a, Supplier<T> gen) {
        // 使用get()填充数组a
        Arrays.setAll(a, n -> gen.get());
        return a;
    }

    static int[] fill(int[] a, IntSupplier gen) {
        Arrays.setAll(a, n -> gen.getAsInt());
        return a;
    }

    static long[] fill(long[] a, LongSupplier gen) {
        Arrays.setAll(a, n -> gen.getAsLong());
        return a;
    }

    static double[] fill(double[] a, DoubleSupplier gen) {
        Arrays.setAll(a, n -> gen.getAsDouble());
        return a;
    }
}

interface Rand {
    // SplittableRandom也是用于生成随机数的类
    SplittableRandom r = new SplittableRandom(47);


    class StringGenerator implements Supplier<String> {
        int strlen;

        StringGenerator(int strlen) {
            this.strlen = strlen;
        }

        @Override
        public String get() {
            return r.ints(strlen, 'a', 'z' + 1)
                    .collect(StringBuilder::new,
                            StringBuilder::appendCodePoint,
                            StringBuilder::append).toString();
        }
    }

    class IntegerGenerator implements IntSupplier {
        @Override
        public int getAsInt() {
            return r.nextInt(10_000);
        }
    }
}

public class PrimitiveGenericTest {
    public static void main(String[] args) {
        String[] strings = FillArray.fill(
                new String[5], new Rand.StringGenerator(7));
        System.out.println(Arrays.toString(strings));

        int[] integers = FillArray.fill(
                new int[9], new Rand.IntegerGenerator());
        System.out.println(Arrays.toString(integers));
    }
}

        程序执行的结果是：

        由于自动装箱对数组无效，因此需要我们手动重载FillArray.fill()方法，或者通过一个生成器来包装输出结果。

实现参数化接口

        一个类无法实现同一个泛型接口的两种变体：

因为类型擦除，这两个变体实际上都表示着原生的Payable。换言之，上述代码中Hourly将同一个接口实现了两次。

类型转换和警告

        因为类型擦除，我们无法对类型参数使用类型转换或instanceof。因此，有时会需要在边界处进行类型转换：

【例子：在泛型边界处进行类型转换】

import java.util.Arrays;
import java.util.stream.Stream;

class FixedSizeStack<T> {
    private final int size;
    private Object[] storage;
    private int index = 0;

    FixedSizeStack(int size) {
        this.size = size;
        storage = new Object[size];
    }

    public void push(T item) {
        if (index < size)
            storage[index++] = item;
    }

    @SuppressWarnings("unchecked")
    public T pop() {
        return index == 0 ?
                null : (T) storage[--index];
    }

    @SuppressWarnings("unchecked")
    Stream<T> stream() {
        return (Stream<T>) Arrays.stream(storage);
    }
}

public class GenericCast {
    static String[] letters =
            "ABCDEFGHIJKLMNOPQRST".split("");

    public static void main(String[] args) {
        FixedSizeStack<String> strings =
                new FixedSizeStack<>(letters.length);
        Arrays.stream(letters)
                .forEach(strings::push);
        System.out.println(strings.pop());
        strings.stream()
                .map(s -> s + " ")
                .forEach(System.out::print);
    }
}

        程序执行的结果是：

        pop()和stram()会产生警告，因为编译器无法知道这种类型转换是否安全。在本例中，类型参数T会被擦除成Object。

        虽然在泛型的边界处，类型转换会自动发生。但有时我们仍然需要手动进行类型转换，此时编译器会发出警告：

【例子：对泛型进行转型】

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.List;

public class NeedCasting {
    @SuppressWarnings("unchecked")
    public void f(String[] args) throws Exception {
        ObjectInputStream in = new ObjectInputStream(
                new FileInputStream(args[0]));
        List<Integer> shapes = (List<Integer>) in.readObject();
    }
}

    实际上，readObject()不会知道它正在读取什么，因此它会返回Object。

        现在注释掉@SuppressWarnings("unchecked")，并且使用参数-Xlint:unchecked进行编译：

警告清楚地告诉了我们，readObject()会返回一个未经检查的Object。

        Java 5还引入了一个转型方法，通过Class.cast()，可以将对象强制转换成目标类型。这个方法也适用于泛型：

【例子：尝试强制转换泛型】

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.List;

public class ClassCasting {
    @SuppressWarnings("unchecked")
    public void f(String[] args) throws Exception {
        ObjectInputStream in = new ObjectInputStream(
                new FileInputStream(args[0]));

        // 无法编译的代码：
        // List<Integer> lw1 =
        //         List<>.class.cast(in.readObject()); // 使用cast()进行强制类型转换

        // 会引发警告：
        List<Integer> lw2 = List.class.cast(in.readObject());
        
        // 无法编译：
        // List<Integer> lw3 = List<Integer>.class.cast(in.readObject());

        // 会引发警告
        List<Integer> lw4 = (List<Integer>) List.class.cast(in.readObject());
    }
}

        然而，如代码所示。这些做法都会存在着这样那样的限制。

无法实现的重载

        由于类型擦除，下面的这种写法是不被允许的：

【例子：无法实现的重载】

import java.util.List;

public class UseList<W, T> {
    void f(List<T> v) {
    }

    void f(List<W> v) {
    }
}

        因为被擦除的参数无法作为单独的参数列表，所以我们还需要为每一个相似的方法提高不同的方法名。

基类会劫持接口

        假设我们想要创建一个类，这个类实现了Comparable接口，这样这个类的不同对象就能进行互相的比较：

【例子：实现了Comparable的父类】

public class ComparablePet
        implements Comparable<ComparablePet> {
    @Override
    public int compareTo(ComparablePet arg) {
        return 0;
    }
}

        一个好的想法是，任何继承了这个类的子类，其对象之间应该也能进行比较（在这个例子中，父类是Pet，子类就是Cat）。然而事实并不会如我们所愿：

        遗憾的是，若继承了父类的泛型接口，编译器不会再允许我们添加另一个Comparable接口。在这里，我们只能遵循父类的比较方式。

    我们还可以在子类中重写compareTo()的行为，但这种行为是面向ComparablePet的（而不是限定在这个子类中）。

自限定类型

        自限定类型来自于Java早期的泛型使用习惯：

class SelfBounded<T extends SelfBounded<T>> { // ...

在这里，类型参数的边界就是类本身：SelfBounded有一个类型参数T，而参数T的边界却又是SelfBounded。

    这种写法更加强调extends在泛型参数中使用时的含义。

奇异递归类型

        先看一个自限定类型的简化版本。尽管无法直接继承泛型参数，但我们可以继承一个使用了泛型参数的类。

【例子：继承泛型类】

class GenericType<T> {
}

public class CuriouslyRecurringGeneric
        extends GenericType<CuriouslyRecurringGeneric> {
}

        这种方式被称为奇异递归泛型。其中，“奇异递归”是指子类奇怪地出现在了其基类中的现象、

        要理解这一点，首先需要明确：Java泛型的重点在于参数和返回类型，因此可以生成将派生类型作为参数和返回值的基类。派生类型也可作为字段，不过此时它们会被擦除为Object。

【例子：用子类替换基类的参数】

        首先定义一个简单的泛型：

public class BasicHolder<T> {
    T element;

    void set(T arg) {
        element = arg;
    }

    T get() {
        return element;
    }

    void f() {
        System.out.println(
                element.getClass().getSimpleName());
    }
}

        在这个基类中，所有方法的接收或返回值（若有）都是T。接下来尝试使用这个类：

class Subtype extends BasicHolder<Subtype> {
}

public class CRGWithBasicHolder {
    public static void main(String[] args) {
        // Subtype中的所有方法，其接收和返回的都是Subtype：
        Subtype st1 = new Subtype(),
                st2 = new Subtype();
        st1.set(st2);
        Subtype st3 = st1.get();
        st1.f();
    }
}

        程序执行的结果是：

        需要注意的是，Subtype类中，所有方法的接收和返回值都已经变成了Subtype。这就是一个奇异递归泛型：基类用子类替换了其参数。在这里，基类用于提供通用的方法模板，而子类使用的方法都会具有一个具体的类型，即子类自身。

自限定

        上述的BasicHolder可以将任何类型作为其泛型参数：

【例子：BasicHolder的广泛应用】

class Other {
}

// 将不相关的Other作为参数
class BasicOther extends BasicHolder<Other> {
}

       自限定在这种操作的基础上更进一步，它强制地把泛型作为自身的边界参数进行使用：

// 自限定类型：
class SelfBounded<T extends SelfBounded<T>> {
    T element;

    SelfBounded<T> set(T arg) {
        element = arg;
        return this;
    }

    T get() {
        return element;
    }
}

class A extends SelfBounded<A> {
}

// 属于SelfBounding<>的类型也可以这样使用：
class B extends SelfBounded<A> {
}

class C extends SelfBounded<C> {
    C setAndGet(C arg) {
        set(arg);
        return get();
    }
}

class D {
}
// 但这种做法是不被允许的：
// class E extends SelfBounding<D> {
// }

// 这样的可以（自限定的语法并非强制性的）：
class F extends SelfBounded {
}

public class SelfBounding {
    public static void main(String[] args) {
        A a = new A();
        a.set(new A());
        a = a.set(new A()).get();
        a = a.get();

        C c = new C();
        c = c.setAndGet(new C());
    }
}

        需要注意的是，自限定类型会要求类处于继承关系中。因此像E这种并不处于继承关系中的类无法使用自限定。

        除此之外，可以看到编译器并没有对F这种写法发出警告：

class F extends SelfBounded {}

由此可知，编译器对自限定的语法并不做强制要求，这需要程序员自己注意（或使用工具保证不会使用原生类型）。

        注意：自限定类型只服务于强制继承关系。若使用自限定，这意味着该类使用的类型参数和使用该参数的类属于同一个基类。

    对于普通的泛型类而言，像上例中的E这样的类型是可以作为泛型参数的。这种泛型类就没有对继承关系的强制性要求。

        除此之外，自限定还可用于泛型方法：

【例子：使用了自限定的泛型方法】

public class SelfBoundingMethods {
    static <T extends SelfBounded<T>> T f(T arg) {
        return arg.set(arg).get();
    }

    public static void main(String[] args) {
        A a = f(new A());
    }
}

这种做法的特点是，方法f()无法应用于自限定参数规定范围之外的对象。

自限定提供的参数协变性

        自限定类型的价值在于它可以生成协变参数类型，即方法参数的类型会随着子类而变化。现在先来看一个协变参数类型的例子，这种写法是Java 5引入的：

【例子：Java中的协变参数类型】

class Base {
}

class Derived extends Base {
}

interface OrdinaryGetter {
    Base get();
}

interface DerivedGetter extends OrdinaryGetter {
    @Override
    Derived get();
}

public class CovariantReturnTypes {
    void test(DerivedGetter d) {
        Derived d2 = d.get();
    }
}

        这种做法有着自洽的逻辑：子类方法可以返回比其基类方法更加具体的类型（但这种写法在Java 5之前是行不通的）。

        而自限定方法则可以直接返回精确的派生类型：

【例子：自限定的返回值】

interface GenericGetter<T extends GenericGetter<T>> {
    T get();
}

interface Getter extends GenericGetter<Getter> {
}

public class GenericsAndReturnTypes {
    void test(Getter g) {
        Getter result = g.get();
        // 因为返回的类型是子类，因此可以用基类来承接：
        GenericGetter gg = g.get();
    }
}

    不过，这种做法只在引入了协变类型的Java 5之后有效。

        与上述这两种形式不同，在普通的类中，参数的类型无法随子类型而变化。

【例子：普通类的返回值】

class OrdinarySetter {
    void set(Base base) {
        System.out.println("OrdinarySetter.set(Base)");
    }
}

class DerivedSetter extends OrdinarySetter {
    void set(Derived derived) {
        System.out.println("DerivedSetter.set(Derived)");
    }
}

public class OrdinaryArguments {
    public static void main(String[] args) {
        Base base = new Base();
        Derived derived = new Derived();

        DerivedSetter ds = new DerivedSetter();
        ds.set(derived);
        // 编译通过，但这里发生的不是重写，是重载：
        ds.set(base);
    }
}

        程序执行的结果是：

        尽管在main()中，ds.set(derived)和ds.set(base)都是合法的，但发生的并不是重写，而是重载。从输出可以看出，在子类DerivedSetter中存在着两个set()方法，一个参数是Base，另一个的是Derived。

    若对DerivedSetter的set()方法使用@Override注释，就可以看出问题。

        当使用自限定类型时，子类中来自基类的方法的参数会发生改变，因此会出现下面这种情况：

【例子：子类方法的参数会被重写】

interface SelfBoundSetter<T extends SelfBoundSetter<T>> {
    void set(T arg);
}

interface Setter extends SelfBoundSetter<Setter> {
    // 未进行任何改动，但实际上set()已经被重写
}

public class SelfBoundingAndCovariantArguments {
    void testA(Setter s1, Setter s2, SelfBoundSetter sbs) {
        s1.set(s2);
        // 不允许这么做：
        // s1.set(sbs);
    }
}

        s1.set(sbs)存在问题：

编译器认为基类无法匹配当前set()的类型，尽管上述代码中并没有在Setter中显式地重写set()方法，但set()的参数确实已经被重写了。

        若不使用自限定，那么普通的继承机制就会启动：

【例子：普通的继承机制】

// 非自限定的类型：
class OtherGenericSetter<T> {
    void set(T arg) {
        System.out.println("GenericSetter.set(Base)");
    }
}

class DerivedGS extends OtherGenericSetter<Base> {
    void set(Derived derived) {
        System.out.println("DerivedGS.set(Derived)");
    }
}

public class PlainGenericInheritance {
    public static void main(String[] args) {
        Base base = new Base();
        Derived derived = new Derived();
        DerivedGS dgs = new DerivedGS();
        dgs.set(derived);
        // 发生了重载：
        dgs.set(base);
    }
}

        程序执行的结果是：

        显然，这里发生的还是重载。若使用的是自限定，最后只会有一个接收确切类型参数的方法版本。

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

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

相关文章

MySQL使用函数和存储过程实现：向数据表快速插入大量测试数据

MySQL使用函数和存储过程实现：向数据表快速插入大量测试数据

实现过程 1.创建表 CREATE TABLE user_info (id INT(11) NOT NULL AUTO_INCREMENT,name VARCHAR(20) DEFAULT NULL,age INT(3) DEFAULT NULL,pwd VARCHAR(20) DEFAULT NULL,phone_number VARCHAR(11) DEFAULT NULL,email VARCHAR(255) DEFAULT NULL,address VARCHAR(255) DEF…
阅读更多...
wsl 命令详解

wsl 命令详解

WSL 简介 WSL全称 Windows Subsystem for Linux &#xff0c;是微软开发的一个运行在Windows上的兼容层&#xff0c;它允许开发人员和用户直接在Windows上运行原生Linux二进制文件&#xff0c;而无需配置或修改系统。 WSL命令是用于管理和操作WSL子系统的工具。 常用WSL命令…
阅读更多...
UE5学习（游戏存档，两种适应性的射线检测，时间膨胀）

UE5学习（游戏存档，两种适应性的射线检测，时间膨胀）

游戏存档 0.建立游戏存档类 1.建立存档 命名要用规律&#xff0c;读档时根据命名调用 2.读取存档 这里是用存档时间&#xff08;秒&#xff09;验证是否有存档成功。 两种鼠标位置射线检测方法 两种适用性未使用大量项目验证&#xff0c;为个人观点 1.适用于游戏中 2.适用于…
阅读更多...
Update this scope and remove the “systemPath“

Update this scope and remove the “systemPath“

问题 解析&#xff1a; 在特定的指定路径上查找系统相关性。这大大降低了可移植性&#xff0c;因为如果您将工件部署在一个与您的环境不同的环境中&#xff0c;代码将无法工作。 解决&#xff1a; 1 使用官方maven仓库的第三方jar包 2 如果官方仓库不存在jar包&#xff0c;…
阅读更多...
AcWing 2816. 判断子序列

AcWing 2816. 判断子序列

文章目录 AcWing 2816. 判断子序列我的思路CODE 欣赏大神代码给点思考 AcWing 2816. 判断子序列 题目链接&#xff1a;https://www.acwing.com/activity/content/problem/content/2981/ 我的思路 直接硬套模版&#xff0c;把两个指针两层循环写上如果匹配&#xff0c;记录数组…
阅读更多...
WebGL的项目类型

WebGL的项目类型

WebGL 是一种用于在 Web 浏览器中渲染交互式 3D 和 2D 图形的技术&#xff0c;它可以用于开发各种类型的应用。以下是一些常见的应用类型和它们各自的特点&#xff0c;希望对大家有所帮助。北京木奇移动技术有限公司&#xff0c;专业的软件外包开发公司&#xff0c;欢迎交流合作…
阅读更多...
港科夜闻｜2023年全球大学毕业生就业力排名公布,香港科大位列香港第一名

港科夜闻｜2023年全球大学毕业生就业力排名公布,香港科大位列香港第一名

关注并星标 每周阅读港科夜闻 建立新视野 开启新思维 1、2023年全球大学毕业生就业力排名公布&#xff0c;香港科大位列香港第一名。香港科大在泰晤士高等教育2023年全球就业能力大学排名中上升一位至全球第29位&#xff0c;继续位居香港首位。香港科大的毕业生就业能力持续跻身…
阅读更多...
游戏开发原画的设计方法

游戏开发原画的设计方法

游戏原画设计是游戏开发中至关重要的一环&#xff0c;因为它直接影响到游戏的视觉吸引力和用户体验。以下是一些常见的游戏原画设计方法&#xff0c;希望对大家有所帮助。北京木奇移动技术有限公司&#xff0c;专业的软件外包开发公司&#xff0c;欢迎交流合作。 理解游戏概念&…
阅读更多...
服务器中启动和停止项目

服务器中启动和停止项目

服务器中启动和停止项目 一、前言二、使用命令启动和关闭项目1、启动项目2、停止项目 三、使用可执行脚本启动和关闭项目1、启动项目2、停止项目 一、前言 在服务器上部署项目&#xff0c;一般就是将项目挂在后台&#xff0c;如果是微服务首选docker-compose&#xff0c;可以看…
阅读更多...
【LangChain实战】LangChain快速入门

【LangChain实战】LangChain快速入门

1、什么是大语言模型 大语言模型是一种人工智能模型&#xff0c;通常使用深度学习技术&#xff0c;比如神经网络&#xff0c;来理解和生成人类语言。这些模型的“大”在于它们的参数数量非常多&#xff0c;可以达到数十亿甚至更多&#xff0c;这使得它们能够理解和生成高度复杂…
阅读更多...
Web框架与Django简介

Web框架与Django简介

Web框架与Django简介 一、Web应用的组成 我们为了开发一款Web软件首先要了解什么才是Web应用软件呢&#xff1f; 对于传统的应用软件来说&#xff0c;基本都是部署单机使用&#xff0c;而Web应用软件就不一样&#xff0c;Web应用软件是基于B/S架构的&#xff0c;B和S都在不同…
阅读更多...
QT6 Creator编译KDDockWidgets并部署到QT

QT6 Creator编译KDDockWidgets并部署到QT

为什么使用KDDockWidgets 为什么使用KDDockWidgets呢&#xff1f; 首先它是一个优秀的开源dock库&#xff0c;弥补QDockWidget的不足&#xff0c;详情见官网。 其次它支持QML&#xff0c;这是我最终选择这个dock库的主要原因&#xff0c;因为最近在考虑将前端界面用QML做&…
阅读更多...
机器学习之自监督学习（五）MAE翻译与总结（一）

机器学习之自监督学习（五）MAE翻译与总结（一）

Masked Autoencoders Are Scalable Vision Learners Abstract 本文表明&#xff0c;掩蔽自动编码器&#xff08;MAE&#xff09;是一种可扩展的计算机视觉自监督学习器。我们的MAE方法很简单&#xff1a;我们屏蔽输入图像的随机patch&#xff0c;并重建缺失的像素。它基于两个…
阅读更多...
可自行DIY单TYPE-C接口设备实现DRP+OTG功能芯片

可自行DIY单TYPE-C接口设备实现DRP+OTG功能芯片

随着USB-C接口的普及&#xff0c;欧盟的法律法规强制越来越多的设备开始采用这种接口。由于 USB-C接口的高效性和便携性&#xff0c;使各种设备之间的连接和数据传输变得非常方便快捷&#xff0c;它们不仅提供了强大的功能&#xff0c;还为我们的日常生活和工作带来了极大的便利…
阅读更多...
MySQL- CRUD

MySQL- CRUD

一、INSERT 添加 公式 INSERT INTO table_name [(column [, column...])] VALUES (value [, value...]); 示例&#xff1a; CREATE TABLE goods (id INT ,good_name VARCHAR(10),price DOUBLE ); #添加数据 INSERT INTO goods (id,good_name,price ) VALUES (20,华为手机,…
阅读更多...
商城免费搭建之java商城 鸿鹄云商 B2B2C产品概述

商城免费搭建之java商城 鸿鹄云商 B2B2C产品概述

【B2B2C平台】&#xff0c;以传统电商行业为基石&#xff0c;鸿鹄云商支持“商家入驻平台自营”多运营模式&#xff0c;积极打造“全新市场&#xff0c;全新 模式”企业级B2B2C电商平台&#xff0c;致力干助力各行/互联网创业腾飞并获取更多的收益。从消费者出发&#xff0c;助…
阅读更多...
Moonbeam生态项目分析 — — 去中心化交易所Beamswap

Moonbeam生态项目分析 — — 去中心化交易所Beamswap

流动性激励计划Moonbeam Ignite是帮助用户轻松愉快体验Moonbeam生态的趣味活动。在Moonbeam跨链连接的推动下&#xff0c;DeFi的各种可能性在这里爆发。DeFi或许不热门&#xff0c;但总有机会捡漏&#xff0c;了解Monbeam生态项目&#xff0c;我们邀请Moonbeam大使分享他们的研…
阅读更多...
重庆数字孪生技术推进制造业升级，工业物联网可视化应用加速

重庆数字孪生技术推进制造业升级，工业物联网可视化应用加速

重庆数字孪生、5G、人工智能、物联网、大数据等新一代信息技术的出现及终端计算设备的发展&#xff0c;带来了研发模式、生产模式、消费模式、体制机制的系统性变革&#xff0c;企业应该建设适应工业4.0时代发展要求的新型生产体系。巨蟹数科数字孪生智能工厂通过部署多样化用例…
阅读更多...
基于SSM的高校学生实习管理系统设计与实现

基于SSM的高校学生实习管理系统设计与实现

末尾获取源码 开发语言&#xff1a;Java Java开发工具&#xff1a;JDK1.8 后端框架&#xff1a;SSM 前端&#xff1a;Vue 数据库&#xff1a;MySQL5.7和Navicat管理工具结合 服务器&#xff1a;Tomcat8.5 开发软件&#xff1a;IDEA / Eclipse 是否Maven项目&#xff1a;是 目录…
阅读更多...
SEO工具-免费功能最全的5款SEO工具

SEO工具-免费功能最全的5款SEO工具

随着互联网的蓬勃发展&#xff0c;搜索引擎优化&#xff08;SEO&#xff09;已经成为许多企业和个人网站必备的关键技能。然而&#xff0c;对于初学者或者运营小型网站的人来说&#xff0c;使用专业的SEO工具可能涉及较高的成本。在这篇文章中&#xff0c;我们将向您推荐五款高…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站