抽象类和接口的区别：
抽象类：
1.抽象类是一个类
2.定义抽象类时，使用abstract关键字修饰，继承抽象类时，使用extends
3.只能继承一个抽象类
4.抽象类中可以有抽象方法，也可以没有抽象方法，抽象类中可以有具体的方法
接口：
1.接口不是一个类
2.定义接口时使用interface，实现接口时使用implements
3.可以实现多个接口
4.jdk1.8之前接口中的方法都是抽象方法，jdk1.8之后接口中可以有非抽象方法、静态方法
抽象类和接口的相同点：
1.都不可以实例化，即不能使用new关键字来实例化对象
2.子类/实现类需要实现抽象类父类/要实现的接口中的所有抽象方法，如果没有实现它们中的全部抽象方法，子类/实现类需要定义成抽象类
3.可以引用抽象类/接口，指向子类/实现类---》形成多态
抽象方法：只有方法体，没有具体实现。eg:
public abstract void a();
jdk1.8之前和jdk1.8之后，接口区别：
jdk1.8之前接口中有：1.常量 2.抽象方法
jdk1.8之后接口中有：1.常量 2.抽象方法 3.非抽象方法 4.静态方法
常量：public static final
抽象方法：public abstract
非抽象方法：public default
静态方法：public static
注意：接口中的静态方法不能被继承。实现类实现接口时，重写接口中的的非抽象方法不可以带关键字default
抽象类：
abstract public class Person {
int age;
String name;
public void eat(){
System.out.println("能吃是福");
}
public abstract void sleep();
}
jdk1.8之前接口：
public interface TestInterface01 {
//常量
public static final int NUM = 10;
//抽象方法：
public abstract void a();
public abstract void b(int num);
public abstract int c(String name);
}
interface TestInterface02{
public abstract void e();
public abstract void f();
}
继承父类、实现接口：
class Student extends Person implements TestInterface01, TestInterface02{
@Override
public void a() {
System.out.println("------aaa");
}
@Override
public void b(int num) {
System.out.println("------bbb");
}
@Override
public int c(String name) {
return 110;
}
@Override
public void e() {
System.out.println("--------eee");
}
@Override
public void f() {
System.out.println("-------fff");
}
@Override
public void sleep() {
System.out.println("我喜欢睡硬板床");
}
}
class Test{
//这是一个main方法，程序的入口
public static void main(String[] args) {
//10.接口不能创建对象：
//TestInterface02 t = new TestInterface02();
//抽象类不能创建对象
//Person p = new Person();
Person p = new Student(); // 父类指向子类---》多态
TestInterface02 t = new Student(); //接口指向实现类---》多态
//11.接口中常量如何访问：
System.out.println(TestInterface01.NUM);
System.out.println(Student.NUM);
Student s = new Student();
System.out.println(s.NUM);
TestInterface01 t2 = new Student();
System.out.println(t2.NUM);
}
}
jdk1.8之后接口：
package com.test12;
/**
* jdk1.8之后，除了常量，抽象方法，还新增了非抽象方法、静态方法
* 常量：public static final
* 抽象方法：public abstract
* 非抽象方法：public default
* 静态方法：public static
*/
public interface TestInterface {
//常量
public static final int NUM = 10;
//抽象方法
public abstract void a();
//非抽象方法
public default void b(){
System.out.println("-----TestInterface---b()---");
}
//静态方法
public static void c(){
System.out.println("这是TestInterface的静态方法c()");
}
}
package com.test12;
public class Demo implements TestInterface{
@Override
public void a() {
System.out.println("Demo重写接口TestInterface的a()方法");
b();
//调用接口中的方法
TestInterface.super.b();
}
@Override
public void b() {
System.out.println("Demo重写接口TestInterface中的b()方法");
}
public static void c(){
System.out.println("Demo中的静态方法c()");
}
}
class TestDemo{
//这是一个main方法，程序的入口
public static void main(String[] args) {
Demo d = new Demo();
d.a();
Demo.c();
TestInterface.c();
}
}
打印结果：
Demo重写接口TestInterface的a()方法
Demo重写接口TestInterface中的b()方法
-----TestInterface---b()---
Demo中的静态方法c()
这是TestInterface的静态方法c()
