抽象类概述

一.抽象类的概述：
(1).如果类里有抽象方法,那么这个类必须修饰成抽象类.
(2).如果一个方法,没有方法体,那么这个方法必须是一个抽象方法.
(3).抽象类是程序设计的结果,用来优化父类的.

二.抽象类的特点：

通过java关键字abstract实现
可以修饰方法或者类
抽象类中可以没有抽象方法（由子类去实现）
如果类中有抽象方法，那该类必须定义为一个抽象类
子类继承了抽象类以后，要么还是一个抽象类，要么就把所有抽象方法都重写
多用于多态中
抽象类不可以被实例化

举个例子：

//测试 抽象类的特点
public class Test1_Abstract {
		public static void main(String[] args) {
				//TODO 抽象类不能被实例化
		//		Fu f = new Fu();
				Fu f = new Zi();//多态
				//多态对象,只能调用父类的功能
				f.eat();
				f.he();
		}
}
//TODO 1,抽象类是程序设计的结果,不提供了方法体
//TODO 3,类里包含抽象方法,就是一个抽象类
//TODO 4,抽象类灵活,可以有普通方法,也可以是抽象方法
abstract class Fu{
	public void eat(){
		System.out.println("吃饭");
	}
	//TODO 2,没有方法体的方法叫 抽象方法
	abstract public void he();
}
//TODO 子类继承抽象类以后,可以是一个抽象的子类
//abstract class Zi extends Fu{  }
//TODO 子类继承抽象类以后,可以重写抽象方法
//TODO 子类需要重写哪些方法?
//抽象方法必须重写,否则是一个抽象的子类
//普通方法不必须,,,想改的时候才重写
class Zi extends Fu{
	//重写抽象方法:
	//	abstract public void he();
		@Override
		public void he() {
			System.out.println("喝茶");
		} 
}

三.抽象类的使用
1,构造方法/成员变量
1,抽象类里 有 构造方法,不是为了自己new,为了子类new
2,抽象类里 有变量,有常量
3,常量的值一旦定义就不能改了.
4,继承时,除了private和构造方法,都可以被继承的

举个例子：

public class Test2_Use {
	public static void main(String[] args) {
		//TODO 
		Fu2 f = new Zi2();
		f.name = "小芳" ;//修改变量的值
		System.out.println(f.name);//获取变量的值
			
		//Fu2.MAX_VALUE = 120;//常量的值不能改
	}
}
abstract class Fu2{
	//TODO 1,抽象类里可以有 -- 构造函数
	//构造方法用来new,抽象类不能new?--为了子类new
	public Fu2(){
		System.out.println(1);
	}
	//TODO 2,抽象类里可以有 -- 成员变量
	String name = "小潘" ;
	//TODO 3,抽象类里可以有 -- 常量 
	public static final int MAX_VALUE = 127;
			
}
class Zi2 extends Fu2{ 
	public Zi2(){
		super();
		System.out.println(2);
	}
}

2,成员方法
1,抽象类很灵活,因为可以有普通方法也可以有抽象方法
2,子类继承抽象类以后,要么就还是一个抽象类(包含着抽象方法)要么是重写 所有 抽象方法
3,子类怎么决定到底要重写哪个方法呢?
（1）.对于普通方法,想改就重写
（2）.对于抽象方法,不重写全 的话,就是一个抽象的子类

举个例子：

public class Test3_Use {
	public static void main(String[] args) {
	//TODO 
	}
}
//TODO 抽象类里都是抽象方法
abstract class Fu3{
	abstract void save1();
	abstract void save2();
	abstract void save3();
}
abstract class Zi3 extends Fu3{
	//要么是一个抽象的类,要么重写所有抽象方法
	//	abstract void save1();
	void save1(){
		System.out.println(1);
	}
}
//TODO 抽象类里都是普通方法
abstract class Fu4{
	public void delete1(){System.out.println(1);}
	public void delete2(){System.out.println(2);}
	public void delete3(){System.out.println(3);}
}
class Zi4 extends Fu4{
	//由于抽象类里,没有抽象方法,都是普通方法
	//普通方法不是必须重写的??想改时才重写.
}
//TODO 抽象类里有普通方法和抽象方法
abstract class Fu5{
	public void get1(){
		System.out.println(1);
	}
	abstract public void get2();
}
class Zi5 extends Fu5{
	//重写 所有的 抽象方法,否则是一个抽象的子类
	public void get2(){
		System.out.println(2);
	}
}