javaSE知识点及练习
day01
1、JDK8对应的eclipse中选择jdk的版本号是什么
1.8。
2、java语言的版本有哪些
Java SE(标准版)，Java EE(企业版)，Java ME(微缩版)。
3、java.exe和javac.exe命令的作用分别是什么
java.exe:运行字节码文件；javac.exe:将源文件编译成字节码文件。
4、配置环境变量的目录在你自己电脑上是什么样子的
右键此电脑，点击属性，点击高级系统设置。
5、JDK和jre的关系是什么
JDK包含jre。
6、什么是JDK
java开发工具。
7、什么是jre
Java 运行时环境
8、主方法的作用是什么
程序入口
9、程序的注释有哪几种
单行 //； /* 多行*/； /** 文档 */。
10、eclipse代码提示的快捷键是什么
alt + /.
11、数据类型的分类有哪些？
基本数据类型:字符型，布尔型，数值型（整型，浮点型）；
引用数据类型：类，接口，数组。
12、解释2147483648直接赋值给long类型为什么会报错
2147483648默认是int类型，超出了int的取值范围，所以报错。
long a = 2147483648l;
13、解释1.2直接赋值给float类型为什么会报错
1.2默认是double类型，double取值范围大于float，存储空间小的存了个存储空间大的，所以报错.
float b = 1.2f;
14、用自己的话描述ASCII码表的作用
简单易用
15、解释一下什么是编译
将源文件转换成计算机能够读懂的机器语言。
day02
1、简述标识符的定义规则
标识符必须以字母、下划线（）、数字或美元（ $ ）组成；标识符必须由字母、下划线（）或美元（$）开头，不能由数字开头；标识符不能是关键字或者保留字；标识符中不能有空格;标识符没有长度限制。
2、简述下面代码有什么问题：
class VariableDemo{
public static void main( String args[]) {
double salary;
System.out.println(salary);
}
}
没有给变量赋值。
3、简述什么是常量
final 数据类型 常量名 = 初始值；
4、数据类型转换分几类？
自动数据类型转换和强制数据类型转换。
5、什么类型不参与类型转换
boolean类型。
6、byte、short、char在计算时首先会转换为什么类型
int类型
7、运算符有哪些分类
算术运算符：+加，-减，* 乘，/除，%取余，++自增，–自减，+字符串连接
赋值运算符：=，+=，-=，=，/=，%=
逻辑运算符：&&与运算符, ||或运算符, !非运算符
关系运算符：>,>=,<,<=,==,!=
三目运算符：表达式1 ？表达式2：表达式3
8、简述运算符的优先级
按操作数分：一元操作符>二元操作符>三元操作符
按运算类型分：算术运算符>关系运算符>逻辑运算符>赋值运算符
类型转换>++，–>!>,/,%>+,->关系运算符>&>|>&&>||>赋值运算符
9、简述三目运算符的作用
简化if-else语句
10、写出三种if条件语句的语法
(1)if(){}
(2)if(){}
else{}
(3)if(){}
else if(){}
…
else{}
11、什么情况下if后面的大括号可以省略
功能代码块为一行
day03
1、简述while语句的代码执行过程
首先判断循环条件，如果循环条件为true，则执行循环体代码，然后再判断循环条件，直到 循环条件不成立时停止执行。如果首先判断循环条件就为false，则不执行循环体，直接执行while语 句后续的代码。
2、简述for语句的代码执行过程
for（表达式1;表达式2;表达式3）
执行表达式1，实现初始化；执行表达式2，判断循环条件是否成立，如果循环条件为false， 则结束循环，否则执行下一步； 执行循环体；执行表达式3，完成迭代；跳转到步骤2重复执行。
3、写出while循环和for循环的死循环代码形式
while（true）{System.out.print(““);}
for(int i=0;;i++){System.out.print(””);}
4、简述break和continue关键字的作用
break:跳出循环；
continue：跳过当前循环
5、必会代码：
1）九九乘法表
for(int i=1;i<10;i++) {
for(int j=1;j<i+1;j++) {
if(i==j) {
System.out.println(i+"*"+j+"="+i*j);
}else {
System.out.print(i+"*"+j+"="+i*j+"\t");
}
}
}
2）水仙花数
for (int i = 100; i < 1000; i++) {
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100;
// int temp = (int) Math.pow(ge,3) + (int) Math.pow(shi,3)+(int)
// Math.pow(bai,3);
int temp = ge * ge * ge + shi * shi * shi + bai * bai * bai;
if (i == temp) {
System.out.println(i);
}
}
3）比较三个数大小
（1）int x = 7;
int y = 8;
int z = 9;
int max=x>y?x:y;
max=max>z?max:z;
int min=x<y?x:y;
min=min<z?min:z；
int center = x+y+z-max-min;
System.out.println("从大到小排序："+max+" "+center+" "+min);
（2） int x = 17;
int y = 20;
int z = 15;
int max = z,min = z,cen;
if(x>max) {
max = x;
}if(y>max) {
max=y;
}
if(x<min) {
min = x;
}if(y<min) {
min = y;
}
cen = x+y+z-max-min;
System.out.println("从大到小排序："+max+","+cen+","+min);
4）打印等腰*号三角形
for(int i=1;i<6;i++) {
for(int j=1;j<=5-i;j++) {
System.out.print(" ");
}
for(int z=1;z<=2*i-1;z++) {
System.out.print("*");
}
System.out.println();
}
}
day04
1. 企业发放的奖金根据利润提成。利润低于或等于10万元时，奖金可提10%；利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，在程序中设定一个变量为当月利润，求应发放奖金总数？
public static void main(String[] args) {
double profit=50;//利润
double bonus;//奖金
double b1 = 10*0.1;
double b2 = b1 + 10*0.075;
double b3 = b2 +20*0.05;
double b4 = b3+20*0.03;
double b5 = b4 + 40*0.015;
if (profit <=10) {
bonus = profit*0.1;
}else if (profit<20) {
bonus = b1+(profit-10)*0.075;
}else if (profit<40) {
bonus = b2+(profit-20)*0.05;
}else if (profit<60) {
bonus =b3+ (profit-40)*0.03;
}else if (profit<100) {
bonus = b4+(profit-60)*0.015;
}else {
bonus = b5+(profit-100)*0.001;
}
System.out.println("应发放奖金总数:"+bonus+"万元");
}
2. 给定一个成绩a，使用switch结构求出a的等级。A：90-100，B：80-89，C：70-79，D：60-69，E：0~59。
public static void main(String[] args) {
int a = 85;
switch (a/10) {
case 10:
case 9:
System.out.println("等级为A");
break;
case 8:
System.out.println("等级为B");
break;
case 7:
System.out.println("等级为C");
break;
case 6:
System.out.println("等级为D");
break;
default:
System.out.println("等级为E");
break;
}
}
3. 假设某员工今年的年薪是30000元，年薪的年增长率6%。编写一个Java应用程序计算该员工10年后的年薪，并统计未来10年（从今年算起）总收入。
public static void main(String[] args) {
double salary = 30000;
double sum = 0;
for (int i = 1; i <=10; i++) {
salary = salary*1.06;
sum+=salary;
}
sum=sum-salary+30000;
System.out.println("10年后的年薪:"+salary);
System.out.println("未来10年（从今年算起）总收入:"+sum);
}
4. 猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个，第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
public static void main(String[] args) {
int i = 1;
int num =1;
while(i<10) {
num = (num +1)*2;
i++;
}
System.out.println("第一天共摘了"+num+"桃子");
}
5. 输入一个数字，判断是一个奇数还是偶数。
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
if (a % 2 == 0) {
System.out.println(a + "是一个偶数");
} else {
System.out.println(a + "是一个奇数");
}
}
6. 编写程序， 判断一个变量x的值，如果是1，输出x=1，如果是5，输出x=5，如果是 10，输出x=10，除了以上几个值，都输出x=none。
public static void main(String[] args) {
int x = 10;
switch (x) {
case 1:
System.out.println("x=1");
break;
case 5:
System.out.println("x=5");
break;
case 10:
System.out.println("x=10");
break;
default:
System.out.println("x=none");
break;
}
}
7. 判断一个数字是否能被5和6同时整除（打印能被5和6整除），或只能被5整除（打印能被5整除），或只能被6整除，（打印能被6整除），不能被5或6整除，（打印不能被5或6整除）
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
if (a % 30 == 0 && a != 0) {
System.out.println("能被5和6整除");
} else if (a % 5 == 0 && a != 0) {
System.out.println("只能被5整除");
} else if (a % 6 == 0 && a != 0) {
System.out.println("只能被6整除");
} else {
System.out.println("不能被5或6整除");
}
}
8. 输入一个年份，判断这个年份是否是闰年。
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int year = sc.nextInt();
if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
System.out.println(year + "是闰年");
} else {
System.out.println(year + "不是闰年");
}
}
9. 输入一个0～100的分数，如果不是0～100之间，打印分数无效，根据分数等级打印A,B,C,D,E。
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int mark = sc.nextInt();
if (mark <0 || mark >100) {
mark = 110;
}
switch (mark/10) {
case 10:
case 9:
System.out.println("A");
break;
case 8:
System.out.println("B");
break;
case 7:
System.out.println("C");
break;
case 6:
System.out.println("D");
break;
case 11:
System.out.println("分数无效");
break;
default:
System.out.println("E");
break;
}
}
10. 输入三个整数x,y,z，请把这三个数由小到大输出。
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int x=sc.nextInt();
int y=sc.nextInt();
int z=sc.nextInt();
int max,min,cen;
max=x>y?x:y;
max=max>z?max:z;
min=x<y?x:y;
min=min>z?z:min;
cen = x+y+z-min-max;
System.out.println(min+","+cen+","+max);
}
11. 有一个不多于5位的正整数，求它是几位数，分别打印出每一位数字。
public static void main(String[] args) {
int a=99999;
int yu;
int temp=0;
String[] str = {"个位:","十位:","百位:","千位:","万位:"};
while(true) {
yu = a%10;
a=a/10;
temp++;
System.out.println(str[temp-1]+yu);
if (a==0) {
System.out.println("它是"+temp+"位数");
break;
}
}
}
12. 编写一个程序，计算邮局汇款的汇费。如果汇款金额小于100元，汇费为一元，如果金额在100元与5000元之间，按1%收取汇费，如果金额大于5000元，汇费为50元。汇款金额由命令行输入。
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double amount = sc.nextInt();
double cny;
if (amount >5000) {
System.out.println("汇费为50元");
}else if (amount >=100) {
System.out.println("汇费为"+amount*0.01+"元");
}else if(amount >0) {
System.out.println("汇费为1元");
}else {
System.out.println("输入的金额不合法！！");
}
}
13. 分别使用for循环，while循环，do循环求1到100之间所有能被3整除的整数的和。
public static void main(String[] args) {
/*1.for循环*/
int sum = 0;
for(int i=1;i<101;i++) {
if (i%3==0) {
sum +=i;
}
}
/*2.while循环*/
int sum1 = 0;
int z=1;
while(z<101) {
if (z%3==0) {
sum1 +=z;
}
z++;
}
/*3.do循环*/
int sum2 = 0;
int m=1;
do{
if (m%3==0) {
sum2 +=m;
}
m++;
}while(m<101);
System.out.println(sum);
System.out.println(sum1);
System.out.println(sum2);
}
14. 输出0-9之间的数，但是不包括5。
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
if (i == 5) {
continue;
}
System.out.println(i);
}
}
15. 编写一个程序，求整数n的阶乘，例如5的阶乘是1*2*3*4*5。
public static void main(String[] args) {
// 编写一个程序，求整数n的阶乘，例如5的阶乘是1*2*3*4*5。
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int sum=1;
if(a>0) {
for (int i = 1; i <= a; i++) {
sum*=i;
}
System.out.println(a+"的阶乘为:"+sum);
}else {
System.out.println("输入的数不合法");
}
}
16. 编写一个程序，找出大于200的最小的质数。
public static void main(String[] args) {
for(int i=201;;i++) {
boolean b = true;
for(int j= 2;j<=i/2;j++) {
if(i%j==0) {
b=false;
}
}
if (b) {
System.out.println("大于200的最小的质数是"+i);
break;
}
}
}
17. 由命令行输入一个4位整数，求将该数反转以后的数，如原数为1234，反转后的数位4321。
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(true) {
System.out.println("输入一个4位整数");
int a=sc.nextInt();
if (a>9999||(a<1000&&a>-1000)) {
System.out.println("输入的数字不合法！！");
continue;
}
int yu;
int temp=0;
int sum=0;
while(true) {
yu = a%10;
a=a/10;
temp++;
sum = sum *10 +yu;
if (a==0) {
break;
}
}
System.out.println(sum);
break;
}
}
day05
1、方法的作用是什么
使程序变得更简短而清晰。有利于程序维护。可以提高程序开发的效率。提高了代码的重用性
2、什么是方法的重载及其作用
方法的重载：方法名字一样，方法的参数个数、类型和顺序不一样。
作用：可以根据不同的参数个数，顺序，类型，自动匹配方法，减少写多个函数名或方法名的重复步骤。
3、怎么定义多维数组
int[][] arr=new int[3][4];
int[][] arr =new int[3][];
int[][] arr ={{1,},{3,4,5,6},{7,8,9}};
4、定义一个二维数组，3行4列，并且进行遍历输出
public static void main(String[] args) {
int[][] num = new int[3][4];
//给二维数组赋值
for(int i=0;i<num.length;i++){
for(int j=0;j<num[i].length;j++){
num[i][j] = i+j;
}
}
//遍历二维数组
for(int i=0;i<num.length;i++){
for(int j=0;j<num[i].length;j++){
System.out.print(num[i][j] + " ");
}
System.out.println();
}
}
5、给定一维数组{ -10，2，3，246，-100，0，5} ，计算出数组中的平均值、最大值、最小值。
public static void main(String[] args) {
int a[]={-10,2,3,246,-100,0,5};
int sum = 0;
for (int i = 0; i < a.length; i++) {
sum = sum +a[i];
}
Arrays.sort(a);
int max = a[a.length-1];
int min = a[0];
System.out.println("平均值为:"+sum/a.length);
System.out.println("最大值为:"+max);
System.out.println("最小值为:"+min);
}
6、将一个数组中的元素逆序存放。
public static void main(String[] args) {
// 将一个数组中的元素逆序存放。
int a[]= {-10,2,3,246,-100,0,5};
for (int i = 0; i < a.length/2; i++) {
int b = a[i];
a[i]=a[a.length-1 - i];
a[a.length-1 - i]= b;
}
System.out.println(Arrays.toString(a));
}
7、必会代码：
冒泡排序
public static void main(String[] args) {
// 冒泡排序
int[] a = { 1, 1, 2, 3, 6, 2, 3, 5, 6, 7, 5 };
for (int i = 1; i < a.length; i++) {
for (int j = 0; j < a.length-i; j++) {
if (a[j]>a[j+1]) {
int tmp = a[j];
a[j]=a[j+1];
a[j+1]=tmp;
}
}
}
System.out.println(Arrays.toString(a));
}
二分查找
public static void main(String[] args) {
// 折半查找
int[] a = { 1,2,3,4,5,6,7,8,9,10,11};
Arrays.sort(a);
int key = 7;
int high = a.length-1;
int low = 0;
boolean b = true;
while(high>=low) {
int index = (high+low)/2;
if (a[index] > key) {
high = index -1;
}else if (a[index] < key) {
low = index +1;
}else {
System.out.println(index);
b=false;
break;
}
}
if (b) {
System.out.println("没有");
}
}
生成不同随机整数
public static void main(String[] args) {
// 6个不同随机整数
Random r = new Random();
int[] a = new int[6];
for (int i = 0; i < 6; i++) {
a[i] = r.nextInt(6);
for (int j = 0; j < i; j++) {
if (a[i] == a[j]) {
i--;
}
}
}
System.out.println(Arrays.toString(a));
}
数组去重（重复元素设成0）
public static void main(String[] args) {
// 去重
int[] a = { 1, 1, 2, 3, 6, 2, 3, 5, 6, 7, 5 };
for (int i = 0; i < a.length; i++) {
for (int j = i+1; j < a.length; j++) {
if (a[i] == a[j]) {
a[j] = 0;
}
}
}
System.out.println(Arrays.toString(a));
}
数组复制（直接复制和利用方法复制）
public static void main(String[] args) {
int aa[] = new int[] { 1, 2, 3, 4, 5 };
int bb[] = new int[] { 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
int cc[] = new int[] { 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
//方法复制
System.arraycopy(aa, 0, bb, 0, 5);
for (int i = 0; i < aa.length; i++) {
System.out.print(aa[i] + " ");
}
System.out.println();
for (int j = 0; j < bb.length; j++) {
System.out.print(bb[j] + " ");
}
System.out.println();
//直接复制
for (int i = 0; i < aa.length; i++) {
cc[i] = aa[i];
}
for (int j = 0; j < cc.length; j++) {
System.out.print(cc[j] + " ");
}
}
数组排序（利用方法排序）
public static void main(String[] args) {
int a[] = {1,6,2,3,9,4,5,7,8};
Arrays.sort(a);
System.out.println(Arrays.toString(a));
}
day06
1、什么是类
具有共同特征（组成部分和功能）的事物的集合 ----- 抽象
2、什么是对象
类的具体化 ----------- 具体
3、构造方法的作用
用来实例化对象和初始化对象属性的
4、构造方法的特点
不显示的定义构造方法，类会生成一个默认的无参构造方法；如果显示的写了其他有参构造，系统就不会生成默认无参构造了
5、什么是局部变量
定义在方法体中的变量；或是方法的形参
6、什么是全局变量
即类的属性，也是类内的全局变量。
7、什么是匿名对象
对象在程序中只使用一次，使用完就会被垃圾回收机制GC回收掉
8、什么是GC
垃圾回收机制
9、简述this关键字的作用
this关键字： this关键字代表对象自身的引用，它是一个引用，指向调用该方法的当前对象，通常在类的方法定义中使用
this():代表调用其他构造方法，但是不能形成调用的闭环，而且需要写在方法体中的第一行
10、什么时候使用this关键字（课件里找）
一是方法中的变量与属性重名时
二是在一个构造方法中，调用其它重载的构造方法
三是返回当前对象的引用
11、什么是方法的递归调用
方法在定义的时候调用了自己
12、解释什么是栈内存什么是堆内存
栈stack：栈的存取速度比堆快，效率高。在栈内保存基本数据类型的局部变量和对象的引用值。
堆heap：堆可以保存那些对空间要求较大的变量。如对象的属性和数组的元素。在堆内存中开辟空间，只能通过内存分配操作符号new，凡 是出现关键字new的地方必定分配了一个堆内存。
我们在实例化一个对象时，同时操作了栈内存和堆内存。在栈内保存对象的首地址，即引用；在堆内存中保存了对象的属性。对对象的所有 操作只能通过引用完成，一旦引用出栈释放没有任何引用指向该对象，对象就变成垃圾失效。
13、描述构造方法和普通方法的区别
1. 作用不同 构造方法是为了创建一个类的实例。这个过程只可以在创建一个对象的时候用到。普通方法的作用是为了完成一段业务功能。
2. 修饰符不同 和普通方法一样，构造方法可以有任何访问的修饰：public，protected，private或者没有修饰。不同于普通方法的是，构造 方法不能有以下非访问性质的修饰：abstract，final， native，static或者synchronized。
3. 返回值不同 返回类型也是非常重要的。普通方法能返回任何类型的值或者无返回值（void），构造方法没有返回值，也不需要void。
4. 命名不同 构造方法使用和类相同的名字，而普通方法则不同。按照习惯，普通方法通常用小写字母开始，而构造方法通常用大写字母开始 。构造方法通常是一个名词，因为它和类名相同；而方法通常更接近动词，因为它说明一个操作。
5. 必会代码：
方法递归调用
public static void main(String[] args) {
// 方法递归调用,阶乘
int sum = jieCheng(5);
System.out.println(sum);
}
public static int jieCheng(int n) {
if (n==1) {
return 1;
}
return n*jieCheng(n-1);
}
定义一个类并且实例化这个类的一个对象
class Actor {
String name;
int age;
Actor () {
}
Actor (String name, int age) {
this.name = name;
this.age = age;
}
public void talk() {
System.out.println("我叫：" + this.name+","+"我今年"+this.age);
}
}
public class Test6 {
public static void main(String[] args) {
Actor t = new Actor ();
t.name="黑土";
t.age=35;
t.talk();
}
day07
1、简述static关键字的作用
用static修饰的成员变量会提升为类层级，在内存中只有一份（静态成员变量）；
用static修饰的方法，提升为类层级；
static修饰的方法不能包含非static修饰的变量；
static修饰的方法不能包含非static修饰的方法。
2、使用static修饰方法的作用有哪些
a. 简化方法的使用；
b. 便于访问静态属性。
3、静态变量有哪两种方式可以对其进行访问
a. 直接访问：类名.属性；
b. 实例化后访问：对象名.属性
4、静态方法有哪两种方式可以对其进行访问
a. 直接访问：类名.方法名()
b. 实例化后访问：对象名.方法名()
5、什么是单例模式
单例：无论实例化多少次，只得到一个实例化对象
6、单例模式要点包括哪些
a. 某个类只能有一个实例
b. 它必须自行创建这个实例
c. 必须自行向整个系统提供这个实例
7、简述单例模式实现方式
a. 拥有一个私有构造方法
b. 提供一个自身静态私有的成员变量
c. 提供一个公有的静态方法
8、简述什么是封装性
使用访问权限修饰符对类的成员进行控制
9、简述super关键字的作用
指向父类的引用(在子类中访问父类的内容)
10、简述super关键字和this关键字的区别
this指向的是当前对象的调用，super指向的是当前调用对象的父类
11、什么是方法重写，需要注意什么
重写：子类将从父类中继承下来的方法重新实现。
a.重写过程当中，子类可以修改父类方法的访问权限，但是子类重写的方法访问权限不能低于从父类继承过来的方法访问权限。父类的私有方 法子类能继承过来，但不能重写。
b.相同的方法名，相同的参数列表（参数数量、参数类型、参数顺序都要相同），相同的返回值类型。
12、简述方法重写和方法重载的区别
重载方法是提供多于一个方法，这些方法的名字相同，但是参数形式不同；覆盖方法就是在子类定义一个方法，该方法与父类中的方法方法 名相同，参数形式也相同，并且返回值类型也相同。
13、简述子类实例化的过程
子类实例化时先实例化其父类，然后实例化子类。要先调用父类的构造方法，父类构造方法运行完毕，才调用子类的构造方法。
14、什么是继承
继承是从已有的类中派生出新的类，新的类能拥有已有类的属性和行为，并能扩展新的属性和行为。
15、必会代码：
统计实例化对象个数
//统计实例化对象的个数
class Student{
int id;
String name;
static int count=0;
public Student(String name,int id) {
this.name = name;
this.id = id;
count++;
}
}
public class Work2 {
public static void main(String[] args) {
Student stu = new Student("lisi",1);
Student stu1 = new Student("zhangsani",2);
Student stu2 = new Student("wangwu",4);
Student stu3 = new Student("zhaoliu",3);
System.out.println(Student.count);
}
}
单例设计模式
//单例：无论实例化多少次，只得到一个实例化对象
class A {
String name;
private static A a = new A();
private A() {
System.out.println("实例化了");
}
public static A getA() {
// System.out.println("得到");
return a;
}
}
public class Work1 {
public static void main(String[] args) {
A a1 = A.getA();
A a2 = A.getA();
A a3 = A.getA();
System.out.println(a1==a2);
System.out.println(a1==a3);
System.out.println(a3==a2);
}
}
day08
1、简述final关键字的作用
a.用final修饰的类不允许被继承
b.用final修饰的方法不允许被重写
c.用final修饰的成员变量不允许被修改
d.用final修饰的局部变量不允许被修改
2、继承关系的关键字用什么
extends
3、实现的关键字用什么
implements
4、在一个文件中导入其他包中的内容用什么关键字
import
5、什么是上溯造型
上溯造型，即向上转型（Upcasting）是指子类转换为父类，这是自动转换；转换的前提是具有继承或实现关系。向上转型损失了子类新扩 展的属性和方法，仅可以使用从父类中继承的属性和方法。
6、什么是下塑造型
下溯造型，即向下转型（Downcasting）称之为强制转换，是将父类对象显式的转换成子类类型。曾经向上转换过的对象，才能再向下转换 。对象不允许不经过上溯造型而直接下溯造型。
7、什么是抽象类
包含一个抽象方法的类（抽象类可以没有抽象方法）
8、什么是抽象方法
用abstract关键字修饰的,没有方法体的方法
9、什么是接口
接口是一种用于描述类对外提供功能规范的、能够多继承的、特殊的抽象类。接口中只能定义静态常量和抽象方法。
10、instanceof 运算符的作用是什么
instanceof 运算符用来判断一个类是否实现了某个接口和一个实例对象是否属于一个类，返回值类型都是布尔类型，
11、什么是多态
多态是Java的重要特征之一，方法的覆盖、重载与动态绑定构成了多态性。
多态是具有表现多种形态的能力的特征，是同一个实现接口，使用不同的实例而执行不同操作，不同的对象对同一行为作出的不同响应。
12、满足多态的三个必要条件是什么
● 要有继承，或实现
● 要有重写
● 父类引用指向子类对象
day09
1、运行Java程序时会遇到的错误问题分为哪三种
语法错误，逻辑错误，运行时错误
2、异常按照处理方式可以分为哪两种类型
a．检查性异常（checked exception）
b．非检查性异常（unchecked exception）
3、分别翻译以下异常
RuntimeException java.lang包中多数异常的基类
ArithmeticException 算术错误
illegalArgumentException 方法收到非法参数
ArraylndexOutOfBoundsException 数组下标出界
ClassNotFoundException 无法找到想要创建对象的类文件
IOException I/O异常的根类
FileNotFoundException 不能找到文件
EOFException 文件结束
illegalAccessException 对类的访问被拒绝
NoSuchMethodException 请求的方法不存在
InterruptedException 线程中断
NullPointerException 试图访问null对象引用
4、处理异常分为哪两种方式
自行处理：可能引发异常的语句封入在 try 块内，而处理异常的相应语句则封入在 catch 块内。
回避异常：在方法声明中包含 throws 子句，通知潜在调用者，该方法可能会出现异常，但没有处理这种异常，必须由调用者处理。
5、分别解释以下关键字
throw 抛出异常
throws 声明异常
finally fianlly语句中的代码块不管异常是否被捕获总是要执行。
6、简述接口和抽象类的区别
接口与抽象类的对比，接口不能含有任何非抽象方法，而抽象类可以。类可以实现多个接口，但只能有一个父类。接口和接口之间可以多继承。
抽象类可以理解为抽象方法和非抽象方法的混合体，而接口中的方法完全是抽象方法，是一套纯粹的规范。
一般来说，有关系的类才能继承同一个抽象类，而无关的类不可能有同一个抽象父类，但是无关的类可以实现同一个接口。
day10
“abc”.equals(“ABC”) :比较的内容区分大小写
“abc”.equalsIgnoreCase(“ABC”) :比较的内容忽略大小写
“a”.compareTo(“a”) :比较字符串顺序（前面的比后面的在字母表里排列顺序大多少）
“hello”.startsWith(“he”) :判断字符串是否已参数的字符串开头
“hello”.endsWith(“lo”) :判断字符串是否已参数的字符串结尾
String str = new String(chr) :将一个字符数组变为字符串
String str1 = String.valueOf(chr) :将一个字符数组变为字符串
“helloworld”.toCharArray() :将字符串变为字符数组
“helloworld”.getBytes() :将一个字符串变成字节数组
“helloworld”.length()) :字符串长度
“helloworld”.charAt(5) :获取字符串索引的字符
“helloworld”.substring(5) :从指定下标位置截取字符串到结尾
“helloworld”.substring(1,8) :从指定下标位置截取字符串到下一个下标前一个位置，包左不包右
“helloworld”.indexOf(‘l’) :指定字符在字符串中首次出现的位置（找不到返回-1）
“helloworld”.indexOf(‘l’,3) :从指定的下标位置开始找指定字符所在位置（找不到返回-1）
str2.replace(‘s’, ‘a’) :前面的参数用后面的参数替换(单个字符)
str2.replace(“is”, “si”) :前面的参数用后面的参数替换(字符串)
str2.replaceFirst(“is”, “IS”) :前面的参数用后面的参数替换(字符串,只替换第一个)
str2.toUpperCase() :全变成大写字母
str2.toLowerCase() :全变成小写
day11
1、Object类中的equals方法作用
比较两个引用所指向的对象是否是同一个对象，即两个引用所指向对象的地址是否相等。
2、什么是装箱操作
装箱就是把基本类型用它们相应的包装类型包装起来，使其具有对象的性质。
3、什么是拆箱操作
拆箱和装箱相反，将包装类型的对象转化成基本类型类型的数据。
4、简述String 对象的不可变性
任何一个String对象在创建之后都不能对它的内容作出任何改变。对于连接、获得子串和改变大小写等操作，如果 返回值同原字符串不同，实际上是产生了一个新的String对象，在程序的任何地方，相同的字符串字面常量都是同一个对象。
5、简述Calender类中的set方法和get方法的作用。
使用Calendar类代表指定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。
set方法：使用Calendar类中的set()方法可以设定Calendar对象中对应的信息，set()方法的声明为：
public final void set(int year,int month,int date)
get方法：使用Calendar类中的get()方法可以获得Calendar对象中对应的信息，get()方法的声明如下：
public int get(int field)
day12
1、内部类的作用
方便访问外部类的私有成员
2、匿名内部类的作用
简化接口实现过程，节省一个子类（前提是只是用一次）
3、描述一下比较对象内容大小的方式
a.compareTo方法是Java中的一个接口Comparable定义的方法，它用于比较当前对象与另一个对象的大小关系 。compareTo方法返回一个整数值，表示当前对象与参数对象的大小关系。如果返回值为负数，则表示当前对象小于参 数对象；如果返回值为正数，则表示当前对象大于参数对象；如果返回值为零，则表示当前对象等于参数对象。
b.compare方法是Java中的一个接口Comparator定义的方法，它用于比较两个对象的大小关系。compare方法 接受两个参数，分别是要比较的两个对象，返回一个整数值表示它们的大小关系。与compareTo方法不同的是，compare 方法不依赖于对象自身的实现，而是通过一个独立的比较器对象来进行比较。
compareTo方法
package com.neuedu.test15;
import java.lang.reflect.Array;
import java.util.Arrays;
class Student implements Comparable<Student>{ //<Student> 是泛型
private int id;
private String name;
public Student(int id,String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + "]";
}
@Override
public int compareTo(Student stu) {
if (this.id == stu.id) {
return 0;
}else if (this.id > stu.id) {
return 1;
}else {
return -1;
}
}
}
public class Test1 {
public static void main(String[] args) {
Student s1 = new Student(1,"zs");
Student s2 = new Student(2,"ls");
Student s3 = new Student(3,"ww");
Student[] stus = {s3,s1,s2};//对象数组
Arrays.sort(stus);
System.out.println(Arrays.toString(stus));
}
}
compare方法
package com.neuedu.test15;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;
class Person {
private int id;
private String name;
public Person(int id,String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
@Override
public String toString() {
return "Person [id=" + id + ", name=" + name + "]";
}
}
class PersonComparator implements Comparator<Person>{
@Override
public int compare(Person o1, Person o2) {
if (o1.getId() == o2.getId()) {
return 0;
}else if (o1.getId() > o2.getId()) {
return 1;
}else {
return -1;
}
}
}
public class Test2 {
public static void main(String[] args) {
Person s1 = new Person(1,"zs");
Person s2 = new Person(2,"ls");
Person s3 = new Person(3,"ww");
Person[] stus = {s3,s1,s2};//对象数组
Arrays.sort(stus,new PersonComparator());
System.out.println(Arrays.toString(stus));
}
}
4、set集合特点
Set接口是Collection接口的子接口，表示集合，对实现该接口的对象有个要求，就是集合中的元素不允许重复， 该接口与Collection接口基本一致，方法与Collection完全相同。
5、list集合特点
List接口继承了Collection接口，用来包含一组有序有重复的对象。List中的每个元素都对应一个整数型的序号，记 载其在容器中的位置，可以根据序号存取容器中的元素。List就是通常所说的链表，是一种特殊的集合，集合中的元素是有 序的，所以多了一些与顺序相关的方法。
6、linkedList和ArrayList的区别
a.ArrayList 使用数组方式存储数据，所以根据索引查询数据速度快，而新增或者 删除元素时需要设计到位移操作 ，所以比较慢。
b.LinkedList 使用双向链接方式存储数据，每个元素都记录前后元素的指针， 所以插入、删除数据时只是更改前 后元素的指针指向即可，速度非常快，然后通过下标查询元素时需要从头开始索引，所以比较慢，但是如果查询前几个元 素或 后几个元素速度比较快
必会代码：
list集合遍历的方式
public static void main(String[] args) {
// 集合的遍历
ArrayList<String> strList = new ArrayList<String>();
strList.add("深海中 那点光 昏暗的诱惑");
strList.add("她以为 抓得住 名为爱的泡沫");
strList.add("人心 扑朔 晦涩 幽蓝如墨");
strList.add("怎么 猜透 看透 故事的结果");
//普通for循环
for (int i = 0; i < strList.size(); i++) {
System.out.println(strList.get(i));
}
System.out.println("-------------------");
//增强for循环
for(String str : strList) {
System.out.println(str);
}
System.out.println("-------------------");
//迭代器
Iterator<String> it = strList.iterator();
while (it.hasNext()) {
String string = (String) it.next();
System.out.println(string);
}
System.out.println("-------------------");
//双向遍历
ListIterator<String> list = strList.listIterator();
while (list.hasNext()) {
String string = (String) list.next();
}
while (list.hasPrevious()) {
String string = (String) list.previous();
System.out.println(string);
}
}
对象内容大小排序
-----------------------------compareTo----------------------------------------------
class Student implements Comparable<Student>{ //<Student> 是泛型
private int id;
private String name;
public Student(int id,String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + "]";
}
@Override
public int compareTo(Student stu) {
if (this.id == stu.id) {
return 0;
}else if (this.id > stu.id) {
return 1;
}else {
return -1;
}
}
}
public class Test1 {
public static void main(String[] args) {
Student s1 = new Student(1,"zs");
Student s2 = new Student(2,"ls");
Student s3 = new Student(3,"ww");
Student[] stus = {s3,s1,s2};//对象数组
Arrays.sort(stus);
System.out.println(Arrays.toString(stus));
}
}
-----------------------------compare----------------------------------------------
class Person {
private int id;
private String name;
public Person(int id,String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
@Override
public String toString() {
return "Person [id=" + id + ", name=" + name + "]";
}
}
class PersonComparator implements Comparator<Person>{
@Override
public int compare(Person o1, Person o2) {
if (o1.getId() == o2.getId()) {
return 0;
}else if (o1.getId() > o2.getId()) {
return 1;
}else {
return -1;
}
}
}
public class Test2 {
public static void main(String[] args) {
Person s1 = new Person(1,"zs");
Person s2 = new Person(2,"ls");
Person s3 = new Person(3,"ww");
Person[] stus = {s3,s1,s2};//对象数组
Arrays.sort(stus,new PersonComparator());
System.out.println(Arrays.toString(stus));
}
}
day13
1、列出你所知道的File类相关方法及其作用
boolean createNewFile() 当且仅当不存在具有此抽象路径名指定的名称的文件时，创建由此抽象路径名指定的一个新的空文件。
static File createTempFile(String prefix,String suffix) 在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称
static File createTempFile(String prefix,Stirng suffix,File directory) 在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称
boolean exists() 测试此抽象路径名表示的文件或目录是否存在
boolean delete() 删除此抽象路径名表示的文件或目录
boolean equals(Object obj) 测试此抽象路径名与给定对象是否相等
boolean canRead() 测试应用程序是否可以读取此抽象路径名表示的文件
boolean canWrite() 测试应用程序是否可以修改此抽象路径名表示的文件
String[] list() 返回由此抽象路径名所表示的目录中的文件和目录的名称所组成字符串数组
String getAbsolutePath() 返回抽象路径名的绝对路径名字符串
String getName() 返回由此抽象路径名表示的文件或目录的名称，不包括路径名称
String getPath() 将此抽象路径名转换为一个路径名字符串
File[] listFiles() 返回一个抽象路径名数组，这些路径名表示此抽象路径名所表示目录中的文件
boolean renameTo(File dest) 重新命名此抽象路径名表示的文件
long length() 返回由此抽象路径名表示的文件的大小，以byte为单位
boolean mkdir() 创建此抽象路径名指定的目录
boolean mkdirs() 创建此抽象路径名指定的目录，包括创建必需但不存在的父目录。注意，如果此操作失败，可能已成功创建了一些必需的父目录
2、什么是io流
流（Stream)的概念代表的是程序中数据的流通，数据流是一串连续不断的数据的集合。在Java程序中，对于数据的输入/输出操作是以流(Stream)的方式进行的。可以把流分为输入流和输出流两种。程序从输入流读取数据，向输出流写入数据。在java程序中，从输入流读取数据（读到内存中），而从输出流输出数据（从内存存储到文件或显示到屏幕上）.
3、io流有哪些分类
● 按流的方向不同分为：输入流、输出流
● 按处理数据的单位不同分为：字节流、字符流
● 按功能不同分为：节点流、处理流
4、什么是对象序列化
对象序列化是指将对象转换为字节序列的过程，以便在网络上传输或将对象保存到文件中。在序列化过程中，对象的状态（即对象的数据）被转换为字节流，可以在需要时重新恢复为原始对象。
通过对象序列化，可以实现以下功能：
对象的持久化：将对象保存到文件或数据库中，以便在程序重新启动时恢复对象的状态。
对象的传输：将对象通过网络传输给其他计算机或进程，实现分布式系统中的通信和数据共享。
在Java中，对象序列化是通过实现java.io.Serializable接口来实现的。该接口是一个标记接口，没有任何方法需要实现。当一个类实现了Serializable接口时，表示该类的对象可以被序列化。
要进行对象序列化，可以使用ObjectOutputStream类将对象写入输出流，而要进行对象
5、排除序列化字段的关键字是什么
transient
6、必会代码
List集合和Map集合的遍历方式
---------------------------Map集合的遍历方式---------------------------------------------
public class Test11 {
public static void main(String[] args) {
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "zs");
map.put(2, "ls");
map.put(3, "ww");
map.put(4, "ww");
map.put(4, "zl");//值可以重复键不可以重复，后添加的元素会把原来添加的替换掉（键一样）
System.out.println(map.containsKey(2));//判断是否包含指定的键，有的话返回true否则false；
System.out.println(map.containsValue("zl"));//判断是否包含指定的值，有的话返回true否则false；
System.out.println(map.remove(3));//按照指定的键删除元素，删除成功时会返回被删除元素的值，如果找不到指定的键会返回null
System.out.println(map.size());
System.out.println(map.isEmpty());
map.clear();
System.out.println(map.isEmpty());
System.out.println(map);
}
}
-----------------------List集合遍历方式-----------------------------
public class Test11 {
public static void main(String[] args) {
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "zs");
map.put(2, "ls");
map.put(3, "ww");
map.put(4, "ww");
map.put(4, "zl");//值可以重复键不可以重复，后添加的元素会把原来添加的替换掉（键一样）
System.out.println(map.containsKey(2));//判断是否包含指定的键，有的话返回true否则false；
System.out.println(map.containsValue("zl"));//判断是否包含指定的值，有的话返回true否则false；
System.out.println(map.remove(3));//按照指定的键删除元素，删除成功时会返回被删除元素的值，如果找不到指定的键会返回null
System.out.println(map.size());
System.out.println(map.isEmpty());
map.clear();
System.out.println(map.isEmpty());
System.out.println(map);
}
}
字节流实现文件复制
public class Test5 {
public static void main(String[] args){
File f = new File("F:\\text.txt");//读
InputStream input = null;
byte b[] = null;
try {
input = new FileInputStream(f);
b = new byte[(int) f.length()];
input.read(b);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (input != null) {
input.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println(Arrays.toString(b));
//String str = String.valueOf(b);
String str = new String(b);
System.out.println(str);
}
}
将指定目录下的图片文件复制到另外的目录中
public class Test10 {
public static void main(String[] args) throws IOException {
File f = new File("F:" + File.separator+"picture");
print(f);
}
private static void print(File f) throws IOException {
if (f != null) {
if (f.isDirectory()) {// 目录
File[] farrs = f.listFiles();
if (farrs != null) {
for (File fs : farrs) {
print(fs);
}
}
} else {// 文件
System.out.println(f.getName());
if (f.getName().contains(".jpg")||f.getName().contains(".png")) {
String path = "F:" + File.separator+"zhx";
File f1 = new File(path);
if(!f1.exists()) {
f1.mkdir();
}
File f2 = new File(path+File.separator+f.getName());
InputStream instream = new FileInputStream(f);
OutputStream outputStream = new FileOutputStream(f2);
int temp = 0;
while ((temp = instream.read())!= -1) {
outputStream.write(temp );
}
System.out.println("复制完成");
instream.close();
outputStream.close();
}
}
}
}
}
将对象序列化到文件中
//对象序列化
class Student implements Serializable{
private static final long serialVersionUID = 1L;
String name;
transient String id;//排除序列化字段
static int age;//类层级，不参与序列化
@Override
public String toString() {
return "Student [name=" + name + ", id=" + id + ", age=" + age + "]";
}
public Student(String name, String id, int age) {
super();
this.name = name;
this.id = id;
this.age = age;
}
}
public class Test14 {
public static void main(String[] args) throws IOException {
File f = new File("C:"+File.separator +"student.txt");
Student stu = new Student("zs","0001",18);
OutputStream out = new FileOutputStream(f);
ObjectOutputStream oos = new ObjectOutputStream(out);
oos.writeObject(stu);
oos.close();
out.close();
}
}
day14
1、什么是泛型?
泛型（Generics）是自JDK5.0开始引入的一种Java语言新特性，其实质是将原本确定不变的数据类型参数化，作为对原有Java类型体系的扩充，使用泛型可以提高Java应用程序的类型安全、可维护性和可靠性。
2、解释以下两种泛型写法是什么意思?
描述了通配符上界, 即具体的泛型参数需要满足条件: 泛型参数必须是 Number 类型或它的子类
描述了通配符下界, 即具体的泛型参数需要满足条件: 泛型参数必须是String 类型或它的父类。
3、列出目前你所见到的异常类
--------------非检查型异常----------------------
RuntimeException java.lang包中多数异常的基类
ArithmeticException 算术错误
illegalArgumentException 方法收到非法参数
ArrayIndexOutOfBoundsException 数组下标出界
NullPointException 试图访问null对象引用
--------------检查型异常----------------------
ClassNotFoundException 无法找到想要创建对象的类文件
IOException I/O异常的根类
FileNotFoundException 不能找到文件
EOFException 文件结束
IllegalAccessException 对类的访问被拒绝
NoSuchMethodException 请求的方法不存在
InterruptedException 线程中断
4、列出String类的常用API方法并说出其功能
byte[] getBytes(Charset charset) 使用给定的 charset将此String 编码到byte 序列，并将结果存储到新的byte 数组
String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。
String replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用newChar 替换此字符串中出现的所有oldChar 得到的
String toUpperCase() 将String对象中的所有字符都转换为大写
String toLowerCase() 将String对象中的所有字符都转换为小写
char charAt(int) 返回指定索引处的 char 值
String substring(int begin) 返回一个新字符串，该字符串是从begin开始的字符串的内容
String substring(int begin,int end) 返回一个新字符串，该字符串是从begin开始到end-1结束的字符串的内容
int indexOf/lastIndexOf(char) 返回指定字符在此字符串中第一次/最后一次出现处的索引。
int indexOf/lastIndexOf(char,int) 从指定的索引开始搜索，返回在此字符串中第一次/最后一次出现指定字符处的索引
int indexOf/lastIndexOf(String) 返回第一次出现的指定子字符串在此字符串中的索引
int indexOf/lastIndexOf(String,int) 从指定的索引开始搜索，返回在此字符串中第一次/最后一次出现指定字符串处的索引
String trim() 返回新的字符串，忽略前导空白和尾部空白
int length() 返回此字符串的长度
String concat(String str) 将指定字符串连接到此字符串的结尾
byte[] getBytes() 使用平台的默认字符集将此String 编码为byte 序列，并将结果存储到一个新的byte 数组中
5、列出Collection集合中的常用方法并说出其功能
（1）、第一类方法，向集合中添加对象的方法
可以添加一个，也可以添加多个，添加多个也就是把另外一个集合的元素添加进来，下面的两个方法是添加对象的方法：
public boolean add(Object o)：向集合中添加参数指定的元素。
public boolean addAll(Collection c) ：向集合中添加参数指定的所有元素。
（2）、第二类方法，从集合中删除元素的方法
可以删除一个，可以删除多个，还可以删除所有的元素，此外还有一个特殊的，删除某些元素之外的所有元素，所以对应的方法也有四个：
public boolean remove(Object o) ：删除指定的某个元素。
public boolean removeAll(Collection c) ：删除指定的多个元素。
public void clear()：删除所有的元素。
public boolean retainAll(Collection c) ：只保留指定集合中存在的元素，其他的都删除，相当于取两个集合的交集。
（3）、第三类方法，判断集合中元素的方法
public boolean isEmpty()：用于判断集合是否是空的。
public boolean contains(Object o) ：判断是否包含指定的元素。
public boolean containsAll(Collection c) ：判断是否包含指定的多个元素。
public int size()：用于获取集合中元素的个数。
（4）、第四类方法，与其它类型的对象进行转换的方法
public Iterator iterator()：转换成迭代器，方便集合中元素的遍历。
public Object[] toArray()：返回一个包含所有元素的对象数组，也是方便集合中元素的遍历。
通常在管理集合的过程中，使用集合本身提供的方法，但是遍历集合最好先转换成迭代器或者数组，这样访问比较方便，并且效率比较高。
（5）、第五类方法，比较通用的方法
public boolean equals(Object o) ：判断是否与另外一个对象相同。
public int hashCode()：返回集合的哈希码。
6、写出所有基本数据类型对应的包装类名字
boolean Boolean
byte Byte
char Character
double Double
float Float
int Integer
long Long
short Short