【备考复习】智慧树作业复习题

1.简述在Java程序中数据库连接的主要步骤。

创建数据源；

注册、加载特定的驱动程序；

创建连接Connection对象, 利用Connection对象生成Statement对象；

利用Statement对象执行SQL语句，如查询、更新、插入、删除等；

若是执行查询语句，还要从ResultSet读取数据；

关闭ResultSet、Statement、Connection等。

2.方法覆盖（重写）必须满足哪些规则？

（1）子类方法的名称、参数签名和返回类型必须与父类方法的名称、参数签名和返回类型一致。

（2）子类方法不能缩小父类方法的访问权限。

（3）子类方法不能抛出比父类方法更多的异常。

3.代码题

interface Creature {
    public void display(Creature name) ;
}

abstract class Animal implements Creature {    
    String name="";
     public abstract void display(Animal name) ;
}

class Dog extends Animal {
    public void display(Creature name) {
        System.out.println("我是汪星人");        
    }
    @Override
    public void display(Animal name) {
        System.out.println("小狗的名字叫旺财");        
    }
}
class Cat extends Animal {
    public void display(Creature name) {
        System.out.println("我是喵星人");        
    }
    @Override
    public void display(Animal name) {
        System.out.println("小猫的名字叫喵喵");        
    }
}

public class Test{

public static void main(String[] args) {
 
     Creature testobjCreature =  new Dog();
// testobjCreature是Dog
     Animal testobjAnimal=(Animal)testobjCreature;
// testobjCreature转为animal类（testobjAnimal）
     testobjAnimal.display(new Cat());
 //去狗类中没有发现cat类参数的方法，参数转型，cat——animal——“小狗的名字叫旺财”
     testobjCreature =  new Cat();
//Creature类——testobjCreatur句柄——Cat类
     testobjCreature.display(testobjAnimal);
 
}
}

的运行结果是：

小狗的名字叫旺财
我是喵星人

4.简述什么是多态性？分为那两类？

类的属性或功能在各个子类中可以具有彼此不同的具体形态。简单来说就是，同一个对象不同时刻表现出多种状态
分为静态多态和动态多态

5.【问答题】 (5分)

import java.util.ArrayList;
import java.util.List;

public class Test {
    public void testGeneric() {// 泛型
        List<String> strList = new ArrayList<String>();
        strList.add("张三");
        strList.add("李四");
        strList.add("王五");
//将张三、李四、王五依次放入到list集合中
//for循环，定义Name_1去获取集合中的内容，然后输出
        for (int i = 0; i < strList.size(); i++) {
            String Name_1 = strList.get(i);
            System.out.println("Name is:" + Name_1);
        }
    }

