abstract class Teacher
{
        abstract void giveLesson();

        public void sleep()
        {
                System.out.println("老师睡觉。。。。。。");
        }
}
class JaTeacher extends Teacher
{
        public void giveLesson()
                {
                System.out.println("老师在讲课");
        }
        public void sleep()
                {
                System.out.println("老师在睡觉");
        }
}
        

class  Demo5
{
        public static void main(String[] args)
        {
                Teacher te = new JaTeacher();
                ck(te);
               
        }
        
                public static void ck(Teacher teacher)
                        {
                System.out.println("领导对老师开始考核......");
                teacher.giveLesson();
                }
        
}
在主程序中，最后一个方法，是建立的抽象的参数，抽象类不能建立对象，为什么还可以调用方法呢，想不明白

这里应用到的是多态，父类引用可以指向子类的对象，抽象类本身虽然不能建立对象，但是其子类却可以，父类虽然不能建立对象，却不影响其声明，这里只是声明形参为Teacher类，也就是将来传过来的实参要么是本身的实例对象要么是其子类，而这里显然只能是其子类！这是多态的应用，方便程序的调用和扩展。另外，补充一点，虽然抽象类不能建立对象，但它是可以调用本身的方法的，当本身的方法是静态方法时，就可以通过类名.方法名来调用！

这就是多态的应用，父类名  变量名=new 子类名;也是就父类引用指向子类的对象，这个变量名，只能访问父类中有的方法，但实际运行时，却是走的子类的方法，多态的应用很常见，主要是为了程序的扩展性。

这个问题涉及到面向对象特征中的多态.
当两个类有继承或实现关系并且有方法的重写时,
就可以应用多态,声明父类变量引用子类对象,或者是用接口的变量引用实现类的对象,
本例中,JaTeacher继承自Teacher,且有方法的重写,
因此可以实现多态,即用父类Teacher的变量引用子类JaTeacher的对象

[code]  public static void ck(Teacher teacher)
                        {
                System.out.println("领导对老师开始考核......");
                teacher.giveLesson();
                }[/code
这个方法没有建立抽象参数，只是说定义了参数类型是Teacher ，然后main方法中使用了多态对子类建立了对象，因此其实它调用的是子类覆盖父类后的方法。

这是多态的问题,可以其父类是抽象的,不能建立对象,但是其子类可以建立对象.
抽象类虽不能建立对象,但是可以调用本身的方法啊.

首先来说下多态的前提：
1、必须是类与类之间的关系，如继承和实现关系
2、要存在覆盖的操作，父类中必须由方法被子类覆盖，即重写
3、有父类引用指向子类对象

首先楼主的代码JaTeacher extends Teacher，因此条件1符合，
其次

1. public void giveLesson()
   
2. {
   
3.     System.out.println("老师在讲课");
   
4. }
   

复制代码

重写了父类方法，因此，条件2满足，
最后 Teacher te = new JaTeacher();因此，条件3也满足。
所以楼主的这个是多态。
楼主估计是这段代码不懂

1. public static void ck(Teacher teacher)
   
2. {
   
3.     System.out.println
   
4.              ("领导对老师开始考核......");
   
5.     teacher.giveLesson();
   
6. }
   

复制代码

为什么可以直接调用 teacher.giveLesson();

其实代码开始是这样的

1. public static void ck(JaTeacher Jteacher)//JaTeacher Jteacher = new JTeacher()
   
2. {
   
3.     System.out.println
   
4.              ("领导对老师开始考核......");
   
5.     Jteacher.giveLesson();
   
6. }
   

复制代码

本类对象接受本类对象，

但由于他是多态，也就是可以父类引用指向子类对象，换句话说就是父类的引用也可以接收自己的子类对象，
也就是可以写成Teacher teacher = new JaTeacher();
因此这段代码

1. public static void ck(Teacher teacher)//Teacher teacher = new JaTeacher();
   
2. {
   
3.     System.out.println
   
4.              ("领导对老师开始考核......");
   
5.     teacher.giveLesson();
   
6. }
   

复制代码

也就理所当然了，是父类对象接收子类对象。

多态的好处在于其扩展性，
如果来年除了JaTeacher外，还要加入EnglishTeacher，MathTeacher的话
就只要创建其对象，并继承Teacher类，重写其giveLesson()即可
到时候主方法里面就只要
ck(new EnglishTeacher());
ck(new MathTeacher());即可。

如果楼主还有疑问的话可以去看毕老师08-02，面向对象(多态-扩展性)那个视频。
那个毕老师的例子更简单详细。