南北软件

一、问题类

1、java 中实现多态的机制是什么?

1. 方法的重载（Overloading）：
   • 同一个类中可以有多个同名的方法，但是这些方法的参数列表（包括类型、个数和顺序）必须不同。
   • 编译器通过检查调用方法时提供的参数来决定调用哪个方法版本，这个过程在编译时期就已完成，因此称为编译时多态或静态多态。
2. 方法的覆盖（Overriding）：
   • 子类可以重新定义父类中已经存在的非私有（private）的方法。子类中的这个方法必须与父类中的方法具有相同的返回类型、方法名和参数列表。
   • 当使用父类引用指向子类实例对象时，通过父类引用调用被覆盖的方法，实际执行的是子类的方法版本。这个绑定过程是在运行时期动态完成的，所以被称为运行时多态或动态多态。

2、是否可以从一个 static 方法内部发出对非 static 方法的调用，为什么?

不可以，静态方法只能访问静态成员，因为非静态方法的调用要先创建对象，在调用静态方法时可能对象并没有被初始化

因为非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以直接调用。
也就是说，当一个static方法被调用时，可能还没有创建任何实例对象，如果从一个static方法中发出对非static方法的调用，那个非static方法关联到那个对象上的呢？这个逻辑无法成立，所以，一个static方法内部不能发出对非static方法的调用。

static方法是静态方法，是属于类的方法；非static方法是属于对象的方法，所以在static方法中想要调用非static方法，要先新创建一个对象，再有这个对象来调用非static方法。

3、静态变量和实例变量的区别?

1. 存储位置：
   • 静态变量存储在方法区中，与类相关联，因此属于整个类。
   • 实例变量存储在堆内存中，与对象相关联，每个对象都有自己的副本。
2. 生命周期：
   • 静态变量的生命周期从类加载时开始，直到程序结束。
   • 实例变量的生命周期从创建对象时开始，到对象被垃圾回收时结束。
3. 访问方式：
   • 静态变量可以通过类名直接访问，不需要创建任何对象。
   • 实例变量只能通过创建的对象来访问。
4. 初始化时机：
   • 静态变量在类加载时就会被初始化，并且只初始化一次。
   • 实例变量在创建对象时才会被初始化，每个对象都会有自己的初始化值。
5. 作用域：
   • 静态变量的作用域在整个类内，所有该类的对象都可以访问到同一个静态变量。
   • 实例变量的作用域仅限于对象内部，每个对象都有自己的实例变量副本。
6. 修饰关键字：
   • 静态变量使用 static 关键字进行修饰。
   • 实例变量无需使用特殊的关键字，如果没有显式声明为 static，那么它默认就是实例变量。
7. 多线程环境中的行为：
   • 静态变量在多线程环境下共享，可能需要同步控制。
   • 实例变量由每个线程独立拥有，一般情况下不需要同步控制。

4、说明“==”和“equals”区别？

1. ==

• == 是一个关系运算符，用于比较两个变量的值是否相等。
• 对于基本数据类型（如 int、char、boolean 等），== 比较的是它们的值是否相等。
• 对于引用数据类型（如 String、Integer、Object 等），== 比较的是两个引用是否指向同一个对象。也就是说，如果两个引用变量都指向了内存中的同一个对象，则 == 返回 true；否则返回 false。

2. equals()

• equals() 是 Object 类的一个方法，因此所有类的实例都可以使用这个方法进行比较。
• 默认情况下，equals() 方法的行为与 == 相同，也是比较两个引用是否指向同一个对象。
• 但是，像 String、Integer 这样的类重写了 equals() 方法，使其具有更具体的语义，比如比较字符串的内容是否相等。

5、final，finally，finalize 的区别?

1. final

• final是一个修饰符，可以用于类、方法和变量。

• 当用在类上时，表示这个类不能被继承，例如：public final class MyClass {}

• 当用在方法上时，表示这个方法不能被子类重写，例如：public final void myMethod() {}
• 当用在变量（包括成员变量和局部变量）上时：
  • 对于基本数据类型，表示该变量一旦赋值后就不能再更改其值。
  • 对于引用类型，表示该变量不能再指向其他对象，但其引用的对象内部状态是可以改变的。

2. finally

• finally 是 Java 异常处理机制的一部分，它与 try-catch 块一起使用。
• 在一个 try-catch 结构中，无论是否抛出异常，finally 块中的代码总是会被执行。
• finally 常用于释放资源（如关闭文件流、数据库连接等），确保即使在发生异常的情况下也能正确清理资源。

javatry {
    // 一些可能会抛出异常的代码
} catch (Exception e) {
    // 处理异常
} finally {
    // 清理资源，这段代码始终会被执行
}

3. finalize()

• finalize() 是 Object 类的一个 protected 方法，子类可以重写它。
• 当垃圾回收器确定不存在对该对象的更多引用时，由垃圾回收器调用此方法。
• finalize() 的主要目的是提供一种清理机制，允许对象在被销毁前执行一些必要的清理工作，比如释放系统资源或关闭打开的文件。
• 使用 finalize() 需要谨慎，因为它的执行时机不可预测，并且可能带来性能问题。Java 9 开始废弃了 finalize() 方法，并计划在未来的版本中移除。

