抽象方法，接口，多态的总结

　　为什么要写这篇博客？前天，女友问过我两次关于继承与多态的问题，而没心没肺的我却没立刻帮她解答。反而最后和她吵架，说了的不好话语。现在我只想稍微补偿一下她，以我不成熟的java理解给她很简单讲解一下。然后本篇博客参考了黑马的相关内容，由于是第一篇博客，大佬看见了有意见随便说。

目录：

• 继承　
• 抽象类
• 接口
• 多态

继承

继承是什么意思？

　　A用extends关键字继承了B后，那么A类可以调用B类的非私有属性与方法。

　　eg:

public class ncu {
    String name ="昌大研究生";
    public void study(){
        System.out.println("昌大学生爱学习..");
    }
}

　上述代码是父类

public class huanhuan extends ncu {
    String name1 ="张焕";
}

上述代码是子类继承了父类ncu

public class 继承demo {
    public static void main(String[] args) {
        huanhuan hh = new huanhuan();
        System.out.println(hh.name); //调用父类的属性
        System.out.println(hh.name1);
        hh.study();//调用父类的方法
    }
}

上面是运行程序，下面是运行结果：

昌大研究生
张焕
昌大学生爱学习..

可以看到，huanhuan继承了nuc，所以可以调用nuc的属性以及方法study。

抽象类

抽象类是什么意思？

　　了解抽象类前我们说下抽象方法。抽象方法就是没有主主体的方法。比如：

public abstract void eat();

　　我们可以看到这个方法名前面有个abstract，表明这个方法是抽象的。并且方法后面没有主体，也就是没有大括号那部分。而抽象类就是包含了抽象方法的类。比如：

public abstract class ncu_absract {
    String name ="昌大研究生";
    public void study(){
        System.out.println("昌大学生爱学习..");
    }
    public abstract void eat();
}

我们可以看到这个类名前面有个abstract修饰符代表这个类是抽象的，然后类里面有个抽象方法。

抽象类的使用：

继承抽象类的子类必须重写父类所有的抽象方法。这句话很重要。我们看个例子吧，还是刚才的ncu只是里面多了个抽象方法，所以变成了抽象类。

//抽象类
public abstract class  nuc_abstract {
    String name ="昌大研究生";
    public void study(){
        System.out.println("昌大学生爱学习..");
    }
    public abstract void eat();//抽象方法
}

上述代码是抽象类

public class huanhuan extends nuc_abstract {
    String name1 ="张焕";
    @Override
    public void eat() {//重写了抽象父类中的抽象方法
        System.out.println("吃包子");
    }
}

上述代码是子类继承了父类ncu_abstract且重写了父类中的抽象方法eat。注意，必须重写抽象方法。

public class 抽象类demo {
    public static void main(String[] args) {
        huanhuan hh = new huanhuan();
        hh.eat();//重写后的方法
        hh.study();//父类的方法
    }
}

运行结果：

吃包子
昌大学生爱学习..

小结，抽象方法就是没有主体的方法。有抽象方法的类叫作抽象类，继承抽象类要重写抽象方法。

接口

什么是接口？

　　上面解释了抽象类，那么我们将很好的理解什么是接口。有抽象方法的类叫抽象类，但是抽象类里面还可以有非抽象的方法与属性，就像上面nuc_abstact里面的study方法一样。但是接口里面只有方法。

我们来看一个接口：

public interface ncu_interface {
        abstract   void  exercise();
        abstract   void  play();
          default  void  walk(){
        System.out.println("走路");
    }
}

我们可以看到接口的修饰符是interface。然后接口内部全是方法，上面有两个抽象方法，exercise与play。还有一个默认方法，walk。

public class huanhuan implements ncu_interface {

    @Override//重写方法
    public void exercise() {
        System.out.println("打羽毛球");
    }
    @Override//重写方法
    public void play() {
        System.out.println("看剧");
    }
}

上面的代码是huanhuan这个类实现了接口nuc_interface并且重写了接口中的抽象方法。注意：抽象方法必须重写，如同继承抽象类一样。

public class 接口_demo {
    public static void main(String[] args) {
        huanhuan hh = new huanhuan();
          hh.exercise();
          hh.play();
          hh.walk();
    }
}

运行结果：

打羽毛球
看剧
走路

我们可以看到，主程序输出了接口中的默认方法与我们重写后的方法的内容。

小结：接口就是里面就是一堆方法，实现接口的类要重写接口中的抽象方法。

　　　注意：一个类只能继承一个类，但是一个类可以实现多个接口。

public class huanhuan implements ,inter1,inter2 {
    
}

多态

学习到了多态，的确最开始很懵逼，我当时也是看不太懂。然后后面多看了几遍，才有了一些理解。所以焕焕在这里看着难受是正常的，不要烦躁，继续加油。

什么是多态？

生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如我和焕焕都有自己娱乐的方式，她是看剧，我是打游戏。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。可见，即使我和焕焕有一些不同的性格与习惯，但是我们要互相包容，而不是放弃，逃避。

回到正题，我们来看个例子：

public interface ncu_多态 {
    abstract void play();
    abstract void eat();
}

上述代码我们先定义一个接口

public class huanhuan extends ncu_多态 {
    @Override
    public void play() {
        System.out.println("看剧");
    }

    @Override
    public void eat() {
        System.out.println("吃包子");
    }
}

public class wzw iextends ncu_多态 {
    @Override
    public void play() {
        System.out.println("玩游戏");
    }

    @Override
    public void eat() {
        System.out.println("吃干饭");
    }
}

上面两个代码可以看到我和焕焕都实现了nuc_多态这个接口，只是我们在play与eat这两个抽象方法的重写不一样。她的play是看剧，我的play是玩游戏，这就是多态的意思。

public class 多态_demo {
    public static void main(String[] args) {
        ncu_多态 wzw =new wzw();
        ncu_多态 hh =new huanhuan();
        wzw.eat();
        wzw.play();
        hh.eat();
        hh.play();
    }
}

然后这上面的代码有点难以理解了，这就是父类引用指向子类对象。即：引用是父类ncu_多态，但是对象时子类，wzw与huanhuan。我们不用立即理解什么意思，我们只需要看这个下面的公式。

父类类型 变量名 = new 子类对象；

变量名.方法名(); 

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。 

我们可以看到上面的代码就是按照这个格式写的，父类类型，子类对象。然后如何调用方法就是下面的口诀，这就是简单的多态的知识。

 

 

 

焕焕你看见这儿你就是胜利了，不懂找我