全网最全抽象类abstract讲解

抽象类 abstract

抽象类的特点：

        1)一个类要被定义为抽象类,必须有关键字 :abstract	
			位置在类上进行修饰 : abstract class 
			
		2)什么抽象方法?
			只是给一个方法声明,不做具体体现 (就是一个方法没有方法体{})
			public abstract void method(); 抽象方法
			如果一个方法被abstract修饰了,那么是抽象方法,不能使用{}
		3)有抽象方法的类一定要被abstract修饰,否则编译报错
		
		4)抽象类中一定都是抽象方法吗?
			错的,不一定,抽象类中可以有 抽象方法,也可以是非抽象方法;
			
		5)抽象类不能实例化,如何创建对象呢?
			可以通过抽象类的子类进行实例化
			a)子类是抽象类,无意义(子类都不能实例化)
			b)子类是具体类,创建对象使用多态
				Animal a = new Cat() ;
			
		6)抽象类的子类,必须重写父类中的抽象方法!
			抽象类中是有构造方法的,但是不能直接实例化,需要子类进行数据初始化!

代码示例：

abstract class Animal{
		
		//抽象的方法
		//public abstract void eat(){}  //抽象方法不能有主体
		public abstract void eat(); //仅仅是一个声明
		public void method(){
			System.out.println("method animal...");
		}
		
		public Animal(){ //无参
		
		}
		public Animal(String name,int age){
			
		}
}
//狗类 ,抽象类
abstract class Dog extends Animal{//dog是抽象的; 无法实例化
	
}

//具体类
//class Cat extends Animal{ //报错 Cat不是抽象的, 并且未覆盖Animal中的抽象方法eat()
	
//}

class Cat extends Animal{
	//子类继承抽象的父类,一定要将抽象父类中的所有的抽象方法复写
	public void eat(){
		System.out.println("猫吃鱼...") ;
	}
}


//测试类
class AbstractDemo{
	public static void main(String[] args){
		
		//创建Animal对象
		//Animal a = new Animal() ;//Animal是抽象的; 无法实例化(无法创建对象)
		//使用多态进行对象的创建
		//Animal a = new Dog() ;
		
		//子类是具体类,使用多态的形式
		Animal a = new Cat() ;  
		a.eat() ;
		
	}	
}

抽象类的成员特点：

     成员变量
			既可以是常量(需要用final进行修饰),也可以是变量
	 成员方法
			既可以定义抽象方法,也可以定义非抽象方法;
	 构造方法
		可以有有参,无参的构造方法,由于类抽象类,所以不能直接实例化,构造方法如何初始化?
				通过子类进行数据的初始化  Animal a = new Cat() ;

代码示例：

abstract class Animal{
	//成员变量
	public int num = 100 ;
	public final int num2 = 50 ;
	
	public void show(){
		System.out.println(num) ;
		System.out.println(num2) ;
	}
	
	//public  void method();  //缺少方法主体, 或声明抽象
	//只要定义一个抽象方法,那么一定要使用abstract关键字声明,否则报错
	public abstract void method() ;
	public Animal(){}
	public Animal(String name,int age){
		
	}

abstract关键字和那些修饰符冲突：

private:私有的,被私有修饰的成员方法不能被继承,而abstract修饰的方法是一个抽象的,需要子类重写方法;
非法的修饰符组合: abstract和static
静态和类有关系 ,所以这两个修饰符冲突
非法的修饰符组合: abstract和final
被final修饰的成员方法不能被重写
abstract修饰的成员方法需要被子类重写,冲突了!

代码示例：

abstract class Fu{
	
	//abstract可以修饰成员方法
	//private abstract void show() ;  // 非法的修饰符组合: abstract和private
	//public abstract void show() ;
	//abstract static void show() ;//非法的修饰符组合: abstract和static  ()
	//public final abstract void show() ; //非法的修饰符组合: abstract和final
	
	public abstract void show() ;
}
class Zi extends Fu{
	public void show(){  //重写父类的方法的时候,访问权限最好给大,public
		System.out.println("show Zi...") ;
	}
}

class AbstractDemo3{
	public static void main(String[] args){
		Fu fu  = new Zi() ;
		fu.show() ;
	}
}