2020-11-24day12super关键字，this关键字，抽象类，接口

最新推荐文章于 2024-09-19 13:19:42 发布

crazy韩先森

最新推荐文章于 2024-09-19 13:19:42 发布

阅读量73

点赞数

文章标签： java

本文链接：https://blog.csdn.net/crazyhsl/article/details/110040873

版权

本文详细介绍了Java中的`super`和`this`关键字的使用，包括它们在访问成员变量和方法以及调用构造方法时的角色。此外，文章深入探讨了抽象类的概念，强调了抽象方法和抽象类的定义与使用规则。同时，文章讲解了接口的特性，如默认方法、静态方法、私有方法，并展示了接口的实现方式和多继承特性。最后，对比了抽象类与接口的区别，强调了它们在设计和扩展性上的考量。

摘要由CSDN通过智能技术生成

super和this的含义：

super :代表父类的存储空间标识（可以理解为父类的引用）；

this: 代表当前对象的引用（谁调用就是代表谁）；

super和this的用法：

super：

1.访问父类的成员：

super.成员变量

super.成员方法（）；

2.访问父类的构造方法：

super(...) 父类的构造方法

3.继承关系中，父类的构造方法的访问特点：

子类的构造方法当中有一个默认的隐式的super（）调用，所以一定是先调用父类的构造，后执行的子类构造
子类构造可以通过super关键字来调用父类的重载构造
super的父类构造调用，必须是子类构造方法中的第一个语句，不能一个子类构造调用多次super构造

总结：子类必须调用父类的构造方法，不写则赠送super();写了则用写的指定的super()调用，super只能有一个，还必须是第一个。

this：

1.访问当前类的成员：

this.成员方法（）；

this.成员变量;

2.访问当前的构造方法

this(....) 当前类的构造方法

this() 构造方法在调用时不能形成闭合；

this（...）调用时也必须是构造方法的第一个语句，唯一一个。

super(...)和this(...)两种构造方法调用时，不能同时调用。

继承的特点：

java语言只支持单继承，不支持多继承
Java语言只支持多级继承（继承体系）
顶级父类时Object类，所有的类默认都继承Object类
子类和父类是一种相对的概念

抽象类：

概述：父类当中的方法被子类们重写，子类的实现又不一样，那么父类的方法声明和方法体，只有声明还有意义，而方法体内容没有存在的意义。我们把这种没有方法体内容的方法称为抽象方法，Java语言规定，如果一个类包含了抽象的方法，那么该类就是一个抽象类。

定义：

抽象方法：没有方法体的方法。

抽象类：包含抽象方法的类。

abstract关键字的使用格式：

抽象方法：

使用abstract关键字修饰成员方法，该方法就成了抽象方法，抽象方法只包含了一个方法名，而没有方法体。

定义格式：

修饰符   abstract   返回值类型  方法名（参数列表）；
public  abstract  void   run();
public  abstract  void   eat();
public  abstract  void   jump();

抽象类：

如果一个类包含了抽象方法，那么该类就是一个抽象类；

定义格式：

修饰符   abstract  class ClassName{}

public abstract  class Animsl{

    //奔跑的抽象方法
    public  abstract  void  run();
    //吃饭的抽象方法
    public  abstract  void   eat();
    //跳跃的抽象方法
    public  abstract  void   jump();


}

抽象的使用：

继承抽象类的子类必须重写父类所有的抽象方法，否则，该子类也必须声明为一个抽象类。

不能直接创建new抽象类对象。
必须用一个子类来继承抽象父类。
子类必须重写抽象父类当中的所有的抽象方法。
重写实现，子类重写父类当中抽象方法，去掉抽象方法中的abstract关键字，然后添加方法体大括号。
创建子类对象进行使用。
方法重写，是子类对父类的抽象方法的完全实现，我们将这种方法重写操作，也叫做【实现方法】。

注意事项：

关于抽象类的使用，需要注意的事项：

1.抽象类不能创建对象，如果创建对象，编译无法通过。只能创建其非抽象子类的对象

2. 抽象类中可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

3.抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

4.抽象类的子类，必须重写父类中的所有的抽象方法，否则编译无法通过，除非该子类也是抽象类。

接口：

概述：

