Java 抽象类常见问题及程序实例

1、请问抽象类在定义的时候是否能使用final关键字？

         不能。因为抽象类必须有子类，而final定义的类不能有子类，产生了矛盾。

2、请问抽象类之中是否能定义构造函数？

          能，因为抽象类只是比普通类多了抽象方法而已，其他的结构（属性、全局常量、普通方法）均存在，
有属性的话就必须有构造方法。

abstract class A {
    public A() {
        System.out.println("*******************");
    }
    private String msg = "hello";
    abstract public void fun() ;
}

class B extends A {
    public B() {
        System.out.println("#####################");
    }

    public void fun() {
        System.out.println("class B fun");
    }
}

public class Demo {
    public static void main(String args[]) {
        A a = new B();            //向上转型
        //a.fun();
    }
}

输出结果：

*******************
#####################
class B fun

3、请问一个抽象类是否可以没有抽象方法？此时抽象类是否可以直接产生实例化对象？

        可以没有抽象方法，但此时仍然无法产生实例化对象。

4、请问抽象类是否可以使用static定义？

         普通外部类不可以使用static来定义抽象类，但是内部类可以（内部类加static成为外部类）

// 使用static来定义外部抽象类
abstract static class A {
    
}

class B extends A {
    
}

public class Demo {
    public static void main(String args[]) {
        A a = new B();            //向上转型
        //a.fun();
    }
}

输出结果：

此处不允许使用修饰符static ，abstract static class A {

// 使用static定义内部抽象类
abstract class A {
    abstract static class B {
        abstract void fun() ;
    }
}

class C extends A.B {
    public void fun() {
        System.out.println("it is C fun!");
    }
}

public class Demo {
    public static void main(String args[]) {
        C c = new C();            
        c.fun();
    }
}

输出结果：
it is C fun!

5、请问一个抽象类能否在此抽象类的内部提供实现此抽象类的子类呢？

          一个抽象类可以直接定义一个内部类继承本抽象类。此时A类无法进行对象实例化。

abstract class A {
        abstract void fun() ;
    public static class B extends A {        //声明为static
        public void fun() {
            System.out.println("it is B fun ,inner extends from A");
        }
    }
    
}


public class Demo {
    public static void main(String args[]) {
        A a = new A.B();
        a.fun();
    }
}

abstract class A {
        abstract void fun() ;
    private static class B extends A {        //声明为static
        public void fun() {
            System.out.println("it is B fun ,inner extends from A");
        }
    }
    public static B getclass() {        //声明为static
        return new B();
    }
}


public class Demo {
    public static void main(String args[]) {
        A a = A.getclass();          //自动完成向上转型
        a.fun();
    }
}

两个程序运行结果相同

产生文件如下：

A$B.class  A.class  Demo.class  Demo.java

输出结果如下：

it is B fun ,inner extends from A

6、通过抽象类来体验Java的多态性

          程序在抽象父类中定义三个抽象方法，不同的子类在继承该父类的时候，根据自身需要实现不同的抽象方法。然后在主函数中，定义父类引用来表示子类实例（向上转型），通过父类引用调用方法，但此时方法的实现依据不同子类而不同，实现多态性。

abstract class A {
	public final static int EAT = 1;                //类似宏定义，后面程序依据数字值来判断需要调用的方法
	public final static int SLEEP = 5;
	public final static int WORK = 10;

	public abstract void eat() ;
	public abstract void sleep() ;
	public abstract void work() ;

	public void command(int flag) {
		switch(flag) {
			case EAT :
				this.eat() ;
				break ;
			case SLEEP :
				this.sleep() ; 
				break ;
			case WORK :
				this.work() ;
				break ;
			case SLEEP + EAT + WORK :
				this.eat() ;
				this.work() ;
				this.sleep() ;
				break ;
			case SLEEP + EAT :
				this.eat() ;
				this.sleep() ;
				break ;
			case SLEEP + WORK :
				this.work() ;
				this.sleep() ;
				break ;
			case EAT + WORK :
				this.eat() ;
				this.work() ;
				break ;
			default :
				System.out.println("the command is wrong!");
		}
	}
}

class robot extends A {
	public void eat() {
		System.out.println("robot is fueling!"); 
	}
	public void sleep() {

	}
	public void work() {
		System.out.println("robot is working!"); 	
	}
}

class pig extends A {
	public void eat() {
		System.out.println("pig is eating!"); 
	}
	public void sleep() {
		System.out.println("pig is sleeping to get fat!"); 	
	}
	public void work() {

	}
}

class people extends A {
	public void eat() {
		System.out.println("people is eating food!"); 
	}
	public void sleep() {
		System.out.println("people is sleeping for dream!"); 
	}
	public void work() {
		System.out.println("people is working for dream!"); 	
	}
}

public class Demo {
	public static void main(String args[]) {
		A r = new robot();
		r.command(r.WORK + r.SLEEP + r.EAT) ;

		A p = new pig();
		p.command(p.WORK + p.SLEEP + p.EAT) ;

		A people = new people();
		people.command(people.WORK + people.SLEEP + people.EAT) ;
	}
}

输出结果：

robot is fueling!
robot is working!
pig is eating!
pig is sleeping to get fat!
people is eating food!
people is working for dream!
people is sleeping for dream!