Java2EE基础练习及面试题_chapter04面向对象(上_03)

简介: Java2EE基础练习及面试题_chapter04面向对象(上_03)

面试01

/*
微软面试题:
定义一个int型的数组:int[] arr = new int[]{12,3,3,34,56,77,432};
让数组的每个位置上的值去除以首位置的元素,得到的结果,作为该位置上的
新值。遍历新的数组。
 */
package com.jerry.java;
import java.util.Arrays;
/**
 * @author jerry_jy
 * @create 2022-09-26 17:53
 */
public class Exer10 {
    /*
    微软面试题:
    定义一个int型的数组:int[] arr = new int[]{12,3,3,34,56,77,432};
    让数组的每个位置上的值去除以首位置的元素,得到的结果,作为该位置上的
    新值。遍历新的数组。
     */
    public static void main(String[] args) {
        int[] arr = new int[]{12, 3, 3, 34, 56, 77, 432};
        int temp = arr[0];
        for (int i = 0; i < arr.length; i++) {
//            arr[i] = arr[i] / arr[0];
            arr[i] = arr[i] / temp;
        }
        System.out.println(Arrays.toString(arr));
        // 说出下面的结果
        int[] arr = new int[10];
        System.out.println(arr);//[I@1b6d3586
        char[] arr1 = new char[10];
        System.out.println(arr1);//空 不是null值
    }
}

面试02

/*
方法的使用
哪个选项和show()方法重载
class Demo{
    void show(int a,int b,float c){}
}
A.void show(int a,float c,int b){}//yes
B,void show(int a,int b,float c){}//一模一样。不可以出现在同一个类中。
C.int show(int a,float c,int b){return a;}//yes。
D.int show(int a,float c){return a;}//yes
 */

面试03

/*
方法的重载
方法重载(overload)必须满足________
A. 在不同class中定义的方法     B.在同一类型中定义的方法
C. 方法名必须相同              D.返回类型必须相同
E. 参数一定不同                F.参数可以相同
答案:BCE
 */

面试04

/*
    写出输出结果
 */
    public static void main(String[] args) {
        show(0);//15
        show(1);//14
    }
    public static void show(int i) {
        switch (i) {
            default:
                i += 2;
            case 1:
                i += 1;
            case 4:
                i += 8;
            case 2:
                i += 4;
        }
        System.out.println("i=" + i);
    }

面试05

/*
写出输出结果 */
    public static void main(String[] args) {
        int x = 1;
        for (show('a'); show('b') && x < 3; show('c')) {
            show('d');
            x++;
        }
    }
    public static boolean show(char ch) {
        System.out.print(ch);//abdcbdcb
        return true;
    }

面试06

//以下代码的运行结果是什么?
    public static boolean foo(char c) {
        System.out.print(c);//ABDCBDCB
        return true;
    }
    public static void main(String[] args) {
        int i = 0;
        for (foo('A'); foo('B') && (i < 2); foo('C')) {
            i++;// 1 2
            foo('D');
        }
    }

面试07

面向对象三大特征的说明

答:面向对象有三大特点:封装、继承、多态。(如果要回答四个,可加上 抽象性 这一特点)

1.继承性:继承是一种联结类的层次模型,并且允许和鼓励类的重用,它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生,这个过程称为类继承。新类继承了原始类的特性,新类称为原始类的派生类(子类),而原始类称为新类的基类(父类)。派生类可以从它的基类那里继承方法和实例变量,并且类可以修改或增加新的方法使之更适合特殊的需要。

2.封装性:

封装是把过程和数据包围起来,对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念,即现实世界可以被描绘成一系列完全自治、封装的对象,这些对象通过一个受保护的接口访问其他对象。

3. 多态性:

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势,很好的解决了应用程序函数同名问题。

4.抽象性:

抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题,而只是选择其中的一部分,暂时不用部分细节。抽象包括两个方面,一是过程抽象,二是数据抽象。

面试08

