java中抽象类

一、抽象类的概念

类--用来描述具有共同性质的一组事物的自定义复合数据类型
类--class关键字创建
        public class Hello{} --- 类
抽象类--通过abstract 修饰的java类就是。
        public abstract class Hello{}---抽象类

二、为什么要有抽象类？ 

例如:坐车收费，出租车有收费功能【1元/公里】，
                           公交车有收费功能【全程1元】。
    出租车/公交车----汽车---收费功能
    出租车 extends 汽车 ---重写收费功能---【1元/公里】
    公交车 extends 汽车 ---重写收费功能--- 【全程1元】
    我们可以理解为汽车就是一个抽象类，出租车/公交车都是汽车的子类，出租车/公交车就会从汽车中继承来收费功能然后在根据自身的实际情况，重写收费功能就可以得到属于自己的收费功能实现。
    抽象类的子类往往都是同一种类型。
    抽象类实际上就是提供同一种类型事物的公共内容，由抽象类的子类根据自身的实际情况，来实现这个抽象类提供的公共内容。这样子类就不需要创建这个公共内容，只需要继承来重写一下就好。

三、抽象类可以有哪些元素

类--实例变量，静态成员变量，构造方法，实例方法，静态方法
抽象类--实例变量，静态成员变量，构造方法，实例方法，静态方法，【抽象方法】
误区？判断一个类是不是抽象类不看有没有抽象方法。
方法基本格式:修饰符  返回值  名称([参数]){方法体}
实例方法:修饰符  返回值  名称([参数]){方法体}
静态方法:修饰符 static  返回值  名称([参数]){方法体}
构造方法：修饰符    类名([参数]){方法体}
抽象方法：修饰符 abstract 返回值  名称([参数])
抽象方法--使用abstract修饰的没有方法体的方法

例如：

package com.wangxing.test1;
/**
 * 创建抽象类
 * @author 联想
 *
 */
public abstract class abstractClass {
	//在抽象类中创建实例成员变量
	public String name="zhangsan";
	//在抽象类中创建静态成员变量
	public static int int1=1001;
	//在抽象类中创建实例方法
	public int abstractClass(int num){
		int num1=num;
		return num1;
	}
	//在抽象类中创建静态方法
	public static double  testmethod1(int num){
		return num;
	}
	//创建抽象方法
	public abstract void testmethod2();
}

 四、抽象类的具体用法

1.抽象类不能new,借助子类访问抽象类中的实例元素。
2.普通的java类继承了抽象类，就需要重写抽象类中的所有抽象方法，否则将这个普通的java类改成抽象类。
3.抽象类可以继承其他的抽象类，可以不用重写抽象方法。
4.利用上转型对象创建出抽象类对象
5.抽象类对象可以访问抽象类中的实例变量、类变量、构造方法、实例方法、类方法、【抽象方法实际上是子类重写以后的方法】。
6.当某一个普通的java类中的方法参数是抽象类类型的时候，可以传递上转型对象，也可以是抽象类的子类对象。

例如：
创建抽象类的父类

package com.wangxing.test2;
/**
 * 创建抽象类父类
 * @author 联想
 *
 */
public abstract class abstractFuClass {
	//创建抽象类的实例标变量
	String name="zhangsan";
	static int int1=1001;
	public abstractFuClass(){
		System.out.println("abstractFuClass抽象类的构造方法");
	}
	//创建抽象类的实例方法
	public void abstractShiLi(){
		System.out.println("abstractFuClass抽象类的实例方法");
	}
	//创建抽象类的方法
	public abstract void abstractMethod1();
}

创建抽象类的子类

package com.wangxing.test2;
public class sunClass extends abstractFuClass{
	//抽象类不能创建对象
	//new abstractFuClass();
	//重写从抽象父类继承的抽象方法
	@Override
	public void abstractMethod1() {
		System.out.println("sunClass重写的抽象类方法");
		sunClass sc = new sunClass();
		sc.abstractShiLi();
		System.out.println(sc.int1);
	}
	//重写父类的abstractShiLi方法
	//此时调用子类sunClass因为重写了这个方法，结果是sunClass里的结果
	public void abstractShiLi(){
		System.out.println("sunClass抽象类的实例方法");
	}
}

创建普通类参数为抽象类型

