Java面向对象（8）抽象类，接口的定义和实现，接口中的默认方法，静态方法，接口的多继承

目录

1：抽象方法和抽象类

2：接口的定义和接口的实现

3：JDK 新特性，接口——默认方法

4：JDK 新特性，接口——静态方法（类方法）

 5：接口的多继承

---

1：抽象方法和抽象类

抽象方法没有方法体，它是一种规范，规范了子类必须去实现它

抽象类和抽象方法的一些要点

1：有抽象方法的类只能被定义成抽象类

2：抽象类不能被实例化（抽象类不能够创建对象）

3：抽象方法必须由子类事项

4抽象类只能被用来继承

5：抽象类里面可以定义属性，构造方法，和普通方法，但是就是不能创建对象

package com;

 abstract public class TestAbstract {//有抽象方法的类只能够被定义成抽象类
     //创建属性和构造方法，但是不能够实例化
     private  int id;
     private  String name;
     public TestAbstract(){

     }
     abstract public void shout();

     public static void main(String[] args) {
         ChildeAbstract c=new ChildeAbstract();//抽象类不够创建对象
         //但是他的子类可以创建对象
         c.shout();

     }

 }
 class ChildeAbstract extends TestAbstract{//抽象类只能够被继承
     @Override
     public void shout() {//子类必须实现抽象方法
         System.out.println("我在实现抽象方法");

     }
 }

2：接口的定义和接口的实现

接口像一堵墙一样彻底的将设计和实现分开，有的人在办公室想接口，然后定义一个标准（规则），然后一个或多个人去实现这个标准。

接口也是一个类，接口与其他类的区别

普通类：具体实现

抽象类：规范，具体实现

接口：规范

子类通过implements来实现接口中的规范

package com.gnlxy.test;

public class TestJiekou {

}
interface Tool{
    int length=18;//接口内部定义的属性只能是常量
    // 默认是public static final
    void test();//声明的方法都是抽象方法，默认是abstract public

    public static void main(String[] args) {
        Test0 t=new Test0();
        t.goodMan();
        t.test();
        Test1 t1=new Test1();
        t1.test();
        Test2 t2=new Test2();
        t2.goodMan();

    }
}
interface People{
    void goodMan();
}
class Test0 implements Tool,People{
    @Override
    public void test() {

        System.out.println("你的工具是什么？");
    }

    @Override
    public void goodMan() {
        System.out.println("你是一个好人吗？");
    }
}
class Test1 implements Tool{
    @Override
    public void test() {
        System.out.println("我的工具是电脑");
    }
}
class Test2 implements People{
    @Override
    public void goodMan() {
        System.out.println("我是一个好人！");
    }
}

3：JDK 新特性，接口——默认方法

接口会提供默认方法的实现，所有子类通过继承都可以获得这个方法

实际开发中用的极少，只是为了开阔视野

默认方法是具体的，他有方法体，但是在声明方法的时候必须要加上default，看下面代码

package com.gnlxy.test;

interface Moren{
    default void testMoren(){
        System.out.println("我在测试接口的默认方法");
    }

    public static void main(String[] args) {
        Moren m=new Test4();
        m.testMoren();
    }
}
class Test4 implements Moren{
    @Override
    public void testMoren() {
        System.out.println("我正在重写接口中的默认方法");
    }
}
//public class TestMoren {
//
//
//}

4：JDK 新特性，接口——静态方法（类方法）

我们可以在接口中定义静态方法的实现，它从属于接口，用接口名来调用

interface Test5{
    public static void test(){
        System.out.println("我是Test5的静态方法，我属于Test5");
    }
}
class TestStaticJikou implements Test5{
    public static void test(){
        System.out.println("我是TestStaticJiekou的静态方法，" +
                "我属于TestStaticJiekou");
    }

}
public class TestStaticJiekouy {
    public static void main(String[] args) {
        Test5.test();//static是类方法，需要类名来调用
        TestStaticJikou.test();
    }
}

当子类的静态方法名和父类的静态方法名一样时，他们是不同的方法

在默认方法中可以调用静态方法，看下面的代码

interface Test5 {
    public static void test() {
        System.out.println("我是Test5的静态方法，我属于Test5");
    }

    default void test22() {
        test();
        System.out.println("我是默认方法，我可以调用静态方法");
    }
}

 5：接口的多继承

接口完全支持多继承。和类的继承类似，子接口扩展某个父接口，将会获得父接口中所 定

义的一切。

interface A{
    void testa();
}
interface B{
    void testb();
}
interface C extends A,B{
    void testc();
}
public class TestJiekouExtends {
    public static void main(String[] args) {
        C c=new ComeTrue();
        c.testc();
        c.testa();
        c.testb();


    }
}
class ComeTrue implements C{
    @Override
    public void testa() {
        System.out.println("a");
    }

    @Override
    public void testb() {
        System.out.println("b");
    }

    @Override
    public void testc() {
        System.out.println("c");
    }
}