JAVA基础知识——抽象类和接口

---

必备知识

大家首先了解下方法重载、重写、重构的区别

1.方法重载：
同名不同参。指的是在同一个类中，方法名相同，但是参数数量、参数类型或者返回类型不同的方法就叫做重载。比如：

	public Person() {
		System.out.println("这是我喜欢的人");
	}
	public Person(String name) {
		this();
		this.name = name;
	}
	public Person(String name,int age) {
		this(name);
		this.age= age;
	}

2.方法重写：

方法重写也叫覆盖，重写分两种：
（1）在子类继承父类的情况下，通过@Override注解，子类方法名、参数、返回值全部一样，方法体不一样的方法就是重写。
（2）接口实现，实现接口必须实现接口下的所有方法，因为实现方法上也有@Override注解，所以也算是重写的一种。

public class A{//定义类A
  public void s(){//定义方法s
  }
}
public class B extends A{//定义子类B，继承A
  public void s(){//重写父类A的方法s
  }
}

3.方法重构：
重构就是在原有的代码上，进行优化，使代码执行速度更快、或者更简单易读。
4.总结：
重写：是对方法本身重新编写。
重载：同名不同参。
重构：重写算是重构的一部分，但重构还包括对程序结构的优化。

---

参考链接重载，重写，重构
提示：以下是本篇文章正文内容，下面案例可供参考

一、抽象类（单继承）

1.抽象类：事物的分类，词性是名词，为什么会有抽象类，因为某些行为无法具体化。比如：苹果----->水果。想要通过例子来更好地理解抽象类，可以看这一博主的文章——什么是抽象类
2.抽象方法
（1）需要用abstract关键字修饰方法，并且不能有方法的实现。
（2）在一个抽象类既可以有抽象方法，也可以有非抽象方法。
（3）抽象方法必须在抽象类里面，抽象类里面不一定有抽象方法。
（4）抽象类不能被实例化。（也就是说不能通过new来实例化）需要通过他的非抽象后代类来产生这个类型的对象。
3.举例代码：

public class E01 {

	public static void main(String[] args) {
		//多态：相同的操作，作用在不同地实例产生不同的结果
		Animal animal = new Dog();//不能去new一个抽象的类，实例化(具体的类Dog)
		animal.speak();
		animal = new Cat();//new了两次，两个对象，
		animal.speak();

	}

}
//1.定义抽象类,没办法实例化
abstract class Animal{
	//可以有抽象方法
	abstract public void speak();
	//也可以有非抽象方法
	public void breath() {
		System.out.println("动物们需要呼吸新鲜空气");
	}
}
//2.抽象类要被子类继承,抽象类是重构的结果。
class Dog extends Animal{

	@Override
	public void speak() {
		// TODO Auto-generated method stub
		System.out.println("小狗汪汪地叫");
	}
	
}
class Cat extends Animal{

	@Override
	public void speak() {
		// TODO Auto-generated method stub
		System.out.println("小猫喵喵地叫");
	}
	
}

二、接口（多实现）

1.接口：事物能力的体现，词性是动词或者形容词居多。它是更高级的抽象，抽象到里面不能有任何的实现。
比如：飞（接口），听（接口）
鸟可以有飞的能力，也可以有听的能力。
2.特点：（
（1）接口的关键字是interface，接口的实现用implements关键字。
（2）接口不能被实例化，我们通过接口的实现类来产生这个接口类型的对象。
3.举例
代码演示1：

public class E02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//3.接口不能实例化，通过接口的实现类来产生这个接口类型的对象
		IFly fly = new Bird();//向上转型，就可能面临着丢失子类或者实现类的特性
		//丢失了实现类听的特性
		fly.fly();
		
		fly = new Person();
		fly.fly();
		
		//若果想要得到听的特性，可以通过强制类型转换
		//强制类型转换演示
		IFly fly1 = new Person();
		fly1.fly();
		
		Person p = (Person)fly1;
		p.listen();

	}

}
//1.定义接口，接口名前面加个I代表是个接口
interface IFly{
	//声明一个飞的方法，不可以有大括号{ }，有了就意味着实现
	//接口是更高级的抽象，抽象到里面不能任何的实现。
	public void fly();
}
interface IListen{
	public void listen();
}
//2.接口的实现,多实现
class Bird implements IFly,IListen{

	@Override
	public void fly() {
		// TODO Auto-generated method stub
		System.out.println("鸟有翅膀可以飞");
	}

	@Override
	public void listen() {
		// TODO Auto-generated method stub
		System.out.println("鸟可以倾听");
	}
	
}
class Person implements IFly,IListen{

	@Override
	public void fly() {
		// TODO Auto-generated method stub
		System.out.println("人有理想就可以飞");
	}

	@Override
	public void listen() {
		// TODO Auto-generated method stub
		System.out.println("人可以听");
	}
	
	
}

代码演示2：

public class E03 {

	public static void main(String[] args) {
		//通过接口的实现类来产生这个接口类型的对象
		IUsb usb = new PhonePrinter();
		usb.install();
		usb.work();
		
		usb = new PCPrinter();
		usb.install();
		usb.work();
		
		System.err.println("...............");
		/*
		强制类型转换演示
		IUsb usb1 = new PCPrinter();
		usb1.install();
		//usb1.work();
		
		PCPrinter p = (PCPrinter)usb1;
		//p.install();
		p.work();
*/
		//假如有一个数组，既可以放PhonePrint,也可以放PCPrint
		IUsb[] usbs = new IUsb[3];//给空间
		usbs[0] = new PCPrinter();
		usbs[1] = new PhonePrinter();
		usbs[2] = new PCPrinter();
		
		for (IUsb iUsb : usbs) {
			iUsb.install();
			iUsb.work();
		}
		}

}
//1.定义接口
interface IUsb{
	 public void install();
	 public void work();
}
//2.写实现类
class PhonePrinter implements IUsb{

	@Override
	public void install() {
		// TODO Auto-generated method stub
		System.out.println("安装手机驱动程序");
	}

	@Override
	public void work() {
		// TODO Auto-generated method stub
		System.out.println("从电脑拷贝数据到手机上");
	}
	
}
class PCPrinter implements IUsb{

	@Override
	public void install() {
		// TODO Auto-generated method stub
		System.out.println("安装打印机驱动程序");
	}

	@Override
	public void work() {
		// TODO Auto-generated method stub
		System.out.println("打印一份文件");
	}
	
}

三、抽象类与接口的区别

（1）抽象类要被子类继承，接口要被类实现。
（2）接口只能做方法声明，抽象类中可以作方法声明，也可以做方法实现。
（3）接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
（4）接口是设计的结果，抽象类是重构的结果。
（5）抽象类和接口都是用来抽象具体对象的，但是接口的抽象级别最高。
（6）抽象类可以有具体的方法和属性，接口只能有抽象方法和不可变常量。
（7）抽象类主要用来抽象类别，接口主要用来抽象功能。
大家还想更好的了解抽象类与接口的区别可以参考这位博主的文章。

四、思维导图