Java面向对象篇(三)——抽象、接口

一.抽象

1.何为抽象类？

• 被abstract关键字所修饰的类就是个抽象类。
• 有抽象方法的类就是抽象类。

2.何为抽象方法？

• 没有方法体的方法就是抽象方法。

抽象方法没有方法体。

实例一：

abstract class Person {
	public abstract void eat(); //无方法体。
}

3.抽象类的特点？

1.抽象类和抽象方法都要由abstract关键字来修饰。

实例二：

public class abstract01 {
	public static void main()
	{
		Cat01 c = new Cat01();
		Amal a = new Cat01();
	}
}


abstract class Amal
{
	//建立抽象方法
	int i = 3;
	static int j = 1;
	final int d = 0;
	abstract public void eat();
}

class Cat01 extends Amal
{
	//重写抽象方法
	public void eat()
	{
		System.out.println("吃菜");
	}
}

2.抽象类可以没有抽象方法，但是有抽象方法的类一定是抽象类。

实例三：

abstract class Person {
    //成员方法体
	public void eat() {}
	public void sleep() {}
	//抽象方法
	public abstract void drink();
}

3.抽象类不能创建对象。
4.一个类想要继承一个抽象类，要么该类也是一个抽象类，要么该类是一个普通类，但是必须重写所有的抽象方法（参见实例二）。

4.抽象类的成员特点？

1.成员变量：

可以有静态的成员变量。
可以有非静态的成员变量。
可以自定义常量。
参见实例二

2.成员方法：

可以有抽象方法。
可以有非抽象方法。
参见实例三。

5.abstract关键字和不能哪些关键字共存？

1.abstract不能和private关键字共存：

因为被abstract关键字修饰的方法是抽象方法，子类是一定要重写的，如果该方法同时又被private修饰的话，子类还重写不了，所以冲突.

2.abstract不能和static关键字共存：

因为被static关键字所修饰的方法可以通过类名直接调用，但是同时被abstract关键字修饰的方法，没有方法体的，故无法修饰。

3.abstract不能和final关键字共存：

因为被abstract关键字修饰的方法是抽象方法，子类是一定要重写的，如果该方法同时又被final修饰的话，子类还重写不了，所以冲突。

实例四：

abstract class Fu {
	private abstract void print();//报错
	public abstract static void print();//报错
	public final abstract void print();//报错
}

class Zi extends Fu {
	public void print() {}
}

二.接口

1.何为接口？

比抽象类更加抽象的表现形式，就是接口。

2.格式？

interface 接口名 {}

3.使用格式？

interface Inter {}	
class Zi implements Inter {}

4.接口的特点？

1.接口不能创建对象。
2.一个类想要实现一个接口，要么该类是一个抽象类，要么该类是一个普通类，就必须重写接口中的所有的抽象方法。

5.接口的成员特点？

• 成员变量：

接口中的所有的变量全部都是自定义常量。
默认修饰符：public static final。

public static final int i = 1;
static final int j = 1;
int x = 1;

• 成员方法：

在老版本中接口中的所有的方法必须是抽象方法。
在新版本中接口中的所有的方法可以不是是抽象方法。
默认修饰符：public abstract。

public abstract void aaa();
abstract void bbb();
//仅限于新版本
public void ccc();
void ddd();

• 构造方法：

接口中没有构造方法。

6.接口与接口，类与类，接口与类之间的关系？

1.类与类：继承关系，单继承，不可以多继承，也可以实现其他的接口。

class Fu {
	public void eat() {
		System.out.println("吃肉");
	}
}

class Zi extends Fu {}

2.类与接口：实现关系，支持单实现，也可以多实现。

interface Inter {}

interface Inter1 {}

class Zi implements Inter, Inter1 {}

3.接口与接口：继承关系，支持单继承，也可以多继承。

interface A {
public abstract void eat();
}
interface B {}

//接口与接口继承。
interface C extends A, B {}
//实现接口。
class Zi implements C {
	public void eat() 
	{}
}

7.我们什么时候使用接口，什么时候使用类(包含抽象类)？

当两个类之间存在"is a"，就要定义类，两个类之间是继承关系。
接口是额外扩展的功能，本身该类不具备这个功能，而且还不是"is a"的关系，就需要去实现这样的接口了。

实例五：

package interface1;

public class interface03 {
	public static void main(String[] args)
	{
		Dog01 d = new Dog01();
		d.drink();
		d.eat();
		d.play();
		d.swmming();
	}

}

//父类的抽象函数
abstract class Aminal
{
	public abstract void eat(); //吃的东西不一样，定义抽象函数。
	public void drink()
	{
		System.out.println("喝水"); //共有的特性
	}
}
//接口

interface Swim
{
	public void swmming();
}

interface Aircar
{
	public void fiy();
}
//子类的继承函数
class Dog01 extends Aminal implements Swim
{
	//特有的功能
	public void play()  
	{
		System.out.println("玩球");
	}
	//继承的抽象函数
	@Override
	public void eat() {
		System.out.println("狗粮");
	}
	//以下实现的是接口
	@Override
	public void swmming() {
		System.out.println("仰泳");
	}
}

class Cat04 extends Aminal
{
	//特有的功能
	public void sleep()
	{
		System.out.println("睡觉");
	}
	//继承的抽象函数
	@Override
	public void eat() {
		System.out.println("猫粮");
	}
}

class Big01 extends Aminal implements Swim,Aircar //单继承多实现
{
	//特有的功能
	public void gong()
	{
		System.out.println("拱白菜");
	}
	//继承的抽象函数
	@Override
	public void eat() {
		System.out.println("猪食");
	}
	//以下实现的是接口
	@Override
	public void fiy() {
		System.out.println("横着飞");
	}

	@Override
	public void swmming() {
		System.out.println("自由泳");
	}
}

三.结束语：

本文讲解的抽象、接口已经讲完啦，欢迎小伙伴们前来指正呦。