抽象类语法
在Java中，一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用 给出具体的实现体:\]
// 抽象类：被abstract修饰的类 public abstract class Shape { // 抽象方法：被abstract修饰的方法，没有方法体 abstract public void draw(); abstract void calcArea(); // 抽象类也是类，也可以增加普通方法和属性 public double getArea(){ return area; } protected double area; // 面积 }
抽象类也是类，内部可以包含普通方法和属性，甚至构造方法.
抽象类特性
①抽象类不能直接实例化对象
Shape shape = new Shape(); // 编译出错 Error:(30, 23) java: Shape是抽象的; 无法实例化
②抽象方法不能是 private 的
abstract class Shape { abstract private void draw(); } // 编译出错 Error:(4, 27) java: 非法的修饰符组合: abstract和private
③抽象方法不能被final和static修饰，因为抽象方法要被子类重写
我们知道被final修饰的方法不能被子类重写。通过在方法声明前加上final关键字，可以限制子类对该方法的修改和重写，保持方法的原始实现不受改变.
被static修饰的方法一般被称为静态方法。静态方法可以通过类名和方法名直接引用，而不需要实例化一个对象。 静态方法属于类方法，可以在没有创建对象的情况下直接调用。静态方法在类加载时就已经存在，可以直接使用。与非静态方法不同，非静态方法需要实例化一个对象后才能调用.
静态方法不具有多态性。子类可以继承父类中的静态方法，但是不能重写父类中的静态方法
public abstract class Shape { abstract final void methodA(); abstract public static void methodB(); } // 编译报错： // Error:(20, 25) java: 非法的修饰符组合: abstract和final // Error:(21, 33) java: 非法的修饰符组合: abstract和static
④ 抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰
// 矩形类 public class Rect extends Shape { private double length; private double width; Rect(double length, double width){ this.length = length; this.width = width; } public void draw(){ System.out.println("矩形: length= "+length+" width= " + width); } public void calcArea(){ area = length * width; } } // 圆类: public class Circle extends Shape{ private double r; final private static double PI = 3.14; public Circle(double r){ this.r = r; } public void draw(){ System.out.println("圆：r = "+r); } public void calcArea(){ area = PI * r * r; } } // 三角形类： public abstract class Triangle extends Shape { private double a; private double b; private double c; @Override public void draw() { System.out.println("三角形：a = "+a + " b = "+b+" c = "+c); } // 三角形：直角三角形、等腰三角形等，还可以继续细化 //@Override //double calcArea(); // 编译失败：要么实现该抽象方法，要么将三角形设计为抽象类 }
普通类 & 抽象类
在 Java 中，普通类和抽象类是两种不同的类类型。普通类是可以直接实例化的类，而抽象类则不能直接实例化。抽象类通常用于定义一些基本的行为和属性，而具体的实现则由其子类来完成。以下是普通类和抽象类的一些区别：
- 实例化：普通类可以直接实例化，而抽象类不能直接实例化。
- 方法：抽象类中既包含抽象方法又可以包含具体的方法，而普通类只能包含普通方法。
- 实现：普通类实现接口需要重写接口中的方法，而抽象类可以实现接口方法, 可以不需要重写接口中的方法。
下面是普通类的案例:
class Dog { public String name; public int age; public void action() { System.out.println("小狗汪汪汪!!"); } }
下面是抽象类的案例:
interface haha { void functionInterface(); } abstract class Animal implements haha{ public String name; public int age; // 可以包含具体方法 public static void function() { System.out.println("haha"); } // 可以包含抽象方法 public abstract void abstractFuntion(); }
对于抽象类:
抽象类是一种特殊的类，它可以包含抽象方法和具体方法。抽象方法是没有具体实现的方法，而具体方法是有具体实现的方法。抽象类的主要目的是为了提供一种设计机制，让子类能够只实现抽象方法而不需要实现具体方法。这样可以实现代码的重用和灵活性。
具体方法在抽象类中的存在有以下几个意义：
- 提供默认实现：具体方法可以在抽象类中提供默认的实现，这样子类就可以直接使用这个实现，避免了重复编写相同的代码。
- 完善抽象类的功能：具体方法可以在抽象类中实现一些通用的功能，为子类提供更完善的功能支持。
- 简化子类的实现：具体方法的存在可以减少子类的实现工作量，子类只需要实现抽象方法即可。
因此，抽象类里面包含具体方法的意义在于提供了默认实现、完善抽象类的功能和简化子类的实现。这样可以提高代码的可维护性和可扩展性
抽象类 & 接口
什么是接口
在现实生活中，接口的例子比比皆是，比如：笔记本上的USB口，电源插座等:
电脑的USB口上，可以插：U盘、鼠标、键盘...所有符合USB协议的设备 电源插座插孔上，可以插：电脑、电视机、电饭煲...所有符合规范的设备 通过上述例子可以看出：接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。 在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型.
语法
接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。
接口方法
接口的方法是默认public abstract的, 可以不用写, 接口的方法如果被static修饰, 就必须添加方法体, 例如:
public interface 接口名称{ // 抽象方法 public abstract void method1(); // public abstract 是固定搭配，可以不写 public void method2(); abstract void method3(); void method4(); // 注意：在接口中上述写法都是抽象方法，跟推荐方式4，代码更简洁 }
interface接口里面的方法是默认public abstract的:
灰色字体表名未被使用过.
接口里面静态方法的使用:
public class Test2 { public static void main(String[] args) { testInterface.function2(); } } interface testInterface { public abstract void function1(); public static void function2() { System.out.println("hello"); } }
变量
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量 :
public interface USB { double brand = 3.0; // 默认被：final public static修饰 void openDevice(); void closeDevice(); } public class TestUSB { public static void main(String[] args) { System.out.println(USB.brand); // 可以直接通过接口名访问，说明是静态的 // 编译报错：Error:(12, 12) java: 无法为最终变量brand分配值 USB.brand = 2.0; // 说明brand具有final属性 } }
接口特性
①接口类型是一种引用类型，但是不能直接new接口的对象
public class TestUSB { public static void main(String[] args) { USB usb = new USB(); } } // Error:(10, 19) java: day20210915.USB是抽象的; 无法实例化
②接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错)
public interface USB { // Error:(4, 18) java: 此处不允许使用修饰符private private void openDevice(); void closeDevice(); }
③接口中的方法是不能在接口中实现的，只能由实现接口的类来实现
public interface USB { void openDevice(); // 编译失败：因为接口中的方式默认为抽象方法 // Error:(5, 23) java: 接口抽象方法不能带有主体 void closeDevice(){ System.out.println("关闭USB设备"); } }
④重写接口中方法时，不能使用默认的访问权限
public interface USB { void openDevice(); // 默认是public的 void closeDevice(); // 默认是public的 } public class Mouse implements USB { @Override void openDevice() { System.out.println("打开鼠标"); } // ... } // 编译报错，重写USB中openDevice方法时，不能使用默认修饰符 // 正在尝试分配更低的访问权限; 以前为public
⑤接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
⑥接口中不能有静态代码块和构造方法
⑦接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
⑧如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
⑨jdk8中：接口中还可以包含default方法。
抽象类&接口的区别
在 Java 中，抽象类和接口是两种不同的类类型。它们都不能直接实例化，并且它们都是用来定义一些基本的属性和方法的，但它们有以下几点不同：
- 定义：定义的关键字不同，抽象类是 abstract，而接口是 interface。
- 方法：抽象类可以包含抽象方法和具体方法，而接口只能包含方法声明（抽象方法）。
- 方法访问控制符：抽象类无限制，只是抽象类中的抽象方法不能被 private 修饰；而接口有限制，接口默认的是 public 控制符。
- 实现：一个类只能继承一个抽象类，但可以实现多个接口。
- 变量：抽象类可以包含实例变量和静态变量，而接口只能包含常量。
- 构造函数：抽象类可以有构造函数，而接口不能有构造函数。
以下是一个抽象类和一个接口的示例代码：
