文章目录
- Ⅰ.Java基础:
- (1)一个“,java”源文件中是否可以包括多个类(不是内部类)?有什么限制?
- (2)Java有没有goto?
- (3)说说&和&&的区别
- (4)在java中如何跳出当前的多重循环
- (5)Switch能否作用于byte上,能否作用在long上,能否作用在String上?
- (6)short s1=1;s1=s1+1;有什么错?short s1=1;s1+=1;有什么错?
- (7)char型变量中能不能存贮一个中文汉字?为什么?
- (8)用最有效的方法算出2乘以8等于几?
- (9)请设计一个一百亿的计算器
- (10)使用final关键字修饰一个变量时,是引用不能变,还是引用对象不能变?
- (11)"=="和equals方法究竟有什么区别
- (12)静态变量和实例变量的区别?
- (13)是否可以从一个static方法内部发出对非static方法的调用
- (14)Integer和int的区别
- (15)Math.round(11.5)等于多少?Math.round(-11.5)等于多少?
- (16)下面代码有什么不妥之处?
- (17)请写出作用域public,private,protected,以及不写时的区别
- Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?
- (19)构造器Constructor是否可被override(重写)?
- (20)接口是否可以继承接口?抽象类是否可以实现(implements)接口?抽象是否可以继承具体类(concrete class)?抽象类中是否可以有静态的main方法?
- (21)写clone()方法,通常都有一行代码,是什么?
Ⅰ.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("不优秀");
}
}
}
控制台成功输出 |
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("不优秀");
}
}
}
控制台成功输出 |
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("不优秀");
}
}
}
控制台未能成功输出 |
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("不优秀");
}
}
}
控制台成功输出 |
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("不优秀");
}
}
}
控制台未能成功输出 |
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("不优秀");
}
}
}
控制台成功输出 |
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("不优秀");
}
}
}
控制台未能成功输出 |
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("不优秀");
}
}
}
控制台成功输出 |
(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)静态变量和实例变量的区别?
静态变量:
- 属于类的,存在方法区中
- 只有一份
- 常常通过类名.来访问
实例变量:
- 属于对象的,存在堆中
- 有几个对象就有几份实例变量
- 必须通过对象名.来访问
(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());
}
}
成功输出 |
(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() 方法的对象。