抽象方法及注意事项

抽象类是不完整的,它只能用作基类。在面向对象方法中,抽象类主要用来进行类型隐藏和充当全局变量的角色。

  1. 被abstract修饰的类叫抽象类,抽象类中,可以含有抽象方法,也可以不含有抽象方法
  2. 抽象方法无法被实例化
  3. 抽象类中的抽象方法,默认权限是public
  4. 抽象方法是没有方法体的
  5. 抽象类中可以被抽象类继承,不必重写父类的抽象方法
  6. 非抽象类在继承抽象类后,必须实现父类的抽象方法
  7. 抽象类中,可以有成员变量
  8. 抽象关键字abstract不能与private,final,static关键字组合使用
  9. 抽象方法,必须在抽象类中

原因如下:

  • private修饰的类,其构造方法是private 类名,而被private修饰的方法,是无法在外部调用 的,在继承中,子类构造方法中第一行会调用父类的构造方法,显然会失败。
  • final修饰的类不能被继承,final修饰的方法无法被重写。抽象类有两个要求,一是要被继承,二是非抽象类继承了抽象类,必须 要重写父类的抽象方法
  • static修饰的方法,在JVM加时会放入方法区,而抽象方法是没有方法体的,必须要重写抽象方法,显然与抽象的定义冲突

抽象类的代码:

//抽像类,被abstract修饰的类
abstract class AbstractDemo{
	String name;
	int age;
	//抽象方法,被abstract修饰的方法,没有方法体
	public abstract void sleep();
}

class Student extends AbstractDemo{
	//抽象方法必须被重写(前提是子类不是抽象类,如果子类是抽象类,可以不必重写父类(抽象类)的抽象方法)
	public void sleep(){
		System.out.println("学生"+super.name+"正在睡觉");
	}
}

class Teacher extends AbstractDemo{
	//抽象方法有不同的实现
	public void sleep(){
		System.out.println("老师"+super.name+"正在睡觉");
	}
}

class Test{
	public static void main(String[] args){
		Student student = new Student();
		student.name = "小二";
		student.sleep();
		
		Teacher teacher = new Teacher();
		teacher.name = "小样";
		teacher.sleep();
	}
}
运行结果 :

学生小二正在睡觉
老师小样正在睡觉

==抽象方法不能实例化,代码如下:

//抽像类,被abstract修饰的类
abstract  class AbstractDemo{
	String name;
	int age;
	//抽象方法,被abstract修饰的方法,没有方法体
	public abstract void sleep();
	
	public void eat(){
		System.out.println(this.name+"在吃饭");
	}
}


class Test{
	public static void main(String[] args){
		//抽象类不能被实例化
		AbstractDemo demo = new AbstractDemo();
	}
}

运行结果如下 :

AbstractDemo.java:17: 错误: AbstractDemo是抽象的; 无法实例化
                AbstractDemo demo = new AbstractDemo();
                                    ^
1 个错误


==抽象方法必须被重写,代码如下:

//抽像类,被abstract修饰的类
abstract  class AbstractDemo{
	String name;
	int age;
	//抽象方法,被abstract修饰的方法,没有方法体
	public abstract void sleep();
	
	public void eat(){
		System.out.println(this.name+"在吃饭");
	}
}

class Student extends AbstractDemo{
	//抽象方法必须被重写(前提是子类不是抽象类,如果子类是抽象类,可以不必重写父类(抽象类)的抽象方法)
	public void outPrint(){
		System.out.println("学生"+super.name+"正在睡觉");
	}
}

class Test{
	public static void main(String[] args){
		//抽象方法必须被重写
		Student student = new Student();
		student.name = "小二";
		student.sleep();
		
	}
}

运行结果 如下:

