抽象类、抽象方法以及接口

分手后的思念是犯贱 2022-05-12 07:22 441阅读 0赞

抽象方法声明语法:
abstract void f();
包含抽象方法的类叫做抽象类,如果一个类包含一个或多个抽象方法,该类必须被限定为抽象类,负责编译器就会报错。且抽象类不允许被创建对象
如果一个类继承自一个抽象类,如果想创建此类的对象,就必须为父类(基类)中的抽象方法提供方法定义,否则此类只能被abstract修饰成为抽象类。
下面看一段代码

  1. abstract class Animal{ //以abstract关键字修饰的抽象类中可以含有普通方法
  2. abstract void voice();
  3. abstract void run(); //抽象方法必须定义在抽象类中
  4. public void eat() {
  5. System.out.println("eating...");
  6. }
  7. }
  8. class Bird extends Animal{
  9. @Override
  10. void voice() { //抽象方法在子类中必须进行重写
  11. System.out.println("zhazhazha...");
  12. }
  13. @Override
  14. void run() {
  15. System.out.println("flying...");
  16. }
  17. }
  18. public class Testabstract {
  19. public static void main(String[] args) {
  20. Animal a = new Bird();
  21. a.voice();
  22. a.run();
  23. a.eat();
  24. }
  25. }
  26. /** * output: * zhazhazha... * flying... * eating... */

总结一下抽象类和抽象对象的几个要点:

  • 有抽象方法的类只能定义抽象类
  • 抽象类不能实例化,即不能用new来实例化抽象类
  • 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实力,只能被子类调用
  • 抽象类只能用来继承
  • 抽象方法必须被子类实现

接口:interface关键字使抽象的概念更向前迈了一步。这个关键字产生一个完全抽象的类,他不提供任何具体的实现,,允许创建者确定方法名、参数列表和返回类型,但是没有方法提。换句话说,接口只提供了形式,不提供任何具体实现。
再来看一段代码:

  1. public interface Testjiekou { //所有接口都是由public所修饰
  2. public static int MAX_VALUE = 100;
  3. abstract void run();
  4. abstract void eat();
  5. abstract int num(int a,int b);
  6. }
  7. class Pig implements Testjiekou{ //实现接口时必须重写所有抽象方法
  8. @Override
  9. public void run() {
  10. System.out.println("running..");
  11. }
  12. @Override
  13. public void eat() {
  14. System.out.println("eating...");
  15. }
  16. @Override
  17. public int num(int a, int b) {
  18. System.out.println(a+b);
  19. return a+b;
  20. }
  21. }
  22. public class Test01 {
  23. public static void main(String[] args) {
  24. Testjiekou pig = new Pig();
  25. pig.run();
  26. pig.eat();
  27. pig.num(10,20);
  28. }
  29. }
  30. /** * output: * running.. * eating... * 30 */

接口可以实现多继承,我们用一段代码来看这一过程

  1. interface Printtest1 {
  2. abstract void test1();
  3. }
  4. interface Printtest2{
  5. abstract void test2();
  6. }
  7. interface Printtest3 extends Printtest1,Printtest2{
  8. abstract void test3();
  9. }
  10. class Test implements Printtest3{
  11. @Override
  12. public void test1() {
  13. System.out.println("test1()");
  14. }
  15. @Override
  16. public void test2() {
  17. System.out.println("test2()");
  18. }
  19. @Override
  20. public void test3() {
  21. System.out.println("test3()");
  22. }
  23. }
  24. public class Printtest{
  25. public static void main(String[] args) {
  26. Test t = new Test();
  27. t.test1();
  28. t.test2();
  29. t.test3();
  30. }
  31. }
  32. /** * output: * test1() * test2() * test3() */

可以看见,在Printtest3中继承了前面两个接口,所以当类Test实现Printtest3接口是需要重写三个接口的所有方法。

发表评论

表情:
评论列表 (有 0 条评论,441人围观)

还没有评论,来说两句吧...

相关阅读

    相关 抽象抽象方法接口

    抽象方法:使用abstract修饰的方法,没有方法体,只有声明。 抽象类:包含抽象方法的类就是抽象类、通过抽象类,我们可以做到严格限制子类的设计,使子类之间更加通用 •使用

    相关 抽象抽象方法

    抽象类和抽象方法的修饰符abstract 一、含有抽象方法的类必须声明为抽象类         换句话说就是抽象方法只能存在于抽象类中 二、抽象类必须被继承,抽象类中的方

    相关 抽象抽象方法

    抽象类: 1、抽象类的定义? 当多个类中出现相同功能,但是功能主体不同,这时可以进行向上抽取。只抽取功能定义,而不抽取功能主体。 如果在本类有无法实现的