java学习笔记总结，持续更新中

java学习的笔记，目前正在学习中，持续更新。
标识符是直接copy下来的，命名一定要规范。

标识符规范：
1>标识符由大小写字母, 下划线, 数字, $符号组成.2>开头可以是大小写字母, 下划线, 和$符号.(数字不能开头)3>标识符长度没有限制4>标识符不能是关键子和保留字标识符的命名最好能反映出其作用 ,java语言对字母的大小写有严格的要求.所有自定义标识符需全部遵循标识符的命名规范.
变量:  1>如果是单个单词, 单词全部字母小写. 如:intcount;  2>如果是由多个单词组成的复合单词, 除第一个单词外,  其后所有单词首字母大写. 如: codeName; 常量 : 常量所有单词字母大写, 如果是由多个单词组成, 由下划线连接.如:String PERSON_NAME;方法:方法命名规范与变量相似, 如 count(); getSum();类:  类名的所有单词首字母均大写. 如Person{}  , DataCenter{}; 包:  用小写的倒置域名来命名. 格式: 前缀 + 项目名 + 模块名 + 层如: org.itfuture.domain.sort 
2>开头可以是大小写字母, 下划线, 和$符号.(数字不能开头) 3>标识符长度没有限制 4>标识符不能是关键子和保留字

1.成员变量是直接定义在类中的
2.局部变量具有“就近原则”
    例：static int aa=15;
            int aa=17;
    System.out.println(aa);

    // string aa; //在main方法中已经定义了aa    然后有从新定义了aa       就近原则  所以是  aa=17
3.java表达式：
                表达式：由数字，运算符，数字分组符号（括号），变量等已能够求得结果的有意义排列的组合
        直接使用运算符链接的变量/常量可以称为表达式
例如：
// a;
// a+b;
// 3.14+a;
// (x+y)

变量是有类型的，java中的数据类型有多少类型
* 分两种：
* 1）基本数据类型-》原生数据类型
* 2）引用数据类型-》对象数据类型
* --------------------
* 数据类型： 占位字节   数据分为   默认值
* 整数：byte     1 [-128,127]  0

*             int             4                                           0   
                                short            2                                 
                                 long     8                                           0L
* 小数：float                4                                          0.0F
                            double             8                                           0.0D

应用类型：
* 类-》String
* 接口->implements Runable

* 数组-》array

基本数据类型，仅仅是容量的大小不一样而已-》true

强制转化：
                byte b1=126;

byte b2=(byte)(b1+1);

//byte的包装类
byte bMax=Byte.MAX_VALUE;
System.out.println(bMax);//127
byte bMin=Byte.MIN_VALUE;
System.out.println(bMin);//-128
byte b3=(byte)(bMax+1);//127+1  超出范围[-128   127]  所以是-128

System.out.println(b3);//-128

在8大基本数据类型中，boolean不属于数据类型，不参与转换》true
* 基本数据类型
* 方式1：自动类型转换-》隐式类型转换
* 方式2：强制类型转换-》显示类型转换
* 遵循规则
* 1：小数据转大数据，系统可以完成自动转换
* 2：大数据转小数据，需要加强制转换符
* 
* 溢出和精度损失：
* 例如：3公斤的苹果，放到一个1公斤容器里，动用保留   会造成缺失

赋值需要注意：
byte abc=2; //1
double bca=abc; //8
//int ddd=bca; //4
//小往大赋值 可以
//大往小赋值    不可以

//自动类型转换
byte b=17;
short s=b;
int i=s;
float f=i;
double d=f;

//byte b2=d; //错误：不兼容的类型，从double->byte,可能出现精度损失

数据过大和溢出
//当要表示的数据超出数据类型的临界范围时，称为溢出
//溢出清空发生时程序并没有做出数据范围检查处理，此时会出现    数据絮乱情况

//int 类型的取值范围【-2147483648,2147483647】

表达式的自动提升

/*
* 
* 当一个算数表达式中包含多个基本数据类型（boolean）除外的值时，整个算数表达式类型将在数据类型运算出现数据自动提升    其规则是：
* 所有byte,short,char类型被自动提升到int类型
* 整个表达式的最终结果被提升到表达式中类型最高的类型
* 
*/

++和--：
/*
* 自增++
* 自减--
*    ++在前 先++
*    ++在后 后++

*/

