第三章：java语言基础（java知识点），

第三章：java语言基础（java知识点），

课1：
    1）数据类型中补充的几个小问题
（1）byte值的问题                          -128 ~ 127
byte b1 = 127;
byte b2 = (byte)128;               -128
byte b3 = (byte)129;               -127
byte b4 = (byte)130;               -126
（2）浮点数在内存中的存储
例题：17.625在内存中的存储
①首先要把17.625换算成二进制 ：10001.101
整数部分除以2，直到商为0，余数反转；
小数部分乘以2，直到乘位为0，进位顺序取
②再将10001.101右移，直到小数点前只剩1位
1.0001101*2^4          因为右移了4位
底数：因为小数点前必为1，所以IEEE规定只记录小数点后的就好，所以，此处的底数为 ：0001101
指数：实际为4，必须加上127（转出的时候，减去127），所以为131，也就是10000011
     符号部分是整数，所以是0
结果 ：01000001    10001101     00000000     00000000


课2：
    1）java语言中的字符char可以存储一个中文汉字吗？为什么？
可以，因为java语言中的字符占用2个字节
java采用的是Unicode编码


课3）
    1）逻辑运算符
（1）&与&&的区别：
单&时，左边无论真假，右边都进行运算
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算
（2）|和||的区别同理，双|时，左边为真，右边不参与运算
（3）异或（^）和 或（|）的不同之处：当左右都为true时，结果为false
例如 ：情侣关系


课4：
    1）位运算符
因为是位运算符，所以我们必须先把数据换算成二进制
&   位与运算：        有0则0
|   位或运算：        有1则1
^   位异或运算：      相同则0，不同则1 （一个数据对另一个数据位异或两次，该数本身不变）
~   按位取反运算：    0变1,1变0
<<  左移：            左边最高位丢弃，右边补齐0
>>  右移：            最高位是0，左边补齐0，最高位是1，左边补齐1
>>> 无符号右移：      无论最高位是0还是1，左边补齐0
例子： System.out.println(3<<2);               3*2^2 = 12
      System.out.println(24>>2);              24/(2^2) = 6
面试题：请用最有效率的方式写出计算2乘以8的结果
2<<3


课5：
    1）三目运算符
（1）格式： （关系表达式）？表达式1 : 表达式2 ;
如果条件为true,运算后的结果为1
如果条件为false，运算后的结果为2
   例子：获取三个整数中的最大值
int a = 10;                          分两步：
int b = 20;                              A：先比较a,b的最大值
int c = 30;                              B: 拿a,b的最大值再和c比较


   解： int temp = ((a>b)?a:b);
int max  = (temp>c?temp:c);


课6：
    1)选择结构（switch语句）：
switch(表达式){           表达式取值类型为 ： byte,short,int,char
case 值1;
语句体;
break;
case 值2;
语句体2；
break;
 ...
default:
语句体;
break;
}


课7：
    1）选择结构（各自使用场景）
if语句使用场景：
（1）针对结果是boolean类型的判断
（2）针对一个范围的判断
（3）针对几个常量的判断
switch语句使用场景
（1）针对几个常量值的判断


课8：
    1）求取水仙花数。（所谓水仙花数是指一个三位数，其各位数字的立方和等于该数本身）
例如：153就是一个水仙花数               153 = 1*1*1+5*5*5+3*3*3
思想：个位：153%10       = 3
     十位：153/10%10    = 5
     百位：153/10/10%10 = 1
  for(int x=100;x<1000;x++){
int ge  = x%10;
int shi = x/10;
int bai = x/10/10%10;
if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)){
System.out.println(x);
}
  }


课9：
    1）for循环的统计思想（统计水仙花数共有多少个）
int count = 0;
for(int x=100;x<100;x++){
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)){
count++;
}
}
System.out.println("水仙花数共有"+count+"个");


课10：
    1）输出10遍HelloWorld
int x = 0;
while(x<10){
System.out.println("HelloWorld");
x++;
}
注释 ：while循环结构
（1）基本格式：
while(判断条件语句){
循环体语句;
}
（2）扩展格式：
初始化语句;
while(判断条件语句){
循环体语句;
控制条件语句;
}


课11：
    1）while循环的统计思想（统计水仙花数共有多少个）
