java SE学习初步整理

一、基础知识点：
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;
}
}