Skip to main content
 首页 » 编程设计

Java中的继承抽象类和接口

2022年07月19日29wuhuacong

一、总结

1.使用extends关键字继承,eg: class Student extends Persion { ...};

2.Java编程规范中类的首字母大写,方法的首字母小写单词首字母代谢,eg: setYourName()

3.子类继承父类后可以重写(override)父类的成员方法。如果子类override了,子类中再调用就是调用自己的,若没有提供,调用的就是父类的。

4.对象实例化的时候,会先调用父类的构造函数,然后再调用子类的构造方法。若类没有定义构造方法,java编译器会帮你生成一个public的无参的什么都不做的构造方法。
若父类有多个构造函数,使用super()调用父类的无参构造函数,这个super()在子类的构造方法中是否显示的写出来无所谓。也可以在子类的构造函数中显式调用super()来调用父类的无参构造方法;

也可以用 super(参数描述) 来调用父类的有参数的构造函数super()必须要在子类的构造函数的最开始处调用。

5.final关键字,final表示最终的

若使用final修饰一个类就表示它是一个最终的类,那么它就不能再有子类。 eg. final class A {...}
若使用final来修饰一个方法,就表示它是一个最终的方法,就不能再被复写
若使用final修饰成员变量就表示它不能再被修改,就变成了常量

6.继承的限制(父传子)
(1) 子类无法直接访问父类的privete属性.
(2) 子类无法访问父类的"绝招",比如父类将某个方法定位为privete的。
(3) 子类不能私吞祖传的东西,必须还要继续往下传。比如父类的public方法,子类将其重写成private的是不行的。也就是是子类可以复写,但是不能缩小其权限

7.若父类中有一个private的函数,子类实现了一个同名的函数,这不是override,而是自己又重写写的一个函数。因为子类根本就看不见父类的这个方法。只不过刚好名字相同而已。

8.抽象类
作用:可以作为一个“模板”来规定子类必须实现的方法。抽象类不能实例化对象,用于继承。类前加abstract关键字修饰。
抽象方法:抽象方法需要加abstract修饰。若有子类继承这个抽象类的时候,子类中必须实现父类中的抽象方法。

抽象类中可以定义各种变量、常量、方法,从这里看抽象类强于接口。

abstract class 类名 {
  属性
  普通方法{}

  //抽象方法,可以一个或多个
  访问权限 abstract 返回值类型 方法名(参数); /*只需要声明,不需要实现*/
}
子类继承抽象类:
class Student extends Persion {}

9.接口
interface 接口名称 {
  全局常量;
  抽象方法;
}

eg:
interface A {
  public static final i = 10; //定义成全局常量
  public static int j = 15;
  public abstract int getNumber();
}

子类实现接口:
  class Student implement A,B{ //这里子类同时实现A B这两个接口(java中只有单继承,但是可以同时implements多个接口)
}

class Student extends Persion implement A,B{ //实现A B这两个接口的同时继承(抽象)类
}

有了抽象类还存在接口的原因:抽象类的使用中,一个子类只能继承一个抽象类,而接口可以突破这个限制。

接口也可以继承接口,eg: interface B extends A {}, 此时接口B中也会有接口A的方法。

10.抽象类和接口对比
抽象类和接口非常相似,里面都有abstract修饰的抽象方法抽象类中可以定义变量,也可也定义常量,还可以定义普通的方法对于接口里面只能定义常量抽象方法。接口比抽象类优秀的一点是可以突破单继承的限制。接口和抽象类一般用作模板,其里面定义一些抽象方法,其子类必须实现这些抽象方法。
eg:
接口中写int i = 10; 编译器会把它变成 public static final int i = 10;
接口中直接写成int getNum();编译器会把它变成 public abstract int getNum();
也就是说这些关键字不写,还是常量,还是抽象方法。

11.只有abstract修饰的抽象类中才可以使用abstract修饰成员方法为抽象方法。

12.java中只有单继承,但是可以同时implements多个接口

13.抽象类虽然不能直接实例化对象,但是同样可以有构造函数,且被继承时构造函数的调用次序和普通类相同。

14.抽象类的构造函数不能是抽象函数,也即不能加abstract修饰。