int count = 0;
int x = 100;
while(x<1000){
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)){
count++;
}
x++;
}
System.out.println(count);


课12：
    1）while循环和for循环的区别：
使用区别：如果你想在循环结束后继续使用控制条件的那个变量，用while循环，否则用for循环
 因为变量及早地从内存中消失，可以提高内存的使用效率
其实还有一种场景的理解：
 如果是一个范围的，用for循环非常明确
 如果是不明确要循环多少次，用while循环较为合适
 举例：吃葡萄
    2）输出10遍HelloWorld
for循环实现：
for(int x=0;x<10;x++){
System.out.println("HelloWorld");
}
//System.out.println(x);          这里不能继续访问
while循环实现：
int y = 0;
while(y<10){
System.out.println("HelloWorld");
y++;
}
System.out.println(y);            这里是可以访问的


课13：
    1）do...while循环结构
基本格式：
do{
循环体语句;
}while(判断条件语句);
扩展格式：
初始化语句;
do{
循环体语句;
控制条件语句;
}while(判断条件语句);


课14：
    1）两种基本的死循环格式
（1）  while(true){
...
}
（2）  for( ; ; ){
...
}
例题1：  
while(true){
System.out.println("今天我很高兴，学习了死循环");
}
例题2：
for( ; ; ){
System.out.println("今天我很高兴，学习了死循环");
}


课15：
    1）九九乘法表
for(int i=1;1<=9;i++){
for(int j=1;j<=i;j++){
int num = i*j;
System.out.println(j+"*"+i+"="+num+"\t");
}
System.out.println();
}


课16：
    1）break    : 中断
       continue : 继续
       return   : 返回
    2）break:
（1）跳出单层循环 （在switch语句或循环语句中直接使用break时）
（2）跳出多层循环 （要想实现这个效果，就必须知道一个东西，带标签的语句）
格式： 标签名：语句
多层循环示例:
wc:for(int x=0;x<3;x++){
for(int y=0;y<4;y++){
if(y == 2){
break wc;
}
System.out.println("*");
}
System.out.println();
}
continue ：跳出一次循环，进入下一次的执行    （循环语句中使用）
continue循环示例：
for(int x=1;x<=10;x++){
if(x == 3){
break;                     跳过3输出
}                                  结果为 ：1245678910
System.out.print(x);
}
return : 它的作用不是结束循环的，而是结束方法的
return示例：
public static void main(String[] args){
for(int x=0;x<10;x++){
if(x == 2){
System.out.println("退出");                  结果：  0   1   退出
return;
}
System.out.println(x);
System.out.println("over");
}
}


课17：
    1）循环语句结合break的练习题
小芳的妈妈每天给她2.5元钱，她都会存起来，但是，每当这一天是存钱的第5天或者5天的倍数的话，她都会花去6元钱。
请问：经过多少天，小芳才可以存到100元钱。
double dayMoney = 2.5;
double daySum = 0;
int dayCount = 1;
int result = 100;
while(true){
daySum += dayMoney;
if(daySum >= result){
System.out.println("共花了"+dayCount+"天存储了100元");
break;
}
if(dayCount%5 == 0){
daySum -= 6;
System.out.println("第"+dayCount+"天花了6元钱");
}
dayCount++;
}


课18：
    1）方法：完成特定功能的代码块（不调用不执行）
方法格式：           修饰符  返回值类型  方法名（参数类型  参数名1，参数类型  参数名2，...）{
方法体语句;
return 返回值;
    }
参数：
实际参数：就是实际参与运算的
形式参数：就是方法定义上的，用于接收实际参数的
方法体语句：就是完成功能的代码块
方法的注意事项：如果方法有明确的返回值，一定要有return带回一个值


课19：
    1）函数的调用
（1）单独调用
（2）输出调用
（3）赋值调用（推荐）


课20：
    1）思考题：键盘录入两个数据，比较两个数是否相等
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个数据");
int a = sc.nextInt();
System.out.println("请输入第二个数据");
int b = sc.nextInt();
boolean flag = compare(a,b);
System.out.println(flag);
}
//方法一：
public static boolean compare(int a,int b){
if(a == b){
return true;
}else{
return false;
}
}
//三元改进：
public static boolean compare(int a,int b){
boolean flag = ((a==b)?true:false);
return flag;
}
//继续改进：
public static boolean compare(int a,int b){
return ((a==b)?true:false);
}
//最终版：
public static boolean compare(int a,int b){
return a == b;           能够使用这种方法，是因为a==b本来就可以表判断，返回布尔类型
}
    2）键盘录入三个数据，输出其中的最大值
