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

简介: 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. 构造函数:抽象类可以有构造函数,而接口不能有构造函数。

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

目录
相关文章
|
1天前
|
Java 编译器 API
java.lang.NoClassDefFoundError:无法初始化类XXX
java.lang.NoClassDefFoundError:无法初始化类XXX
6 0
|
1天前
|
安全 Java 数据安全/隐私保护
Java 程序设计 第3章 类与对象 笔记
Java 程序设计 第3章 类与对象 笔记
|
2天前
|
Java
Java动态获取某个接口下所有的实现类对象集合
Java动态获取某个接口下所有的实现类对象集合
8 1
|
2天前
|
存储 安全 算法
Java基础19-一文搞懂Java集合类框架,以及常见面试题(二)
Java基础19-一文搞懂Java集合类框架,以及常见面试题(二)
30 8
|
2天前
|
安全 Java 开发工具
Java基础19-一文搞懂Java集合类框架,以及常见面试题(一)
Java基础19-一文搞懂Java集合类框架,以及常见面试题(一)
29 6
|
29天前
|
存储 Java 编译器
Java中的抽象类与接口,在阿里工作5年了
Java中的抽象类与接口,在阿里工作5年了
|
1月前
|
设计模式 Java
Java基础—笔记—多态、final、抽象类、接口篇
该文介绍了编程中的多态、final和抽象类、接口相关概念。多态允许子类重写父类方法,通过父类引用调用子类方法,实现解耦和提高代码灵活性,但也可能导致无法使用子类特有功能,需通过强制类型转换解决。final用于修饰不可变的类、方法或变量,防止继承、重写和多次赋值。抽象类是一种包含抽象方法的类,用于强制子类重写特定方法,实现多态,适用于模板方法设计模式,解决代码重复问题。
25 0
|
15天前
|
Java
Java抽象类与接口的技术性文章
Java抽象类与接口的技术性文章
23 1
|
2天前
|
Java
Java基础7-一文搞懂抽象类和接口,从基础到面试题,揭秘其本质区别(二)
Java基础7-一文搞懂抽象类和接口,从基础到面试题,揭秘其本质区别(二)
9 0
|
2天前
|
设计模式 Java 内存技术
Java基础7-一文搞懂抽象类和接口,从基础到面试题,揭秘其本质区别(一)
Java基础7-一文搞懂抽象类和接口,从基础到面试题,揭秘其本质区别(一)
12 0