使用create-react-app脚手架创建react项目-CFANZ编程社区

JAVA相关

JAVA语言概述

1. 一个".java"源文件中是否可以包含多个类？有什么限制？

可以。
一个源文件可以声明多个类，但是最多只能有一个类使用public进行声明
且要求声明public的类的类名与源文件相同。

2. Java的优势？

跨平台性
安全性高
简单性
高性能
面向对象性
健壮性
社区繁荣

3. Java中是否存在内存溢出、内存泄漏？如何解决？

存在。
（内存溢出、内存泄漏：程序在执行过程中，已经不再使用的内存空间， JVM通过相关算法判定以后不认为是垃圾，于是构成内存泄漏）

4. 如何看待Java是一门半编译半解释型语言？

java源码经过编译器生成字节码(.class)，字节码可以通过解释器（解释执行） | JIT编译器（编译执行）得到机器码

变量与运算符

1. 如何高效的计算2*8的值？

使用<<（左移）

2. &和&&区别？

都是表示且的关系，&左边是false时仍然执行，&&左边是false不再执行

3. Java中的基本数据类型有哪些？String时最基本的数据类型吗？

8种基本数据类型：byte，short，int，long，char，boolen，float，double
String不是，属于引用类型

4. Java开发中计算金额是是用什么数据类型？

不能使用double，float，因为精度不高
使用BigDecimal类替换，可以实现任意精度的运算

5. char变量中能不能存储一个中文汉字？

可以，应为char使用Unicode字符集，包含了世界范围的所有字符集。
char='中'

6. 代码分析

short s1=1;
s1=s1+1;	//有什么错？（右边是int类型，需要强制转换）

short s1=1;
s1+=1;	//有什么错？（没错）

7. int i=0; i++; 执行这两句话后，i的值为？

8. 如何将两个变量值互换

String s1 = "abc"
String s2 = "def"

String temp = s1;
s1 = s2;
s2 = temp;

9. boolean占几个字节？

编译的时候不谈占几个字节。
但是JVM再给boolean类型分配内存空间是，boolean类型的变量占据一个slot（4B）。

10. 为什么Java中0.1+0.2≠0.3?

不是每个小数都有对应的二进制数字，可以采用四舍五入或同乘同除方法进行验证，避免上述问题。

流程控制语句

1. break和continue的作用

在这里插入图片描述

2. if分支语句和switch分支语句的异同之处？

if-else语句优势

if语句的条件是一个布尔类型值，if条件表达式为true则进入分支，可以用于范围的判断，也可以用于等值的判断，使用范围更广。

switch语句的条件是一个常量值（byte,short,int,char,枚举,String），只能判断某个变量或表达式的结果是否等于某个常量值，使用场景较狭窄。

switch语句优势

当条件是判断某个变量或表达式是否等于某个固定的常量值时，使用if和switch都可以，习惯上使用switch更多。因为效率稍高。当条件是区间范围的判断时，只能使用if语句。

使用switch可以利用穿透性，同时执行多个分支，而if…else没有穿透性。

3. switch语句中忘写break会发生什么？

case穿透

4. Java至此和那些类型循环？

while，do-while，for，foreach

5. while和do-while循环的区别？

do-while至少会执行一次

IDEA安装与使用

1. 开发中你接触过的开发工具有哪些？

IDEA，Eclipse

2. 谈谈你对Eclipse和IDEA使用上的感受？

IDEA是一种智能化开发工具，Eclipse不够人性化

数组

1. 数组有没有length()这个方法？String有没有length()这个方法？

数组没有length()方法，是length属性
String有length()方法

2. 有数组int[] arr，用Java代码将数组元素顺序颠倒

for(int i=0;i<arr.length/2;i++){
	int temp=arr[i]
	arr[i]=arr[arr.length-i-1];
	arr[arr.length-i-1]=temp;
}

3. 为什么数组要从0开始编号，而不是1？

数组索引，表示了数组元素距离首地址的偏移量。因为第一个元素与首地址元素相同，所以偏移量为0。

4. 数组有什么排序？手写

冒泡排序，快速排序，二分算法

