java里调用方法 方法名前面的写的是接口名 不是实现类名

抱歉，我理解错了你的问题。在Java中，调用方法时，确实是通过接口名来引用方法，而不是实现类名。这是因为接口定义了方法的契约，而实现类则提供了具体的方法实现。当一个类实现了一个接口时，可以通过接口类型的引用来调用该接口中定义的方法。

例如，假设有一个接口`MyInterface`，其中定义了一个方法`myMethod()`。然后有一个实现类`MyClass`，实现了`MyInterface`接口并提供了`myMethod()`的具体实现。在调用这个方法时，可以使用接口类型的引用来调用：

MyInterface obj = new MyClass();
obj.myMethod();

这种方式使得代码更加灵活，可以方便地切换不同的实现类，而不需要修改调用方的代码。同时，这也符合面向对象编程的多态性原则。

相关问题

将自己写的.java文件弄成接口形式

将自己写的.java文件变成接口形式，需要进行以下步骤：

1. 在原有的.java文件中，将类名改为接口名，并在前面加上关键字“interface”。

2. 将原有的方法声明改为接口方法声明，即去掉方法体，只保留方法名、参数列表和返回值类型。

3. 将原有的属性声明改为常量声明，即在属性名前加上关键字“final”，并赋初值。

4. 将原有的方法实现移到实现类中，实现类需要实现接口，并实现接口中的所有方法。

5. 在实现类中，可以添加自己的属性和方法，但必须实现接口中的所有方法。

6. 在使用时，先创建实现类的对象，再将对象转换为接口类型，即可调用接口中的方法。

总之，将自己写的.java文件变成接口形式，需要将原有的类改为接口，去掉方法体和属性值，将方法实现移到实现类中，并实现接口中的所有方法。

java基础(十二 )-----Java泛型详解

Java泛型是Java 5引入的新特性，可以提高代码的可读性和安全性，降低代码的耦合度。泛型是将类型参数化，实现代码的通用性。

一、泛型的基本语法

在声明类、接口、方法时可以使用泛型，泛型的声明方式为在类名、接口名、方法名后面加上尖括号<>，括号中可以声明一个或多个类型参数，多个类型参数之间用逗号隔开。例如：

public class GenericClass<T> {
    private T data;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

public interface GenericInterface<T> {
    T getData();
    void setData(T data);
}

public <T> void genericMethod(T data) {
    System.out.println(data);
}

其中，`GenericClass`是一个泛型类，`GenericInterface`是一个泛型接口，`genericMethod`是一个泛型方法。在这些声明中，`<T>`就是类型参数，可以用任何字母代替。

二、泛型的使用

1. 泛型类的使用

在使用泛型类时，需要在类名后面加上尖括号<>，并在括号中指定具体的类型参数。例如：

GenericClass<String> gc = new GenericClass<>();
gc.setData("Hello World");
String data = gc.getData();

在这个例子中，`GenericClass`被声明为一个泛型类，`<String>`指定了具体的类型参数，即`data`字段的类型为`String`，`gc`对象被创建时没有指定类型参数，因为编译器可以根据上下文自动推断出类型参数为`String`。

2. 泛型接口的使用

在使用泛型接口时，也需要在接口名后面加上尖括号<>，并在括号中指定具体的类型参数。例如：

GenericInterface<String> gi = new GenericInterface<String>() {
    private String data;

    @Override
    public String getData() {
        return data;
    }

    @Override
    public void setData(String data) {
        this.data = data;
    }
};

gi.setData("Hello World");
String data = gi.getData();

在这个例子中，`GenericInterface`被声明为一个泛型接口，`<String>`指定了具体的类型参数，匿名内部类实现了该接口，并使用`String`作为类型参数。

3. 泛型方法的使用

在使用泛型方法时，需要在方法名前面加上尖括号<>，并在括号中指定具体的类型参数。例如：

genericMethod("Hello World");

在这个例子中，`genericMethod`被声明为一个泛型方法，`<T>`指定了类型参数，`T data`表示一个类型为`T`的参数，调用时可以传入任何类型的参数。

三、泛型的通配符

有时候，我们不知道泛型的具体类型，可以使用通配符`?`。通配符可以作为类型参数出现在方法的参数类型或返回类型中，但不能用于声明泛型类或泛型接口。例如：

public void printList(List<?> list) {
    for (Object obj : list) {
        System.out.print(obj + " ");
    }
}

在这个例子中，`printList`方法的参数类型为`List<?>`，表示可以接受任何类型的`List`，无论是`List<String>`还是`List<Integer>`都可以。在方法内部，使用`Object`类型来遍历`List`中的元素。

四、泛型的继承

泛型类和泛型接口可以继承或实现其他泛型类或泛型接口，可以使用子类或实现类的类型参数来替换父类或接口的类型参数。例如：

public class SubGenericClass<T> extends GenericClass<T> {}

public class SubGenericInterface<T> implements GenericInterface<T> {
    private T data;

    @Override
    public T getData() {
        return data;
    }

    @Override
    public void setData(T data) {
        this.data = data;
    }
}

在这个例子中，`SubGenericClass`继承了`GenericClass`，并使用了相同的类型参数`T`，`SubGenericInterface`实现了`GenericInterface`，也使用了相同的类型参数`T`。

五、泛型的限定

有时候，我们需要对泛型的类型参数进行限定，使其只能是某个类或接口的子类或实现类。可以使用`extends`关键字来限定类型参数的上限，或使用`super`关键字来限定类型参数的下限。例如：

public class GenericClass<T extends Number> {
    private T data;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

public interface GenericInterface<T extends Comparable<T>> {
    T getData();
    void setData(T data);
}

在这个例子中，`GenericClass`的类型参数`T`被限定为`Number`的子类，`GenericInterface`的类型参数`T`被限定为实现了`Comparable`接口的类。

六、泛型的擦除

在Java中，泛型信息只存在于代码编译阶段，在编译后的字节码中会被擦除。在运行时，无法获取泛型的具体类型。例如：

public void genericMethod(List<String> list) {
    System.out.println(list.getClass());
}

在这个例子中，`list`的类型为`List<String>`，但是在运行时，`getClass`返回的类型为`java.util.ArrayList`，因为泛型信息已经被擦除了。

七、泛型的类型推断

在Java 7中，引入了钻石操作符<>，可以使用它来省略类型参数的声明。例如：

List<String> list = new ArrayList<>();

在这个例子中，`ArrayList`的类型参数可以被编译器自动推断为`String`。

八、总结

Java泛型是一个强大的特性，可以提高代码的可读性和安全性，降低代码的耦合度。在使用泛型时，需要注意它的基本语法、使用方法、通配符、继承、限定、擦除和类型推断等问题。