• JavaSE | 初始Java(十一) | 抽象类和抽象接口

    抽象类概念
    在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的， 如果 一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类
    在 Java 中，一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。 
    1. // 抽象类：被abstract修饰的类
    2. public abstract class Shape {
    3.     // 抽象方法：被abstract修饰的方法，没有方法体
    4.     abstract public void draw();
    5.     abstract void calcArea();
    6.     // 抽象类也是类，也可以增加普通方法和属性
    7.     public double getArea(){
    8.         return area;
    9.     }
    10.     protected double area; // 面积
    11. }
    注意：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法
    抽象类特性
    1. 抽象类不能直接实例化对象 
    1. Shape shape = new Shape();
    2. // 编译出错
    3. Error:(30, 23) java: Shape是抽象的; 无法实例化
    2. 抽象方法不能是 private 的 
    1. abstract class Shape {
    2.     abstract private void draw();
    3. }
    4. // 编译出错
    5. Error:(4, 27) java: 非法的修饰符组合: abstract和private
    3. 抽象方法不能被 final 和 static 修饰，因为抽象方法要被子类重写 
    1. public abstract class Shape {
    2.     abstract final void methodA();
    3.     abstract public static void methodB();
    4. }
    5. // 编译报错：
    6. // Error:(20, 25) java: 非法的修饰符组合: abstract和final
    7. // Error:(21, 33) java: 非法的修饰符组合: abstract和static
    4. 抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰 
    1. // 矩形类
    2. public class Rect extends Shape {
    3.     private double length;
    4.     private double width;
    5.     Rect(double length, double width){
    6.         this.length = length;
    7.         this.width = width;
    8.     }
    9.     public void draw(){
    10.         System.out.println("矩形: length= "+length+" width= " + width);
    11.     }
    12.     public void calcArea(){
    13.         area = length * width;
    14.     }
    15. }
    16. // 圆类：
    17. public class Circle extends Shape{
    18.     private double r;
    19.     final private static double PI = 3.14;
    20.     public Circle(double r){
    21.         this.r = r;
    22.     }
    23.     public void draw(){
    24.         System.out.println("圆：r = "+r);
    25.     }
    26.     public void calcArea(){
    27.         area = PI * r * r;
    28.     }
    29. }
    30. // 三角形类：
    31. public abstract class Triangle extends Shape {
    32.     private double a;
    33.     private double b;
    34.     private double c;
    35.     @Override
    36.     public void draw() {
    37.         System.out.println("三角形：a = "+a + " b = "+b+" c = "+c);
    38.     }
    39.     // 三角形：直角三角形、等腰三角形等，还可以继续细化
    40.     //@Override
    41.     //double calcArea(); // 编译失败：要么实现该抽象方法，要么将三角形设计为抽象类
    42. }
    5. 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类
    6. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量
    接口
    接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用 。
    在 Java 中，接口可以看成是：多个类的公共规范，是一种引用数据类型。
    接口的定义格式与定义类的格式基本相同，将 class 关键字换成 interface 关键字，就定义了一个接口。 
    1. public interface 接口名称{
    2.     // 抽象方法
    3.     public abstract void method1(); // public abstract 是固定搭配，可以不写
    4.     public void method2();
    5.     abstract void method3();
    6.     void method4();
    7.     // 注意：在接口中上述写法都是抽象方法，跟推荐方式4，代码更简洁
    8. }
    提示:
    • 1. 创建接口时, 接口的命名一般以大写字母 I 开头.
    • 2. 接口的命名一般使用 "形容词" 词性的单词.
    • 3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性
    接口不能直接使用，必须要有一个 " 实现类 " 来 " 实现 " 该接口，实现接口中的所有抽象方法。 
    1. public class 类名称 implements 接口名称{
    2.     // ...
    3. }
    注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。 
    1. // USB接口
    2. public interface USB {
    3.     void openDevice();
    4.     void closeDevice();
    5. }
    6. // 鼠标类，实现USB接口
    7. public class Mouse implements USB {
    8.     @Override
    9.     public void openDevice() {
    10.         System.out.println("打开鼠标");
    11.     }
    12.     @Override
    13.     public void closeDevice() {
    14.         System.out.println("关闭鼠标");
    15.     }
    16.     public void click(){
    17.         System.out.println("鼠标点击");
    18.     }
    19. }
    20. // 键盘类，实现USB接口
    21. public class KeyBoard implements USB {
    22.     @Override
    23.     public void openDevice() {
    24.         System.out.println("打开键盘");
    25.     }
    26.     @Override
    27.     public void closeDevice() {
    28.         System.out.println("关闭键盘");
    29.     }
    30.     public void inPut(){
    31.         System.out.println("键盘输入");
    32.     }
    33. }
    34. // 笔记本类：使用USB设备
    35. public class Computer {
    36.     public void powerOn(){
    37.         System.out.println("打开笔记本电脑");
    38.     }
    39.     public void powerOff(){
    40.         System.out.println("关闭笔记本电脑");
    41.     }
    42.     public void useDevice(USB usb){
    43.         usb.openDevice();
    44.         if(usb instanceof Mouse){
    45.             Mouse mouse = (Mouse)usb;
    46.             mouse.click();
    47.         }else if(usb instanceof KeyBoard){
    48.             KeyBoard keyBoard = (KeyBoard)usb;
    49.         keyBoard.inPut();
    50.     }
    51.     usb.closeDevice();
    52.     }
    53. }
    54. // 测试类：
    55. public class TestUSB {
    56.     public static void main(String[] args) {
    57.         Computer computer = new Computer();
    58.         computer.powerOn();
    59.         // 使用鼠标设备
    60.         computer.useDevice(new Mouse());
    61.         // 使用键盘设备
    62.         computer.useDevice(new KeyBoard());
    63.         computer.powerOff();
    64.     }
    65. }
    接口特性
    1. 接口类型是一种引用类型，但是不能直接 new 接口的对象 
    1. public class TestUSB {
    2.     public static void main(String[] args) {
    3.         USB usb = new USB();
    4.     }
    5. }
    6. // Error:(10, 19) java: day20210915.USB是抽象的; 无法实例化
    2. 接口中每一个方法都是 public 的抽象方法 , 即接口中的方法会被隐式的指定为 public abstract （只能是 public abstract，其他修饰符都会报错 ) 
    1. public interface USB {
    2.     // Error:(4, 18) java: 此处不允许使用修饰符private
    3.     private void openDevice();
    4.     void closeDevice();
    5. }
    3. 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现 
    1. public interface USB {
    2.     void openDevice();
    3.     // 编译失败：因为接口中的方式默认为抽象方法
    4.     // Error:(5, 23) java: 接口抽象方法不能带有主体
    5.     void closeDevice(){
    6.         System.out.println("关闭USB设备");
    7.     }
    8. }
    4. 重写接口中方法时，不能使用默认的访问权限 
    1. public interface USB {
    2.     void openDevice(); // 默认是public的
    3.     void closeDevice(); // 默认是public的
    4. }
    5. public class Mouse implements USB {
    6.     @Override
    7.     void openDevice() {
    8.         System.out.println("打开鼠标");
    9.     }
    10.     // ...
    11. }
    12. // 编译报错，重写USB中openDevice方法时，不能使用默认修饰符
    13. // 正在尝试分配更低的访问权限; 以前为public
    5. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量 
    1. public interface USB {
    2.     double brand = 3.0; // 默认被：final public static修饰
    3.     void openDevice();
    4.     void closeDevice();
    5. }
    6. public class TestUSB {
    7.     public static void main(String[] args) {
    8.         System.out.println(USB.brand); // 可以直接通过接口名访问，说明是静态的
    9.         // 编译报错：Error:(12, 12) java: 无法为最终变量brand分配值
    10.         USB.brand = 2.0; // 说明brand具有final属性
    11.     }
    12. }
    6. 接口中不能有静态代码块和构造方法 
    1. public interface USB {
    2.     // 编译失败
    3.     public USB(){
    4.     }
    5.     {} // 编译失败
    6.     void openDevice();
    7.     void closeDevice();
    8. }
    7. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是 .class
    8. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
    9. jdk8 中：接口中还可以包含 default 方法。
    实现多个接口
    在 Java 中，类和类之间是单继承的，一个类只能有一个父类，即 Java 中不支持多继承 ，但是 一个类可以实现多个接 口 。 
    1. class Animal {
    2.     protected String name;
    3.     public Animal(String name) {
    4.         this.name = name;
    5.     }
    6. }
    7.  
    8.  
    9. interface IFlying {
    10.     void fly();
    11. }
    12.  
    13. interface IRunning {
    14.     void run();
    15. }
    16.  
    17. interface ISwimming {
    18.     void swim();
    19. }
    1. class Frog extends Animal implements IRunning, ISwimming {
    2.     public Frog(String name) {
    3.         super(name);
    4.     }
    5.     @Override
    6.     public void run() {
    7.         System.out.println(this.name + "正在往前跳");
    8.     }
    9.     @Override
    10.     public void swim() {
    11.         System.out.println(this.name + "正在蹬腿游泳");
    12.     }
    13. }
    注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类 。
    接口间的继承
    在 Java 中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到 多继承的目的。
    接口可以继承一个接口 , 达到复用的效果 . 使用 extends 关键字 . 
    1. interface IRunning {
    2.     void run();
    3. }
    4. interface ISwimming {
    5.     void swim();
    6. }
    7. // 两栖的动物, 既能跑, 也能游
    8. interface IAmphibious extends IRunning, ISwimming {
    9. }
    10. class Frog implements IAmphibious {
    11. ...
    12. }
    通过接口继承创建一个新的接口 IAmphibious 表示 " 两栖的 ". 此时实现接口创建的 Frog 类 , 就继续要实现 run 方 法, 也需要实现 swim 方法 .
    接口间的继承相当于把多个接口合并在一起.
  • 相关阅读:
    微信小程序第四天
    Postman(1): postman的介绍和安装
    Java手写位运算算法和位运算算法应用拓展案例
    python连接自己的机器人接口在微信聊天
    elastic-job源码（1）- job自动装配
    基于springboot的药品管理
    嵌入式学习笔记（55）LCD简介
    SpringBoot上传文件夹
    dpdk PMD
    linux c socket编程里SO_REUSEADDR的作用
  • 原文地址：https://blog.csdn.net/khh1014173041/article/details/133520590