AbstractDemo.java:13: 错误: Student不是抽象的, 并且未覆盖AbstractDemo中的抽象方法sleep()
class Student extends AbstractDemo{
^
1 个错误



==抽象方法不能有方法体,代码 如下:

//抽像类,被abstract修饰的类
abstract  class AbstractDemo{
	String name;
	int age;
	//抽象方法,被abstract修饰的方法,没有方法体
	public abstract void sleep(){
		System.out.println("抽象方法不能有方法体");
	}
	

}

class Student extends AbstractDemo{
	//抽象方法必须被重写(前提是子类不是抽象类,如果子类是抽象类,可以不必重写父类(抽象类)的抽象方法)
	public void sleep(){
		System.out.println("学生"+super.name+"正在睡觉");
	}
}

class Test{
	public static void main(String[] args){
		//抽象方法不能有方法体
		Student student = new Student();
		student.name = "小二";
		student.sleep();
		
	}
}

运行代码 如下:

AbstractDemo.java:6: 错误: 抽象方法不能有主体
        public abstract void sleep(){
                             ^
1 个错误


== 抽象类可以被抽象类继承,代码如下:

//抽像类,被abstract修饰的类
abstract  class AbstractDemo{
	String name;
	int age;
	//抽象方法,被abstract修饰的方法,没有方法体
	public abstract void sleep();
}

abstract class Student extends AbstractDemo{
	//抽象方法必须被重写(前提是子类不是抽象类,如果子类是抽象类,可以不必重写父类(抽象类)的抽象方法)
	public abstract void printOut();
}


class Test{
	public static void main(String[] args){
	
		
	}
}

运行结果 :

编译通过


== 如果继承的父类是抽象类,且父类还继承了别的抽象为在,同样要把抽象类重写,代码如下:

//抽像类,被abstract修饰的类
abstract  class AbstractDemo{
	String name;
	int age;
	//抽象方法,被abstract修饰的方法,没有方法体
	public abstract void sleep();
}

abstract class Persion extends AbstractDemo{
	//抽象方法必须被重写(前提是子类不是抽象类,如果子类是抽象类,可以不必重写父类(抽象类)的抽象方法)
	public abstract void printOut();
}

class Student extends Persion{
	//如果继承的父类是抽象类,且父类还继承了别的抽象为在,同样要把抽象类重写
	public void printOut(){
		System.out.println("这是直系父类的抽象方法重写");
	}
	//这里没有重写父类Persion的父类的sleep()方法,所以会报错
}


class Test{
	public static void main(String[] args){
		Student student = new Student();
		
		
	}
}

运行结果如下:

AbstractDemo.java:14: 错误: Student不是抽象的, 并且未覆盖AbstractDemo中的抽象方法sleep()
class Student extends Persion{
^
1 个错误


== abstract抽象关键字,不能与private组合使用,代码如下:

//抽像类,被abstract修饰的类,不能与private/static/final关键字组合使用
private abstract  class AbstractDemo{
	String name;
	int age;
	//抽象方法,不能被private修饰
	private abstract void sleep();
}



class Test{
	public static void main(String[] args){
		
	}
}

运行结果如下:

AbstractDemo.java:2: 错误: 此处不允许使用修饰符private
private abstract  class AbstractDemo{
                  ^
AbstractDemo.java:6: 错误: 非法的修饰符组合: abstract和private
        private abstract void sleep();
                              ^
2 个错误




== abstract抽象关键字,不能与static组合使用,代码如下:

//抽像类,被abstract修饰的类,不能与private/static/final关键字组合使用
 abstract  class AbstractDemo{
	String name;
	int age;
	//抽象方法,不能被static修饰
	public static abstract void sleep();
}



class Test{
	public static void main(String[] args){
		
	}
}

运行结果 如下:


AbstractDemo.java:6: 错误: 非法的修饰符组合: abstract和static
        public static abstract void sleep();
                                    ^
1 个错误







== abstract抽象关键字,不能final组合使用,代码如下:

//抽像类,被abstract修饰的类,不能与private/static/final关键字组合使用
 abstract  class AbstractDemo{
	String name;
	int age;
	//抽象方法,不能被final修饰
	public static final abstract void sleep();
}



class Test{
	public static void main(String[] args){
		
	}
}

运行结果如下:

AbstractDemo.java:6: 错误: 非法的修饰符组合: abstract和static
        public static final abstract void sleep();
                                          ^
1 个错误






== abstract抽象关键字,不能与static组合使用,代码如下:
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值