抽象类定义
 
 
 

         普通类可以直接产生实例化对象，并且在普通类中可以包含构造方法、普通方法、static 方法、常量、变量的内容。而所谓抽象类就是指在普通类的结构里面增加抽象方法的组成部分，抽象方法指的是没有方法体的方法，同时抽象类方法还必须使用abstract关键字定义。拥有抽象方法的类一定属于抽象类，抽象类要使用abstract声明。
 
 
 

  定义抽象类：
 
 
 
 
abstract class A{    //定义一个抽象类，使用abstract声明
    public void fun(){  //普通方法
       System.out.println("存在又方法体的方法");  
//此方法没有方法体的声明，并且存在abstract关键字，表示抽象方法
    public abstract void print();
 }
}
 
 

  在本程序的类中定义了一个抽象方法print()，既然类中有抽象方法，那么类就必须定义为抽象类，所以使用了“abstract class”来定义。但是一定要记住：抽象类只是比普通类多了抽象方法的定义，其他结构与普通类完全一样。
 
 
 

  
 
 
 
 

  注意：抽象类不能直接实例化对象
 
 
 

  
 
 
 
 

  范例：错误的实例化抽象类的操作。
 
 
 
 
public class TestDemo{
    public static void main(String[] args){
       A a = new a();  //A是抽象的，无法实例化
  }
}
  
 

  
 如果要想使用抽象类，必须遵守如下原则。
 
 
 

  1.抽象类必须有子类，即每一个抽象类一定要被子类所继承（使用extends关键字），但是在“java”中每一个子类只能够继承一个抽象类，所以具备单继承局限；
 
 
 

  2.抽象类的子类（子类不是抽象类）必须覆写抽象类中的全部抽象方法（强制子类覆写）；
 
 
 

  3.依靠对象的向上转型概念，可以通过抽象类的子类完成抽象类的实例化对象操作。
 
 
 

  
 
 
 
 
 
  

   
 
  
 
  

   范例：错误的实例化抽象类的操作。
  
 
  
abstract class A{	//定义一个抽象类，使用abstract声明
		public void fun(){	//普通方法
			System.out.println("存在有方法体的方法！");
	}
	//此方法并没有方法体的声明，并且存在abstract关键字，表示抽象方法
	public abstract void print();
}
//一个子类只能够继承一个抽象类，属于单继承局限
class B extends A{   //B类是抽象类的子类，并且是一个普通类
    public void print(){ //强制要求覆写的方法
       System.out.println("Hello World !");
  }    
}

public class TestDemo{
  public static void main(String[] args){
     A a = new B();  //向上转型
     a.print();          //被子类覆写过的方法
  }
}



本程序为抽象类定义了一个子类B，而子类B（是一个普通类）必须要覆写抽象类中的全部抽象方法，而在主方法中依靠子类对象的向上转型实现了抽象类A对象的实例化操作，而调用的print()方法由于被子类所覆写，所以最终调用的是在子类B中覆写过的print()方法。




 
 

 可以用一个抽象类定义一个指向该类的指针，但是不能定义或声明对象。
 
 这个中原因就是，定义一个类的对象是，编译器在编译时需要了解类的所有信息以便准确的为要实例化的对象分配内存；由此可见，定义一个类对象是要生成一个类的实例的，而C++规定抽象类是不能实例化的，所以会报出如下错误：
 
 error C2259: 'CBase' : cannot instantiate abstract class
 
 