/*
1、冒泡排序（最经典）
思想：每一次比较“相邻（位置相邻）”元素，如果它们不符合目标顺序（例如：从小到大），
     就交换它们，经过多轮比较，最终实现排序。
     （例如：从小到大）     每一轮可以把最大的沉底，或最小的冒顶。
     
过程：arr{6,9,2,9,1}  目标：从小到大
第一轮：
    第1次，arr[0]与arr[1]，6>9不成立，满足目标要求，不交换
    第2次，arr[1]与arr[2]，9>2成立，不满足目标要求，交换arr[1]与arr[2] {6,2,9,9,1}
    第3次，arr[2]与arr[3]，9>9不成立，满足目标要求，不交换
    第4次，arr[3]与arr[4]，9>1成立，不满足目标要求，交换arr[3]与arr[4] {6,2,9,1,9}
    第一轮所有元素{6,9,2,9,1}已经都参与了比较，结束。
    第一轮的结果：第“一”最大值9沉底（本次是后面的9沉底），即到{6,2,9,1,9}元素的最右边
第二轮：
    第1次，arr[0]与arr[1]，6>2成立，不满足目标要求，交换arr[0]与arr[1] {2,6,9,1,9}
    第2次，arr[1]与arr[2]，6>9不成立，满足目标要求，不交换
    第3次：arr[2]与arr[3]，9>1成立，不满足目标要求，交换arr[2]与arr[3] {2,6,1,9,9}
    第二轮未排序的所有元素 {6,2,9,1}已经都参与了比较，结束。
    第二轮的结果：第“二”最大值9沉底（本次是前面的9沉底），即到{2,6,1,9}元素的最右边
第三轮：
    第1次，arr[0]与arr[1]，2>6不成立，满足目标要求，不交换
    第2次，arr[1]与arr[2]，6>1成立，不满足目标要求，交换arr[1]与arr[2] {2,1,6,9,9}
    第三轮未排序的所有元素{2,6,1}已经都参与了比较，结束。
    第三轮的结果：第三最大值6沉底，即到 {2,1,6}元素的最右边
第四轮：
    第1次，arr[0]与arr[1]，2>1成立，不满足目标要求，交换arr[0]与arr[1] {1,2,6,9,9}
    第四轮未排序的所有元素{2,1}已经都参与了比较，结束。
    第四轮的结果：第四最大值2沉底，即到{1,2}元素的最右边
*/
public class Test19BubbleSort{
    public static void main(String[] args){
        int[] arr = {6,9,2,9,1};
 
        //目标：从小到大
        //冒泡排序的轮数 = 元素的总个数 - 1
        //轮数是多轮，每一轮比较的次数是多次，需要用到双重循环，即循环嵌套
        //外循环控制 轮数，内循环控制每一轮的比较次数和过程
        for(int i=1; i<arr.length; i++){ //循环次数是arr.length-1次/轮
            for(int j=0; j<arr.length-i; j++){
                //希望的是arr[j] < arr[j+1]
                if(arr[j] > arr[j+1]){
                    //交换arr[j]与arr[j+1]
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
 
        //完成排序，遍历结果
        for(int i=0; i<arr.length; i++){
            System.out.print(arr[i]+"  ");
        }
    }
}

面向对象（基础）

1. 代码输出

		int[] arr = new int[]{1,2,3};
        System.out.println(arr);

        char[] arr1 = new char[]{'a','b','c'};
        System.out.println(arr1);

        boolean[] arr2 = new boolean[]{true,false,false};
        System.out.println(arr2);

int：地址
char：abc
boolean：地址
在这里插入图片描述

2. 代码问题

编写method(a,b)，输出a=100，b=200

    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        method(a,b);
        System.out.println("a="+a);
        System.out.println("b="+b);
    }

解答：

    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        method(a,b);
        System.out.println("a="+a);
        System.out.println("b="+b);

    }
    public static void method(int a,int b){
        a=a*10;
        b=b*20;
        System.out.println("a="+a);
        System.out.println("b="+b);
        System.exit(0);//强制退出
    }

形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

3. 面向对象，面向过程理解？

4. Java引用类型有几种？

类，数组，接口，枚举，记录，注解

5. 类和对象的区别？

类是抽象的
对象是具体的，是类的实例

6. 对象存在Java内存的哪块区域里？

堆空间

7. private、缺省、protected、public的作用区域？

在这里插入图片描述

8. main方法的public能不能换成private，为什么？

能。当修改以后就不能作为程序入口，就只是一个普通的方法。

9. 构造方法和普通方法有什么区别？

编写代码角度：声明格式，作用均不同
字节码文件角度：构造器会以<init>()方法的形态呈现，用以初始化对象

10. 构造器Constructor是否可以被overload？

可以

11. 无参构造器和有参构造器的作用和应用？

初始化属性

12. 成员变量和局部变量区别？

1、声明位置和方式

（1）实例变量：在类中方法外

（2）局部变量：在方法体{}中或方法的形参列表、代码块中

2、在内存中存储的位置不同

（1）实例变量：堆

（2）局部变量：栈

3、生命周期
（1）实例变量：和对象的生命周期一样，随着对象的创建而存在，随着对象被GC回收而消亡，而且每一个对象的实例变量是独立的。

（2）局部变量：和方法调用的生命周期一样，每一次方法被调用而在存在，随着方法执行的结束而消亡，而且每一次方法调用都是独立。

4、作用域

（1）实例变量：通过对象就可以使用，本类中直接调用，其他类中“对象.实例变量”

（2）局部变量：出了作用域就不能使用

5、修饰符（后面来讲）

（1）实例变量：public,protected,private,final,volatile,transient等

（2）局部变量：final

6、默认值

（1）实例变量：有默认值

（2）局部变量：没有，必须手动初始化。其中的形参比较特殊，靠实参给它初始化。

13. 变量赋值和构造方法加载的优先级问题？

变量显式赋值先于构造器赋值（字节码文件）

面向对象（进阶）

1. 区分方法重载和重写？

重载：方法名相同，形参列表不同。不看返回值类型。
重写：不同类中，继承以后，子类覆盖父类中方法

2. 区分 == 和 equals()

== 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址
equals只能用在引用数据类型上，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是==；我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中用的比较多，久而久之，形成了equals是比较值的错误观点。
具体要看自定义类里有没有重写Object的equals方法来判断。
通常情况下，重写equals方法，会比较类中的相应属性是否都相等。