/*
找错
public class Something {
   void doSomething () {
       private String s = "";
       int l = s.length();
   }
}

有错吗?

答案: 错。局部变量前不能放置任何访问修饰符 (private,public,和protected)。

面试09

Java的内存管理之垃圾回收

**分配:**由JVM自动为其分配相应的内存空间

**释放:**由JVM提供垃圾回收机制自动的释放内存空间

垃圾回收机制(GC:Garbage Collection):将垃圾对象所占用的堆内存进行回收。Java的垃圾回收机制是JVM提供的能力,由单独的系统级垃圾回收线程在空闲时间以不定时的方式动态回收。

垃圾对象:不再被任何引用指向的对象。

面试10

面试题:

问:在程序中是否可以通知垃圾回收机制过来回收垃圾?

能,通过调用System.gc();或Runtime.getRuntime().gc();

再问:调用了System.gc();或Runtime.getRuntime().gc();后是立刻执行垃圾回收吗?

不是,该调用并不会立刻启动垃圾回收机制开始回收,但会加快垃圾回收机制的运行。

代码演示:

public class TestGC{
  public static void main(String[] args)throws Exception{
    for(int i=0; i<10; i++){
      MyClass m = new MyClass();//这里本次循环完,本次创建的对象就成为垃圾了
      System.out.println("创建第" + (i+1) + "的对象:" + m);
    }
    //通知垃圾回收机制来收集垃圾
    System.gc();
    //为了延缓程序结束
    for(int i=0; i<10; i++){
      Thread.sleep(1);
      System.out.println("程序在继续....");
    }
  }
}
class MyClass{
  //这个方法是垃圾回收机制在回收它的对象时,自动调用,理解成对象留临终遗言的方法
  public void finalize(){
    System.out.println("轻轻的我走了.....");
  }
}

面试11

构造器

构造器Constructor是否可被override

答:构造器Constructor不能被继承,因此不能重写Override,但可以被重载Overload

面试12

//以下程序的运行结果是:
    public static void main(String[] args) {
        new A(new B());//BAAB
    }
}
class A {
    public A() {
        System.out.println("A");
    }
    public A(B b) {
        this();
        System.out.println("AB");
    }
}
class B {
    public B() {
        System.out.println("B");
    }

实验01

918d47db22d74eb0883338fd8435440d.png

package com.jerry.experiment1;
/**
 * @author jerry_jy
 * @create 2022-09-27 11:11
 */
public class Account {
    private int id;
    private double balance;
    private double annualInterestRate;
    public Account(int id, double balance, double annualInterestRate) {
        this.id = id;
        this.balance = balance;
        this.annualInterestRate = annualInterestRate;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public double getBalance() {
        return balance;
    }
    public void setBalance(double balance) {
        this.balance = balance;
    }
    public double getAnnualInterestRate() {
        return annualInterestRate;
    }
    public void setAnnualInterestRate(double annualInterestRate) {
        this.annualInterestRate = annualInterestRate;
    }
    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", balance=" + balance +
                ", annualInterestRate=" + annualInterestRate +
                '}';
    }
    public void withdraw(double amount) {//取钱
        //System.out.println("请输入取款金额:");
        if (amount > balance) {
            System.out.println("余额不足,取款失败!");
        } else {
            balance -= amount;
            System.out.println("取款成功!本次成功取出:" + amount);
        }
    }
    public void deposit(double amount) {//存钱
        balance += amount;
        System.out.println("存款成功!本次成功存入:" + amount);
    }
}
package com.jerry.experiment1;
/**
 * @author jerry_jy
 * @create 2022-09-27 11:22
 */
