1.JDK?JRE?
JDK :java开发工具包
JRE + 类库
JRE:Java运行环境 + JVM(Java虚拟机)
2.java文件运行步骤?
先由javac编译为class文件,再由java执行
3.数据类型分类?
void
基本数据类型
整数
字节byte :-128 到 127 1字节
短整型short : 2字节
整型int : 4
长整型long : 8
浮点型
单精度float :
多精度double :
字符型
char :
布尔型
boolean :
引用数据类型
字符串String
数组Arrays[]
类class
接口interface
枚举
注解
4.byte,short的范围
byte :-128 ~ 127
short :-32768 ~ 32767
5.变量?常量?
变量:一个存储空间,空间中的值可变
常量:final,值不可变
6.&&和||的特点?
逻辑运算符 && ||:具备短路特点,效率高;&&与 一false为false,||或 一 true 为 true
7.运算符优先级?
()
! ++ --
算术
* / %
+ -
关系
> >= < <=
== !=
逻辑
&&
||
条件
?:
赋值
= +=
9.break和continue的区别?
跳转语句:改变程序的流程;
break;
用于 switch ,循环 作用:结束循环;
continue; 用于循环; 作用:结束本次循环进行下一次循环。
10.一维数组边声明边初始化的两种方式?
int [] n = {3,5,5};
int [] n1 = new int[]{5,6,7};
11.类和对象区别?
类:
相似对象的集合。
抽象的概念。
规定了 对象共同的属性 和方法;
是一种数据类型。
是一个模板,根据类的模板创建出具体的对象。
对象:
实体,可以被描述的具有确定边界的事物。
是具体的,真是存在的。
12.封装?作用?
概念:
隐藏类中的属性和实现细节,
对外只提供公共的访问方式。
作用:
1.隐藏类的实现细节,安全性;
2.对外只能通过提供的方式访问;
3.访问器方法中可以使用条件语句。
13.重载和重写区别?
方法重载overload:
同一个类中,
方法名相同,
参数列表不同(类型个数顺序),
与返回值无关。
作用:
对于功能相同的方法,采取相同的名字方便记忆。
方法重写override(覆盖)
子类中,
方法名、参数、返回值与父类完全相同
访问修饰符不能比父类更严格,
异常范围不能比父类更大。
14.抽象类和接口区别?
相同点:
1.都不能创建对象;
2.都需要用 子类 或实现类 创建对象使用;
3.都可以定义 抽象方法;
4.普通的子类 或实现类 必须
实现 抽象父类 或 接口中的
所有抽象方法(抽象子类和实现类除外)。
不同点:
1.定义 的 成员不同;
2.类 是 单一继承;
接口可以多继承;
3.子类 只能继承一个抽象父类;
实现类 可以实现多个 接口的功能;
15.访问修饰符的可见性?
访问修饰符:
本类 同包 子类 不同包
private 是
默认 是 是
protected 是 是 是
(保护)
public 是 是 是 是
16.final的作用?
终态
修饰类:此类不能被继承;
例如:String
修饰方法:此方法不能被重写;
修饰变量:是常量,值不能被更改。
17.什么是多态?实现多态的两个特征?
定义:一种物质的多种形态
同一种引用类型,使用不同的实例(对象)执行不同的操作。
实现多态的两个条件:
1.方法重写;
2.父类引用->子类对象
接口引用->实现类对象
子类中特有的功能不能被实现
18.向上转型?向下转型?
1.向上类型转换
子类->转 父类类型
2.向下类型转换
父类-> 子类
强制转;
子类 对象= (子类)父类对象;
19.成员变量和局部变量区别?作用域、初始值、同名
1.成员变量作用域范围 整个类中有效;
局部变量 带定义它的 代码块中有效
2.成员变量 系统自动赋值
局部变量 必须自己赋值,系统不赋值。
3.成员变量 和 局部变量 同名,
优先 使用 局部变量。
20.成员变量和静态变量区别?
1.静态变量 属于 类,又叫类变量;
实例变量 属于 对象。
2.静态变量存在 方法区中 ,被所有对象共享;
实例变量存在 堆中。
3.静态变量随着类的加载而加载,类消失而释放;
实例变量随着对象消失而释放。
4.静态变量优先于对象而存在。
21.成员方法和静态方法区别?
1.静态方法 中 只能直接使用静态成员;
实例方法中都可以使用;
2.静态方法中 不能使用 this,super
实例方法可以使用。
22.异常和错误区别?
Error :错误。不能处理
Exception:异常。可以处理。
分类:运行时异常:可以不处理。
RuntimeException类及其子类。
非运行时异常(编译): 必须处理。
23.try,catch,finally的作用?
try{
容易出现异常的代码;
}catch(异常类型 对象){
捕获并处理异常;
}finally{
一定会执行的代码;
}
注意:
finally块唯一一种不执行的情况。
System.exit(0);//执行到退出 JVM
24.throw,throws的作用
throws声明异常
把异常抛给调用者
调用者处理方式:
1.try-cath
2.throws 不建议使用
注意:
throws 运行时异常(RuntimeException类及其子类)
可以不用处理。
throw抛异常
自己抛异常
throw new 异常类型("异常字符串描述信息");
注意:
运行时异常(RuntimeException类及其子类)
可以不用throws 声明。
二、经典算法:
1.变量互换?
int a = 1;
int b = 2;
int temp;
temp = a;
a = b;
b = temp;
2.累加?
int sum = 0;
for(int i = 1, i <= 50, i++){
sum += i;
}
3.累乘?
int sum = 0;
int sum2 = 0;
for(int i = 1, i <= 50, i++){
sum *= i;//累乘
sum2 += sum;//阶乘
}
4.最大值最小值?
//求最大值:
int b[] = new int[]{22, 44, 11, 55, 33};
int max = b[0];
//方法1:
for (int i : b) {
if (max < i) {
max = i;
}
}
//方法2:
for (int i = 1; i < b.length; i++) {
if (max < b[i]) {
max = b[i];
}
}
System.out.println(max);
5.冒泡排序?每轮每次比较相邻的两个数,小的数换到前面,每轮结束后最大的在最后面(比较n个数,比较n-1轮,每轮比较次数由n-1依次减一递减到1)
int []n = {29, 4, 66, 33, 9, 21};
int temp;
for (int i = 0; i < n.length - 1; i++) {//控制轮数
for (int j = 0; j < n.length - 1 -i; j++) {//比较次数
if (n[j] > n[j + 1]) {//控制由大到小还是由小到大
temp = n[j];
n[j] = n[j + 1];
n[j + 1] = temp;
}
}
}
for (int i : n) {
System.out.println(i);
}
6.选择排序?确定一个位置,与之后的数进行比较,小的在确定的位置,大的互换
int []a = {33, 1, 53, 27, 30, 9};
for (int i = 0; i < a.length - 1; i++) {//确定位置
for (int j = i + 1; j < a.length; j++) {//比较元素
if (a[i] > a[j]) {//控制由大到小还是由小到大
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
for (int i : a) {
System.out.println(i);
}
7.单例模式?
//饿汉式:在类加载时就创建了,在多线程中比较安全
class Window{
private static Window win = new Window();
private Window(){
}
public static Window getInstance(){
return win;
}
}
//懒汉式:使用时才创建,多线程时不安全
class Windows{
private static Windows wins = null;
private Windows(){
}
public static Windows getWindows(){
if (wins == null) {
wins = new Windows();
}
return wins;
}
}