. 补全代码。本题有一定难度，多查阅教学课件。 1、已知有一个接口： interface Inter{ void show();//默认修饰符为public abstract }

2、现在有一个类A，实现了该接口： class A implements Inter{ public void show(){ System.out.println("Hello World!"); } }

3、请补全代码，创建类B，继承自类A，并重写show()方法，使得程序输出“Hello Java!”：

class B extends A {
@Override
public void show() {
System.out.println("Hello Java!");
}
}

4、现在在主函数中创建B的实例，并调用其show()方法： public static void main(String[] args) { B b = new B(); b.show(); }

输出结果为：“Hello Java!”

相关问题

2.补全代码。本题有一定难度，多查阅教学课件。 1、已知有一个接口： interface Inter{ void show();//默认修饰符为public abstract } 2、已知一个类如下： class Outer{ public Inner method(){ //给出了内部类名字 Inner //这里需要补全 } //根据下面的OuterDemo测试类的方法调用和输出结果 //补全Outer类中的代码使测试类中的输出成立。 //补全对Inner的定义，要去该类实现接口Inter。 } public class OuterDemo { public static void main(String[] args) { Outer.method().show();//输出HelloWorld } }

补全代码如下：

interface Inter {
    void show();// 默认修饰符为public abstract
}

class Outer {
    public static class Inner implements Inter {
        @Override
        public void show() {
            System.out.println("HelloWorld");
        }
    }

    public static Inner method() {
        return new Inner();
    }
}

public class OuterDemo {
    public static void main(String[] args) {
        Outer.method().show();// 输出HelloWorld
    }
}

解析：

1. 在Outer类中定义了一个静态内部类Inner，并且该类实现了接口Inter。
2. Outer类中提供了一个静态方法method，该方法返回Inner类的实例对象。
3. 在测试类OuterDemo中，通过调用Outer.method()方法获取Inner类的实例对象，并且调用show()方法输出“HelloWorld”。

用c语言编写代码：已知有一个链表，任意输入一个值，实现链表的顺序插入及链表反序.

链表的定义如下：

typedef struct node {
    int data;           // 存储节点的值
    struct node *next;  // 下一个节点
} Node, *LinkedList;

链表的顺序插入可以通过遍历链表，找到插入位置后，将节点插入到链表中。

// 链表的顺序插入
void insert(LinkedList *list, int value) {
    Node *new_node = (Node *) malloc(sizeof(Node));
    new_node->data = value;
    new_node->next = NULL;
    if (*list == NULL) {
        *list = new_node;
    } else {
        Node *p = *list;
        while (p->next != NULL) {
            p = p->next;
        }
        p->next = new_node;
    }
}

链表的反序可以通过遍历链表，将每个节点插入到头部，实现链表的反序。

// 链表的反序
void reverse(LinkedList *list) {
    if (*list == NULL || (*list)->next == NULL) {
        return;
    }
    Node *p = *list;
    Node *q = (*list)->next;
    (*list)->next = NULL;
    while (q != NULL) {
        Node *temp = q->next;
        q->next = p;
        p = q;
        q = temp;
    }
    *list = p;
}

完整的代码如下：

#include <stdio.h>
#include <stdlib.h>

typedef struct node {
    int data;           // 存储节点的值
    struct node *next;  // 下一个节点
} Node, *LinkedList;

// 链表的顺序插入
void insert(LinkedList *list, int value) {
    Node *new_node = (Node *) malloc(sizeof(Node));
    new_node->data = value;
    new_node->next = NULL;
    if (*list == NULL) {
        *list = new_node;
    } else {
        Node *p = *list;
        while (p->next != NULL) {
            p = p->next;
        }
        p->next = new_node;
    }
}

// 链表的反序
void reverse(LinkedList *list) {
    if (*list == NULL || (*list)->next == NULL) {
        return;
    }
    Node *p = *list;
    Node *q = (*list)->next;
    (*list)->next = NULL;
    while (q != NULL) {
        Node *temp = q->next;
        q->next = p;
        p = q;
        q = temp;
    }
    *list = p;
}

// 遍历链表
void print_list(LinkedList list) {
    while (list != NULL) {
        printf("%d ", list->data);
        list = list->next;
    }
    printf("\n");
}

int main() {
    LinkedList list = NULL;
    int value;
    while (scanf("%d", &value) == 1) {
        insert(&list, value);
    }
    printf("顺序插入：");
    print_list(list);
    reverse(&list);
    printf("链表反序：");
    print_list(list);
    return 0;
}