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!