//三元改进：
int temp = ((a>b)?a:b);
int max  = ((temp>c)?temp:c);
return max;


课21：
    1）void类型返回值的方法调用只能是单独调用
方法格式：      方法名（参数1，参数2，...）；
    2）方法重载：在同一个类中，方法名相同，参数列表不同，与返回值类型无关
单数列表不同： （1）参数个数不同
      （2）参数类型不同


课22：
    1）数组
（1）数组概念：数组是存储同一种数据类型多个元素的集合
      数组既可以存储基本数据类型，也可以存储引用数据类型
（2）数组的定义格式：
格式1：  数据类型[]  数组名;
格式2：  数据类型  数组名[];
    例1： int[] a;       定义一个int类型的数组a变量
    例2： int a[];       定义一个int类型的a数组变量
    注释：效果可以认为是一样的，只是念法区别，推荐第1种
（3）数组的初始化：为数组开辟内存空间，并为数组每个元素赋值
（1）动态初始化：只指定长度，由系统给出初始化值
格式：  数据类型[]  数组名 = new 数据类型[数组长度];
例子：  int[]  arr = new int[3];          定义了一个int类型的数组，这个数组中可以存放3个int类型的值
new分配内存空间
（2）静态初始化：给出初始化值，由系统决定长度
格式：  数据类型[]  数组名 = new 数据类型[]{元素1，元素2，元素3，...};
例子：  int[]  arr = new int[]{1,2,3};    
定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别为1,2,3
简写方法：  int[]  arr = {1,2,3};           隐含有new


课23：
    1）java程序为了提高程序的效率，就对数据进行了不同空间的分配
具体的是划分了如下5个内存空间  ： 
栈 ：存放的是局部变量                       局部变量：在方法定义中或者方法声明上的变量都成为局部变量
堆 ：存放的是所有new出来的东西
方法区
本地方法区（和系统相关）
寄存器（CPU使用）
栈内存的特点：栈内存的数据用完就释放掉
堆内存的特点：（1）每个new出来的东西都有地址值
     （2）每个变量都有默认值
byte,short,int,long           0
float,double                  0.0
char                          '\u0000'
boolean                       false
引用类型                      null
     （3）使用完毕就变成了垃圾，但是并没有立即回收
  会在垃圾回收器空闲的时候回收
  例如 ：清洁工阿姨


课24：
    定义一个数组 ：
  int[] arr = new int[3];
  arr[0] = 88;
  arr[1] = 33;
  arr[2] = 66;
  System.out.println(arr);                0x001    内存地址
  System.out.println(arr[0]);             88 
  System.out.println(arr[1]);             33
  System.out.println(arr[2]);             66
    定义第二个数组 ：
  int[] arr2 = arr;
  arr2[0] = 100;
  arr2[1] = 200;
  System.out.println(arr);                0x001
  System.out.println(arr[0]);             100
  System.out.println(arr[1]);             200
  System.out.println(arr[2]);             60
结论：栈内存的两个引用指向同一个堆内存空间
     无论是它们谁的操作，都是针对同一个地方


课25：
    1）数组操作常见的两个小问题
ArrayIndexOutOfBoundsException : 访问到了数组中的不存在的索引时发生          （越界）
NullPointerException : 数组引用没有指向实体，却在操作实体中的元素时发生      （空指针）


课26：
    1）数组遍历：就是依次输出数组中的每一个元素
格式：  数组名.length   返回数组的长度
例子：  for(int x=0;x<arr.length;x++){
System.out.println(arr[x]);
}


课27：
    1）思考题：将数组逆序               （reverse  反转）
思路：把0索引和arr.length-1的数据交换，
     把1索引和arr.length-2的数据交换
     ...
     直到做到arr.length-2的时候即可
     for(int x=0;x<arr.length/2;x++){
int temp = arr[x];
arr[x] = arr[arr.length-1-x];
arr[arr.length-1-x] = temp;
     }