按位运算：

/*
* 位运算符
* & 按位与   同时为1则为1
* | 按位或   有1则为2
* ^ 异或
* ~ 去反
* <<左位移
* >>右位移
* >>>无符号右位移
* 
* 
*/

/*
* 二进制A  二进制B   与 或 异或
* 0 0 0 0 0
* 1 0 0 1 1
* 0 1 0 1 1
* 1 1 1 1 0
* 
*/
/*
* a:0b00000101
* b:0b00000011 &
* ------------------
* 0b00000001
* 
* 参与运算的两个数，若相应位数的值都为1，则该结果值是1，  否则都是为0
* 
* 

*/
运算顺序：
/*
* 
* () [] 从左到右
* ！ + - ~ ++ -- 从右向左 
* ？ ： 从右向左
* + - 从左向右
* 

*/

注意：不推荐连续赋值,耦合度太高
例如：int a, b,c;

a=b=c=5;

三元运算：也叫三目运算符   ：
                //常用的三元
int x1=30;
int y1=50;
int max=x1>=y1?x1:y1;  // 这个是算法

例：//判断一个数是奇数还是偶数
int n=1;//0以下不做判断
String ret=n%2==1?"奇数":"偶数";

System.out.println(ret);

笔试题：
1.//forfor嵌套循环  九九乘法表
for(int line =1;line<=9;line++){
for(int i=1;i<=line;i++){
System.out.print(i+"*"+line+"="+i*line+"\t");
}
System.out.println();
}

2.//案例描述：请对以下代码进行优化：
//循环体代码执行的次数都是相同的-》没法优化
//优化只能从循环变量，i,j,k的实例、比较
//自增次数等方面的耗时上进行分析
for(int i=0;i<1000;i++){
for(int j=0;j<100;j++){
for(int k=0;k<10;k++){
//循环体代码
}
}

}

解：最优方案
* 该方案主要是将该方案循环数少的放在外面，循环数多的放在里面，这样可以最大程度的减少相关循环遍历的实例化次数，初始化次数等
* 将循环遍历的实例化放在循环外，这样可以进一步减少实例化次数

* 耗时减少
private static void testB() {
// TODO Auto-generated method stub
int i,j,k;

long start=System.nanoTime();
for( i=0;i<10;i++)
for( j=0;j<100;j++)
for( k=0;k<1000;k++)
;
System.out.println("TestB time>>"+(System.nanoTime()-start));

}

标签：
/* 
* 使用标签：
* 标签用来给某个循环起的别名：
* 有一个标准：
* 标签的命名得满足标识符的规范。
* 
*/

方法/方法引入：
函数有四种     有参  无参   有反   无反

main方法专门由JVM来负责调用，我们只管启动JVM





/*
* 
* 循环操作：
* while,do while ,for
* 目的-》解决代码重复的问题，重复的做某一件事情
* 循环解决的重复->要求是有规律的，语句格式是相同的
* 针对于某一种功能的重复操作，循环解决不了，此时使用方法。
* 
* 
* 开发遵循的原则之一：DRY原则
* Do not repeat yoursele， 不要重复你 自己的代码
* 原因：重复意味着维护成本的增大
* 
* 
* 语法结构：
* 方法的定义：
* 方法-》和c里面的函数一样-》属于特定功能的代码
* 
* 定义格式：
* 【修饰符】 返回值类型  方法名称（[形式参数....]）{
* 方法体：
* 【return 值】；
* 
* }
* 
* 注意：
* 1）在类中定义，在java中最小的程序单元是类
* 2）方法定义在其他方法之外，方法和方法是兄弟关系
* 3）方法定义的先后顺序不影响
* 
* 
*/

方法的重载设计：
/*
* 
* 方法重载设计：overload
* 定义：
* 在同一个类中，某方法允许存在一个以上同名方法
* 只要他们的参数列表不同即可。
* 
* 如何判断方法重载设计
* 规则：两同一不同
* 两同：同一个类中。方法名相同
* 不同：方法参数不同（参数类型，个数，顺序）
* 注意点：方法重载和方法返回值类型无关，只是一般要求返回值类型一致
* 参数列表和参数的名称没关系，方法的重载和形参没关系
* 
* 
*/

