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!

转载地址：http://antii.baihongyu.com/

你可能感兴趣的文章