抽象方法及注意事项

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

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组合使用，代码如下：