一日不书,百事荒芜

Ⅰ.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){
        case1:
        System.out.println("优秀");
        break;
        case2:
            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() 方法的对象。

评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值