java抽象类和抽象方法

抽象类就是不能使用new方法进行实例化的类，即没有具体实例对象的类。抽象类有点类似“模板”的作用，目的是根据其格式来创建和修改新的类。对象不能由抽象类直接创建，只可以通过抽象类派生出新的子类，再由其子类来创建对象。当一个类被声明为抽象类时，要在这个类前面加上修饰符abstract。
    在抽象类中的成员方法可以包括一般方法和抽象方法。抽象方法就是以abstract修饰的方法，这种方法只声明返回的数据类型、方法名称和所需的参数，没有方法体，也就是说抽象方法只需要声明而不需要实现。当一个方法为抽象方法时，意味着这个方法必须被子类的方法所重写，否则其子类的该方法仍然是abstract的，而这个子类也必须是抽象的，即声明为abstract。
    抽象类中不一定包含抽象方法，但是包含抽象方法的类一定要被声明为抽象类。抽象类本身不具备实际的功能，只能用于派生其子类。抽象类中可以包含构造方法，但是构造方法不能被声明为抽象。
    抽象类不能用final来修饰，即一个类不能既是最终类又是抽象类。
    abstract不能与private、static、final、native并列修饰同一个方法。
    程序举例：
abstract class Animal    //定义抽象类
{
    String str;
    Animal(String s)     //定义抽象类的一般方法
   {
        str=s;
   }
    abstract void eat();      //定义抽象方法
}
class Horse extends Animal     //定义继承Animal的子类
{  
    String str;
    Horse(String s)
   {
      super(s);      //调用父类的构造方法
   }
    void eat()      //重写父类的抽象方法
   {     
      System.out.println("马吃草料！");
   }
}
class Dog extends Animal
{
    String str;
    Dog(String s)
   {
   &nb ......

=========================================================================

抽象方法就是以abstract修饰的方法，这种方法是不完整的；仅有声明而没有方法体。如：

abstract void f();

当一个子类继承某个抽象类时，它可以有两个选择：

• 部分实现或完全不实现父类的所有抽象方法，但此时子类必须声明为抽象类。
• 实现父类所有的抽象方法，此时之类不比声明为抽象类。

包含抽象方法的类叫做“抽象类”。如果一个类包含一个或多个抽象方法，该类必须被限定为抽象的。（否则，编译器就会报错。）

抽象类不能被实例化（be instantiated)，但可以实例化非抽象子类。

PS：抽象类和接口的区别：

• 一个类可以实现任意多个接口，但最多只能作为一个抽象类的子类。
• 一个抽象类可以有若干个抽象方法（但到少要有一个），而接口的所有方法都是抽象的，无论是否将它的方法显示地声明为抽象的。
• 一个抽象类可以声明实例变量，其子类可以继承这些实例变量。而一个接口不能声明实例变量，不过接口可以声明static final修饰域。
• 抽象类可以有构造方法，而接口不能。
• 抽象类的可见性修饰符可以是public、protected、private或无修饰符（表示包内可见）；而接口的可见性修饰符只能是public，或无修饰符（包内可见）。
• 抽象类的方法的可见性修饰符可是以protected、private，或无（表示包内可见）；而一个接口的方法的可见性修饰符只能是public。
• 抽象类是从object类派生而来，它继承了object的clone()和equals()方法。

实际例子：

 NoteSplashActivity.java

public class NoteSplashActivity extends SplashActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

    }

    @Override
    public boolean handleMessage(Message msg) {
        switch (msg.what) {
            case MSG_HELP:
            case MSG_LAUNCH:
                startActivity(new Intent(this, NoteMainActivity.class));
                break;
        }
        finish();
        return true;
    }
}


SplashActivity.java

public abstract class SplashActivity extends AppCompatActivity implements Handler.Callback {
    protected final int MSG_LAUNCH = 0x0;
    protected final int MSG_HELP = 0x1;
    /**
     * 进入主页面的最小延迟时间，程序进入主页面的时间可能大于该值
     */
    protected final int MIN_DELAY_MS = 1000;
    @Inject
    SharedPreferences mSharedPreference;
    private Handler splashHandler;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_splash);
        splashHandler = new Handler(this);
        splashHandler.sendEmptyMessageDelayed(MSG_LAUNCH, MIN_DELAY_MS);
    }

    @Override
    public void onBackPressed() {

    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        splashHandler.removeCallbacksAndMessages(null); //清除消息
        splashHandler = null;
    }

    @Override
    public void onResume() {
        super.onResume();
    }

    @Override
    public void onPause() {
        super.onPause();
    }
}


1.抽象类的所有方法，如果其直接子类不是抽象(abstract)的,那必须重写抽象方法
 
2.如果其直接子类是抽象(abstract)的,那可以不被重写,由孙子类来实现