黑马程序员------java基础

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

Java语言的基础组成：
1、关键字
2、标识符
3、注释
4、常量和变量
5、运算符
6、语句
7、函数
8、数组

1、关键字：
被JAva赋予特殊含义的单词
类，接口，方法，变量等在命名的时候不能使用关键字

2、标识符：
程序中自定义的名称 例如：类名，接口，变量，方法
书写规则：由26个大小写字母，0-9，_ $组成；
1、数字不能开头
2、不能使用关键字（由于关键字已经被Java赋予特殊含义）
(main比较特殊，他不是关键字，但是它能够被Java虚拟机识别)

4、常量：
不能被改变的数值，使用 final 修饰
整数的表现形式：二进制，八进制，十进制，十六进制
一般数据使用十六进制来表示，主要原因是进制越大，表现形式越短

5、进制转换
进制越大，表现形式越短
1、首先把进制都转换成2进制，再通过2进制转换成其他进制

例子：十进制转换成二进制，例如：7
通过不断地除以2来计算，结果为：（7/2=3–>1）（3/2=1–>1） 二进制为：111，写的时候倒过来写
二进制转换成十进制就是乘以2的过程，最后相加：例如：1110 —>14

八进制为3位一组，十六进制为4位一组
例如：
01011010 —-> 132 （二进制转换成八进制）（数据不够在前面加0）
1010101111 —–> 2AF（二进制转换成十六进制）（数据不够在前面加0）

负数的二进制表现形式：例如：-7
7在内存中的变现形式为：4字节=32位（整数）
0000-0000 0000-0000 0000-0000 0000-0111 —> 7
1111-1111 1111-1111 1111-1111 1111-1000 —> 取反再加上1
+0000-0000 0000-0000 0000-0000 0000-0001
1111-1111 1111-1111 1111-1111 1111-1001 —>-7（二进制的表现形式）

6、变量：
变化的值，在内存中开辟一处空间，将不确定的数进行存储

数据类型：基本数据类型和引用数据类型

基本数据类型：数值型：整数型和浮点型：
整数型：byte（8位），short（16位），int（32位），long（64位）
浮点型：float（32位），double（64位）
字符型：char（16位）
布尔型：boolean（true，false）
引用数据类型：类（class），接口（interface），数组([])(String 是引用数据类型)
一个字节占8位

整数默认为int类型，小数默认为double类型

例题：byte b= 3；（3是int类型，自动判断是否属于byte的范围，若属于byte范围，自动强转，否则要手动强转内，然后进行赋值（强制转换成byte））
b = b+2；（报错：损失精度，由于b是一个byte类型，占1个字节，2是int类型，占4个字节
此时b自动向上提升，原则是小的向大的提升（byte–>int），这时候b自动向上提升就变成int类型，然后b与2相加，赋值时候b还是1个字节，int类型赋值给byte类型要强制转换，否则损失精度）
（两次运算，先加，然后再赋值）
正确写法：强制转换：b=（byte）（b+2）
byte b=2; b+=2;（不会报错，因为会自动强制转换）（一次运算，就是把左右两边和赋值给左边）

7、运算符：+ - * / %（取余）

实例：a++
a=2；b=++a； a=2；b=3；（a先自加然后再赋值给b）
a=2；b=a++； a=3；b=2；（先把a赋值给b，然后再自加）

转义符：\ 转变后面字母或符号 ：
\n换行，\b退移，\r回车，\t制表符
Linux中：\n换行 Windows中：\r\n换行
char ch = ‘\n’（正确，因为\n看成是一个字符）

+=，-=，*=，/=，%=，==，！=，>，<，<=，>=，这些都是一个符号

8、逻辑运算符：
&（与），|（或），^（异或），！（非），&& ||（短路）

例子： x>3&x<6 （x大于3并且小于6）（两边都会进行判断）
&：true true = true ， true false = false ， false false = false

|： true true = true ， true false = true， false false = false

^：true true = false ， true false = true， false false = false

&&（x>3&&x<5）（当条件不满足左边的条件时候不会再判断右边的条件，直接返回结果）

||（当条件满足左边的时候不会再去判断右边的条件）
&& || ：可以提高性能

位运算符:
<< （左移），>>（右移），>>>（无符号右移），~（反码）

例子：
0000-0000 0000-0000 0000-0000 0000-0111 右移两位变成1，前面用0补全
0000-0000 0000-0000 0000-0000 0000-0001 结果
3<<2 = 12 （3*2的平方）(左移几位就是 数 * 2的几次方 )
6>>3 =0.75 (左移几位就是 数 / 2的几次方 )（6/2的三次方=0.75 取整数0）

(>> 和 >>> 区别)：
>>，最高位是什么补什么，是0补0，是1补1
>>>>，最高位无论是什么都补0，在进制转换与运算时候用到

异或：一个数异或同一个数两次的结果还是原来的数。例子：7^4^4=7

两个值互换：
1、通过第三方变量来实现
2、n=n+m，m=n-m，n=n-m（容易损失精度，不明确nm的值）
3、n=n^m，m=n^m，n=n^m

9、三元运算符：a>b?a=0:b=0
例子：
x>1?’a’:200 （输出结果如果都是整数， ‘a’会自动提升变为ASCII码表的值）
三元运算符局限性：必须要有结果，if else 不一定需要有结果

函数的定义：
1、函数就是定义在类中的具有特定功能的一段独立小程序，也称为：方法

2、函数的使用：当代码出现了重复，为了提高代码的重用性，对代码进行了提取
函数的格式：修饰符 返回值类型 函数名（参数类型 参数……………）{
执行语句；
return 返回值；
}
3、若是没有返回值，返回值类型为void

