一日不书,百事荒芜

Ⅰ.Java基础：

(1)一个“，java”源文件中是否可以包括多个类（不是内部类）？有什么限制？

可以有很多类，但只能有一个public类，并且public类名必须与文件名一致。
首先区分什么是外部类，内部类：

public class A{}；
class B {};
class C {};

以上为外部类；生成3个class文件。

public class A{
	class B{};
};

以上为内部类，生成1个class。
java虚拟机实例通过调用某个类的main()来运行一个Java程序，而这个main（）必须是public static void 并接收一个字符串数组作为参数，任何拥有这样一个main()的类都可以作为java程序的起点。

(2)Java有没有goto？

Java中的保留字，现在没有在java使用。
goto：起源于汇编语言：跳转；
Java中类似跳转操作——break和continue，但它们是中断迭代语句。

(3)说说&和&&的区别

相同点：
都能用作逻辑与(and)的运算符.
在程序中，当所有表达式的判断结果为true时，则结果才为真，返回true，否则，只要有其中一个表达式为假，结果都为false。
不同点：
㈠ &可以是位运算（返回值类型int），也可以是逻辑运算(返回值类型boolean)
位运算规则：如果两个相应的二进制位都为1，则该位的结果值为1，否则为0
3&5 即 0000 0011& 0000 0101 = 00000001控住台输出----1；
&&主要是是逻辑运算(返回值类型boolean)
㈡运算方式不同

public class TakeAnExample {
        public static void main(String[] args){
            int x=1,y=1;
            if(x++==2 && ++y==2){
                x=7;
            }
            System.out.println("x="+x+",y="+y);
            int x1=1,y1=1;
            if(x1++==2 & ++y1==2){
                x=7;
            }
            System.out.println("x="+x1+",y="+y1);
        }
}

解析：
①&&②，①程序不正确，②不会运行，最终结果false。（短路功能）
① &②，①程序不正确，②继续运行， 最后结果为false。

(4)在java中如何跳出当前的多重循环

原代码：

public class TakeAnExample {
    public static void main(String[] args) {
        for(int i=0;i<5;i++){
            for (int j=0;j<5;j++){
                System.out.print("*");
            }
            System.out.println("&");
        }
    }
    }

第一种方法：

public class TakeAnExample {
    public static void main(String[] args) {
        ok:      //定义一个标号：
        for(int i=0;i<5;i++){
            for (int j=0;j<5;j++){
                System.out.print("*");
                if(j==3)break ok;   //设立if语句，调用break 标号
            }
            System.out.println("&");
        }
    }
    }
 

第二种方法：