二、读程序

1、 执行结果是？

int x=0;
int y=10;
do{
    y--;
    ++x;
}while(x<5);
System.out.print(x+","+y);

5,5

2、执行结果是？

public class ClassA {
    public int getValue() {
        int value = 0;
        boolean setting=true;
        String title="Hello";
        if(value || (setting && title == "Hello")){
            return 1;
        }
        if (value == 1 & title.equals("Hello")){
            return 2;
        }
    }
    public static void main(String[] args) {
        ClassA a=new ClassA();
        a.getValue();
    }
}

报错

3、修改以下代码使之不报错。

 class Super{
     private int a;
     protected Super(int a){
         this.a=a;
     }

 }
 class Sub extends  Super{
     public Sub(int a){
         super(a);
     }
     public Sub(){
         this.a=5;
     }
 }

修改后：

class Super{
    private int a;

    // 无参数构造函数
    public Super() {
        this.a = 0; // 或者其他默认值
    }

    protected Super(int a){
        this.a=a;
    }
}

class Sub extends  Super{
    public Sub(int a){
        super(a);
    }

    public Sub(){
        this.a=5;
    }
}

4、以下代码执行结果是？

public static String join(Object a[],char link,Object nullObj)
       {
           if(a==null){
               return null;
           }
           if(a.length==1){
               return a[0]==null ? (nullObj==null?null:nullObj.toString()):a[0].toString();
           }
           final StringBuilder sb=new StringBuilder();
           for(int i=0;i<a.length;i++){
               if(i>0){
                   sb.append(link);
               }
               sb.append(a[i]==null? nullObj:a[i]);
           }
           return sb.toString();
       }
      public static void main(String[] args) {
          System.out.println(join(new Object[]{"abc","bcd",null,"def"},'-',"xxx"));
      }

abc-bcd-xxx-def

三、数据库题

表结构描述
gcode(商品表) : gcode(商品 ID)、gname(商品名称)、type(分类)；
purorder(采购表):id(主键 ID)、gcode(商品 ID)、qty(采购数量)、rmb(采购金额)、odate(采购日期)；
salorder(销售表):id(主键 ID)、gcode(商品 ID)、qty(销售数量)、rmb(销售金额)、odate(销售上期)；

问题：请给出下面每一个查询的 SQL 语句。
1、找出“A”商品在本年的采购明细，显示字段( 商品D、商品名称、数量、日期）。

2、找出商品分类为“001”的商品，在本年的采购数量合计，显示字段( 商品D、商品名称、数量）。

3、出《采购销售一览表》，显示字段( 商品D、采购数量、销售数量、库存数量 ）。

4、找出采购数量合计前 10 名和销售数量合计前 10名的商品统计表，显示字段(类型(采购\销售)商品ID、数量 。

1. 找出“A”商品在本年的采购明细，显示字段( 商品D、商品名称、数量、日期）。

SELECT gcode, gname, qty, odate
FROM purorder po
JOIN gcode gc ON po.gcode = gc.gcode
WHERE gname = 'A' AND YEAR(odate) = YEAR(CURDATE());

2. 找出商品分类为“001”的商品，在本年的采购数量合计，显示字段( 商品D、商品名称、数量）。

SELECT gcode, gname, SUM(qty) as total_qty
FROM gcode gc
JOIN purorder po ON gc.gcode = po.gcode
WHERE type = '001' AND YEAR(po.odate) = YEAR(CURDATE())
GROUP BY gcode, gname;

3. 出《采购销售一览表》，显示字段( 商品D、采购数量、销售数量、库存数量 ）。
   • 假设有一个名为 stock 的表来存储库存信息，包含 gcode 和 quantity 字段。
   • 如果没有这样的表，那么你可能需要创建一个临时的中间表来计算库存量，这个过程通常涉及到复杂的查询和事务处理。

SELECT gcode, 
       (SELECT SUM(qty) FROM purorder WHERE gcode = gs.gcode AND YEAR(odate) = YEAR(CURDATE())) AS purchase_quantity,
       (SELECT SUM(qty) FROM salorder WHERE gcode = gs.gcode AND YEAR(odate) = YEAR(CURDATE())) AS sales_quantity,
       (SELECT quantity FROM stock WHERE gcode = gs.gcode) AS inventory_quantity
FROM gcode gs;

4. 找出采购数量合计前 10 名和销售数量合计前 10名的商品统计表，显示字段(类型(采购\销售)商品ID、数量 ）。

-- 采购数量前 10 名
SELECT 'purchase', gcode, SUM(qty) as total_qty
FROM purorder
WHERE YEAR(odate) = YEAR(CURDATE())
GROUP BY gcode
ORDER BY total_qty DESC
LIMIT 10;

UNION ALL

-- 销售数量前 10 名
SELECT 'sales', gcode, SUM(qty) as total_qty
FROM salorder
WHERE YEAR(odate) = YEAR(CURDATE())
GROUP BY gcode
ORDER BY total_qty DESC
LIMIT 10;

Was this helpful?

YesNo

0 / 0