字符串非基元类型的java泛型类

我正在学习java泛型类。创建一个以T作为类型参数的泛型类

public class Genericstring<T> {
    String name;

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

    public static void main(String[] args){
        Genericstring<String> o = new Genericstring<String>();
        o.set("Generic");

        System.out.println(o.name);
    }
}

public class Genericstring {
  String name;

  // Etc
}

公共类泛型字符串{
字符串名；
公共无效集（字符串名称）{
this.name=名称；
}
公共静态void main（字符串[]args）{
Genericstring o=新的Genericstring（）；
o、 集合（“通用”）；
系统输出打印项次（o.name）；
}
}

---

在上面的示例中，T的类型可以是string、integer或任何其他类型。但这是可能的，我可以创建具有特定类型参数的泛型类。与下面的示例类似，但其显示错误“无法对非静态类型字符串进行静态引用”

公共类泛型字符串{
字符串名；
公共静态void main（字符串[]args）{
//这里创建的对象总是有字符串类型的属性。不需要像上面的例子那样指定。
}

有人能告诉我，可以用字符串作为参数创建泛型类吗？如果不可以，为什么？

Genericstring

正在声明一个名为

String

的类型变量

这使得

String

的所有其他用法都引用该类型变量，而不是

java.lang.String

，它认为您指的是类型变量。由于这是一个静态方法，您不能在此处引用该类型参数，因为它属于类的实例

---

但这是可能的，我可以创建具有特定类型参数的泛型类

您描述的是非泛型类。请删除类型参数

public class Genericstring<T> {
    String name;

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

    public static void main(String[] args){
        Genericstring<String> o = new Genericstring<String>();
        o.set("Generic");

        System.out.println(o.name);
    }
}

public class Genericstring {
  String name;

  // Etc
}

Genericstring

正在声明一个名为

String

的类型变量

这使得

String

的所有其他用法都引用该类型变量，而不是

java.lang.String

，它认为您指的是类型变量。由于这是一个静态方法，您不能在此处引用该类型参数，因为它属于类的实例

---

但这是可能的，我可以创建具有特定类型参数的泛型类

您描述的是非泛型类。请删除类型参数

public class Genericstring<T> {
    String name;

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

    public static void main(String[] args){
        Genericstring<String> o = new Genericstring<String>();
        o.set("Generic");

        System.out.println(o.name);
    }
}

public class Genericstring {
  String name;

  // Etc
}

不，你不能。 此代码：

Genericstring

仅命名泛型类型变量，而不是设置为java.lang.String

您最多只能声明扩展特定类的泛型类型：

public class Genericstring<T extends String>

abstract class B<T extends String> {
    protected T value;
    
    public T getValue() {
        return value;   
    }

    public void handleValue() {
        System.out.println(this.getValue().substring(0, 5));
    }
}

class C extends B<String>{
    public C() {
        this.value = "Hello World";
    }
}

public class A {
    public static void main(String[] args) {
        C obj = new C();
        obj.handleValue(); // prints Hello
    }
}

公共类泛型字符串

示例：

public class Genericstring<T extends String>

abstract class B<T extends String> {
    protected T value;
    
    public T getValue() {
        return value;   
    }

    public void handleValue() {
        System.out.println(this.getValue().substring(0, 5));
    }
}

class C extends B<String>{
    public C() {
        this.value = "Hello World";
    }
}

public class A {
    public static void main(String[] args) {
        C obj = new C();
        obj.handleValue(); // prints Hello
    }
}

抽象类B{
保护T值；
公共T getValue（）{
返回值；
}
公共无效手册价值（）{
System.out.println（this.getValue（）.substring（0,5））；
}
}
C类扩展到B类{
公共C（）{
this.value=“Hello World”；
}
}
公共A类{
公共静态void main（字符串[]args）{
C obj=新的C（）；
obj.handleValue（）；//打印Hello
}
}

更新：根据评论，我的答案产生了很多混乱，因为我的实施方式

@linuxman这不是实现您的场景和权利的唯一方法，当您提到时，我们不能只提到

B或B

B类{
保护T值；
公共T getValue（）{
返回值；
}
公共无效手册价值（）{
System.out.println（this.getValue（）.substring（0,5））；
}
}
公共A类{
公共静态void main（字符串[]args）{
B obj=新的B（）；
对象handleValue（）；
}
}

@Pshemo是正确的：

在这个场景中，唯一可用的类型是String本身，但如果它只是一种类型，那么使用泛型类型就没有意义了，因为它允许我们将类与许多类型一起使用

另外，关于您对期末课程的疑问： 参考资料：

final

类只是一个不能扩展的类

（这并不意味着对类的所有对象的引用都会被声明为

final

）

如果将一个类声明为最终类很有用，请参见此问题的答案：

如果Java是面向对象的，并且您声明了一个类

final

，那么它不会停止类具有对象特性的想法吗？

从某种意义上说是的

通过将一个类标记为final，您可以禁用该部分代码的强大而灵活的语言功能。但是，有些类不应该（在某些情况下不能）以良好的方式考虑子类化。在这些情况下，将该类标记为final是有意义的，即使它限制了OOP。（但是请记住，最终类仍然可以扩展另一个非最终类。）

相关文章：

---

@linuxman您试图完成的事情没有意义，因为泛型类型的目的是声明可以实现不同类型行为的契约

希望它能帮助并消除你的疑虑。

不，你不能。 此代码：

Genericstring

仅命名泛型类型变量，而不是设置为java.lang.String

您最多只能声明扩展特定类的泛型类型：

public class Genericstring<T extends String>

abstract class B<T extends String> {
    protected T value;
    
    public T getValue() {
        return value;   
    }

    public void handleValue() {
        System.out.println(this.getValue().substring(0, 5));
    }
}

class C extends B<String>{
    public C() {
        this.value = "Hello World";
    }
}

public class A {
    public static void main(String[] args) {
        C obj = new C();
        obj.handleValue(); // prints Hello
    }
}

公共类泛型字符串

示例：

public class Genericstring<T extends String>

abstract class B<T extends String> {
    protected T value;
    
    public T getValue() {
        return value;   
    }

    public void handleValue() {
        System.out.println(this.getValue().substring(0, 5));
    }
}

class C extends B<String>{
    public C() {
        this.value = "Hello World";
    }
}

public class A {
    public static void main(String[] args) {
        C obj = new C();
        obj.handleValue(); // prints Hello
    }
}

抽象类B{
保护T值；
公共T getValue（）{
返回值；
}
公共无效手册价值（）{
System.out.println（this.getValue（）.substring（0,5））；
}
}
C类扩展到B类{
公共C（）{
this.value=“Hello World”；
}
}
公共A类{
公共静态void main（字符串[]参数