一.抽象
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("自由泳");
}
}三.结束语：
本文讲解的抽象、接口已经讲完啦，欢迎小伙伴们前来指正呦。
