1. 
   

复制代码

这个抽象类， 和不抽象的普通类。。。这两种写法都能正常运行？？ 什么时候需要用抽象类？？为什么要用抽象类？？ 求解答 谢谢
/*   abstract class chuanzhi
{
       public abstract void study();
}
*/

class chuanzhi
{
        public  void study(){}
}

class jichu extends chuanzhi
{
        public void study()
        {
                System.out.println("学习 基础");
        }

}

class tigao extends chuanzhi
{
        public void study()
        {
                System.out.println("学习 提高");
        }

}

class chongci extends chuanzhi
{
        public void study()
        {
                System.out.println("学习 冲刺");
        }

}

class demo
{
        public static void main(String[] args)
        {
                methoe(new jichu());
                methoe(new tigao());
                methoe(new chongci());
        }

        public static void methoe(chuanzhi i)
        {
                i.study();
        }


}

抽象类的理解是一个很大的领域，随便百度下都能看到。我只说下简单个人理解吧。
1.以上两种父类的写法都是可以运行的。主要在于两者的理解不同。定义为一个抽象类，说明该事物不能建立对象，也就是说是一个概念性的东西，没有具体的事物，因此也没有具体的方法来描述它。例如物体的体积的计算方式，圆锥型，圆柱形等有不同的体积计算方式，所以可以将两者的体积抽取出来作为父类，因为计算方式不明确，说以可以定义为抽象的，又不需要用具体的属性去描述它，所以这是一个抽象的类，没有与之对应的具体事物。之子类继承他的时候，必须复写其抽象方法。圆锥形复写圆锥形的体积计算方式，圆柱形复写圆柱形的体积计算方式。class chuanzhi{public  void study(){}}是一个具体的类，现实中能找到与之对应的对象，内部只是一个空方法的函数，作为父类时，子类继承他，但是不需要复写他也可以。该父类的存在就没有什么意义了。
2，该类中有不确定的方法时，就用抽象类。
3，从存在上看，抽象类必然是一个父类，由子类具体实现之。
   从功能上看，抽象类定义的方法子类在继承的时候会报错，提示你要实现没有实现的方法。
   

下面是一个例子，希望能帮你理解，这个例子还涉及到多态。

1. 
   
2. //由于汽车是一个抽象的概念，所以把它定义为抽象类
   
3. public abstract class Car {
   
4.         public abstract void run();
   
5. 
   
6. }

复制代码

1. //具体的类，表示奔驰这一类车
   
2. public class BenChi extends Car
   
3. {
   
4.         public void run()
   
5.         {
   
6.                 System.out.println("BenChi is running");
   
7.         }
   
8. }

复制代码

1. //具体的类，表示宝马这一类车
   
2. public class BaoMa extends Car
   
3. {
   
4.         public void run()
   
5.         {
   
6.                 System.out.println("BaoMa is running");
   
7.         }
   
8. 
   
9. }

复制代码

1. public class Person {
   
2.         private Car car;
   
3.         public void drive(Car car)//这里面用抽象类，以后但凡是继承此类的类如奥迪类等等都可以在继承Car之后作为参数传进来，定义抽象类方便了程序的扩展。
   
4.         {
   
5.                 car.run();
   
6.         }
   
7. 
   
8. }

复制代码

1. public class Event {
   
2. 
   
3. /**
   
4. * 人开奔驰，奔驰跑起来。
   
5. * 人开宝马，宝马跑起来。
   
6. * @param args
   
7. */
   
8. public static void main(String[] args) {
   
9. // 人开奔驰，奔驰跑起来。
   
10. Person p = new Person();
    
11. BenChi benChi = new BenChi();
    
12. p.drive(benChi);
    
13. 
    
14. //人开宝马，宝马跑起来。
    
15. BaoMa baoMa = new BaoMa();
    
16. p.drive(baoMa);
    
17. }
    
18. }

复制代码

抽象类是共性，多个子类继承了一个抽象类，每个子类可以重写不同的抽象方法，拥有自己的个性，抽象类为多个子类提供统一的接口。

抽象类中可以有抽象方法、普通方法，其子类必须实现其抽象方法

abstract class Chuanzhi//类名要首字母大写
{
       //抽象方法：abstract修饰+没有方法体+子类必实现该方法
       public abstract void study();//抽象类中可以没有抽象方法；如果没有此方法，Chuanzhi类的子类就可以不写study方法【扩展：接口必是抽象类】
       public void studyMusic(){... ...}//抽象类中可以有普通方法
}

class Jichu extends Chuanzhi
{
        //子类必须继承抽象类中的抽象方法【扩展：子类必须实现其继承的接口的所有方法】
        public void study()
        {
                System.out.println("学习 基础");
        }
        //子类可以有其他的方法
         public void myLife()
        {
                System.out.println("认识新同学，学习OOP");
        }
        //更多其他方法... ...
}

class Tigao extends Chuanzhi
{
        public void study()
        {
                System.out.println("学习提高");
        }
        //其他方法
         public void myLearn()
        {
                System.out.println("学习框架，练项目");
        }
}

class Chongci extends Chuanzhi
{
        public void study()
        {
                System.out.println("学习冲刺");
        }
        //其他方法
        public void myFeeling()
        {
                System.out.println("找工作，学后感言");
        }

}

class demo{
        ... ...
}

1当方法描述事情，描述不清楚的时候，使用抽象方法
2abstract修饰，没有方法体，没有大括号
3抽象方法，必须存在于抽象类，类需要abstract修饰
4也有构造方法
5 抽象类不能实例化对象
6需要子类继承抽象类，覆盖全部抽象方法，建立子类对象
7子类覆盖了一部分抽象方法，子类还是一个抽象类
8抽象类可以有普通方法，子类继承直接使用
9抽象类是这个体系的最共性内容