Java——抽象和接口

---

本人是个新手，写下博客用于自我复习、自我总结。
如有错误之处，请各位大佬指出。
参考教材：零基础学Java

---

抽象

抽象是一种建立编程思路的思想。
抽象就是将拥有共同方法和属性的对象提取出来，即提取所有对象的共性，
提取后，重新设计一个更加通用、更加大众化的类，这个类称为抽象类。

抽象类就是指具有共同特性的类，其通过关键字abstract表示。
这些抽象类只是定义了共同特性的方法和属性，但是没有具体实现共同特性的方法。
具有一个抽象或多个抽象方法的类，本身就要定义成抽象类。

所谓的抽象方法就是带关键字abstract表示。抽象类不仅可以有抽象方法，也可以有具体的方法，一个类中只要有一个抽象方法，那么这个类就是抽象类。

抽象类是可以继承的，如果子类没有实现抽象类的全部抽象方法，那么子类也是抽象类。如果实现了抽象类的全部抽象方法，那么子类就不是抽象类。含有抽象方法的类一定是抽象类，但抽象类不一定含有抽象方法，也可以全部都是具体的方法。

抽象类都不能被实例化，即不能使用new来生成实例对象，但可以声明一个抽象类的变量指向具体子类的对象。

抽象类的好处在于，当有的方法在父类中不想实现时，可以不用实现。
抽象类的另一个用处是：在抽象类中定义一个统一的、通用的抽象方法，这个方法允许子类去实现，这样就能保证整个程序的一致性。

例：

public class Abstract {
	public static void main(String args[])//主方法
	{
		student1 s1=new student1();
		student3 s3=new student3();
		s1.setschoolname("理工");
		s1.setclassname("计算机");
		s1.setlocation("长春");
		s1.setstudentname("李");
		s1.setstudentcode("113");
		s1.setstudentsexy("男");
		s1.setstudentbirthday("1998");
		s3.setschoolname("四川大学");
		s3.setclassname("金融");
		s3.setlocation("四川");
		s3.setstudentname("李一");
		s3.setstudentcode("112");
		s3.setstudentsexy("女");
		s3.setstudentbirthday("1999");
		System.out.println(s1.tostring());
		System.out.println(s3.tostring());
	}
}
//创建一个抽象类 
abstract class school2{
	String schoolname;
	String classname;
	String location;
	//通过设置器来设置各个参数
	public void setschoolname(String schoolname) {
		 this.schoolname=schoolname;	
	}
	public void setclassname(String classname) {
		this.classname=classname;	
	}
    //通过访问器来获得对象的参数
	public String getschoolname() {
		return schoolname;
	}	
	public String getclassname() {
		return classname;
	}
	//设计抽象方法
	abstract void setlocation(String location);
	abstract String getlocation();
	//重写tostring()方法
	public String tostring()
	{
		String infor="学校名称："+schoolname+" 班级名称："+classname;
		return infor;
	}
}
//创建学生类，继承抽象类school2
class student1 extends school2{
	//创建成员变量
	String studentname;
	String studentcode;
	String studentsexy;
	String studentbirthday;
	void setlocation(String location){
		this.location=location;
	}
	String getlocation(){
		return location;
	}
	void setstudentname(String studentname) {
		this.studentname=studentname;			
	}
	void setstudentcode(String studentcode) {
		this.studentcode=studentcode;	
	}
	void setstudentsexy(String studentsexy) {
		this.studentsexy=studentsexy;
	}
	void setstudentbirthday(String studentbirthday) {
		this.studentbirthday=studentbirthday;
	}
	String getstudentname() {
		return studentname;
	}
	String getstudentcode() {
		return studentcode;
	}
	String getstudentsexy() {
		return studentsexy;
	}
	String getstudentbirthday() {
		return studentbirthday;
	}
	//通过tostring()方法来让对象以字符串的形式输出
	public String tostring(){
		String infor=super.tostring()+" 学校地址："+location+" 学生姓名："+
                studentname+" 学号："+studentcode+" 性别："+studentsexy+
                " 出生年月："+studentbirthday;
		return infor;
	}
}
//设计抽象类student2，继承抽象类school2
abstract class student2 extends school2{
	//创建成员变量
	String studentname;
	String studentcode;
	String studentsexy;
	String studentbirthday;
	//设计抽象方法
	abstract void setlocation(String location);
	abstract String getlocation();
	void setstudentname(String studentname) {
		this.studentname=studentname;			
	}
	void setstudentcode(String studentcode) {
		this.studentcode=studentcode;	
	}
	void setstudentsexy(String studentsexy) {
		this.studentsexy=studentsexy;
	}
	void setstudentbirthday(String studentbirthday) {
		this.studentbirthday=studentbirthday;
	}
	String getstudentname() {
		return studentname;
	}
	String getstudentcode() {
		return studentcode;
	}
	String getstudentsexy() {
		return studentsexy;
	}
	String getstudentbirthday() {
		return studentbirthday;
	}
	//通过tostring()方法来让对象以字符串的形式输出
	public String tostring(){
		String infor=super.tostring()+" 学生姓名："+
                studentname+" 学号："+studentcode+" 性别："+studentsexy+
                " 出生年月："+studentbirthday;
		return infor;
	}
}
//设计了类student3，继承类student2
class student3 extends student2{
	void setlocation(String location){
		this.location=location;
	}
	String getlocation(){
		return location;
	}
	//通过tostring()方法来让对象以字符串的形式输出
	public String tostring(){
		String infor=super.tostring()+" 学校地址："+location+";";
		return infor;
	}
}

