抽象类

抽象类：普通类中添加抽象方法，不能实例化，【向上转型】之后实例化
一定要（非抽象类的）子类覆写抽象类（父类）中●全部●的抽象方法【强制子类重写】
★★★强制规定了子类必须要做的事情，可以与自身的普通方法配合★★★
★缺点:单继承局限★
普通类：可以直接产生实例化对象，可以包含构造方法、普通方法、static方法、常量、变量的内容

抽象方法：没有{}，同时使用关键字abstract进行定义
抽象方法一定在抽象类（一定要使用abstract声明）中，抽象类中可以不要抽象方法

范例：
【class文件名和public对应的类名是一样的，class文件只能有一个public】
/**
* 父类
*/
public abstract class B {
/**
* 普通方法
*/
public void fun(){
System.out.println("存在有方法体的方法！");
}

/**
* 抽象方法
*/
public abstract void print();

}

/**
* 子类:一个子类只能继承一个抽象类，属于单继承局限
*/
class F extends B{
@Override
public void print() {//强制重写的抽象父类的抽象方法
System.out.println("Hello");
}
}

class Test{
public static void main(String[] args) {
B b= new F();//向上转型
b.fun();
b.print();//重写的print()方法
}
}

注意：
1.抽象类可以存在属性,那么抽象类就一定会存在构造方法,目的：为属性初始化，并且子类对象实例化
的时候依然先执行父类构造，再调用子类构造
2.抽象类不能用final定义:抽象类必须有子类，而final定义的类不能有子类
3.外部抽象类不允许用static,内部的抽象类可以使用static,（此时的内部抽象类 = 外部抽象类）
继承时使用“外部类.内部类”的形式表示类名称
范例：
/**
* 父类
*/
public abstract class C {
//static 定义的内部类属于外部类
static abstract class G{
public abstract void print();
}
}

/**
* 子类
*/
class X extends C.G{    //调用G的抽象方法
@Override
public void print() {
System.out.println("*************");
}
}

class TestC{
public static void main(String[] args) {
C.G cg= new X(); //调用G的抽象方法
cg.print();
}
}

任何情况下，如果要执行类中的static方法【抽象类】的时候，都可以在没有对象的时候直接调用
范例：
public abstract class StaticDemo {

//静态普通方法
public static void print(){
System.out.println("Hello");
}
}

class TestSttic{
public static void main(String[] args) {
//不要实例化对象，直接【类.方法】
StaticDemo.print();
}
}

★继承：唯一的对象，单例★
有时，抽象类只需一个特定的系统子类操作，可以忽略外部子类（父类内的带static的子类）
为用户隐藏不需要知道的子类
范例：
public abstract class InsideSonType {
public abstract void print();

private static class B extends InsideSonType{  //内部抽象类子类
public void print(){    //覆写抽象类的方法
System.out.println("Hello World！");
}
}

//这个方法不受实例化对象的控制
public static InsideSonType getInstance(){
return new B();
}

public class Test {

public static void main(String[] args) {
//此时取得抽象类对象的时候，完全可以不需知道子类B的存在
InsideSonType insideSonType = InsideSonType.getInstance();
insideSonType.print();
}
}

类实例创建过程：
按照父子继承关系进行初始化，首先执行父类的初始化块，然后执行父类的构造方法，
其次执行继承的子类的初始化块，最后执行子类的构造方法
类实例销毁：
先销毁子类部分，再销毁父类部分
范例:
public abstract class AbstractNum {
/**
* 父类的构造方法
*/
public AbstractNum(){
this.print();//调用print()方法
}

/**
* 抽象方法
*/
abstract void print();

/**
* 子类
*/
class B extends AbstractNum{
private int num = 100;
★没声明调用父类的构造方法，子类默认执行的是父类的无参构造方法★
public B(int num){    //子类带参构造方法
this.num = num;
}
@Override
void print() {
System.out.println("num = " + num);
}
}
}

public class Test {

public static void main(String[] args) {
new B(30);//只执行到父类的构造方法
}
}

◆◆◆◆◆◆◆◆◆模板设计模式◆◆◆◆◆◆◆◆◆(工具画类图：umll)
☉机器人：充电、工作；
☉人：吃饭、工作、睡觉；
☉猪： 吃饭、睡觉。
☉要求可以实现以上的操作控制，即：可以任意的控制人、机器人、猪的操作行为（吃、睡、工作）
abstract class Action {
public static final int EAT = 1;    //常量，奇数比较合适
public static final int SLEEP = 5;
public static final int WORK = 7;
public void command(int flag){
//switch 只支持数值判断，而if支持条件判断
switch(flag){
case EAT:
this.eat();
break;
case SLEEP:
this.sleep();
break;
case WORK:
this.work();
break;
case EAT+WORK:
this.eat();
this.work();
break;
}
}
//因为现在不确定子类的实现是什么样的
public abstract void eat();
public abstract void sleep();
public abstract void work();
}

//子类Robot
public class Robot extends Action {
public void eat(){
System.out.println("机器人补充能量！");
}
public void sleep(){}
public void work(){
System.out.println("机器人正在努力工作！");
}
}

//子类Human
public class Human extends Action {
public void eat(){
System.out.println("人类正在吃饭！");
}
public void sleep(){
System.out.println("人类正在睡觉休息！");
}
public void work(){
System.out.println("人为了梦想在努力工作！");
}
}

//子类Pig
public class Pig extends Action{
public void eat(){
System.out.println("猪正在啃食槽！");
}
public void sleep(){
System.out.println("猪在睡觉养膘！");
}
public void work(){}
}

//测试类
public class TestDemo {
public static void main(String args[]){
fun(new Robot());//调用static方法，不需实例化对象，直接调方法
fun(new Human());
fun(new Pig());
}
public static void fun(Action act){
act.command(Action.EAT);
act.command(Action.SLEEP);
act.command(Action.WORK);
}
}