概念：

类：用来描述具有共同性质的一组事物的自定义复合数据类型

类：class关键字创建

public class Hello{} ---> 类

抽象类:   通过abstract 修饰的java类就是。

public abstract class Hello{} --> 抽象类

1)为什么要有抽象类？

例如:

        坐车收费，出租车有收费功能【1元/公里】，

        公交车有收费功能【全程1元】。

出租车/公交车----->汽车--->收费功能

出租车 extends 汽车 ---->重写收费功能 = 【1元/公里】

公交车 extends 汽车 --->重写收费功能 =【全程1元】

       我们可以理解为汽车就是一个抽象类，出租车/公交车都是汽车的子类，出租车/公交车就会从汽车中继承来收费功能然后在根据自身的实际情况，重写收费功能就可以得到属于自己的收费功能实现。

抽象类的子类往往都是同一种类型。

抽象类实际上就是提供同一种类型事物的公共内容，由抽象类的子类根据自身的实际情况，来实现这个抽象类提供的公共内容。这样子类就不需要创建这个公共内容，只需要继承来重写一下就好。

抽象的部分     子类如果不是抽象类，那么这个重写就是强制性的，必须重写

2）抽象类中可以有哪些元素？

      局部变量不能在其他的方法中访问（不需要考虑）

类 ： 实例变量，静态成员变量，构造方法，实例方法，静态方法

抽象类： 实例变量，静态成员变量，构造函数，实例方法，静态方法，[抽象类]（可有可无）。

误区 : 判断一个类是不是抽象类不是看有没有抽象方法。而是看 当前类有没有abstract 修饰

方法基本格式:

修饰符  返回值  名称([参数]){方法体}

实例方法:

修饰符  返回值  名称([参数]){方法体}

静态方法:

修饰符 static  返回值  名称([参数]){方法体}

构造方法：

修饰符    类名([参数]){方法体}

抽象方法：

修饰符 abstract 返回值  名称([参数])

抽象方法: 使用abstract修饰的没有方法体的方法

例子：

public abstract class AbstractTest {
	public static String name  = "张三";
	public int age = 16;
	public AbstractTest(){
		System.out.println("抽象类的构造方法");
	}
	
	public void methods(){
		System.out.println("抽象类的实例方法");
	}
	
	public static void staticMethods(){
		System.out.println("抽象类的静态方法");
	}
	//抽象方法
	public abstract void fn();
}

3)抽象类的具体用法

(1).抽象类不能new,借助子类访问抽象类中的实例元素。

(2).普通的java类继承了抽象类，就需要重写抽象类中的所有抽象方法，否则将这个普通的java类改成抽象类。

(3).抽象类可以继承其他的抽象类，可以不用重写抽象方法。

(4).利用上转型对象创建出抽象类对象

(5).抽象类对象可以访问抽象类中的实例变量、类变量、构造方法、实例方法、类方法、【抽象方法实际上是子类重写以后的方法】。

(6).当某一个普通的java类中的方法参数是抽象类类型的时候，可以传递上转型对象，也可以是抽象类的子类对象。

例子（2）（3）：

① 普通类继承抽象类
class Fdr extends AbstractTest1{

	@Override
	public void fn() {
		// 必须实现这个方法
	}
}
② 抽象类继承抽象类
Class abstract Fdr extends AbstractTest1{
    // 可以不实现这个方法
}

//抽象类
 abstract class AbstractTest1 {
	public static String name  = "张三";
	public int age = 16;
	public AbstractTest1(){
		System.out.println("抽象类的构造方法");
	}
	
	public void methods(){
		System.out.println("抽象类的实例方法");
	}
	
	public static void staticMethods(){
		System.out.println("抽象类的静态方法");
	}
	//抽象方法
	public abstract void fn();
}

例子（4）

利用上面的例子：

AbstractTest1  abt  =  new Fdr();

抽象类   变量  = new 子类（）;

