Abstract 抽象类

抽象类的定义

1.使用abstract关键字定义的类是抽象类

2.抽象类中允许定义抽象方法

3.抽象方法使用abstract关键字定义的方法，并且没有方法体

4.抽象父类中如果存在抽象方法，则子类必须实现该方法

抽象类的使用

1.抽象类不允许实例化(不能new对象)

/*

* 抽象类的语法总结

* 语法1:使用abstract关键字定义的类

* 语法2:在抽象类中，允许定义“抽象方法”,“普通方法”,“构造方法”

* 语法3:子类继承抽象父类，必须对父类中的抽象方法进行“重写”

* 语法4:抽象类不允许被实例化”

*/

 

package com.ztt.Demo01Pet;

//父类:宠物类
//抽象类的定义
//1.使用abstract关键字定义的类是抽象类
//2.抽象类中允许定义抽象方法
//3.抽象方法使用abstract关键字定义的方法，并且没有方法体
//4.抽象父类中如果存在抽象方法，则子类必须实现该方法

//抽象类的使用
//1.抽象类不允许实例化(不能new对象)
public abstract class Pet {
	
	//抽象方法
	public abstract void eat();
}

//子类：猫
class Cat extends Pet{
	//子类必须实现父类Pet的抽象方法eat()
	public void eat() {
		System.out.println("猫吃： 鱼、猫条、冻干....");
	}
}

//子类：狗
class Dog extends Pet{
	//子类必须实现父类Pet的抽象方法eat()
	public void eat() {
		System.out.println("狗吃： 狗粮、骨头、肉....");
	}
}

测试类：

package com.ztt.Demo01Pet;

public class test1 {

	public static void main(String[] args) {
		// 抽象类不能被实例化
		//Pet p=new Pet();
		
		Cat c=new Cat();
		Dog d=new Dog();
		Pet x=new Dog();
		
		ans(c);
		ans(d);
		ans(x);
	}
		//使用父类作为方法参数类型，可以传入任意一个子类对象
		public static void ans(Pet pet) {
			//通过父类的引用，调用eat()方法
			//运行期间，根据pet指向的子类对象，调用不同子类的eat()方法
			pet.eat();
			
//			if(pet instanceof Cat) {
//				Cat cat=(Cat)pet;
//				cat.eat();
//			}else if(pet instanceof Dog) {
//				Dog dog=(Dog)pet;
//				dog.eat();
//			}
		}
		

	

}

运行结果：

猫吃： 鱼、猫条、冻干....
狗吃： 狗粮、骨头、肉....
狗吃： 狗粮、骨头、肉....

Override 重写

发生在子类中,是对父类中的方法进行"覆盖",方法名和参数必须与父类中的方法保持一致

package com.ztt.Demo02Order;

import java.util.UUID;

//订单类(父类)
public abstract class Order {
	private String orderNo;
	//无参构造方法
	public Order() {
		orderNo = UUID.randomUUID().toString();
	}
	//发送消息(抽象方法)
	public abstract void message();
	public String getOrderNo() {
		return orderNo;
	}
	public void setOrderNo(String orderNo) {
		this.orderNo = orderNo;
	}
}
//滴滴打车订单(子类)
class DidiOrder extends Order{
	//Override 重写
	//发生在子类中,是对父类中的方法进行"覆盖",方法名和参数必须与父类中的方法保持一致
	@Override
	public void message() {
		System.out.println(super.getOrderNo()+":您的专车司机已经到达指定地点,请尽快上车!");
	}
	//重写object父类的toString方法
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return String.format("【滴滴专车订单】订单编号:%s", super.getOrderNo());
	}
}
//美团外卖订单(子类)
class MeituanOrder extends Order{
	//Override 重写
	//发生在子类中,是对父类中的方法进行"覆盖"
	//方法名和参数必须与父类中的方法保持一致
	@Override
	public void message() {
		System.out.println(super.getOrderNo()+":您的外卖送餐已送达,请尽快用餐!");
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return String.format("【美团外卖订单】订单编号:%s", super.getOrderNo());
	}
}

测试类：

package com.ztt.Demo02Order;

public class test1 {

	public static void main(String[] args) {
		 DidiOrder order1=new  DidiOrder();
//		 order1.message();
		 MeituanOrder order2=new MeituanOrder();
//		 order2.message();
		 
		//重写0bject类的toStirng()方法后
		//运行期间按照子类对象的不同，调用该子类对象重写后的toString()方法
		 System.out.println(order1);
		 System.out.println(order2);

	}

}

运行结果：

【滴滴专车订单】订单编号:b3c04644-b615-4921-9b5b-01a705095826
【美团外卖订单】订单编号:f51b27b4-79f1-467e-91a0-d49b85514756

 

package com.ztt.Demo03AbstractClass;
/*
 * 抽象类的语法总结
 *  语法1:使用abstract关键字定义的类
 *  语法2:在抽象类中，允许定义“抽象方法”,“普通方法”,“构造方法”
 *  语法3:子类继承抽象父类，必须对父类中的抽象方法进行“重写”
 *  语法4:抽象类不允许被实例化”
 */

public abstract class AbstractClass {
	//常量
	public static final int MAX =251;
	
	//构造方法
	public AbstractClass() {
		
	}
	
	//抽象方法
	public abstract void dosth();
	
	//普通方法
	public void work() {
		
	}
	
	//子类
	abstract class Ext extends AbstractClass{
		public abstract void dolist();
	}
	
	class Son extends Ext{
		public void dolist() {
			
		}
		
		public void dosth() {
			
		}
	}
	

}