public class TakeAnExample {
    public static void main(String[] args) {
        boolean flag =false;
        for(int i=0;i<5&&!flag;i++){         //----------判断条件加个判断
            for (int j=0;j<5;j++){
                System.out.print("*");
                if(j==3) {
                    flag = true;
                    break;                //---------break后执行一次Sys(“&”)，接着判断外循 
                }                  
             System.out.println("&");
        }
    }
    }

(5)Switch能否作用于byte上，能否作用在long上，能否作用在String上？

①Int：

public class TakeAnExample {
    public static void main(String[] args) {
       int a=1;
       switch (a){
        case 1:
        System.out.println("优秀");
        break;
        case 2:
            System.out.println("不优秀");
        }
    }
    }
 

控制台成功输出

②char：

public class TakeAnExample {
    public static void main(String[] args) {
       char a=’1’;
       switch (a){
        case ‘1’:
        System.out.println("优秀");
        break;
        case ‘2’:
            System.out.println("不优秀");
        }
    }
    }

控制台成功输出

③double：

public class TakeAnExample {
    public static void main(String[] args) {
       double a=1.0;
       switch (a){
        case 1:
        System.out.println("优秀");
        break;
        case 2:
            System.out.println("不优秀");
        }
    }
    }

控制台未能成功输出

④short：

public class TakeAnExample {
    public static void main(String[] args) {
       short a=1;
       switch (a){
        case 1:
        System.out.println("优秀");
        break;
        case 2:
            System.out.println("不优秀");
        }
    }
    }
 

控制台成功输出

⑤long：

public class TakeAnExample {
    public static void main(String[] args) {
       long a=2;
       switch (a){
        case 1:
        System.out.println("优秀");
        break;
        case 2:
            System.out.println("不优秀");
        }
    }
    }
 

控制台未能成功输出

⑥byte：

public class TakeAnExample {
    public static void main(String[] args) {
       byte a=’a’;
       switch (a){
        case ‘a’:
        System.out.println("优秀");
        break;
        case ‘c’:
            System.out.println("不优秀");
        }
    }
    }

控制台成功输出

⑦boolean

public class TakeAnExample {
    public static void main(String[] args) {
       boolean a=true;
       switch (a){
        case true:
        System.out.println("优秀");
        break;
        case false:
            System.out.println("不优秀");
        }
    }
    }

控制台未能成功输出

⑧float:

public class TakeAnExample {
    public static void main(String[] args) {
       float a=1;
       switch (a){
        case 1:
        System.out.println("优秀");
        break;
        case 2:
            System.out.println("不优秀");
        }
    }
    }

控制台未能成功输出

⑨String:

public class TakeAnExample {
    public static void main(String[] args) {
       String a="a";
    switch (a){
        case "a":
        System.out.println("优秀");
        break;
        case "b":
            System.out.println("不优秀");
        }
    }
    }

控制台成功输出

综上：int、short、byte、char、String（引用类型）可以 double、float、long、boolean不可以

(6)short s1=1;s1=s1+1;有什么错?short s1=1;s1+=1;有什么错？

精度小于int的数值运算的时候都回被自动转换为int后进行计算
进度值：
byte＜short<int<long<float<double;
char<int<long<float<<double;

short 2个字符，int 4个字符，数字默认int类型，右边则整体为int类型，左边为short类型，大转小，需要转化类型。
提示错误需要short类型，但实际上是int类型，已经自动转化，相同情况如：char、byte。

package xxx;

import sun.swing.plaf.windows.ClassicSortArrowIcon;
public class TakeAnExample {
    public static void main(String[] args) {
        //short
        short s=1;
        s=(short)(s+1);
        System.out.println(s);
        System.out.println("****************");
        //byte
       byte s1='1';
       s1= (byte) (s1+'1');
        System.out.println(s1);
        System.out.println("****************");
       //char3
        char s2='1';
        s2= (char) (s2+'1');
        System.out.println(s2);
        System.out.println("****************");
        //double
        double s3=1.0;
        s3=s3+1.0;
        System.out.println(s3);
        

}
}

类型转化后，控制台可以输出。double等精度大于int，不需要转换

那么+=这个运算符呢？

package xxx;

import sun.swing.plaf.windows.ClassicSortArrowIcon;
public class TakeAnExample {
    public static void main(String[] args) {
        //short
        short s=1;
        s+=1;
        System.out.println(s);
        System.out.println("****************");
        //byte
       byte s1='1';
       s1= 1+'1';
        System.out.println(s1);
        System.out.println("****************");
       //char3
        char s2='1';
        s2+='1';
        System.out.println(s2);
        System.out.println("****************");
        //double
        double s3=1.0;
        s3+=1.0;
        System.out.println(s3);

}
}

代码可以看出是可以编译运行的。

根据运算规则变量自身值+1，等号右边依然为原类型，左边类型升为int，小转大，自动转换。

(7)char型变量中能不能存贮一个中文汉字？为什么？

可以，单只能存储一个汉字
char类型大小2Byte ，Unicode存储一个字符也是2Byte；
Unicode编码中中包含了汉字,所以char类型可以储存一个汉字
一个中文字符占用2个Byte
一个英文字符占用1个Byte所以它的高位全部补零
但是当Unicode编码没有收录一个特殊汉字时,则不能存储
Unicode编码自行百度（嘻嘻。。）

(8)用最有效的方法算出2乘以8等于几？

2✖8=2✖2的3次方；
最有效方法：2<<3
<<：是逻辑左移，右边补0，符号位和其他位一样要移动。
数学意义：在数字没有溢出的前提下，对于正数和负数，左移一位都相当于乘以2的1次方，左移n位就相当于乘以2的n次方。

验证
①2转化为二进制：
0000000 0000 0000 0000 0000 0000 0000 0010
②然后把该数字高位（左侧）的三个零移出，其他的数字都朝左平移3位，最后在低位（右侧）的三个空位补零
0000000 0000 0000 0000 0000 0000 0001 0000
③转化为十进制：16

(9)请设计一个一百亿的计算器

首先我们得清楚，计算机中的算数运算是会发生越界情况的，两个数值的运算结果不能超过计算机中的该类型的数值范围。

package xxx;

import sun.swing.plaf.windows.ClassicSortArrowIcon;
public class TakeAnExample {
    public static void main(String[] args) {
                // byte
                System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);
                System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);
                System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);
                System.out.println();

                // short
                System.out.println("基本类型：short 二进制位数：" + Short.SIZE);
                System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);
                System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);
                System.out.println();

                // int
                System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);
                System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);
                System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);
                System.out.println();

                // long
                System.out.println("基本类型：long 二进制位数：" + Long.SIZE);
                System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);
                System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);
                System.out.println();

                // float
                System.out.println("基本类型：float 二进制位数：" + Float.SIZE);
                System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);
                System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);
                System.out.println();

                // double
                System.out.println("基本类型：double 二进制位数：" + Double.SIZE);
                System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);
                System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);
                System.out.println();

                // char
                System.out.println("基本类型：char 二进制位数：" + Character.SIZE);
                System.out.println("最小值：Character.MIN_VALUE="+(int) Character.MIN_VALUE);
                System.out.println("最大值：Character.MAX_VALUE="+(int) Character.MAX_VALUE);
            }


    }

