java 抽象类

/**
 * 抽象类 。
 * abstract  可以修饰方法 ， 可以修饰 类 
 * @author Administrator
 * abstract  修饰类  ，不能被实例化    ，抽象类 有构造器  但是不能被实例化  。其子类可以被实例化   【凡事类 都有构造器 】
 * 
 * 抽象方法 所在的类一定是抽象类。
 * 
 * 抽象类 可以没有 抽象方法。
 * 
 * 
 * abstract  修饰方法  抽象方法 。  
 *  public abstract void  eat();   抽象方法 没有方法体  ， 具体实现 由其子类重写 实现。


 * abstract 不能修饰属性、 不能修饰构造器   不能与 private final static  共用 。

 */
public class TestAbstract {
public static void main(String[] args) {
B b =new B();

b.eat();
//抽象类  --》 子类  ---- 多态的体现。 父类的引用 a 指向  子类对象  B();
A a =new B();
a.eat();
}
}


//抽象类  ---不能被实例化 
abstract class A{
private String  name="AD";
// 抽象方法  只能存在抽象类中。   ----抽象方法被子类重写。
public abstract void eat();

public A() {
super();
// TODO Auto-generated constructor stub
}
// 抽象类中 可以有非抽象的 方法，
public void run(){
System.out.println("run ..永远不能被执行， 因为抽象类 不能被实例化  ");
}
public String getName() {
return name;
}


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





}
// 抽象类的子类  要么 全部重写 抽象父类的抽象方法，  如果重写不全 或者不重写父类的抽象方法  则 子类也必须定义为抽象类 。 
class B extends A{
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("B:吃饭  --实现 类 A的 eat 方法  -eat");
}

}




abstract class C extends A{
// 不重写 全  抽象方法    则  c要定义为 抽象 类 。
public  void  show(){
System.out.println();
}
}


abstract class D{
public  void  gun(){
System.out.println("抽象类中  可以没有抽象方法  。。。。");
}
}