接口，是Java语言中的一种引用类型，是方法的集合，如果说类的内部封装了成员变量，构造方法和成员方法，那么接口的内部主要就是【封装了方法】，包含了抽象方法（JDK1.7及以前），默认方法和静态的方法（JDK1.8），私有方法（JDK1.9）.

接口的定义：

它与类的定义很相似，不再使用class关键字声明，而是用interface关键字声明，接口是多个类的公共规范，接口也是一种引用数据类型。

引用数据类型：类，数组，接口
public  interface  接口名称{
     
      （JDK1.7）
     //抽象方法   为主
public  abstract  void  method（）;
     //常量
     //不允许出现普通成员方法
      （JDK1.8）
     //默认方法
     //静态方法
       （JDK1.9）
     //私有方法

}

备注：源文件还是.java，编译之后生成的字节码文件还是.class ，但一定要明确他并不是类，而是另一种引用数据类型。

接口的使用，不能直接创建对象，但是可以被实现(implements关键字，类似于被继承)，一个实现接口的类（可以看做是接口的子类），需要重写接口中的所有的抽象方法，创建该类对象，就可以调用方法了。

含有抽象方法：

抽象方法：使用abstract关键字修饰，没有方法体内容，该方法主要是供子类使用的；

public interface InterfaceName{
    
     public abstract  void  method();
     //public  abstract 可以省略不写
}

含默认方法和静态方法

默认方法：使用default关键字修饰的方法，不可省略，供子类调用或者子类重写。

静态方法：使用static 关键字修饰的方法，供接口直接调用。

含有私有方法和私有静态的方法：

私有方法：使用private关键字，供接口中的默认方法使用或者静态方法调用。

代码如下：

public  interface InterfaceName{

    private  void   method(){
   
        //方法体内容
       
   }
   

}

基本的实现：

实现的概述：

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似于继承，格式相仿，只是关键字不同，实现使用【implements】关键字

非抽象类实现接口：

1.必须重写接口当中的所有的抽象方法

2.继承了接口中的默认方法，既可以直接调用，也可以重写。

实现格式

public class 实现类   implements 接口名称{
       //重写接口当中的所有的抽象方法
       //重写接口当中默认方法【可选】
}

抽象方法的使用：

必须全部实现：

public interface A{
      //定义一个吃东西的功能
       void  eat();
      //定义一个休息的功能
       void  sleep();
}
//定义一个实现类
public class  B implements A{
     
    void  eat(){
    System.out.println("吃东西");
    }

    void sleep(){
     System.out.println("睡觉");
    }
    
}

//定义测试类
public class Test{
    public static void main(String[] args){
    //创建子类对象
    B  b=new B();
    b.eat();
    b.sleep();
  }
}
//输出结果：
 
//吃东西

//睡觉

默认方法的使用:

可以继承，可以重写，二选一,但是只能通过实现类的对象来调用

1. 继承默认方法

public interface A{
      public default void fly(){
      System.out.println("天上飞");
      }
}
//定义一个实现类
public class  B implements A{
     
    //继承  什么也不写，直接调用
}

//定义测试类
public class Test{
    public static void main(String[] args){
    //创建子类对象
    B  b=new B();
    b.fly();
  }
}
//输出结果：
 
//天上飞

2. 重写默认方法,

public interface A{
      public default void fly(){
      System.out.println("天上飞");
      }
}
//定义一个实现类
public class  B implements A{
     
    //继承 
   @override 
     public default void fly(){
     System.out.println("飞");
    }
}

//定义测试类
public class Test{
    public static void main(String[] args){
    //创建子类对象
    B  b=new B();
    b.fly();
  }
}
//输出结果：
 
//飞

静态方法的使用：

一般都是和类.class文件相关，【只能】使用【接口名】来调用，不可以通过实现类的类名或者是实现类的对象来调用。

public interface A{
   public static void run(){
    System.out.println("好好跑");
  }
}
//定义实现类

public class B implements A{
                
  //无法重写静态方法
}

//定义测试类
 
public class Test{
  public static void main(String[] args){
    
    //B.run();//操作错误，无法继承。也无法调用
  
    //调用静态方法
    A.run();
   }
}
//输出结果
//好好跑

私有方法的使用：

私有方法：只有默认方法可以调用，

私有静态方法：默认方法和静态方法都可以调用。

