final关键字 多态 抽象 作业

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

答；防止被更改；final可以修饰类，该类不能被继承，final可以修饰成员方法，
    该方法不能被重写，final可以修饰变量，相当于常量。

2:final关键字的面试题?

A:修饰局部变量
B:初始化时机
答：A：final int sum=20;
    B: final修饰变量，这个变量是常量，只能修改一次（常量）
       被final修饰变量：在调用构造方法之前，被final修饰的变量去使用它

3:多态是什么，前提是什么?

 答：多态指的是一个事物，在不同时刻状态的一个体现。前提是继承。

4:多态中成员访问的特点?

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

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

答:多态的好处：1，提高代码的维护性（继承）2，提高了代码的扩展性（多态）；
   多态的弊端：不能使用子类的具体功能；
   解决多态的弊端：强制转换（向下转型）。

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

答：fu f = new zi ;//向上转型
    zi z = (zi) f ;//向下转型

7:多态练习

答：
package practice01;
/*
 * 假如我们在开发一个系统时需要对员工类进行设计，程序员包含3个属性：姓名、工号以及工资。
经理也是员工，除了含有程序员的属性外，另为还有一个奖金属性。
请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问。


Employee:员工类:抽象类
name,employeeId,selary
work(); 抽象方法

Programmer :程序员类
name,employeeId,selary
work();---->敲代码...

Manager:经理类
name,employeeId,selary,bonus(奖金..)(在经理类中要单独定义为成员变量:在里面给出set()/get())
work();---->和客户(吃饭喝酒/管理程序员的进度)

//Test类:
直接使用具体对象的功能就可以!
 * 
 * */


abstract class Employee{
private String name;
private int employeeId;
private int selary;

public Employee(){

}
public Employee(String name,int employeeId,int selary){
this.name=name;
this.employeeId=employeeId;
this.selary=selary;
}
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
public int getEmployeeId(){
return employeeId;
}
public void setEmployeeId(int employeeId){
this.employeeId=employeeId;
}
public int getSelary(){
return selary;
}
public void setSelary(int selary){
this.selary=selary;
}
public abstract void work();
}
 
 
 class Programmer extends Employee{
public Programmer (){

}
public Programmer(String name,int employeeId,int selary){

}
public void work(){
System.out.println("程序员敲代码...");

}
}
 
 
class Manager extends Employee{
public Manager (){

}
public Manager(String name,int employeeId,int selary){

}
public void work(){
System.out.println("经理和客户喝酒...");
System.out.println("经理管理程序员的进度...");
}
}
//测试类
public class Text {
  public static void main (String[] args){
 Programmer e=new Programmer();
 e.setName("赵四");
 e.setEmployeeId(142);
 e.setSelary(2000);
 System.out.println(e.getName()+"    "+e.getEmployeeId()+"   "+e.getSelary());
 e.work();
 
System.out.println("----------");
 
Manager m= new Manager();
 m.setName("李能");
 m.setEmployeeId(143);
 m.setSelary(3000);
 System.out.println(m.getName()+"    "+ m.getEmployeeId()+"   "+m.getSelary());
 m.work();
 
  }
}

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

答：将功能定义抽象，该类就是抽象类；
    特点：抽象类不能实例化；子类为非抽象类，必须重写（子类为抽象类没有意义）。

9:抽象类成员特点?

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

10:抽象类练习

答:
package practice01;
/*
 * 具体事务：基础班学员，就业班学员
        共性：姓名，年龄，班级，学习，吃饭
 * 
 * 生活类：life     name,age,classroom,
 * 动作类： act      study,eat
 * 
 * 
 * 
 * basicstudent : work类：学习。。。
 * 
 * jobsdudent:   work类：找工作。。。
 * 
 * */
 abstract class life{
String name ;
int age;
int classroom;

life(){

}
life(String name,int age,int classroom){

}
 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 int getClassroom(){
 return classroom;
 }
 public void setClassroom(int classroom){
 this.classroom=classroom;
 }
 public void act(){
 System.out.println("吃饭。。");
 System.out.println("学习。。");
 }
}
 class basicSdudent extends life{
 
 
public void work(){
System.out.println("主要学习JAVA知识");
}
 }
class jobSdudent extends life{
public void show(){
super.act();
}
public void work(){
System.out.println("主要找工作");
}
}
public class Text2 {
  public static void main (String[] args){
 basicSdudent bs=new basicSdudent();
 bs.setName("张三");
 bs.setAge(20);
 bs.setClassroom(1);
 System.out.println(bs.getName()+"  "+bs.getAge()+"  "+bs.getClassroom());
 bs.act();
 bs.work();
 
 System.out.println("----------");
 //就业班
 jobSdudent jb=new jobSdudent();
 jb.setName("李四");
 jb.setAge(21);
 jb.setClassroom(2);
 System.out.println(jb.getName()+"  "+jb.getAge()+"  "+jb.getClassroom());
 jb.act();
 jb.work();
  }
}

11:抽象类的小问题
A:一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
B:abstract不能和哪些关键字共存

答：A:可以；父类是一个抽象类，如果要创建对象必须通过子类实现。
    B：private,final,static