抽象类、abstract关键字

标签：子类 void System public 关键字 抽象类 abstract

目录

• abstract关键字
• 抽象类的匿名子类
• 抽象类的应用：模板方法的设计模式

abstract关键字

1. abstract:抽象的
2. abstract可以用来修饰的结构：类、方法
3. abstract修饰类：抽象类

此类不能实例化
抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作

4. abstract修饰方法：抽象方法

抽象方法只有方法的声明，没有方法体

• 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
• 若子类重写了父类中的所有的抽象方法后，此子类方可实例化
• 若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

abstract class Creature{
	public abstract void breath();
}

abstract class Person extends Creature{
	String name;
	int age;
	
	public Person(){
		
	}
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}	
	//不是抽象方法：
//	public void eat(){
//		
//	}
	//抽象方法
	public abstract void eat();
	
	public void walk(){
		System.out.println("人走路");
	}	
}

class Student extends Person{	

	public Student(String name,int age){
		super(name,age);
	}
	public Student(){
	}
	
	public void eat(){
		System.out.println("学生多吃有营养的食物");
	}
	@Override
	public void breath() {
		System.out.println("学生应该呼吸新鲜的没有雾霾的空气");
	}

abstract使用上的注意点：

1. abstract不能用来修饰：属性、构造器等结构
2. abstract不能用来修饰私有方法、静态方法、final的方法、final的类

抽象类的匿名子类

public class PersonTest {	
	public static void main(String[] args) {		
		method(new Student());//匿名对象		
		Worker worker = new Worker();
		method1(worker);//非匿名的类非匿名的对象		
		method1(new Worker());//非匿名的类匿名的对象		
		System.out.println("********************");		
		//创建了一匿名子类的对象：p
		Person p = new Person(){
			@Override
			public void eat() {
				System.out.println("吃东西");
			}
			@Override
			public void breath() {
				System.out.println("好好呼吸");
			}			
		};		
		method1(p);
		System.out.println("********************");
		//创建匿名子类的匿名对象
		method1(new Person(){
			@Override
			public void eat() {
				System.out.println("吃好吃东西");
			}
			@Override
			public void breath() {
				System.out.println("好好呼吸新鲜空气");
			}
		});
	}		
	public static void method1(Person p){
		p.eat();
		p.breath();
	}	
	public static void method(Student s){
		
	}
}

class Worker extends Person{
	@Override
	public void eat() {
	}
	@Override
	public void breath() {
	}	
}

抽象类的应用：模板方法的设计模式

public class TemplateTest {
	public static void main(String[] args) {		
		SubTemplate t = new SubTemplate();		
		t.spendTime();
	}
}

abstract class Template{	
	//计算某段代码执行所需要花费的时间
	public void spendTime(){		
		long start = System.currentTimeMillis();		
		this.code();//不确定的部分、易变的部分		
		long end = System.currentTimeMillis();	
		System.out.println("花费的时间为：" + (end - start));		
	}	
	public abstract void code();		
}

class SubTemplate extends Template{
	@Override
	public void code() {		
		for(int i = 2;i <= 1000;i++){
			boolean isFlag = true;
			for(int j = 2;j <= Math.sqrt(i);j++){				
				if(i % j == 0){
					isFlag = false;
					break;
				}
			}
			if(isFlag){
				System.out.println(i);
			}
		}
	}	
}

本文由mdnice多平台发布

标签：子类,void,System,public,关键字,抽象类,abstract
From： https://www.cnblogs.com/CGB1804Great/p/16891076.html