这个子类必须继承声明的抽象类，并且子类不能是new 的子类不能是抽象类

例子（5）（6）

public class MainTest1 {
	public static void main(String[] args) {
		AbstractClass b = new B();
		b.sayHi();
		((B) b).methods(); //强制转换成子类不然报错
	}
}

//抽象类
abstract class AbstractClass {
	public String name = "李四";
	//抽象说方法
	public abstract void sayHi();
}
//B类继承抽象类
class B extends AbstractClass{
	
	@Override
	// 重写AbstractClass类中得抽象方法
	public void sayHi() {
		System.out.println("你好呀" + super.name);
	}
	public void methods(){
		System.out.println("我是实例方法");
	}
}

4)上转型对象

1.上转型对象：子类的对象赋值给父类的变量，此时子类对象就向上转型成父类对象

格式： 

父类 父类变量名 = new 子类（）；

2.上转型对象不能方法子类本身的变量和方法，如果我们需要访问子类本身的变量和方法，需要通过强制类型转

格式 ：

子类 子类变量名  = （子类）父类变量名；

格式 ：
子类 子类变量名  = （子类）父类变量名；

抽象类例子解析：
卖水果实例↓
1.需要有一个容纳水果得水果地类
2.需要可以购买水果得方法
3.有各种不同的水果
4.水果有不同的名字
5.水果有颜色

抽象类应该 ： 
水果的名,颜色，（是否可以卖），抽象方法：生产方法
苹果类：实现父类的方法
香蕉类：实现父类的方法

店铺类：
属性：店铺名字
方法：进水果：店铺到对应的水果地里进相应水果

public class BuyFruits {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//	进了10斤红的苹果
		//  进了10斤白的苹果
		// 	进了20斤黄香蕉
		Fruites f1 = new Ipone("苹果", '红', true); 
		Fruites f2 = new Ipone("苹果", '白', true);
		
		Fruites f3 = new Banana("香蕉", '黄', true);
		
		ShopFruites xiaohong = new ShopFruites(); //创建一个多多水果店
		
		//卖水果进行售卖
		xiaohong.buyFruits(f1);
		xiaohong.buyFruits(f2);
		xiaohong.buyFruits(f3);
	}

}
/*
 * 
 * 店铺类
 * */
class ShopFruites{
	public String name ="多多水果店";
	public void buyFruits(Fruites fruites){
		//是否可以买
		if (fruites.isBuy) {
			switch (fruites.name) {
			case "苹果":
			if (fruites.isBuy) {
				//默认 苹果只有10斤
				int f = fruites.productNmubs(10);
				System.out.println("一共有"+f+"斤");
			}
				break;
			case "香蕉":
				if (fruites.isBuy) {
					//默认 香蕉只有20斤
					int f = fruites.productNmubs(20);
					System.out.println("一共有"+f+"斤");
				}
			default:
				break;
			}
		}
		
	}
}


/**
 * 水果类
 * */
abstract class Fruites{
	public String name;
	public char color;
	public boolean isBuy;
	public Fruites(String name,char color,boolean isBuy) {
		// TODO Auto-generated constructor stub
		this.name = name;
		this.color = color;
		this.isBuy = isBuy;
	}
	public abstract int productNmubs(int i);
}
//生产苹果地
class Ipone extends Fruites{
	public Ipone(String name, char color, Boolean isBuy) {
		super(name, color, isBuy);
		// TODO Auto-generated constructor stub
	}
	@Override
	public int productNmubs(int nums){
		if (isBuy) {
			return nums;
		}
		return 0;
	}
}
//生产香蕉地
class Banana extends Fruites{
	public Banana(String name, char color, Boolean isBuy) {
		super(name, color, isBuy);
		// TODO Auto-generated constructor stub
	}
	@Override
	public int productNmubs(int nums){
		if (isBuy) {
			return nums;
		}
		return 0;
	}
}

无奈源于不够强大