如果一个接口中有多个默认方法并且方法中有重复的内容。那么可以抽取出来，封装到私有方法中供默认方法去调用。从设计的角度考虑，私有的方法是对默认的方法和静态的方法的一种辅助。

//定义一个接口
public interface A{
   
     private void  run1(){
    
       System.out.println("跑起来。。。。");
     }
   
     public default  void fun1(){
   
       //System.out.println("跑起来。。。。");
        run1();
     }

     public default  void fun2(){
   
       //System.out.println("跑起来。。。。");
        run1();
     }
    

}

接口的使用步骤：

1. 接口不能直接使用，必须有一个”实现类“来实现该接口，类似于继承，但又不是继承，一个实现接口的类（可以看作是接口的子类），需要重写接口当中的所有抽像方法，创建该类对象，就可以调用方法了。

格式：public class 实现类名称 implements 接口名称{

//类的成员信息

}

2. 接口的实现类必须重写（实现）接口当中的所有的抽象方法

实现：去掉abstract 关键字，分号换成大括号。

3. 创建实现类的对象，进行使用。

注意事项：

如果实现类当中并没有重写接口当中的所有的抽象方法，那么这个实现类自己必须是一个抽象类。

接口的多实现：

在继承体系中，一个类只能直接继承一个父类，而对于接口来说，一个类可以实现多个接口，这叫做接口的【多实现】并且一个类能直接继承一个父类同时还可以实现多个接口。

public   class ClassName  extends  父类  implements 接口名1，接口名2，....{

     //重写接口中的所有的抽象方法
     //重写接口中的默认的方法【可选】
     //抽象方法重名
}

抽象方法

接口中，有多个抽象方法，实现类必须重写所有的抽象方法，如果抽象方法有重名的，只需要重写一次即可

//定义多个接口
 public interface  A
{
   public abstract  void    eat();
   public abstract  void    run();
}

public interface  B{
  
   public abstract  void    eat();
   public abstract  void    run();
}

//定义实现类

public class  C implements A,B{
   @override
   public void eat(){

    System.out.println("吃东西");
   
  }
  public void run(){

    System.out.println("健身");

  }

默认方法

接口中，有多个默认方法时，实现类都可以继承使用，如果默认方法有重名的，【必须重写一次】。

//定义多个接口
 public interface  A
{
   public default  void    eat();
   public default  void    run();
}

public interface  B{
  
   public default void    jump();
   public default void    run();
}

//定义实现类

public class  C implements A,B{
   
  public void run(){

    System.out.println("健身");

  }
}

静态方法

接口中，如果存在同名的静态方法并不会冲突，原因是只能通过各自的接口名访问静态方法。

优先级问题

当一个类，即继承了一个父类，又同时实现了多个接口，父类中的成员方法与接口中的默认方法重名，【子类就近选择执行父类的成员方法】。

public interface A{
  
    public  default  void m1(){
   
       System.out.println("AAAAAA");
    
    }
}

//定义父类

public class B{
   public void  m1(){

     System.out.println("BBBBBB");
   }
}

//定义子类

public class C extends B implements A{
    //未重写m1()方法
}

//定义测试类

public  class Test{

   public static void main(String[]  args){
   
    //创建子类对象C
 
    C c=new C();

    c.m1();


}

}
//输出结果
//BBBBBB

接口的多继承【了解】

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用extends关键字，子接口继承父接口的方法，如果父接口中的默认方法有重名方法，那么子接口需要重写一次。

public interface A{
  
    public default void   m1(){
    
      System.out.println("AAAAAA");
    }
}

public interface B{
  
    public default void   m1(){
    
      System.out.println("BBBBBB");
    }
}
//定义子接口
  
public interface  C extends A,B{
    
   @Override
    
    public default void  m1(){
   
     System.out.println("CCCCCC");

    }
}

备注：子接口重写默认方法default关键字不能省略，

其他成员特点：

1. 接口中无法定义成员变量，但是可以定义常量。因为值不可变，默认使用public static final 修饰的

2. 接口中没有构造方法，不能创建对象。

3. 接口当中，没有静态代码块。

接口的好处：

1.接口可以定义规则；

2.降低耦合性，高内聚，低耦合。

3.扩展原有类的功能。

接口与抽象类的区别：

相同： 都包含抽象方法，其子类都必须重写这些抽象方法。

都不能直接实例化对象。