Day09_Java_作业

A:简答题
1、什么是多态,多态的前提是什么?
2、多态中成员(成员变量,成员方法,静态成员方法)的访问特点是什么?
3、多态的好处?
4、多态的弊端是什么,如果我们想访问子类的特有的功能我们应该怎么办?
5、抽象类是什么,抽象类的特点?
6、抽象类中有没有构造方法,如果有它是用来做什么的?
7、接口中成员变量的特点,以及成员方法的特点?
8、请说出类与类,类与接口,以及接口与接口的关系以及特点?
9、抽象类和接口的区别?
10、abstract不能和那些关键字共存,为什么?
13、请说说下面关键字分别是什么，有什么用?
private
this
super
static
final
abstract
interface
extends
implements

B:看程序写结果(写出自己的分析理由)，程序填空，改错，看程序写结果
1、给出以下代码，请问该程序的运行结果是什么？
interface Base {
int k = 0;
}
class Demo implements Base {
public static void main(String[] args) {
Demo d = new Demo();
System.out.println( d.k );
System.out.println( Demo.k );
System.out.println( Base.k );
}
}

输出：
0（d.k）寻找子类的数据，若没有，寻找父类接口数据
0（Demo.k）寻找子类的数据，若没有，寻找父类接口数据
0（Base.k）寻找父类接口数据

2、给出以下代码，请问该程序的运行结果是什么？
class Super {
int index = 5;
public void printVal() {
System.out.println(“Super”);
}
}
class Sub extends Super {
int index = 2;
public void printVal(){
System.out.println(“Sub”);
}
}
class Demo {
public static void main(String[] args) {
Super sup = new Sub();
System.out.print(sup.index + “,”);
sup.printVal();
}
}

3、给出以下代码，请问该程序的运行结果是什么？
class SuperEx {
String r;
String s;
public SuperEx(String a, String b) {
r = a;
s = b;
}
public void aMethod(){
System.out.println(“r:”+r);
}
}

class SubEx extends SuperEx {
public SubEx(String a, String b){
super(a, b);
}
public static void main(String[] args){
SuperEx a = new SuperEx(“Hi”, “Tom”);
SuperEx b = new SubEx(“Hi”, “Bart”);
a.aMethod();
b.aMethod();
}
public void aMethod(){
System.out.println(“r:”+r+”s:”+s);
}
}
4、给出以下代码，请问该程序的运行结果是什么？
class Demo {
public static void main (String[] args) {
Base b = new SubClass();
System.out.println(b.x);
System.out.println(b.method() );
}
}
class Base {
int x = 2;
int method(){
return x;
}
}
class SubClass extends Base {
int x = 3;
int method() {
return x;
}
}

答：输出：
2 （不太懂）
3（子类继承父类，父类没有被静态修饰，属于一般成员方法，口诀：编译看父类，运行看子类
）

5、给出以下代码，请问该程序的运行结果是什么？
class Demo extends SuperClass {
String s = “this”;
public static void main (String[] args) {
new Demo();
}
Demo(){
super.display();
}
void display(String s){
System.out.println(“this: “+ s);
}
}
class SuperClass {
String s = “super”;
void display(String s){
System.out.println(“super:” + s);
}
}
答输出：

输出：super:this
（不太懂）
父类没有被静态修饰，属于一般成员方法，口诀：编译看父类，运行看子类

C:编程题
1、编写java程序，分析如下需求，写出你分析的类有哪些，以及功能。最后写一个测试类，针对每个类的功能进行测试。
传智播客的老师有基础班的，也有就业班的。
共性：
属性：姓名，年龄
功能：讲课。
现在又要针对日语这种小语种单独开班，
需要部分基础班老师和部分就业班老师会说日语。
请用所学知识把上面的内容用代码体现。

父类
package student;
/**
 * @author Aoman_Hao
 */
public abstract class Teacher {
    String name;
    int age;
    public abstract void Teaching();
    public  void show(String name,int age){};
}

子类1：
package student;
/**
 * @author Aoman_Hao
 */
public class Day09_Job_Teacher1 extends Teacher implements Teacher_Japanese {

    @Override
    public void Teaching() {
        System.out.println("就业班老师");

    }

    @Override
    public void Japanse() {
        System.out.println("会日语");

    }
    public void show(String name,int age){
        System.out.println("姓名："+name+"，年龄："+age);
    }

}

子类2：
package student;
/**
 * @author Aoman_Hao
 */
public class Day09_Teach_Teacher2 extends Teacher implements Teacher_Japanese {

    @Override
    public void Teaching() {
        System.out.println("基础班老师");

    }

    @Override
    public void Japanse() {
        System.out.println("会日语");

    }
    public void show(String name,int age){
        System.out.println("姓名："+name+"，年龄："+age);
    }

}

接口类：
package student;
/**
 * @author Aoman_Hao
 */
public interface Teacher_Japanese {
     public abstract void Japanse();
}

测试类：
package student;
/**
 * @author Aoman_Hao
 */
public class Teacher_Test1 {

    public static void main(String[] args) {

    Teacher Job_t1= new Day09_Job_Teacher1();
    Job_t1.show("一一", 35);
    Job_t1.Teaching();
    Teacher_Japanese Job_t11 = new Day09_Job_Teacher1();
    Job_t11.Japanse();

    Teacher Tea_t1 = new Day09_Teach_Teacher2();
    Tea_t1.show("依依", 33);
    Tea_t1.Teaching();
    Teacher_Japanese Tea_t11 = new Day09_Teach_Teacher2();
    Tea_t11.Japanse();
    }

}

输出结果：
姓名：一一，年龄：35
就业班老师
会日语
姓名：依依，年龄：33
基础班老师
会日语