>        due to following members:
 >        'int CBase::func(int)' : is abstract
 public:
  virtual int func(int param) = 0;
 private:
 };
 public:
  CTestA();
  ~CTestA();
  virtual int func(int param);
 private:
  int m_value;
 };
 {
  CBase cb0; //定义或声明一个对象，error
  CBase *cb = new CTestA(); //定义一个指针，OK
 }
 
  
 
 但是定义一个指针就不同了，指针是什么？大家都知道，无论它指向的是内部类型还是自己定义的结构体类型还是类的类型变量，它只不过就是一个具有32BIT也就是4个字节内存的空间而已，不需要其他任何信息了，所以能成功定义一个抽象类的指针变量。
 
  
 
 class CBase{
 
 
 class CTestA:public CBase{
 
 
 int _tmain(int argc, _TCHAR* argv[])
 
 
  return 0;
 
 
 
 

为什么要使用抽象类? 有什么好处?
 
答案:1  现实中一些父类中的方法没必要写  各个子类中的方法会有所不同 所以没必要在父类中写
 
2  看被人代码时候会注意这是抽象方法 会有个提示作用
 
3 当看到一个类是抽象的,要关心他的抽象方法, 因为他的子类一定会重写他,然后去找抽象类的引用,,会有多态性的体现
 
4  面向对象复杂但是是为了方便解决问题 
 
5  含有抽象方法的类必须定义为抽象类
 
6 不能使用 abstract修饰属相或者局部变量
 
7 抽象类中可以同时含有抽象方法和非抽象方法
 
8 在抽象类里定义的抽象方法只有方法头没有方法体，但这个抽象方法如果被多个子类所调用的时候，各子类可以根据各自需要实例化出不同的对象 并且重新定义不同的方法体上去，从而通过它来实现多态
 
9  抽象类可以有方法体 就是抽象工厂
 
10  抽象类中定义抽象方法不能有方法体(未实现)
 
11  demo 
 
抽象类是在接口和实体类之间的一个桥梁
 例如
 做一个接口叫做飞行FlyAnimalAction，里面定义一个方法叫做flying，再定义一个方法叫做eat
 做一个类叫做蚊子实现接口，蚊子要实现flying方法，实现自己的eat方法
 做一个类叫做苍蝇实现接口，苍蝇也要实现flying方法，实现自己的eat方法
 你发现所有会飞的动物都要实现这个接口，很麻烦，不如
 做一个抽象类FlyAnimal,然后实现上面的接口
 在里面实现flying这个方法，因为大部分的飞行动作是一样的，而eat方法则继续写成抽象方法，因为大部分的动物吃东西是不一样的
 下面你再写蚊子类就简单了，可以直接继承这个抽象类，然后实现自己的吃方法就行了
 而且苍蝇类的制作也是一样，这个时候抽象类的功能就显示出来了，当然抽象类的功能远远不是这些，只是初期理解到这里就够了。

一、抽象类
 
	定义：在普通类的基础上扩充了一些抽象方法 。
 
1. 抽象方法:只声明而未实现的方法（没有方法体）
 
所有抽象方法使用abstract定义。同时抽象方法所在的类也要用abstract定义，表示抽象类。
举例：定义一个抽象类：
 
 
 
抽象类中没有具体实现，因此抽象类不能直接实例化对象
 
 
abstract class Person{
	private String name;//姓名属性
	public String getName(){
		return this.name;
	}
	public void setName(String name){
		this.name = name;
	}
	//{}为方法体，所有抽象方法没有方法体{}
	public abstract void getPersonInfo();//抽象方法
}	
 
2.抽象类的使用原则
 
 
 
（1）抽象类必须有子类（abstract与final不能同时使用）。
 （2）子类覆写抽象类所有的抽象方法（abstract与private不能同时使用）。
 （3）抽象类实例化对象，必须通过子类向上转型来实例化对象（抽象类无法直接实例化对象）。
 
 
 
 
//抽象类的标准操作，也是常用操作。

abstract class Person{
	//姓名属性
	private String name;
	//普通方法
	public String getName(){
		return this.name;
	}
	public void setName(String name){
		this.name=name;
	}
	//抽象方法
	public abstract void getPersonInfo();
}

//子类继承抽象类
class Student extends Person{
	public void getPersonInfo(){
		System.out.println("I am a student");
	}
}	

public class Test{
	public static void main(String[] args){
		//实例化子类，向上转型
		Person per = new Student();	
		//被子类所覆写的方法
		per.getPersonInfo();
	}
}

运行结果：I am a student
 
abstract class Person{
    private String name ; // 属性
    public String getName(){ // 普通方法
        return this.name;
    }
    public void setName(String name){
        this.name = name ;
    }
    
    public abstract void getPersonInfo() ; //抽象方法

    public static Person getInstance() { //取得A类对象
    	//定义抽象类的子类 （内部类）
        class Student extends Person {  
            public void getPersonInfo() {
                System.out.println("I am a student");
            }
        }
        return new Student();
    }
}

public class Test{
    public static void main(String[] args) {
        Person per = Person.getInstance();
        per.getPersonInfo() ; //被子类所覆写的方法
    }
}

运行结果：I am a student
 
3.抽象类的相关规定
 
 
 
（1）抽象类也提供构造方法，并且子类也遵循对象实例化流程：先调用父类构造方法，再调用子类构造方法
 
 
abstract class Person{
	private String name;
	public String getName(){
		return name;
	}
	
	//父类构造方法
	public Person(){
		System.out.println("1.**************");
	}

	//抽象方法
	public abstract void fun();
}

class Student extends Person{
	//子类构造方法
	public Student(){
		System.out.println("2.##############");
	}

	public void fun(){
		System.out.println("子类继承抽象类");
	}
}
public class Test{
	public static void main(String[] args){
		new Student();//先调用父类构造方法，再调用子类构造方法
	}
}

运行结果：
1.**************
2.##############
 
//面试题

abstract class Person{
	public Person(){//3.调用父类构造
		this.print();//4.调用被子类覆写的方法
	}
	public abstract void print();//抽象方法
}

class Student extends Person{
	private int num = 100;//此句在对象new成功后才会用到，此句告诉构造方法要将num赋值为100
	public Student(int num){//2.调用子类实例化对象
		// super();//3.隐含这一句，实际要先调用父类构造。此时还未执行“将num赋值为100”的操作，就去调用父类构造了。num默认为int的默认值0。
		//num=100;//此句在构造方法中隐式实现。
		//总的来说，构造方法会隐藏  给变量的赋值操作。 
		
		this.num=num;//7.为类中属性初始化
	}
	public void print(){//5.此时子类对象的属性还没有被初始化
		System.out.println(this.num);//6.输出其对应数据类型的默认值，为0
	}
}

public class Test{
	public static void main(String[] args){
		//先调用父类构造方法，再调用子类构造方法。调用父类构造后，调用打印方法，输出num的值0。调用子类构造，在内存中完成num赋值为30，但并未调用打印方法，因而只有一个值。
		new Student(30);//1.实例化子类对象
	}
}
//父类中num=0，子类中num=30。但由于子类中没有调用打印方法，所以只有一个父类的num值，为0。
运行结果：0
 
 
 
（2）抽象类中可以不定义抽象方法，但仍然无法直接实例化对象。
 
 （3）abstract与final、private不能一起用。
 
 
final声明的类不允许有子类，而abstract抽象类必须有子类。
抽象方法必须要被覆写，因此不能用private封装。
 （4）抽象类也分为内部抽象类和外部抽象类。
内部抽象类（了解）可以使用static定义来描述外部抽象类
 
 如果此时在外部抽象类中使用static就会出现语法错误，但是内部抽象类允许使用static
 
 
//内部抽象类使用static修饰

abstract class A{//此结果出现几率很低
	public abstract void printA();
	static abstract class B{
		public abstract void printB();
	}
}
class x extends A.B{
	public void printB(){}
}
 
注意：对象实例化的核心步骤
  ①类加载
  ②类对象的空间开辟
  ③类对象中的属性初始化（构造方法）
 
方法可以重写，属性不能重写。