抽象Abstract

• 不能被实例化(即不能有New...)只能被当做父类，且必须被继承，如果子类不是抽象类的话，就需要实现抽象父类的所有方法
• abstract是说必须继承、重载
• abstract和final不能同时修饰一个类
• abstract只能修饰类，方法，不能修饰属性
• 抽象方法中不能指定程序体，即不能有{}，参数表之后直接用 ; 结束
• abstract方法所在的类必须是abstract类

 

在类中声明一个方法，这个方法没有实现体，是一个“空”方法

这样的方法就叫抽象方法，使用修饰符“abstract" ​，当一个类有抽象方法的时候，该类必须被声明为抽象类

添加一个getDescripition方法，可以返回对一个人的简短描述。在Person类中提供什么内容呢？
除了名字，Person类一无所知。使用abstract关键字，
public abstract String getDescripition();为了程序的清晰度，包含一个或多个抽象方法的类本身也要被声明为抽象的。

abstract class Person
{
  public Person(String n)//姓名
  {
   name = n;
  }
  public abstract String getDescripition(); 
  
  publci String getName()//返回姓名的方法
  {
    return name;
  }
   private String name;
}

抽象方法充当占位的角色，集体实现在子类中。扩展抽象类可以有两种选择。一种是在子类中定义部分抽象方法，这样子类必须标记为抽象类；另一种是定义全部的抽象方法，这样一来，子类就不是抽象的了。
例如，通过扩展抽象Person类，并实现getDescription方法来定义Student类。由于在Student类中不在含有抽象方法，所以不必将Stedent类声明为抽象类。
1.类即使不含有抽象方法，也可以将类声明为抽象类。
2.抽象类不能被实例化，表达式new Person（"wu"）是错的
3.值得注意的是，可以定义一个抽象类Person的对象变量，但是它只能引用非抽象子类的对象。
Person p =new Student（"wu","Economics"）;
这里的p是抽象类person的变量，它引用了一个非抽象子类Student的实例。

import java.util.*;


public class PersonTest{
	public static void main(String[] args) {
		Person[] people=new Person[2];
		people[0]=new Employee("jack",5000,1997,2,2);
		people[1]=new Student("dick","computer");
		
		for(Person p:people) {
			System.out.println(p.getName()+":"+p.getDescription());
		}
	}
}
abstract class Person
{
  public Person(String n)//姓名
  {
   name = n;
  }
  public abstract String getDescription(); 
  
  public String getName()//返回姓名的方法
  {
    return name;
  }
   private String name;
}
class Employee extends Person
{
public  Employee(String n,double s,int year,int month,int day)
{
	super(n);
	salary=s;
	GregorianCalendar calendar=new GregorianCalendar(year ,month-1,day);
	hireday=calendar.getTime();
}

public double getSalary() {
	return salary;
}

public Date getHireday() {
	return hireday;
}
public String getDescription()
{
  return String.format("薪水是：%f元%n", salary);
}
public void raiseSalary(double byPercent) {
	double raise=this.salary+byPercent /100;
	this.salary+=raise;
}
private double salary;
private Date hireday;
}
class Student extends Person
{
	public Student(String n,String m)
	{
	 super(n);
	 major=m;
	}
	public String getDescription()
	{
		return "学生主修"+major;
	}
	private String major;
}

 

抽象方法没有方法体，不能被直接调用，必须在子类overriding后才能使用

1.static：用来声明静态方法，静态方法可以被类及其对象调用

static与abstract方法不能同时使用

（why） 用static声明方法表明这个方法在不生成类的实例时可直接被类调用，而abstract方法不能被调用，两者矛盾。

2.synchronized：用于防止多个线程同时调用一个对象的该方法，与static连用可防止多个线程同时调用一个类的该方法

abstract方法与synchronized不能同时使用

（why） 从synchronized的功能也可以看出，用synchronized的前提是该方法可以被直接调用，所以不行

 

抽象类和接口的区别

我的理解是

把接口当成一个协议，实现了这个接口（协议）的类就应该实现接口中的方法（协议内的条例），接口是约束调用本接口的类，

抽象类则是让继承此类的子类一定要实现某个方法。例如取快递是一个抽象类，签收是抽象方法，那么一定要实现签收方法才能完成取快递。

区别1：
子类只能继承一个抽象类，不能继承多个
子类可以实现多个接口
区别2：
抽象类可以定义
public,protected,package,private
静态和非静态属性
final和非final属性
但是接口中声明的属性，只能是
public
静态
final的
即便没有显式的声明

注: 抽象类和接口都可以有实体方法。 接口中的实体方法，叫做默认方法（default修饰符）