15,不可以同时实现接口和继承(抽象)类, class P implements A, extends Person {} 报错

16.abstract修饰的抽象类中若没有实现的函数,必须使用abstract修饰。而且必须写明权限(接口的默认是public abstract,所以可以可不写),

17.abstract类implements接口可以不实现接口中的方法,普通类必须实现

  abstract class Stub implements ILedService{ }

二、试验demo

1.继承

class Person { 
    private int age; 
 
    public void setAge(int age) { 
        if (age < 0 || age > 200) 
            age = 0; 
        else { 
            this.age = age; 
        } 
    } 
 
    public int getAge() { 
        return age; 
    }     
 
    public void printInfo() { 
        System.out.println("age = "+age); 
    } 
 
    public Person () {System.out.println("Person ()");} 
    public Person (int age) { 
        System.out.println("Person (int age)"); 
        this.age = age; 
    } 
     
} 
 
class Student extends Person{ 
    private String school; 
 
    public void setSchool(String school) { 
        this.school = school; 
    } 
 
    public String getSchool() { 
        return school; 
    }     
 
    public Student(String school) { 
        /* will call the super() */ 
        //super(); 
        super(5); 
        System.out.println("Student(String school)"); 
        this.school = school; 
    } 
 
    /* override */ 
    public void printInfo() { 
        System.out.println("school = "+school+"; age = "+getAge()); 
    } 
     
} 
 
public class Ext4 { 
    public static void main (String args[]) { 
        Student stu = new Student("ustc"); 
 
        stu.setAge(10); 
 
        System.out.println(stu.getAge()); 
        System.out.println(stu.getSchool()); 
        stu.printInfo(); 
    } 
}

2.抽象类

abstract class Father { 
    private int money;     
 
    public int getMoney() {return money; } 
    public void setMoney(int money) {this.money = money; } 
 
    public abstract void study(); 
} 
 
class Son extends Father{ 
    public void study() {System.out.println("I am study"); } 
     
} 
 
public class Ext6 { 
    public static void main (String args[]) { 
        //Father f = new Father(); //Abstract classes are not allowed to be instantiated 
        Son son = new Son(); 
        son.study(); 
 
    } 
}

3.接口

abstract class Father { 
    private int money;     
 
    public int getMoney() {return money; } 
    public void setMoney(int money) {this.money = money; } 
 
    public abstract void study(); 
} 
 
interface A { 
    public static final int i = 10; 
    public abstract int getNum(); 
} 
 
interface B { 
    public static String name = "InterfaceB"; 
    public abstract String getName(); 
} 
 
class Son extends Father implements A,B{ 
    public int getNum() {return i;} 
    public String getName() {return name;} 
    public void study() {System.out.println("I am study"); } 
     
} 
 
public class Ext7 { 
    public static void main (String args[]) { 
        Son son = new Son(); 
        System.out.println(son.getName()); 
        son.study(); 
    } 
}

补充:

抽象类和接口的区别:

参数 抽象类 接口
默认的方法实现 它可以有默认的方法实现 接口完全是抽象的。它根本不存在方法的实现
实现 子类使用extends关键字来继承抽象类。如果子类不是抽象类的话,它需要提供抽象类中所有声明的方法的实现。 子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现(若实现类是abstract的也不需要全部实现)
构造器 抽象类可以有构造器 接口不能有构造器
与正常Java类的区别 除了你不能实例化抽象类之外,它和普通Java类没有任何区别 接口是完全不同的类型
访问修饰符 抽象方法可以有publicprotecteddefault这些修饰符 接口方法默认修饰符是public。你不可以使用其它修饰符。
main方法 抽象方法可以有main方法并且我们可以运行它 接口没有main方法,因此我们不能运行它。
多继承 抽象方法可以继承一个类和实现多个接口 接口只可以继承一个或多个其它接口
速度 它比接口速度要快 接口是稍微有点慢的,因为它需要时间去寻找在类中实现的方法。
添加新方法 如果你往抽象类中添加新的方法,你可以给它提供默认的实现。因此你不需要改变你现在的代码。 如果你往接口中添加方法,那么你必须改变实现该接口的类。


本文参考链接:https://www.cnblogs.com/hellokitty2/p/10425650.html