抽象类
抽象的概述
父类当中的方法,被子类们重写,而子类的各自实现不一样,那么父类的方法声明和方法体,只有声明还有意义,而方法体内容则没有存在的意义。我们把这种没有方法体内容的方法称为抽象方法。Java语言规定,如果一个类包含了抽象的方法,那么该类就是一个抽象类。
定义:
抽象方法:没有方法体的方法
抽象类:包含抽象方法的类
关键字的使用格式
抽象方法:
使用abstract关键字修饰成员方法,该方法就成了抽象方法,抽象方法只包含一个方法名,而没有方法体,去掉花括号加分号
定义格式:
修饰符 abstract 返回值类型 方法名(参数列表);
实例代码
public abstract void run();
抽象类
如果一个类包含了抽象方法,那么该类就是一个抽象类。
定义格式:
修饰符 abstract class ClassNmae {};
示例代码
public abstract class Animal{
//奔跑的抽象方法
public abstract void run();
}
public abstract class People{
public abstract void eat();
}
抽象的使用
继承抽象类的子类必须重写父类的所有的抽象方法,否则,该子类也必须声明为一个抽象类。
注意事项
关于抽象类的使用需要注意的事项
-
抽象类不能直接创建new抽象类对象,如果创建对象,编译无法通过,只能创建其非抽象子类的对象。
-
抽象类中,可以有构造方法,时供子类创建对象时,初始化父类成员使用的
-
抽象类中不一定包含抽象方法,但是有抽象方法的类必定是抽象类
-
抽象类子类,必须重写父类中的所有的抽象方法,否则编译无法通过,除非该子类也是抽象类
重写实现:子类重写父类当中的抽象方法,去掉抽象方法当中的abstract关键字,然后添加方法体 和 { }
方法重写,是子类对父类抽象方法的完全实现,我们将这种重写操作,叫做方法实现
- 能够写出定义接口的格式
- 能够写出实现接口的格式
- 能够说出接口的成员特点
- 能够说出使用多态的前提条件
- 理解多态的向上转型
- 理解多态的向下转型
- 能够使用多态和接口完成相应的案例开发
接口
概述:
接口是Java语言中的一种引用类型,是方法的集合,如果说类的内部封装了成员变量,构造方法,成员方法,那么接口的内部主要就是封装了方法,包含了抽象方法(JDK1.7及以前),默认方法和静态方法(JDK1.8),私有方法(JDK1.9)
接口的定义,它与类的定义很相似,但不再使用class关键字进行声明,而是用interface关键字进行声明,但一定要明确它并不是类,而是另外的一种引用数据类型。
接口的使用不能直接创建对象,但可以被实现(interface关键字,类似于被继承),一个实现接口的类可以看作接口的子类,需要重写接口中的所有的抽象方法,创建该类对象,就可以调用方法了
接口就是多个类的公共规范,接口也是一种引用类型数据,如:类 数组 接口
备注:源文件还是.java,编译之后生成的字节码文件还是.class
格式:
public interface 接口名称{
//接口内容
//抽象方法 为主(JDK1.7)
//常量(JDK1.7)
//默认方法(JDK1.8)
//静态方法(JDK1.8)
//私有方法(JDK1.9)
}
含有抽象方法
抽象方法:使用abstract关键字修饰,没有方法体内容,该方法主要是提供子类使用的(重写)
public interface InterfaceName{
public abstract void method();
//public abstract 可以默认不写
}
还有默认方法和静态方法
默认方法:使用default关键字修饰的方法,不可省略,供子类调用或重写
静态方法:使用static关键字修饰的方法,供接口直接调用
还有私有的方法和私有静态方法
私有方法:使用private关键字,供接口中的默认方法和静态方法调用。
代码如下:
public interface InterfaceNmae {
private void method(){
//方法体内容
}
}
接口的使用步骤
1. 接口不能直接使用,必须有一个实现类来实现该接口
格式:
public class 实现类名称 implement 接口名称{
//类的成员信息
}
2. 接口的实现必须重写(实现)接口当中所有的抽象方法实现,去掉abstract关键字,分号写成大括号
3. 创建实现类的对象,进行使用
注意事项:
如果实现类当中并没有重写接口当中的所有的抽象方法,那么这个实现类必须是一个抽象类
基本事项:
实现的概述
类与接口的关系,为实现关系,即类实现接口,该类可以称为接口的实现类,也可以称为接口的子类。实现的动作类似于继承,格式相仿,只是关键字不同,实现使用implement关键字
非抽象类实现接口
- 必须重写接口当中的所有的抽象方法
- 继承了接口当中的默认方法,既可以直接调用,也可以重写
实现格式:
public class 实现类 implements 接口名称{
//重写接口当中的所有的抽象方法
//重写接口当中的默认方法【可选】
}
抽象方法的实现:
必须全部实现
代码如下
public interface Biological{//生物
//定义一个吃东西的功能
public abstract void eat();
//定义一个休息的功能
public abstract void sleep();
}
//定义一个实现类
public class Animal implement Biological {
@Override
public void eat(){
System.out.println("吃东西");
}
@Override
public void sleep()}{
System.out.println("睡觉");
}
}
//定义测试类
public class InterfaceDemo01 {
public static void main(String[] arge){
//创建子类对象
Animal ani = new Animal();
ani.eat;
ani.sleep;
}
}
输出结果
//吃东西
//睡觉
默认方法的使用
可以继承的,可以重写,二选一,但是只能通过实现类的对象来调用
-
继承默认方法,代码如下
public interface Biological{ public default void fly(){ System.out.println("天上飞") } } //定义实现类 public class Animal implement Biological { //继承 什么也不写 直接调用 } //定义测试类 public class InterfaceDemo01 { public static void main(String[] arge){ //创建子类对象 Animal ani = new Animal(); ani.fly(); } } //输出结果 //天上飞
2.重写默认方法,代码如下
public interface Biological{ public default void fly(){ System.out.println("天上飞") } } //定义实现类 public class Animal implement Biological { @Override public void fly(){ System.out.println("自由的飞"); } } //定义测试类 public class InterfaceDemo01 { public static void main(String[] arge){ //创建子类对象 Animal ani = new Animal(); ani.fly(); } } //结果: //自由的飞
静态方法的使用
静态的一般都是和类.class 文件相关。只能使用接口名调用,不可以通过实现类的类名或者实现类的对象来调用,代码如下
public interface Biological{
public static void fly(){
System.out.println("天上飞")
}
}
//定义实现类
public class Animal implement Biological {
//
}
//定义测试类
public class InterfaceDemo01 {
public static void main(String[] arge){
//通过类名直接调用
Biological.fly();
}
}
//结果:
//自由的飞
私有方法的使用
私有方法:只有默认方法可以调用
私有静态方法:默认方法和静态方法都可以调用
如果一个接口中有多个默认方法,并且方法中有重复的内容,那么可以抽取出来,封装到私有方法中,供默认方法去调用。从设计的角度考虑,私有的方法是对默认的方法和静态的方法的一种辅助。
代码如下
//定义一个接口
public interface Biological{
private void run1(){
System.out.println("跑");
}
public default void funMerhid1(){
//System.out.println("跑");
run1();
}
public default void funMerhid2(){
//System.out.println("跑");
run1();
}
public static void fly(){
System.out.println("天上飞")
}
}
接口的多实现
在继承体系中,一个类只能直接继承一个父类,而对于接口来说,一个类可以实现多个接口,这叫做接口的多实现。一个类能直接继承一个父类同时还可以实现多个接口
实现格式:
public class ClassName entends 父类 implement 接口1,接口2...{
//重写接口中的所有的抽象方法
//重写接口中的默认方法
}
抽象方法
接口当中,有多个抽象方法,实现类必须重写所用的抽象方法,如果抽象方法有重名,只需要重写一次即可,
//定义多个接口
public interface Animla{
public abstract void eat();
public abstract void run();
}
public interface Human{
public abstract void eat();
public abstract void run();
}
//定义实现类
public class People implements Animal,Human{
@Override
public void eat(){
System.out.println("吃东西");
}
@Override
public void run(){
System.out.println("健身");
}
}
默认方法
接口中,有多个默认方法时,实现类都可以继承使用,如果默认方法有重名的,必须重写一次,代码如下:
public interface A {
public default void methodA(){}
public default void method(){}
}
public interface B {
public default void methodB(){}
public default void method(){}
}
//定义实现类
public class C implements A,B {
@OVerride
public void method(){
System.out.println("method方法被重写..");
}
}
静态方法
接口中,如果存在同名的静态方法并不会发生冲突,原因是只能通过各自的接口名访问静态的方法。
优先级问题
当一个类,即继承了一个父类,又同时定义了多个接口,父类中的成员方法与接口当中的默认方法重名,子类就近执行父类成员方法
代码如下:
public interface A{
public default void methidA(){
System.out.println("AAA");
}
}
//定义父类
public class D {
public void methodA(){
System.out.println("DDD");
}
}
//定义子类
public class E extends D implements A {
//未重写methodA()方法
}
public interface InterfaceDemo06 {
public static void main(String[] args) {
E e = new E();
e.methodA();
}
}
//结果
//DDD
接口的多继承【了解】
一个接口能继承另一个接口或者多个接口,这和类之间的继承比较相似,接口的继承使用extends关键字,子接口继承父接口的方法,如果父接口中的默认方法又重名,那么子接口需要重新写一次,代码如下
public interface A {
public default void method(){
System.out.println("AAA");
}
}
public interface B {
public default void method(){
System.out.println("BBB");
}
}
//定义子接口
public interface C extends A,B{
@Override
public void method(){
System.out.println("CCC");
}
}
备注:子接口重写默认方法,default关键字保留。
其他成员特点:
- 接口中无法定义成员变量,但是可以定义常量,因为值不可变,默认使用的时public static final 修饰的
- 接口当中,没有构造方法,不能创建对象
- 接口当中,没有静态代码块
接口的好处:
- 设定了规则
- 降低了耦合性,【高内聚,低耦合】
- 可以扩展原有类的功能
接口与抽象类的异同
相同点:
- 都包含抽象方法,其子类都必须重写这些抽象方法
- 都不能直接实例化对象
- 都位于继承的顶端,用于被其他类实现或继承
区别:
- 抽象类里面可以包含普通成员方法,接口不能包含普通成员方法
- 一个类只能继承一个父类(可以是抽象类),一个类可以实现多个接口
- 类于类之间只能是单继承关系,接口与接口之间可以多继承
- 抽象类可以定义普通的成员变量和常量,而接口只能定义常量 public static final 修饰的