各类型数值范围如上

查询Api:得到BigInteger的方法

package xxx;

import sun.swing.plaf.windows.ClassicSortArrowIcon;

import java.math.BigInteger;
import java.util.Scanner;

public class TakeAnExample {
    public void test( ) {
        Scanner  input =new Scanner(System.in);
        System.out.println("输入第一个值x为：");
        long  x =input.nextLong();
        System.out.println("输入第二个值y为：");
        long y =input.nextLong();
        BigInteger xBigInteger = BigInteger.valueOf((long) x);
        BigInteger yBigInteger = BigInteger.valueOf((long) y);
        System.out.println("x*y = " + multiply(xBigInteger, yBigInteger));
        System.out.println("x+y = " + add(xBigInteger, yBigInteger));
        System.out.println("x-y = " + subtract(xBigInteger, yBigInteger));
        System.out.println("x/y = " + divide(xBigInteger, yBigInteger));
    }

    /*
     * 加法：x+y
     */
    public BigInteger add(BigInteger x, BigInteger y) {
        return x.add(y);
    }

    /*
     * 减法： x-y
     */
    public BigInteger subtract(BigInteger x, BigInteger y) {
        return x.subtract(y);
    }

    /*
     * 乘法： x*y
     */
    public BigInteger multiply(BigInteger x, BigInteger y) {
        return x.multiply(y);
    }

    /*
     * 除法：x/y
     */
    public BigInteger divide(BigInteger x, BigInteger y) {
        return x.divide(y);
    }


    public static void main(String[] args) {
        TakeAnExample a =new TakeAnExample();
        a.test();
    }
}

代码如上（精度不太准，实在搞不懂）

(10)使用final关键字修饰一个变量时，是引用不能变，还是引用对象不能变？

final类的特点？不能被继承
final方法的特点？不能被重写
final属性的特点？不能二次赋值

package xxx;

import sun.swing.plaf.windows.ClassicSortArrowIcon;

import java.math.BigInteger;
import java.util.Scanner;

public class TakeAnExample {
    public static void main(String[] args) {
         final StringBuffer a= new StringBuffer("构造语句");
        System.out.println(a);
        System.out.println("****************");
        //a=new StringBuffer("重新赋值");----编译报错
        a.append("加点料");
        System.out.println(a);
    }
}

报错情况

结论：引用变量不能用，引用对象中的内容还是可以继续改变的

(11)"=="和equals方法究竟有什么区别

首先，你得知道object是java.lang.Object类的方法