接口

只说明类应该做什么，但并不指定应该如何去做。 即只有方法名，没有方法体。

实现接口：让其既有方法名又有方法体。

接口的用处：在这个程序段中，将接口作为一种规范，当要创建一个学生类时，就用学生类来实现学校这个接口。它在于让整个程序段中相同类型的类有一个统一的规范，这样看到接口的定义，就知道要实现它的类的功能。

注：
1）声明类需要实现指定的接口。
2）提供接口中所有方法的定义。
3）接口就是接口，类就是类，接口≠类。
4）接口能够补充继承的不足。因为继承必须是单继承的，而接口中，一个类可以实现多个接口。
5）若要生成一个接口的实例：school sc=new student();
6）在接口中，不能声明实例字段及静态方法，但可以声明常量。
7）接口也可以继承。
8）从目前来看，接口不仅仅是一种规范，也是一种编程的思路。接口的所有方法和属性，都代表了后面将要设计的类的基本思路，这些方法就代表着这个程序的需求。

例：

//声明一个学校接口，来告诉程序需要做些什么
	interface school   //接口声明默认为public
	{
		//接口中包括了很多方法，但是都没有实现
		void setschoolname(String schoolname);
		void setclassname(String schoolclassname);
		void setname(String name);
		void setcode(String code);
		void setsexy(String sexy);
		void setbirthday(String birthday);
		String getschoolname();
		String getclassname();
		String getname();
		String getcode();
		String getsexy();
		String getbirthday();
	}
	interface school1 extends school //接口也可以继承
	{
		void setname(String name);
		void setcode(String code);
		void setsexy(String sexy);
		void setbirthday(String birthday);
		String getname();
		String getcode();
		String getsexy();
		String getbirthday();
	}
	//创建一个类，让它实现学校这个接口
	class student implements school1  //关键字implements
	{
		private String schoolname;
		private String classname;
		private String studentname;
		private String studentcode;
		private String studentsexy;
		private String studentbirthday;

//通过设置器来设置各个参数
		
		public void setschoolname(String schoolname) {
			 this.schoolname=schoolname;	
		}

		
		public void setclassname(String classname) {
			this.classname=classname;	
		}

		
		public void setname(String studentname) {
			this.studentname=studentname;			
		}

		
		public void setcode(String studentcode) {
			this.studentcode=studentcode;	
		}

		
		public void setsexy(String studentsexy) {
			this.studentsexy=studentsexy;
		}

		
		public void setbirthday(String studentbirthday) {
			this.studentbirthday=studentbirthday;
		}

	    //通过访问器来获得对象的参数
		public String getschoolname() {
			return schoolname;
		}

		
		public String getclassname() {
			return classname;
		}

		
		public String getname() {
			return studentname;
		}

		
		public String getcode() {
			return studentcode;
		}

		
		public String getsexy() {
			return studentsexy;
		}

		
		public String getbirthday() {
			return studentbirthday;
		}
		//通过tostring方法来让对象以字符串形式输出
		public String tostring()
		{
			String infor="学校名称："+schoolname+" 班级名称："+classname+" 学生姓名："+
		                 studentname+" 学号："+studentcode+" 性别："+studentsexy+
		                 " 出生年月："+studentbirthday;
			return infor;
		}
	}
	//主运行函数
public class Interface {	
	public static void main(String args[])  //主方法
	{
		student st1=new student();
		student st2=new student();
		st1.setschoolname("理工大学");
		st1.setclassname("计算机一班");
		st1.setname("李");
		st1.setcode("11331");
		st1.setsexy("男");
		st1.setbirthday("1998-07-21");
		st2.setschoolname("理工大学");
		st2.setclassname("计算机二班");
		st2.setname("孙");
		st2.setcode("11332");
		st2.setsexy("女");
		st2.setbirthday("1998-10-09");
		System.out.println(st1.tostring());
		System.out.println(st2.tostring());
	 }
}

抽象与接口的共同点：

1）都不能创建实例对象，因为它们都是抽象的；
2）虽然不能用new创建对象实例，但可以声明变量，通过变量指向子类或实现类的对象，来创建对象实例。（上转型对象）

不同点：

1）Java不支持多重继承，但一个子类可以实现多个接口。
2）接口内不能有实例字段，只能用静态变量。抽象类可以拥有实例字段。
3）接口内方法自动设置为public的，抽象类中的方法必须手动声明访问控制符。

(抽象与接口，大多用接口）