Java教程

九、Java抽象类

本文主要是介绍九、Java抽象类,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

概念:

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

类: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;
	}
}

无奈源于不够强大

 

这篇关于九、Java抽象类的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!