    public static void main(String[] args) {
        Test ge = new Test();
        ge.testGeneric();
    }

程序运行的结果是？

Name is:张三
Name is:李四
Name is:王五
 

6.【问答题】 (10分)

import java.util.HashMap;
import java.util.Map;
public class Test {
    public static void main(String[] args) {
        String s[]={"好","好","复习","诚信","考试"};
        Map<Integer, String> map = new HashMap<Integer,String>();
        for (int i = 0; i < s.length; i++) {
            map.put(i+1, s[i]);
        }
//——键值对    key=值
        System.out.println(map);
        for (int i = 1; i <=map.size(); i++) {
            System.out.print(map.get(i));
        }
    }
}

程序运行结果是？

{1=好，2=好，2=复习，4=诚信，5=考试}
好好复习诚信考试

7.【问答题】 (10分)

class A {
    public String show(C c) {
    return ("A and D");
    }
}
class B extends A {
    public String show(B obj) {
    return ("B and B");
    }
    public String show(A obj) {
    return ("B and A");
    }
}
class C extends B {}

public class Test {
    public static void main(String[] args) {
        A a1 = new B();
        B b  = new B();
        C c  = new C();
        System.out.println(a1.show(c));
//a1是A类，但是通过B类对象转型生成的。先去看A类中的方法是否有c参数的，有——“A and D”
        System.out.println(b.show(b));
//b是B类对象，所以调用show方法在B类中看是否有含有b参数的方法，有——“B and B”
        System.out.println(b.show(c));
//b是B类对象，所以调用show方法在B类中看是否有含有c参数的方法，
//没有则去看B的父类——A类是否有，有——“A and D”
    }
}

运行结果是：

【考点：优先级】本类方法——父类方法——参数类型向上转——回到本类去查看

A and D
B and B
A and D

8.

public class Test {
    public static void main(String[] args) {
//String s="  "；————表示是在堆中的常量池生成，如果常量池中存在则不会另外生成
        String str1="2023";
        String str2="2023";
//String s=new String（"  "）；————表示在堆中生成一个空间，新建一个，就相应生成一个地址
        String str3=new String("2023");
        String str4=new String("2023");
//“==”是用来比较字符串的地址
        System.out.println("str1==str2?: "+(str1==str2));
//因为s1\s2都是在常量池中生成的，一旦常量次里面有这个“内容”，它就不会另外生成，所以str2添加进去的时候，是将一开始str1生成的地址传给str2
        System.out.println("str1==str3?: "+(str1==str3));
        System.out.println("str3==str4?: "+(str3==str4));
//“equals（）”是用来比较字符串的值
        System.out.println("str1.equals(str2)?:"+str1.equals(str2));
        System.out.println("str3.equals(str4)?:"+str3.equals(str4));
    }
}

程序运行的结果是？

str1==str2?: true
str1==str3?: false
str3==str4?: false
str1.equals(str2)?:true
str3.equals(str4)?:true

9.【问答题】 (10分)

简述抽象类与接口的异同？

相同点：
都不能被实例化；
继承抽象类和实现接口的类都必须全部实现两者的抽象方法；

不同点：
抽象类没有方法体，接口方法体为空；
接口里的所有方法都是抽象方法，抽象类的方法不全是抽象方法
一个类只能继承一个抽象类，但一个类可以实现多个接口；
定义接口要用关键字interface，接口中的所有变量都默认是公共的、静态的、最终的

10.【问答题】 (10分)

请列举Java线程生命周期中的五种状态？(此答案参考黑马程序员的笔记)

1. 新建状态(New)

创建一个线程对象后，该线程对象就处于新建状态，此时它不能运行，与其他Java对象一样，仅仅由Java虚拟机为其分配了内存，没有表现出任何线程的动态特征。

2. 就绪状态(Runnable)

当线程对象调用了start()方法后，该线程就进入就绪状态。处于就绪状态的线程位于线程队列中，此时它只是具备了运行的条件，能否获得CPU的使用权并开始运行，还需要等待系统的调度。

3. 运行状态(Running)

如果处于就绪状态的线程获得了CPU的使用权，并开始执行run()方法中的线程执行体，则该线程处于运行状态。一个线程启动后，它可能不会一直处于运行状态，当运行状态的线程使用完系统分配的时间后，系统就会剥夺该线程占用的CPU资源，让其他线程获得执行的机会。需要注意的是，只有处于就绪状态的线程才可能转换到运行状态。

4.阻塞状态(Blocked)

一个正在执行的线程在某些特殊情况下，如被人为挂起或执行耗时的输入/输出操作时，会让出CPU的使用权并暂时中止自己的执行，进人阻塞状态。线程进人阻塞状态后，就不能进入排队队列。只有当引起阻塞的原因被消除后，线程才可以转入就绪状态。

5.死亡状态(Terminated)

如果线程调用stop()方法或nun()方法正常执行完毕，或者线程抛出一个未捕获的异常(Exception)错误(Error)，线程就进入死亡状态。一旦进入死亡状态，线程将不再拥有运行的资格，也不能再转换到其他状态。

11.【问答题】 (10分)

import java.util.*;
public class Test{
//主方法
    public static void main( String[] args) {
       //序列集合
        List list = new Vector();
      //for循环，20次  
        for(int i=1;i<=20;i++)
     //将数字添加到集合里面
            list.add(i);
    //生成迭代器
        ListIterator i = list.listIterator();

        while(i.hasNext())//正向访问
  //如果这个数不是偶数
            if(Integer.parseInt(i.next()+"")%2!= 0){
//移除这个数
                i.remove();
//移除后，加. ,既是用.去代替这个奇数
                i.add(".");
            }
//操作完上面的后，向前去输出集合中还存在的数字
        while(i.hasPrevious())
            System.out.print(i.previous()+" ");
    }
}

的运行结果

20 . 18 . 16 . 14 . 12 . 10 . 8 . 6 . 4 . 2 .