java面试基础 -- 普通类 & 抽象类 & 接口

目录

抽象类语法

抽象类特性 

普通类 & 抽象类

抽象类 & 接口

什么是接口

语法

接口方法

变量 

接口特性

抽象类&接口的区别 

---

抽象类语法

        在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 中，普通类和抽象类是两种不同的类类型。普通类是可以直接实例化的类，而抽象类则不能直接实例化。抽象类通常用于定义一些基本的行为和属性，而具体的实现则由其子类来完成。以下是普通类和抽象类的一些区别：

1. 实例化：普通类可以直接实例化，而抽象类不能直接实例化。
2. 方法：抽象类中既包含抽象方法又可以包含具体的方法，而普通类只能包含普通方法。
3. 实现：普通类实现接口需要重写接口中的方法，而抽象类可以实现接口方法, 可以不需要重写接口中的方法。

下面是普通类的案例:

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();
}

对于抽象类:

        抽象类是一种特殊的类，它可以包含抽象方法和具体方法。抽象方法是没有具体实现的方法，而具体方法是有具体实现的方法。抽象类的主要目的是为了提供一种设计机制，让子类能够只实现抽象方法而不需要实现具体方法。这样可以实现代码的重用和灵活性。

具体方法在抽象类中的存在有以下几个意义：

1. 提供默认实现：具体方法可以在抽象类中提供默认的实现，这样子类就可以直接使用这个实现，避免了重复编写相同的代码。
2. 完善抽象类的功能：具体方法可以在抽象类中实现一些通用的功能，为子类提供更完善的功能支持。
3. 简化子类的实现：具体方法的存在可以减少子类的实现工作量，子类只需要实现抽象方法即可。

因此，抽象类里面包含具体方法的意义在于提供了默认实现、完善抽象类的功能和简化子类的实现。这样可以提高代码的可维护性和可扩展性

抽象类 & 接口

什么是接口

        在现实生活中，接口的例子比比皆是，比如：笔记本上的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 中，抽象类和接口是两种不同的类类型。它们都不能直接实例化，并且它们都是用来定义一些基本的属性和方法的，但它们有以下几点不同：

1. 定义：定义的关键字不同，抽象类是 abstract，而接口是 interface。
2. 方法：抽象类可以包含抽象方法和具体方法，而接口只能包含方法声明（抽象方法）。
3. 方法访问控制符：抽象类无限制，只是抽象类中的抽象方法不能被 private 修饰；而接口有限制，接口默认的是 public 控制符。
4. 实现：一个类只能继承一个抽象类，但可以实现多个接口。
5. 变量：抽象类可以包含实例变量和静态变量，而接口只能包含常量。
6. 构造函数：抽象类可以有构造函数，而接口不能有构造函数。

以下是一个抽象类和一个接口的示例代码：

---

---

---