课28：
    1）数组元素查找（查找指定元素第一次在数组中出现的索引）
main方法中：     
 int[] arr = {200,250,38,888,444};
 int index = getIndex(arr,250);          我要查找250在这个数组中第一次出现的索引
getIndex(int[] arr,int value)方法中：
 for(int x=0;x<arr.length;x++){
if(arr[x] == value){              只要是判断，就可能是false，所以一定要小心
return x;
}
 }
 return -1;                              如果找不到数据，我们一般返回一个负数即可，而且是返回-1
//改进版：
getIndex(int[] arr,int value)方法中：
 int index = -1;
 for(int x=0;x<arr.length;x++){
if(arr[x] == value){
index = x;
break;
}
 }
 return index;                           返回index


课29：
    1）二维数组：就是元素为一维数组的一个数组
动态初始化：
格式1：  数据类型[][]  数组名 = new 数据类型[m][n];
m:表示这个二维数组有多少个一维数组
n:表示每一个一维数组的元素有多少个
    例题: int[] x,y[];          x是一个一维数组，y是一个二维数组
格式2：  数据类型[][]  数组名 = new 数据类型[m][];
m:表示这个二维数组有多少个一维数组
n列表没有给出，可以动态的给，这次是一个动态的列数
格式3：  数据类型[][]  数组名 = new 数据类型[][]{元素1，元素2，...};
简化版： 数据类型[][]  数组名 = {{元素1，元素2，元素3，...},{元素1，元素2，元素3，...},{元素1，元素2，元素3，...},...};
    2）二维数组的遍历
例子：  int[][] arr = {{1,2,3},{4,5},{6}};
for(int x=0;x<arr.length;x++){
for(int y=0;y<arr[x].length;y++){
System.out.print(arr[x][y]+" ");
}
System.out.println();
}


课30：
    1）打印杨辉三角（行数可以键盘录入）
分析：看这种图像的规律
   （1）任何一行的第一列和最后一列都是1
   （2）从第3行开始，每一个数据是它上一行的前一列和它上一行的本列之和
步骤：
   （1）首先定义一个二维数组，行数如果是n，我们把列数也先定义为n
        这个n的数据来自于键盘录入
   （2）给这个二维数组任何一行的第一列和最后一列赋值为1
   （3）按照规律给其它元素赋值
从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和
   （4）遍历这个二维数组
 Scanner sc = new Scanner(System.in);
 System.out.println("请输入行数：");
 int n = sc.nextInt();
 int[][] arr = new int[n][n];                定义二维数组
 for(int x=0;x<arr.length;x++){
arr[x][0] = 1;
arr[x][x] = 1;
 }
 for(int x=2;x<arr.length;x++){
for(int y=1;y<=x-1;y++){                                   因为已经限定了首列和末列值为1，
arr[x][y] = arr[x-1][y-1]+arr[x-1][y];             所以y=1，而且x要减1
}
 }
 for(int x=0;x<arr.length;x++){
for(int y=0;y<=x;y++){
System.out.print(arr[x][y]+"\t");
}
System.out.println();
 }


课31：
    1）java中的参数传递问题
基本类型：形式参数的改变对实际参数没有影响（传递时传值）         eg: change(a,b)方法
引用类型：形式参数的改变直接影响实际参数（传递时传地址）         eg: change(arr)方法


课32：
    1）思考题：某公司采用公用电话传递数据信息，数据是小于8位的证书，为了确保安全，
      在传递过程中需要加密，加密规则如下：
  首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字
  最后将第一位和最后一位数字交换
  请任意给定一个小于8位的整数，然后把加密的结果在控制台打印出来
（难点是将数据转为数组）
Scanner sc = new Scanner(System.in);
System.out.println("请输入长度不超过8位的数字密码，不能以0开头");
int num = sc.nextInt();
int[] arr = new int[8];
int index = 0;
while(num>0){                           int类型1~9/10 = 0，所以循环条件num>0
arr[index] = num%10;
index++;
num /= 10;
}
for(int x=0;x<index;x++){
arr[x] += 5;
arr[x] %= 10;
}
int temp = arr[0];
arr[0] = arr[index-1];
arr[index-1] = temp;
for(int x=0;x<index;x++){
System.out.print(arr[x]);
}