/*
* 判断以下方法，在同一个类中，且方法名相同
* void doWork(int a,char b,boolean c){}
* 三个参数，分别是int,char boolean类型
* 下列哪个方法是上述方法的重载
* 
*1）void doWork（char b,int a,boolean c）{}；//是
*2）int doWork（boolean a ,char c,int b）{}；//是
*3）void doWork（int a,char b,double c）{}；//是
*4）void doWork（int x.char b,boolean z）{}；//不是
*5）int doWork（int x,double y）{}；//是
*6）int doWork（int x,char y,boolean）{}；//不是

*/

方法中的术语：
        /*
* 
* 方法中的术语：
* 修饰符：public  static等，static修饰的方法属于类
* 直接使用类名调用即可
* 返回值类型：方法就是为了完成一个功能，是否需要给调用者
* 返回一个结果。不需要使用关键字void,无返回的意思
* 
* 方法的名称：遵循标识符规范，使用动词表示，要用 小 驼峰命名法 比如 getSumName 
*  
* 
* 形式参数：方法原括号中，就是形参   只是占位符。
* 
* 参数列表：参数列表==参数的类型+参数的个数+参数的顺序=》true
* 
* 方法签名：==方法的名称+方法参数列表。
* 在同一个类中，方法签名是唯一的，否则编译报错-》true
* *方法名称  不是唯一的
* 
* 方法体：【】中的代码，表示具体完成该功能的代码
* 
* 实际参数：调用者实际传递参数
* 
* 方法调用者：在哪里调用某一个方法，那么哪里就是该方法的调用者
* 
* 
* 
* 
*/
方法的特点-执行流程





数组和数组的定义:
为什么使用数组？
* 问题1：
* 声明变量的时候 ，要处理一组相同类型的数据，
* 比如：班上有100个人的年龄   int age1=17

* 只能表示一个年龄    表示很多人的年龄   需要用到数组

问题2：
* 求两个数的和，需要一个方法，求五个数的和，需要用到重载，
* 求100,1000,10000数的和？
* 方法参数列表特别的长，很不爽。
* 只是一个数组值得和--》数组
* 
* 
* 大师的建议：方法的形参不要超过五个。
* 
* 数组：就是一组数据
* 把相同类型的若干个变量按照有序的形式，组织起来的一种数据形式
* 
* 

* 数组的索引从0开始，步长为1

静态初始化数组
int arr[]=new int[]{3,4,5};//表示arr[]的一维数组
                int[] arr=new int[]{3,4,5,2,4,1,3,4,1,31};//尽量用这种数组

String[] bs=null;  //String引用数据类型
System.out.println(bs.length);//NullPointerException空指针异常

int[] arr2={};//int 基本数据类型
System.out.println(arr2.length);//0

//用null的时候  在内存中进行了释放

/*
* 
* 数组操作：
* 初始化数组的两种操作方法：
* 1）静态初始化
* 2）动态初始化
* 一旦初始化完成，数组的长度就固定了，不能改变
* 
* -----------***除非重新初始化，也就是说数组时定长的***-------------
* 
* --------------------------
* 数组必须先初始化，才能使用，英文提出时候表示在内存中分配内存
* --------------------------
* 数组静态初始化的特点：
* 数组的长度由系统（JVM）决定，但是由我们来为每一个数组元素设置初始化
* ---------------------------
* 实例化一个数组分几步？？
* 三步：
* 第一，声明什么类型的数组
* int[] nums
* 第二：初始化数组 （用到了new）
* new int[]{1,2,3}
* 第三，把初始化的值赋值给nums变量
* 
* 注意：
* 1.不准动静结合创建数组
* 2.当知道需要存储那些数据的时候就使用静态
* 3.当不知道的时候，就用动态
* 
* 语法结构：
* 数组元素类型[] 数组名=new 数组的元素类型[length];
* 数组元素类型[] 数组名=new 数组的元素类型[]{元素1......};
* 
* 
* 
* 
*/

//int[] arrays=new int[5]{};//动静结合是错的   规定!!!

//获取数组中元素最小/大元素  冒泡排序法
static int getMin(int[] nums){
int min=nums[0];
for (int index = 0; index < nums.length; index++) {
if (nums[index]<min) {
min=nums[index];
}
}
return min;

}

