008—JAVA中的抽象类与接口细数知识点

抽象类： 对一类事物共有特征的描述 但是不能创建对象
抽象方法： 规定此类事物必须有的操作

例如           Animal    （Cat  Dog 实现了Animal  则必须能吃饭  必须能睡觉    即必须实现父                                类的抽象方法） 

描述的是客观世界  is  a  的关系

注意：1.声明抽象类 abstract class 类名{}

           2.声明抽象方法 abstract 返回值类型 方法名()； 抽象方法没有方法体

抽象类的作用严格的规范子类的行为

public abstract class Animal {
    String name;
    int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void show(){
        
    }
}

抽象类除了不能创建对象，抽象类可以拥有普通类的属性方法构造器，普通类中有的，抽象类中也可以有。

抽象类中可以没有抽象方法

抽象方法必须在抽象类中

子类必须 实现 抽象类中所有的抽象方法 否则 此类也要变为抽象类

抽象方法不能被 private  static final 修饰（因为一旦被修饰该方法就不能被重写了）

接口的知识

继承是一个is a的关系  而接口描述的是has a的关系

如果一个类实现了一个接口，可以把这个类看作是接口的一个子类。可以被认为是父亲和孩子的关系。此时可以使用多态。

FlyAble flyAble = new Bird();
flyAble.fly();

接口必须被实现之后才可以被应用，接口不能够创建对象。

public interface FlyAble {

    public abstract void fly();

}

public class SuperMan implements FlyAble{

    @Override
    public void fly() {
        System.out.println("超人飞......");
    }
}

class Bird implements FlyAble{
    @Override
    public void fly() {
        System.out.println("小鸟自由自在的飞....");
    }
}

public class Test {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        superMan.fly();

        FlyAble flyAble = new Bird();
        flyAble.fly();

    }
}

接口的成员

      1>接口中没有普通变量      都是 全局静态常量 默认被 public static final 修饰

      2>接口中没有普通的非静态方法。（比如 ：public void test(){}   会报错）

      3>接口中可以有静态方法（接口内可以有静态的方法 jdk8提供的）

        （默认被 public 修饰）

       4>接口内可以有抽象方法    (默认被 public abstract 修饰)（抽象方法没有方法体）

             但是如果全是抽象方法的话，不利于接口的扩展，比如两个类A,B都实现了某个接口，只需要A类重写某个方法，此时的话，B类也必须重写。（因为抽象方法）

        5>引出了默认方法     （默认方法默认被public修饰）（子类可以重写或者补充些）           public default void test2(){}

接口可以被类多实现

        一个类可以实现多个接口   （class D implements A,B{}）、

        一个接口可以继承多个接口（打破了类的单继承性），但是不能实现多个接口。（interface E extends A,B,C{ void e(); }）    

        （interface F implements D{}   报错）

        一个类实现接口  必须重写/实现 所有的抽象方法  否则 此类也要变为抽象类

        接口可以多继承

        一个类既有接口的实现又有类的继承，继承优先（先使用继承中的方法）

public interface A {
    public default void a(){
        System.out.println("haohaoxuexi");
    }
}

interface B{
    void b();
}
interface C{
    void c();
}
interface E extends A,B,C{
    void e();
}
/*interface F implements D{

}*/
class F{
    public void a(){
        System.out.println("好好学习");
    }
}
class D extends F implements A,B{



    @Override
    public void b() {

    }
}

       

public class Test {
    public static void main(String[] args) {
        D d = new D();
        d.a();
    }
}

当一个类实现了多个接口  接口内有同名的默认方法  此类必须重写

重写后想要使用某个接口内的默认方法     接口名.super.方法名()

 

public class Test {
    public static void main(String[] args) {
        Boy boy = new Boy();
        boy.play();
    }
}

interface YangMi{
    public default void play(){

        System.out.println("YangMi 过来玩儿 小伙子 ");
    }
}
interface WuJing{
    public default void play(){

        System.out.println("YangMi 过来玩儿 小伙子 ");
    }
}
class Boy implements YangMi , WuJing{
    @Override
    public void play() {
        System.out.println("自己玩");
        WuJing.super.play();
        YangMi.super.play();
    }
}

当一个类继承了另一个类实现了另一个接口，如果类和接口中有同名的成员变量，在调用的时候必须指明谁调用的，否则会有模棱两可的错误

public interface A {
        int x = 0;
    }

    class B {
        int x = 1;
    }

    class C extends B implements A{
        public void pX(){
    //        System.out.println(x);
            System.out.println(new B().x);
            System.out.println(A.x);
        }
    }