abstract关键字

抽象类:实现多态机制

abstract关键字一般用来定义抽象类，和抽象方法。(抽象类也是类，只不过包含抽象方法)

抽象类的一大优点:可以充分利用公共属性来提高开发和维护程序的效率。

对于抽象类与抽象方法的限制:

  • 抽象类可以有零个或多个抽象方法，也可以包含非抽象的方法。
  • 抽象类中可以没有抽象方法，但是有抽象方法的一定是抽象类。
  • 对于抽象方法来说，在抽象类中只指定其方法及其类型，而不书写其实现代码。
  • 抽象类不能创建对象，创建对象的工作由抽象类派生子类来实现。
  • 如果父类中已有同名的abstract方法，则子类中就不能再有同名的抽象方法。
  • abstract不能与final并列修饰同一个类。
  • abstract不能与private，static，final或native并列修饰同一个方法。

1.创建动物抽象类

package AbstractKey;
/*
 * 抽象类
 * 	抽象类除了不能实例化对象之外，类的其它功能依然存在，
 * 	成员变量、成员方法和构造方法的访问方式和普通类一样。
 * 
 * 	此案例用动物类说明
 * 	Animal是动物体系最顶级的
 * 		主要用于定义有哪些功能，
 * 		一旦类中定义有抽象的方法，那么这个类就是抽象类。
 * 		但是抽象类中不一定有抽象方法。
 * 
 * */

public abstract class Animal {
	
	// 属性
	private String name;
	private int age;
	
	// 构造方法
	public Animal() {
		
	}
	
	// 抽象方法,不实现(没有方法体即{})
	public abstract void eat();
	
	// 非抽象成员方法get,set方法
	public void setName(String name) {
		 = name;
	}
	public String getName() {
		return name;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getAge() {
		return age;
	}
}

2.创建dog类继承动物类

package AbstractKey;

/*
 * 狗类继承动物类
 *  一旦一个类 继承了 抽象类(抽象类中有抽象方法)
 *  那么这个类
 *         要么重写抽象方法
 *         要么将此类也修饰为抽象类
 */
public abstract class Dog extends Animal {
	// 狗的私有属性---品种
	private String type;
	
	// 狗的特有功能
	public void funcation() {
		System.out.println("Dog function");
	}

	public void setType(String type) {
		this.type = type;
	}
	public String getType() {
		return type;
	}
}

3.创建猫类继承动物类

package AbstractKey;
/*
 * 猫类
 * 	继承动物类
 * 
 * */
public class Cat extends Animal{
	
	// 定义猫的属性
	private String type;
	
	
	// 重写父类中的抽象方法
	@Override
	public String eat() {
		return "Cat eat";
	}
	
	// 特有功能
	public void function() {
		System.out.println("Cat function");
	}
	
	// 成员方法
	public void setType(String type) {
		this.type = type;
	}
	public String getType() {
		return type;
	}
}

5.测试类

package AbstractKey;
/*
 * 测试抽象类
 * 
 * */
public class Test {
	public static void main(String[] args) {
		// 多态，向上转型
		Animal cat = new Cat();
		cat.eat();
		
		// 向下转型，调用子类对象特有的功能
		Cat c = (Cat)cat;
		System.out.print("调用猫类中的catchMouse方法: ");
		c.function();
		c.setType("狸花猫");
		System.out.println("输出猫的品种:"+c.getType());
		System.out.println("----------------");
		
		// Dog是抽象类，不能创建对象，但可以通过匿名内部类进行实例化
		Animal dog = new Dog(){
			@Override
			public String eat() {
				return "通过匿名内部类重写狗吃饭";
			}
		};
		System.out.println("调用dao中的eat方法:"+dog.eat());
		
		// 向下转型为Dog类型
		Dog d = (Dog)dog;
		// 子类是抽象方法，可以重写(也可以不重写)eat()方法
		System.out.println("转型为Dog的对象调用eat方法:"+d.eat());
		d.funcation();
		System.out.println("--------------------");
		
		// 创建一个匿名内部类对象，会自动生成重写抽象类中的方法
		Animal animal = new Animal() {
			
			@Override
			public String eat() {
				return "动物吃饭";
			}
		};
		System.out.println(animal.eat());
	}
}

运行结果:

调用猫类中的catchMouse方法: Cat function
输出猫的品种:狸花猫
----------------
调用dao中的eat方法:通过匿名内部类重写狗吃饭
转型为Dog的对象调用eat方法:通过匿名内部类重写狗吃饭
Dog function
--------------------
动物吃饭