//递归操作的九九乘法表
public static void jiujiu(int i){
if (i==1) {
System.out.println("1*1=1");

}else{
jiujiu(i-1);
for (int j = 1; j <=i; j++) {
System.out.print(j+"*"+i+"="+(i*j)+" ");
}
System.out.println();
}
}

//打印数组   【A,B,C,D】
static void printArray(String[] arr){
if (arr==null) {
System.out.println("null");
return;

}

//左括号
String ret="[";

//遍历数组
for (int index = 0; index < arr.length; index++) {
//判断
ret=ret+arr[index];
if(index!=arr.length-1){

ret=ret+",";
}

}

//添加右括号
ret=ret+"]";

//输出
System.out.println(ret);

}

/*
* 
* 线性搜索
* 
* 查询key元素在数组中第一次出现的位置
* 参数：
* arr：从哪一个数组中去做查询
* key：当前查询的元素
* 返回值：若果key存在于arr数组中，则返回第一次出现的索引的位置
* 如果key不存在，返回-1
* 
*/

static int indexOf(int[] arr,int key){
for (int index = 0; index < arr.length; index++) {
if (arr[index]==key) {
return index;
}
}
return -1;
}

//逆序打印数组元素
/*
* 
* 原数组[a,b,c]
* 逆序操作
* 新数组[c,b,a]
* 
*/

//不用返回值  一个参数

static void print(int[] arr){
String str="[";
for (int i = arr.length-1; i >=0; i--) {
str=str+arr[i];
if (i!=0) {
str=str+",";
}
}
str=str+"]";
System.out.println(str);

}

/*
* 必须掌握的
* 1.方法的定义和调用
* 2.方法中的术语
* 3.方法的特点-执行流程
* 4.方法的重载
* 5.数组的基本操作
* 6.数组常见的异常
* 7.获取，遍历，设置数组元素
* 8.获取最大，最小元素
* 9.打印数组元素
* 10.元素出现索引
* 
* JVM内存模型图，面试前能自己画出来
* 堆:new在堆中开辟新空间
* 栈：每一个方法存在栈帧
* 
* 

*/

/*
* 方法参数的值传递机制：（by value）
* 
* 方法被调用时，方法里的参数是以值传递的方式传递的。
* 所谓值传递，就是将实际参数的副本传入方法，而参数本身不受影响
* 

*/

多维数组

/*
* 
* 数组：用于存放数据，好比是容器
* 如何存放两个数组：
* 一维数组：每个元素都是一个值
* 二维数组：每一个元素都是一个一维数组
* 三维数组：每一个元素都是一个二维数组
* 
* 
*/

//2.java5对数组的支持
/*
* 1）增强for循环（for-each）
* 2)方法的可变参数
* 
* 取出数组中元素值得时候，会使用什么
* for,while,do while   循环遍历
* 
* 循环遍历-》但是循环变量是数组的索引
* 
* 有时候，不关心数组的索引，只关心数组的元素是多少
* java5-》开始-》增强for循环（for-each），可以直接取出数组中的每一个元素
* 语法：
* for(元素类型  变量：数组名){
* 变量就表示每一个元素值
* 
* }
* 
*/

//for-in  for-each

for(int ele:array){
System.out.println(ele);
}

//语法糖

for (int i : array) {
System.out.println(i);
}



/*
* 
* 语法糖：编译器级别的新特性
* 底层依然是for循环
* 什么时候使用：
* 如果需要去除数组元素的索引，就用for循环
* 只取出数组的元素，用foreach更简单
* 区别：
* for循环遍历元素+元素的索引
* foreach只遍历元素
* 
* 
* 
*/

//写一个二维数组，用foreach遍历
int[][] arr6=new int[][]{
{1,2,3},{3,4,5},{5,6,7},
};

for (int[] is : arr6) {
for (int i : is) {
System.out.println(i);
}

}

数组的元素拷贝

/*
* 数组的元素拷贝
* 不用返回值
* 参数：
* src:源，从哪个数组中拷贝数据
* dest:目标，把数据拷贝到哪个数组中
* srcPos:从源数组中的哪一个位置开始拷贝
* destPos:在目标数组中开始存放的位置
* length：拷贝几个元素
*/