4、函数内部不能再包含函数，函数之间都是平级的

5、函数的重载：在同一个类中，允许存在一个以上的同名函数，只要他们的 参数个数或者参数类型不同 即可
特点：与返回值的类型无关，只和参数有关
好处：提高代码的阅读性，优化程序设计
使用：函数功能相同，但是参与运算的未知内容不同，这时候定义一个函数名称表示功能，使用参数列表区分同名函数

6、如何定义一个函数：
1、首先明确运算结果的类型
2、是否需要未知内容参与运算
注意：定义功能的时候不要做多余的功能，本来想要定义一个求最大值的功能，结果把打印功能一起写上，只要完成想要的功能即可，打印是调用者的事情

数组：
概念：同一种类型数据的集合，也就是容器
好处：自动给数组中的元素从0开始编号，方便操作这些元素(查找)
格式：一维数组：
int[] arr = new int[10] ，int arr[] = new int [10]，int[] arr = {0,1,2,2,3,4}

二维数组：
int [][] arr = new int [1][1] ，int arr[][] = new int [1][1]，int[] arr [] = new int [1][1]

栈：
1、用于存储实体的引用（地址值），数据用完自动释放

堆：
1、数组和对象，通过new创建的实例都在堆中开辟一处空间
2、每一个实例都有内存地址
3、实体的变量都有默认的初始值
4、实体不再被使用的时候会在不确定的时间被垃圾回收器回收

1、局部变量和调用方法时都会在栈中开辟一处空间，当变量或方法运行完会自动释放空间
2、arr中的值是数组在内存中的地址值，元素默认值都为0，Boolean类型的都为false
3、arr=null时候，arr不再指向数组，此时数组不再被调用，并在不确定的时间回收内存
4、方法中传递参数时候都是传递的地址值，java中只有值传递，没有引用传递 ，只不过在方法中传递的值是一个引用
5、地址值：[I@3c0007 ，[ （表示数组），I（表示int类型），@，3c0007（内存中的地址）（整个是哈希值，16进制）

排序实例 ：

 "/**
  * 选择排序法 外循环为第一个数，内循环是第一个数与整个数组的每一个数进行比较，然后交换位置
  * 以此类推
  */"
 public static void toHax(int[] arr) {
  for (int i = 0; i < arr.length; i++) {
  "// i+1说明不需要与之前的数进行比较，只是不断地向后比较"
   for (int j = i + 1; j < arr.length; j++) {
   "// 第一个数一直与整个数组进行比较"
    if (arr[i] > arr[j]) {
     int temp = arr[j];
     arr[j] = arr[i];
     arr[i] = temp;
    }
   }
  }
  System.out.println("选择排序");
  for (int i = 0; i < arr.length; i++) {
   System.out.print(arr[i] + ",");
  }

 }

 "/**
  * 冒泡排序法
  * 一个数组相邻的两个进行比较，若是符合条件就进行换位，否则不换位
  * 外圈循环是循环次数，内圈循环是两个数进行比较
  */"
 public static void toMax(int[] arr) {
  for (int i = 0; i < arr.length - 1; i++) {
  "// 由于多次比较后面的数字已经确定，没必要再进行比较，所以减去i"
   for (int j = 1; j < arr.length - i; j++) {
    if (arr[j - 1] > arr[j]) {"// 最好用j-1，这样不会超出数组长度"
     int temp = arr[j];
     arr[j] = arr[j - 1];
     arr[j - 1] = temp;
    }
   }
   System.out.println("");
   for (int k = 0; k < arr.length; k++) {
    System.out.print(arr[k] + ",");
   }
  }
 }

 "/**
  * 折半查找法
  * 条件：数组必须是有序的，否则不能查找
  */"

 public static void halfMethod(int[] arr, int key) {
  int min = 0, max = arr.length, mid = (min + max) / 2;

  while (arr[mid] != key) {"// 判断中间值是否等于key值"
   if (arr[mid] > key) {"// 如果中间值大于key值"
    max = mid - 1;"/ 向左移动，中间值减一等于max"
   } else if (arr[mid] < key) {"// 向右移动"
    min = mid + 1;
   }
   if (min > max) {"// 当数据不存在时候会发生的情况"
    System.out.println("key = " + -1);
    return;
   }
   mid = (min + max) / 2;"// 重新获取中间值"
  }
  System.out.println("key = " + arr[mid]);
 }

 "/*
  * 进制转换 思路：默认全部转换成二进制，然后在转换成其他进制
  */"

 public static void jinzhi(int num) {
  "// 定义一个字符数组，包含0-9，a-f"
  char[] ch = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
  "// 定义一个字符串容器"
  StringBuffer sb = new StringBuffer();
    "//当数据的十进制不为0的时候"
  while (num != 0) {
    "//转成16进制数与上15,转成8进制与上7，转成2进制与上1"
   int temp = num & 15;
   "//现在字符数组中查找对应的字符，然后添加到StringBuffer中"
   sb.append(ch[temp]);
   "//16进制移4位，8进制移3位，2进制移1位，不使用>>，是因为当为负数的时候不能把有效位移干净，所以使用>>>"
   num = num >>> 4;
  }
  "//字符串反转输出"
  System.out.println(sb.reverse());

  System.out.println(Integer.toOctalString(-12));"//八进制"
  System.out.println(Integer.toHexString(-12));"//16进制"
  System.out.println(Integer.toBinaryString(-12));"//2进制"
 }
}

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-