多态,抽象作业

1:final关键字可以干什么?有什么特点?

答:final:最终的

修饰类,该类不能被继承

修饰成员方法,该方法不能被重写

修饰变量,相当于常量

2:final关键字的面试题?
A:修饰局部变量

final int a=10;

B:初始化时机

 修饰变量,此变量只初始化一次

 被final修饰变量：在调用构造方法之前，被final修饰的变量去使用它

3:多态是什么，前提是什么?
答:多态:一个事物在不同时刻有不同的状态;前提是要有继承.

4:多态中成员访问的特点?
成员变量
成员方法
静态方法

答:

    成员变量：编译看左，运行看左；
    成员方法：编译看左，运行看右；
    静态方法：编译看左，运行看左。

5:多态的好处及弊端？如何解决多态的弊端？

答:

    多态的好处：提高代码的维护性和扩展性

    多态的弊端：不能使用子类的具体功能；解决多态的弊端：强制转换（向下转型）.

6:什么是向上转型？什么是向下转型？
答：

   
向上转型 :fu f = new zi 

    向下转型 :zi z = (zi) f 

7:多态练习

package cat_dog;

/*

 * 定义抽象动物类:

 * 成员变量:姓名,年龄

 * 成员方法:吃,睡

 * */

public abstract class Animal {
//成员变量
private String name;
private int age;
//构造方法
public Animal(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Animal() {
super();
// TODO Auto-generated constructor stub
}
//set() get() 方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//抽象成员方法
public abstract void Eat();
public abstract void Sleep();

}

package cat_dog;

/*

 * 定义猫类继承动物类

 * */

public class Cat extends Animal {

@Override
public void Eat() {
System.out.println("猫吃鱼");

}

@Override
public void Sleep() {
System.out.println("猫睡觉");

}

public Cat() {
super();
// TODO Auto-generated constructor stub
}

public Cat(String name, int age) {
super(name, age);
// TODO Auto-generated constructor stub
}

}

package cat_dog;

//测试类

public class test {
public static void main(String[] args) {
//创建猫类对象
Animal c=new Cat();
c.setName("Tom");
c.setAge(2);

System.out.println(c.getName()+"---"+c.getAge());

c.Eat();
c.Sleep();

}

}

运行结果

Tom---2

猫吃鱼

猫睡觉

8:抽象类概述及其特点?

答：

将功能定义抽象，该类就是抽象类；
        特点：

抽象类不能实例化；

子类为非抽象类，必须重写（子类为抽象类没有意义）。

9:抽象类成员特点?
答：

成员变量：可以是变量，也可以是常量；

   
成员方法：可以是抽象类，也可以是非抽象类；
   
构造方法：抽象类中可以有构造方法。

10:抽象类练习?

package extendstest;

/*

 * 抽象类练习:人

 * 成员变量:姓名,年龄,性别

 * 成员方法:吃饭,睡觉,工作

 * 

 * */

public abstract class Man {
//成员变量
private String name;
private int age;
private String sex;
//构造方法
public Man(String name, int age, String sex) {
super();
this.name = name;
this.age = age;
this.sex = sex;
}

public Man() {
super();
// TODO Auto-generated constructor stub
}

//set() get() 方法

public String getName() {
return name;
}

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

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getSex() {
return sex;
}

public void setSex(String sex) {
this.sex = sex;
}

//抽象方法
public abstract void Eat();
public abstract void Sleep();
public abstract void Work();

}

11:抽象类的小问题
A:一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?

答:

可以,但是要通过子类实例化.

B:abstract不能和哪些关键字共存

答:
fianl：首先abstract修饰的类，该类中的方法子类继承之后需要重写的，可是final修饰的

          类不能比继承，也就没子类，方法更不能得到重写，相互冲突；不能共存

      private：私有的意思，方法子类是不能被继承到的，那么方法就没有被重写，可是abstract

          是要求方法重写的也相互冲突；不能共存

    static：static能被实例化可直接调用，abstract是不能被实例化的，冲突，不能共存

    所谓实例化就是创建对象理解为new对象就可以了；