• Java学习笔记（十三）

    在完成对C语言的学习后，我最近开始了对C++和Java的学习，目前跟着视频学习了一些语法，也跟着敲了一些代码，有了一定的掌握程度。现在将跟着视频做的笔记进行整理。本篇博客是整理Java知识点的第十三篇博客。

    本篇博客介绍了Java的抽象类和接口。

    本系列博客所有Java代码都使用IntelliJ IDEA编译运行，版本为2022.1。所用JDK版本为JDK11。

    目录

    抽象类

    抽象类的概述和特点

    抽象类的成员特点

    猫和狗

    接口

    接口的概述和特点

    接口的成员特点

    猫和狗

    类和接口的关系

    抽象类和接口的区别

    运动员和教练案例

    抽象类

    抽象类的概述和特点

    在Java中，一个没有方法体的方法是抽象方法，类中如果有抽象方法，就必须定义为抽象类。

    抽象类和抽象方法必须用关键字abstract修饰。修饰类时插在public和class中间。修饰方法时插在权限修饰符和返回值类型中间。

    抽象类不一定有抽象方法，但是有抽象方法的类一定是抽象类。

    抽象类不能实例化，必须通过多态用子类实例化。抽象类的子类必须重写抽象类的所有抽象方法，否则就是抽象类。

    1. public abstract class animalabstract {
    2.     public abstract void show();
    3. }

    父类animalabstract的show方法是抽象方法，没有方法体。

    1. public class catanimal extends animalabstract{
    2.     public void show(){
    3.         System.out.println("Cat is animal");
    4.     }
    5. }

    catanimal是子类，重写了show方法。

    1. public class abstracttest {
    2.     public static void main(String[] args){
    3.         animalabstract cat = new catanimal();
    4.         cat.show();
    5.     }
    6. }

    abstracttest类通过多态实例化了一个对象。

    程序的输出是：

    Cat is animal

    抽象类的成员特点

    抽象类的成员变量可以是变量，也可以是常量。抽象类有构造方法，但是不能实例化。

    抽象类可以有抽象方法，也可以有非抽象方法。

    猫和狗

    用抽象类实现猫和狗。

    1. public abstract class animalabstracttest {
    2.     String name;
    3.     int age;
    4.     animalabstracttest(){}
    5.     animalabstracttest(String name,int age){
    6.         this.name = name;
    7.         this.age = age;
    8.     }
    9.  
    10.     public String getname(){
    11.         return name;
    12.     }
    13.     public void setname(String name){
    14.         this.name = name;
    15.     }
    16.     public int getage(){
    17.         return age;
    18.     }
    19.     public void setage(int age){
    20.         this.age = age;
    21.     }
    22.     public abstract void eat();
    23.  
    24.     public void show(){
    25.         System.out.println("The name is " + name);
    26.         System.out.println("The age is " + age);
    27.     }
    28. }

    这是父类animalabstracttest，是一个抽象类，其中eat方法是抽象方法。

    1. public class catabstracttest extends animalabstracttest{
    2.     catabstracttest(){}
    3.     catabstracttest(String name,int age){
    4.         super(name,age);
    5.     }
    6.  
    7.     public void eat(){
    8.         System.out.println("Cat can eat something");
    9.     }
    10. }
    1. public class dogabstracttest extends animalabstracttest{
    2.     dogabstracttest(){}
    3.     dogabstracttest(String name,int age){
    4.         super(name,age);
    5.     }
    6.  
    7.     public void eat(){
    8.         System.out.println("Dog can eat something");
    9.     }
    10. }

    子类catabstracttest和dogabstracttest都重写了eat方法。

    1. public class catdoganimalabstract {
    2.     public static void main(String[] args){
    3.         animalabstracttest cat = new catabstracttest();
    4.         cat.setname("Gaston");
    5.         cat.setage(6);
    6.         cat.show();
    7.         cat.eat();
    8.  
    9.         animalabstracttest dog = new dogabstracttest("Paula",6);
    10.         dog.show();
    11.         dog.eat();
    12.     }
    13. }

    catdoganimalabstract类是测试类。程序的输出是：

    The name is Gaston
    The age is 6
    Cat can eat something
    The name is Paula
    The age is 6
    Dog can eat something

    接口

    接口的概述和特点

    接口是一种公共的规范标准。Java的接口体现在对行为的抽象。

    接口用关键字interface修饰，创建接口的格式是：

    public interface 接口名{...}

    类实现接口名用implements表示，格式是：

    public class 类名 implements 接口名

    接口也通过多态用子类进行实例化，多态分为具体类多态，抽象类多态和接口多态。

    接口的实现类必须重写接口的所有抽象方法，否则就是抽象类。

    1. public interface firsttest {
    2.     public void show();
    3. }

    这是一个接口，内含show方法。

    1. public class catcat implements firsttest{
    2.     public void show(){
    3.         System.out.println("This is a cat");
    4.     }
    5. }

    这是catcat类，实现了firsttest接口，具体实现show方法。

    1. public class interfactimplementtest {
    2.     public static void main(String[] args){
    3.         firsttest cat = new catcat();
    4.         cat.show();
    5.     }
    6. }

    这是测试代码。程序输出：

    This is a cat

    接口的成员特点

    接口的成员变量只能是常量，默认修饰符是public static final。

    接口没有构造方法。接口的成员方法只能是抽象方法，默认修饰符是public abstract。JDK8和JDK9出现了一些新特性，在后面。

    猫和狗

    用接口实现猫和狗。

    1. public interface catdogtestinterface {
    2.     public abstract void jump();
    3. }

    catdogtestinterface接口的jump方法是抽象方法。

    1. public class animalinterfacetest {
    2.     String name;
    3.     int age;
    4.     animalinterfacetest(){}
    5.     animalinterfacetest(String name,int age){
    6.         this.name = name;
    7.         this.age = age;
    8.     }
    9.  
    10.     public void setname(String name){
    11.         this.name = name;
    12.     }
    13.     public String getname(){
    14.         return name;
    15.     }
    16.     public void setage(int age){
    17.         this.age = age;
    18.     }
    19.     public int getage(){
    20.         return age;
    21.     }
    22.     public void show(){
    23.         System.out.println("The name is " + name);
    24.         System.out.println("The age is " + age);
    25.     }
    26. }

    这是animalinterfacetest类。

    1. public class cattestinterface extends animalinterfacetest implements catdogtestinterface{
    2.     public cattestinterface(){}
    3.     public cattestinterface(String name,int age){
    4.         super(name,age);
    5.     }
    6.  
    7.     public void jump(){
    8.         System.out.println("Cat can jump");
    9.     }
    10. }
    1. public class dogtestinterface extends animalinterfacetest implements catdogtestinterface{
    2.     public dogtestinterface(){}
    3.     public dogtestinterface(String name,int age){
    4.         super(name,age);
    5.     }
    6.  
    7.     public void jump(){
    8.         System.out.println("Dog can jump");
    9.     }
    10. }

    cattestinferface和dogtestinterface类都继承animalinterfacetest类，并实现catdogtestinterface接口，都重写了jump方法。

    1. public class interfacetest {
    2.     public static void main(String[] args){
    3.         animalinterfacetest cat = new cattestinterface();
    4.         cat.setname("Gafilo");
    5.         cat.setage(6);
    6.         cat.show();
    7.         cattestinterface cattemp = (cattestinterface)cat;
    8.         cattemp.jump();
    9.  
    10.  
    11.         animalinterfacetest dog = new dogtestinterface("Paula",6);
    12.         dog.show();
    13.         dogtestinterface dogtemp = (dogtestinterface)dog;
    14.         dogtemp.jump();
    15.     }
    16. }

    这是interfacetest类，是测试代码。

    程序的输出是：

    The name is Gafilo
    The age is 6
    Cat can jump
    The name is Paula
    The age is 6
    Dog can jump

    类和接口的关系

    类和类只能单继承，不能同时继承多个类。但是类可以实现单个接口，也可以实现多个接口。

    接口可以实现单个接口，也可以实现多个接口。

    抽象类和接口的区别

    抽象类可以有变量和常量，可以有构造方法，抽象方法和非抽象方法。接口只能有常量和抽象方法（后面介绍接口还可以有其他内容）。

    抽象类对类抽象，包括属性和行为。接口主要对行为抽象。

    运动员和教练案例

    有乒乓球教练，乒乓球运动员，篮球教练和篮球运动员。乒乓球相关人员要学习英语。运动员要进行训练，教练要进行教授，所有人都要吃饭。要用代码表示。

    1. public interface studyenglish {
    2.     public void studyenglish();
    3. }

    studyenglish接口的studyenglish是抽象方法。

    1. public abstract class person {
    2.     String name;
    3.     int age;
    4.     person(){}
    5.     person(String name,int age){
    6.         this.name = name;
    7.         this.age = age;
    8.     }
    9.  
    10.     public void setname(String name){
    11.         this.name = name;
    12.     }
    13.     public String getname(){
    14.         return name;
    15.     }
    16.     public void setage(int age){
    17.         this.age = age;
    18.     }
    19.  
    20.     public int getage(){
    21.         return age;
    22.     }
    23.     public void show(){
    24.         System.out.println("The name is " + name);
    25.         System.out.println("The age is " + age);
    26.     }
    27.  
    28.     public abstract void eat();
    29. }

    person类有成员变量name和age，对应的get和set方法，show方法，以及抽象方法eat。是对人的抽象。

    1. public abstract class player extends person {
    2.     public player(){}
    3.     public player(String name,int age){
    4.         super(name ,age);
    5.     }
    6.  
    7.     public abstract void eat();
    8.     public abstract void study();
    9. }

    player类有抽象方法eat和study，是对运动员的抽象，继承了person类。

    1. public abstract class coach extends person{
    2.     public coach(){}
    3.     public coach(String name,int age){
    4.         super(name ,age);
    5.     }
    6.  
    7.     public abstract void eat();
    8.     public abstract void teach();
    9. }

    coach类有抽象方法eat和teach，是对教练的抽象，继承了person类。

    1. public class pingpangcoach extends coach implements studyenglish{
    2.     public pingpangcoach(){}
    3.     public pingpangcoach(String name,int age){
    4.         super(name,age);
    5.     }
    6.  
    7.     public void eat(){
    8.         System.out.println("Pingpang coach eat meal A");
    9.     }
    10.     public void teach(){
    11.         System.out.println("Pingpang coach teach pingpang");
    12.     }
    13.     public void studyenglish(){
    14.         System.out.println("Pinngpang coach should study english");
    15.     }
    16. }

    pingpangcoach类实现了eat，teach和studyenglish方法，继承coach类，实现studyenglish接口，是对乒乓球教练的抽象。

    1. public class pingpangplayer extends player implements studyenglish{
    2.     public pingpangplayer(){}
    3.     public pingpangplayer(String name,int age){
    4.         super(name,age);
    5.     }
    6.  
    7.     public void eat(){
    8.         System.out.println("Pingpang player eat meal B");
    9.     }
    10.     public void study(){
    11.         System.out.println("Pingpang player study pingpang");
    12.     }
    13.     public void studyenglish(){
    14.         System.out.println("Pinngpang player should study english");
    15.     }
    16. }

    pingpangplayer类实现了eat，study和studyenglish方法，继承player类，实现studyenglish接口，是对乒乓球教练的抽象。

    1. public class basketballcoach extends coach{
    2.     public basketballcoach(){}
    3.     public basketballcoach(String name,int age){
    4.         super(name,age);
    5.     }
    6.  
    7.     public void eat(){
    8.         System.out.println("basketball coach eat meal C");
    9.     }
    10.     public void teach(){
    11.         System.out.println("basketball coach teach basketball");
    12.     }
    13. }

    basketballcoach类实现了eat和teach方法，继承coach类，是对篮球教练的抽象。

    1. public class basketballplayer extends player{
    2.     public basketballplayer(){}
    3.     public basketballplayer(String name,int age){
    4.         super(name,age);
    5.     }
    6.  
    7.     public void eat(){
    8.         System.out.println("basketball player eat meal D");
    9.     }
    10.     public void study(){
    11.         System.out.println("basketball player study basketball");
    12.     }
    13. }

    basketballplayer类实现了eat和study方法，继承player类，是对篮球运动员的抽象。

    1. public class playercoachtest {
    2.     public static void main(String[] args){
    3.         pingpangcoach A = new pingpangcoach();
    4.         A.setname("David");
    5.         A.setage(36);
    6.         A.show();
    7.         A.eat();
    8.         A.teach();
    9.         A.studyenglish();
    10.         pingpangplayer B = new pingpangplayer("Simon",25);
    11.         B.show();
    12.         B.eat();
    13.         B.study();
    14.         B.studyenglish();
    15.  
    16.         basketballcoach C = new basketballcoach();
    17.         C.setname("Steve");
    18.         C.setage(56);
    19.         C.show();
    20.         C.eat();
    21.         C.teach();
    22.         basketballplayer D =new basketballplayer("Kevin",31);
    23.         D.show();
    24.         D.eat();
    25.         D.study();
    26.     }
    27. }

    playercoachtest类实现了具体功能，实例化了这四个对象。

    程序的输出是：

    The name is David
    The age is 36
    Pingpang coach eat meal A
    Pingpang coach teach pingpang
    Pinngpang coach should study english
    The name is Simon
    The age is 25
    Pingpang player eat meal B
    Pingpang player study pingpang
    Pinngpang player should study english
    The name is Steve
    The age is 56
    basketball coach eat meal C
    basketball coach teach basketball
    The name is Kevin
    The age is 31
    basketball player eat meal D
    basketball player study basketball

  • 相关阅读:
    动态网页和前端技术基础知识
    oracle 数据链接过多，导致后续链接链接不上
    基于（springmvc+tomcat+JavaScript）的收支管理MoneySSM系统
    计算机毕业设计Java大型商场应急预案管理系统(源码+系统+mysql数据库+lw文档)
    CNM：MERGE INTO
    【NOWCODER】- Python：循环语句（二）
    WebGL 中的灯光设置
    Java反射的详细解析一
    LeetCode算法练习top100：（4）链表
    使用selenium用xpath获取页面元素遇到的bug以及解决办法
  • 原文地址：https://blog.csdn.net/m0_71007572/article/details/126310864