1、“= =”比较两个变量本身的值，即两个对象在内存中的首地址。比较基本类型数据和两个引用变量是否相等，只能用“= = ”操作符
(java中，对象的首地址是它在内存中存放的起始地址，它后面的地址是用来存放它所包含的各个属性的地址，所以内存中会用多个内存块来存放对象的各个参数，而通过这个首地址就可以找到该对象，进而可以找到该对象的各个属性)
2、“equals()”比较字符串中所包含的内容是否相同。一般用来比较字符串内容是否相等

下面2个列子

①

package BlogCodeExercise;

public class BlogCodeExercise {
    public static void main(String[] args) {
        String  a =new String("you are the apple  of my eye"); 
        String  b =new String("you are the apple  of my eye");
        System.out.println(a.equals(b));//两个变量的内存地址不一样，也就是说它们指向的对象不一样
        System.out.println(a==b);//两个变量的所包含的内容是you are the apple  of my eye，故相等。

    }
}

②

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

public class BlogCodeExercise3 {
    public  String name;

    public BlogCodeExercise3(String name) {
        this.name = name;
    }

    public static void main(String[] args) {
        BlogCodeExercise3 a =new BlogCodeExercise3("范闲");
        BlogCodeExercise3 b =new BlogCodeExercise3("范闲");
        System.out.println(a==b);
        System.out.println(a.equals(b));

    }
}

为什么第二个代码中的(a.equals(b))是false？？

解析：
如果一个类没有自己定义equals方法，它将继承Object的equals方法，Object类中的equals方法实现代码为

boolean equals(Object o){
return this ==0;
}

所以：从上面代码默认方法会使用==；
BlogCodeExercise3类中没有重新定义equals这个方法，因此这个方法就来自Object类，
(Object类中的equals方法是用来比较“地址”的，所以等于false)；
而String类中已经默认重写了equals这个方法，而且比较的是值，而不是地址。所以是true。

重写代码源为：

public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = count;
if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n– != 0) {
if (v1[i++] != v2[j++])
return false;
}
return true;
}
}
return false;
}

根据上面上面的代码，如果想要代码②中的(a.equals(b))变为true，可更改代码：

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

public class BlogCodeExercise3 {
    public  String name;

    public BlogCodeExercise3(String name) {
        this.name = name;
    }
    //判断是否为对象地址是否相同
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        //判断对象是否属于该类
        if (!(obj instanceof BlogCodeExercise3)) {
            return false;
        }
        //判断对象内容是否相同
        BlogCodeExercise3 s = (BlogCodeExercise3) obj;
        if (this.name == s.name) {
            return true;
        } else {
            return false;
        }
    }
    public static void main(String[] args) {
        BlogCodeExercise3 a =new BlogCodeExercise3("范闲");
        BlogCodeExercise3 b =new BlogCodeExercise3("范闲");
        System.out.println(a==b);
        System.out.println(a.equals(b));
    }
}

代码更改成功

(12)静态变量和实例变量的区别？

静态变量：

1. 属于类的，存在方法区中
2. 只有一份
3. 常常通过类名.来访问

实例变量：

1. 属于对象的，存在堆中
2. 有几个对象就有几份实例变量
3. 必须通过对象名.来访问

(13)是否可以从一个static方法内部发出对非static方法的调用

不可以

但可以从一个非static方法内部发出对static方法的调用

调用非静态方法的调用必须先创造对象。 调用静态对象方法可以不需要创造对象，可以直接调用。 比如main函数里调用一个非静态方法，必须先创造方法

package blogCodeExercise;

public class BlogCodeExercise {
	// 静态成员
	public static String string = "静态成员";
	// 非静态成员
	public String string2 = "非静态成员";
 
	// 静态方法
	public static void method() {
		string = "范闲";
//		 string2 = "范闲2";
		// method2();//编译报错,因为静态方法里面只能调用静态方法或静态成员
		System.out.println("这是静态方法,静态方法与对象无关");
	}
 
	// 非静态方法
	public void method2() {
		string = "庆帝1";
		string2 = "庆帝2";
		method();// 非静态方法里面可以发出对静态方法的调用
		System.out.println("这是非静态方法,此方法必须和指定的对象关联起来才起作用");
	}
 
	public static void main(String[] args) {
		BlogCodeExercise ble = new BlogCodeExercise();
		ble.method2();// 调用非静态方法
		ble.method();// 调用静态方法
	}
}