//copy操作
static void copy(int [] src,int srcPos,int[] dest,int destPos,int length){
//原理
// dest[destPos]=src[srcPos];
// srcPos++;destPos++;
// dest[destPos]=src[srcPos];
// srcPos++;destPos++;
// dest[destPos]=src[srcPos];
// srcPos++;destPos++;
//优化用for循环
for(int i=srcPos;i<srcPos+length;i++){
dest[destPos]=src[i];
destPos++;
}
}


封装——工具类(专门的工作交给一个工具类    存放各种方法   不用都去学习工作)

工具类——>设计模式之一——>工厂设计模式
封装——>专门存放操作某一类型的方法
封装可以提高代码的复用性




/*
* 为什么用排序 * 很多数据都是数组形式，元素无序——>乱
* 用数组中的数据就用到排序
* 排序分类
* 1）选择排序：直接选择排序  堆排序法
* 2）交换排序：冒泡排序  快速排序法
* 3）插入排序：直接插入排序  二分法排序  shell排序
* 4）归并排序
* 排序分为升序和降序：
* 常用：——>冒泡排序  快速排序  选择排序
* 做到：熟练掌握其中一种排序
* HR1   人事——>技术
* 笔试   机试——>技术面试——>人生
* 机试题：30秒敲
*  
*  冒泡排序：最简单 *  基本思路：对未排序的各元素从头到尾一次比较相邻的两个元素若较大则交换位置

*  

//冒泡  int[] arr={86,22,3,9,10}
//22 86 3 9 10    22 3 86 9 10   ..........
static void bubbleSort(int[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}

}

*  选择排序;
*  基本思路：选定某个索引位置 然后和后面元素依次比较  若大则交换位置 经过第一轮排序后可得出最小值
*  
*/


测试工具类java自带的Array类
Java.lang包下的类  不需要引入// int[] arr={10,20,30,40,50,30,10};
// ArrayUtil.getMax(arr);
// ArrayUtil.getMin(arr);

// ArrayUtil.printArray(arr);

方法的可变参数——>java5开始

可变参数就是方法的数组参数——>ture

为了避免歧义语法有规定 可变参数必须作为方法的最后一个参数。
/*
* 传统做法：在方法调用的时候，传递一个数组。
* 如果形参过多，就把多个数据先封装到数组中，再传递
* 但是 从专业角度不爽——>逼格高
* 不创建数组，直接传递
* 形参不超过五个  不要过多
* 注意：
* 可变参数就是方法的数组参数——>ture
* 为了避免歧义语法有规定 可变参数必须作为方法的最后一个参数。
*/


//需求：编写一个方法  统计使用数组传递过来的总和
// static double getSum(double[] arr){
// double sum =0.0;
// for(double price : arr){
// sum+=price;
// }
// return sum;

// }

构造器

构造器：
  * 主要用于创建并返回对象和初始化对象数据
  * 构造器的特点：
  * 类都有一个默认的构造器 当不显示的定义构造器的时候，编译器会在编译的时候，提供一个默认的构造器
  * 特点；
  * 1）构造器的名字必须和当前所在的类名相同
  * 2）构造器访问权限修饰符和当前类的修饰符相同
  * 3）一旦显示的提供了构造器，则默认的构造器就不在提供了
  * 4）默认构造器，无参数，无方法体
  * 5）不需要定义返回值类型，更不能使用void返回
  * 构造器的目的：创建并返回当前类的对象
  * 
  * 推论：
  * 一个类至少有一个构造器
  * 方法的重载：解决的目的：相同功能的方法，因为参数列表（个数 类型  顺序）不同 而带来的参数名不同的问题
  * 
  * 构造器的重载：
  * 不同类的构造器是不相同的  对于构造器重载来说  肯定是在同一个类中 并且构造器都是和类名相同的
  * 所以在同一个类中的多个构造器就必须参数列表不同

  * （个数 类型  顺序）

其实系统默认提供一个构造器



类是用来描述多个对象共同的行为和状态

static 可以修饰成员变量（字段），可以修饰方法等，
* 就表明该字段或者该方法属于类，而不是属于某一个对象。
* 
* 类成员（static修饰的成员）的特点
* 1）随着类被加载进JVM而同时也初始化和在内存中分配空间
*2）优先于对象存在（对象通过new出来的）
*3）被该类的所有对象所共享
*该状态/行为是整个人类的  那么每个人都有该状态/行为

*4）直接使用类名调用即可