package com.wangxing.test2;
public class puTongClass{
	public void testMethod(abstractFuClass sc){
		System.out.println("普通类中方法参数为抽象类型");
	}
}

测试类

package com.wangxing.test2;
public class main {
	public static void main(String[] args) {
		sunClass su=new sunClass();
		//此时调用子类sunClass因为重写了这个方法，结果是sunClass里的结果
		su.abstractShiLi();
		//利用上转型对象创建出抽象类对象调用父类的
		//上转型对象--子类的对象赋值给父类的变量
		//此时得到抽象类的对象只能调用抽象类的方法变量
		abstractFuClass afc =new sunClass();
		afc.abstractShiLi();
		//如果想要再获得子类的重写后的方法可以对这个进行强制转换
		sunClass sc = (sunClass)afc;
		//此时得到的是重写后的方法，此时也可以调用抽象类的其他方法变量
		sc.abstractShiLi();
		
		//测试普通类参数是抽象类型
		puTongClass ptc = new puTongClass();
		ptc.testMethod(afc);
		ptc.testMethod(sc);
	}

}

 五、上转型对象

上转型对象--子类的对象赋值给父类的变量，此时子类对象就向上转型成父类对象
上转型对象不能方法子类本身的变量和方法，如果我们需要访问子类本身的变量和方法，需要通过强制类型转换
例如:利用上转型对象创建出抽象类对象
父类

package com.wangxing.test3;
/**
 *创建抽象类的作为父类
 * @author 联想
 *
 */
public abstract class abstractFuClass {
	public abstractFuClass(){
		System.out.println("抽象类abstractFuClass的构造方法");
	}
	//创建一个实例方法
	public void testMethod(){
		System.out.println("抽象类abstractFuClass的实例方法");
	}
}

子类

package com.wangxing.test3;
/**
 * 创建abstractFuClass的子类
 * @author 联想
 *
 */
public class sunClass extends abstractFuClass{
	int int1=1001;
	public sunClass(){
		super();//默认被隐藏
		System.out.println("sunClass的构造方法");
	}
	//对abstractFuClass抽象类的testMethod重写
	public void testMethod(){
		System.out.println("sunClass的实例方法");
	}
}

测试类

package com.wangxing.test3;
public class main {
	public static void main(String args[]){
		//创建子类的对象
		sunClass sun=new sunClass();
		//调用子类的testMethod方法只能使用对象调用
		//此时得到的是子类中的方法因为方法被重写了
		sun.testMethod();
		//此时调用父类中的方法就要上转型对象
		//此时得到的是父类抽象类的对象，只能调用父类的方法和变量
		abstractFuClass afc = new sunClass();
		afc.testMethod();
		//上转型对象不能方法子类本身的变量和方法，如果我们需要访问子类本身的变量和方法，需要通过强制类型转换
		sunClass sc =(sunClass)afc;
		System.out.println("sunClass的int1="+sc.int1);
	}
}

六、卖水果实例 

创建水果的抽象类创建一个价格方法作为共有功能

package com.wangxing.test4;
public class xiguo extends shuiGuo {
	int price=4;
	@Override
	public void price() {
		System.out.println("西瓜的价格为："+price+"元/斤");
	}
}

创建不同水果继承抽象类子类，并重组功能
苹果类

package com.wangxing.test4;
public class apple extends shuiGuo{
	int price=10;
	@Override
	public void price() {
		System.out.println("苹果的价格为："+price+"元/斤");
	}
}

西瓜类

package com.wangxing.test4;
public class xiguo extends shuiGuo {
	int price=4;
	@Override
	public void price() {
		System.out.println("西瓜的价格为："+price+"元/斤");
	}
}

创建测试类
当客户输入要购买的水果名称得到他的价格

package com.wangxing.test4;
import java.util.Scanner;

public class main {
	public static void main(String args[]){
		boolean fag = true;
		while(fag){
			Scanner scn=new Scanner(System.in);
			System.out.println("请输入您要购买的水果：");
			String sg=scn.next();
			if(sg.equals("苹果")){
				apple ap=new apple();
				ap.price();
			}
			if(sg.equals("西瓜")){
				xiguo xg=new xiguo();
				xg.price();
			}
			if(!sg.equals("苹果")&&!sg.equals("西瓜")){
				System.out.println("我们超市没有此水果");
				fag=false;
			}
		}
	}
}