public class Customer {
    private String firstName;
    private String lastName;
    private Account account;
    public Customer(){
    }
    public Customer(String firstName, String lastName){
        this.firstName=firstName;
        this.lastName=lastName;
    }
    public String getFirstName() {
        return firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public Account getAccount() {
        return account;
    }
    public void setAccount(Account account) {
        this.account = account;
    }
    @Override
    public String toString() {
        return "Customer{" +
                "firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                ", account=" + account +
                '}';
    }
}
package com.jerry.experiment1;
/**
 * @author jerry_jy
 * @create 2022-09-27 11:25
 */
public class AccountTest {
    public static void main(String[] args) {
        Customer customer = new Customer("Jane", "Smith");
        System.out.println(customer.toString());
        Account account = new Account(1000, 2000, 0.0123);
        System.out.println(account.toString());
        customer.setAccount(account);
        account.deposit(100);
//        customer.getAccount();
        account.withdraw(960);
        account.withdraw(2000);
        System.out.println("Customer[" + customer.getLastName() + "," + customer.getFirstName() +
                "] has a account: id is " + customer.getAccount().getId() + ",annualInterestRate is "+
                customer.getAccount().getAnnualInterestRate() * 100 + "% ,balance is " + customer.getAccount().getBalance());
    }
}

实验02

699f1d6f34054e96af8a84e97f6efd36.png

3c9a47cef866471ba4698e8ec89bd1ad.png

package com.jerry.experiment2;
/**
 * @author jerry_jy
 * @create 2022-09-27 16:02
 */
public class Account1 {
    private double balance;
    public Account1() {
    }
    public Account1(double balance) {
        this.balance = balance;
    }
    public double getBalance() {
        return balance;
    }
    public void deposit(double amount) {//存钱
        balance += amount;
        System.out.println("存款成功!本次成功存入:" + amount);
    }
    public void withdraw(double amount) {//取钱
        //System.out.println("请输入取款金额:");
        if (amount > balance) {
            System.out.println("余额不足,取款失败!");
        } else {
            balance -= amount;
            System.out.println("取款成功!本次成功取出:" + amount);
        }
    }
}
package com.jerry.experiment2;
import com.jerry.experiment1.Account;
/**
 * @author jerry_jy
 * @create 2022-09-27 16:01
 */
public class Customer {
    private String firstName;
    private String lastName;
    private Account1 account;
    public Customer() {
    }
    public Customer(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
    public String getFirstName() {
        return firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public Account1 getAccount() {
        return account;
    }
    public void setAccount(Account1 account) {
        this.account = account;
    }
}
package com.jerry.experiment2;
/**
 * @author jerry_jy
 * @create 2022-09-27 16:04
 */
public class Bank {
    private Customer[] customers;
    private int numberOfCustomer;
    public Bank() {
        customers = new Customer[10];//构造器初始化赋值
    }
    public void addCustomer(String firstName, String lastName) {
        Customer customer = new Customer(firstName, lastName);
        customers[numberOfCustomer++]=customer;//把新new出来的customer放在customers数组中
    }
    public int getNumOfCustomers() {
        return numberOfCustomer;
    }
    public Customer getCustomer(int index) {
        return customers[index];
    }
}


package com.jerry.experiment2;
/**
 * @author jerry_jy
 * @create 2022-09-27 16:21
 */
public class BankTest {
    public static void main(String[] args) {
        Bank bank = new Bank();
        bank.addCustomer("Jin", "Yang");
        //连续操作
        bank.getCustomer(0).setAccount(new Account1(2000));
        bank.getCustomer(0).getAccount().withdraw(500);
        double balance = bank.getCustomer(0).getAccount().getBalance();
        System.out.println("客户:" + bank.getCustomer(0).getFirstName() + "的账户余额为:" + balance);
        System.out.println("***********************");
        bank.addCustomer("万里", "杨");
        System.out.println("银行客户的个数为:" + bank.getNumOfCustomers());
    }
}


相关文章
|
13天前
|
存储 安全 算法
Java面试题之Java集合面试题 50道(带答案)
这篇文章提供了50道Java集合框架的面试题及其答案,涵盖了集合的基础知识、底层数据结构、不同集合类的特点和用法,以及一些高级主题如并发集合的使用。
35 1
Java面试题之Java集合面试题 50道(带答案)
|
1天前
|
存储 Java 程序员
Java面试加分点!一文读懂HashMap底层实现与扩容机制
本文详细解析了Java中经典的HashMap数据结构,包括其底层实现、扩容机制、put和查找过程、哈希函数以及JDK 1.7与1.8的差异。通过数组、链表和红黑树的组合,HashMap实现了高效的键值对存储与检索。文章还介绍了HashMap在不同版本中的优化,帮助读者更好地理解和应用这一重要工具。
10 5
|
9天前
|
Java 程序员
Java 面试高频考点:static 和 final 深度剖析
本文介绍了 Java 中的 `static` 和 `final` 关键字。`static` 修饰的属性和方法属于类而非对象,所有实例共享;`final` 用于变量、方法和类,确保其不可修改或继承。两者结合可用于定义常量。文章通过具体示例详细解析了它们的用法和应用场景。
20 3
|
13天前
|
Java
Java面试题之cpu占用率100%,进行定位和解决
这篇文章介绍了如何定位和解决Java服务中CPU占用率过高的问题,包括使用top命令找到高CPU占用的进程和线程,以及使用jstack工具获取堆栈信息来确定问题代码位置的步骤。
27 0
Java面试题之cpu占用率100%,进行定位和解决
|
17天前
|
存储 安全 Java
java基础面试题
java基础面试题
19 2
|
17天前
|
缓存 NoSQL Java
Java中redis面试题
Java中redis面试题
28 1
|
18天前
|
算法 Java 数据中心
探讨面试常见问题雪花算法、时钟回拨问题,java中优雅的实现方式
【10月更文挑战第2天】在大数据量系统中,分布式ID生成是一个关键问题。为了保证在分布式环境下生成的ID唯一、有序且高效,业界提出了多种解决方案,其中雪花算法(Snowflake Algorithm)是一种广泛应用的分布式ID生成算法。本文将详细介绍雪花算法的原理、实现及其处理时钟回拨问题的方法,并提供Java代码示例。
45 2
|
22天前
|
缓存 安全 Java
三万字长文Java面试题——基础篇(注:该篇博客将会一直维护 最新维护时间:2024年9月18日)
本文是一篇全面的Java面试题指南,涵盖了Java基础、数据类型、面向对象、异常处理、IO流、反射、代理模式、泛型、枚举、Lambda表达式、Stream流等多个方面的知识点,并提供了详细的解析和代码示例。
50 0
三万字长文Java面试题——基础篇(注:该篇博客将会一直维护 最新维护时间:2024年9月18日)
|
2月前
|
Java
java中面向过程和面向对象区别?
java中面向过程和面向对象区别?
29 4
|
14天前
|
存储 Java 程序员
Java基础-面向对象
Java基础-面向对象
11 0