黑马程序员_java抽象类和接口学习笔记

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

Java抽象类和接口

1.抽象类

抽象方法的定义：通过abstract关键字来修饰的类称为抽象类；

抽象类用private修饰，里面可以有用private修饰的方法（没有方法体），强制子类进行覆写；

可以定义被abstract修饰的抽象方法

抽象方法只有返回类型和方法签名，没有方法体。

 

总结：

抽象类可以含有普通方法

抽象类不能创建实例对象（不能new）

需要子类覆盖掉所有的抽象方法后才可以创建子类对象，否则子类也必须作为抽象类

列举常见的几个抽象类：

流的四个基本父类

InputStream，OutputStream，Reader，Writer

抽象类是类的一种特殊情况:据有类的一切特点,但是不能实例化;一般的都得带有抽象方法。

抽象类不可以实例化，有时看到的近似实例化是多态机制的体现，并不是真正的实例化。

如：

abstract class Person{
	abstract void show();
	void print(){
		System.out.println("Person print");
	}
}
class student extends Person{

	@Override
	void show() {//必须实现，否则本类还是抽象类。
		System.out.println("student show");
	}
	void print(){
		System.out.println("student print");//覆盖
	}
	
}
public class Test{
	public static void main(String[] args) {
		//new Person();//抽象类不可以被实例化
		new student().print();
		new student().show();
	}
}

运行结果：student print 

abstract方法:

 分析事物时，发现了共性内容，就出现向上抽取。会有这样一种特殊情况，就是功能声明相同，但功能主体不同。

那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。

abstract [非private访问修饰符] 返回值类型 方法名称(参数列表);

抽象方法要存放在抽象类中。

抽象方法也可以存在于接口中。

抽象类的体现主要就是模板模式设计,抽象类作为多个子类的通用模板,子类在抽象类的基础上进行拓展,但是子类在总体上大致保留抽象类的行为方式;

编写一个抽象父类,该父类提供了多个子类的通用方法,并把一个或多个抽象方法留给子类去实现,这就是模板设计模式;

 

抽象类模板模式应用的简单规则:

1.抽象父类可以只定义需要使用的某些方法,其余留给子类去实现;

2.父类提供的方法只是定义了一个通用算法,其实现必须依赖子类的辅助;

如果父类的方法不想被子类覆写，那么可以在前面加上final关键字修饰。

1.接口

接口只定义了类应当遵循的规范,却不关心这些类的内部数据和其方法内的实现细节.

接口只规定了这些类里必须提供的方法;从而分离了规范和实现.增强了系统的可拓展性和维护性;

 

使用接口的好处,拓展性,维护性更好,所以我们在开发中会经常用到接口.（相当于定义了一种标准）

interface定义

接口定义一种规范,规定一个类必须做什么,但它不管如何具体去做;

[修饰符] interface 接口名 extends 父接口1,父接口2....

没有构造方法,不能实例化;

接口只能继承接口,不能继承类

接口里没有普通方法,方法全是抽象的;

接口里的方法默认修饰符是public abstract；

接口里的字段全是全局常量,默认修饰符是public static final;

 

全局常量

公共的抽象方法

内部类(包括内部类,内部接口,内部枚举类);

 

总结：

接口没有构造方法，不能实例化！

接口里的方法全部是抽象的，没有普通方法，有默认的修饰符 public abstract，必须全部覆写！

如：

abstract class student{
	abstract void study();
	void sleep(){
		System.out.println("sleep");
	}
}
interface Smoking{//扩展的功能
	void smoke();
}
class guan extends student implements Smoking{

	@Override
	public void smoke() {
		System.out.println("guan smoking");
	}

	@Override
	void study() {
		System.out.println("guan study");
	}
	
}
class jia extends student{

	@Override
	void study() {
		System.out.println("jia study");
	}
	
}
public class Test{
	public static void main(String[] args) {
		guan g = new guan();
		g.smoke();
		g.study();
		
		jia j  = new jia();
		j.study();
	}
}

运行结果：

guan smoking
guan study
jia study

interface Windows{
	void max();
	void min();
	void close();
}

//适配器模式，实现接口所有的方法，但是不写方法体！
class AdapterWindows implements Windows{

	@Override
	public void max() {
	}

	@Override
	public void min() {
	}

	@Override
	public void close() {
	}
	
}

class MyWindows extends AdapterWindows{
	//覆写父类的方法
	public void close(){
		System.out.println("这个实现的是关闭功能！");
	}
}

public class test {
	public static void main(String[] args) {
		new MyWindows().close();
	}
}

运行结果：这个实现的是关闭功能！

接口和抽象类的比较：
相同点:都位于继承的顶端,用于被其他实现或继承;都不能实例化;
都包含抽象方法,其子类都必须覆写这些抽象方法; 


区别:
抽象类为部分方法提供实现,避免子类重复实现这些方法,提供代码重用性;接口只能包含抽象方法;
一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)


二者的选用:优先选用接口,尽量少用抽象类;需要定义子类的行为,又要为子类提供共性功能时才选用抽象类;