编译出错状况

控制台成功输出

(14)Integer和int的区别

1、Integer是int提供的封装类，而int是Java的基本数据类型；
2、Integer默认值是null，而int默认值是0；
3、声明为Integer的变量需要实例化，而声明为int的变量不需要实例化；
4、Integer是对象，用一个引用指向这个对象，而int是基本类型，直接存储数值。（Integer的方法详见API）

(15)Math.round(11.5)等于多少？Math.round(-11.5)等于多少？

查询APi

Math.round(X)=Math.floor(x+0.5)

Math.round(11.5)=Math.floor(12)=12
Math.round(-11.5)=Math.floor(-11)=-11
Math.round(11.6)=Math.floor(12.1)=12
Math.round(-11.6)=Math.floor(-11.1)=-12
Math.round(11.4)=Math.floor(11.9)=11
Math.round(-11.4)=Math.floor(-10.9)=-11

(16)下面代码有什么不妥之处？

①if(username.equals(“zxx”)){}

package BlogCodeExercise;

public class BlogCodeExercise {
    //创建静态变量
    public static String username ;
    public static void main(String[] args) {
        //运用条件
        if(username.equals("zxx")){
            System.out.println("两值匹配");
        }else{
            System.out.println("两值不匹配");
        }
    }
}

编译未报错，运行报错，NullPointerException空指针错误

package BlogCodeExercise;

public class BlogCodeExercise {
    //创建静态变量并且赋值
    public static String username ="zxx";
    public static void main(String[] args) {
        //运用条件
        if(username.equals("zxx")){
            System.out.println("两值匹配");
        }else{
            System.out.println("两值不匹配");
        }
    }
}

给静态变量赋值后，成功输出

package BlogCodeExercise;

public class BlogCodeExercise {
    //创建静态变量
    public static String username;
    public static void main(String[] args) {
        //运用条件
        if(("zxx").equals(username)){
            System.out.println("两值匹配");
        }else{
            System.out.println("两值不匹配");
        }
    }
}

结论：成员变量不赋值，变量默认值null；根据Api可知：对于任何非空参考值x,x.equals(null)应该返回false 。但null.equals(x)则会运行错误.该题则有可能出现这个状况

变量与字符互换位置，成功输出

②int x=1?
return x==1?true;false;

package BlogCodeExercise;

public class BlogCodeExercise {
    public static boolean flag() {
       //题目
        int x=1;
        return x==1?true:false;
    }

    public static void main(String[] args) {
        System.out.println(flag());
    }

}

成功输出

结论：程序能够成功运行，只不过x ==1已经是波尔值了，return x能够返回t给方法了.这里的三元运算符用错了，显得多余，保证代码整洁性

(17)请写出作用域public,private,protected,以及不写时的区别

作用域的可见范围如下图所示：

Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型？

Overload（重载） Override（重写） 重载与重写的区别： 方法重载：同一个类中，方法名相同，参数类型、顺序和个数不同，与返回值类型和访问方法的修饰符无关 方法重写：不同类中（父子类）方法名称、参数类型、返回值类型全部相同，被重写的方法不能拥有比父类更严格的权限

package BlogCodeExercise;

public class BlogCodeExercise {
    String name;
    int health;

    public Object method (String name){
        return name;
    }

    public  Object method (String name,int health){
      return health;
    }
    public static void main(String[] args) {
        BlogCodeExercise bce=new BlogCodeExercise();
        System.out.println(bce.method("李华"));
        System.out.println(bce.method("李华",90));
    }






}

控制台输出两种值类型

结果表明是可以改变

(19)构造器Constructor是否可被override(重写)?

构造器就是构造方法，能够被重载（同类中不同参数列表的构造器），不能够被重写（子类使用super方法可以调用）。不能说能被继承，因为能够调用，但是不能重写。

(20)接口是否可以继承接口？抽象类是否可以实现（implements）接口？抽象是否可以继承具体类（concrete class）？抽象类中是否可以有静态的main方法?

都可以

(21)写clone()方法，通常都有一行代码，是什么？

系统默认，重写父接口里面的方法。
super.clone() 将返回一个调用 super.clone() 方法的对象。