JAVA学习历程/基础篇/第二天

1. 常量

常量是程序在运行过程当中值不会改变的量。整数常量（所有整数）、小数常量（所有小数）、布尔常量（true和false）、字符常量（单子字符如’a’）、字符串常量（字符序列如”abcd”）、null常量（只有一个null值）。

 

1. 进制

十进制0~9、星期（七进制0~6）、小时（12进制0~11、24进制0~23）、八进制（0~7）、16进制（0~9、a(10)~f(15)）

进制：用有限的符号来代表所有的数值。

进制转换：

10进制——>2进制，10进制不断除以2，直到商为0为止，从下往上取余数既是2进制。所以10——>10/2=5(余0)/2=2(余1)/2=1(余0)/2=0(余1)(商为0了)——>1010

2进制——>10进制，使用2进制的从右到左每一位乘以2的n次方，n从0开始，每次递增1，然后相加即可。所以1010——>0x20+1x21+0x22+1x23=10

注：1000（十进制）——>1111101000（二进制），太长不方便书写?

解决，每三个二进制位记录为一个数字！先补齐使三个一位，001,111,101,000——>1x20+0x21+0x22 , 1x20+1x21+1x22……=1,7,5,0（亦即八进制）

1. 八进制，相当于三个二进制位。

10进制——>8进制，使用10进制不断除以8，直到商为0为止，从下往上取余数即可。所以44——>44/8=5(余4)/8=0(余5)(商为0了)=54

8进制——>10进制，使用8进制的从右到左每一位乘以8的n次方，n从0开始，每次递增1，然后相加即可。所以43——>3x80+4x81=35

2进制——>8进制

       方法1，2进制——>10进制——>8进制

       方法2，2进制（11100）——>补齐为三个一位（011,100）——>8进制（1x20+1x21，1x22=34）。

1. 十六进制，相当于四个二进制位。

0~9,a(10),b(11),c(12),d(13),e(14),f(15)

10进制——>16进制，使用10进制不断除以16，直到商为0为止，从下往上取余数即可。

16进制——>10进制，使用16进制的从右往左每一位乘以16的n次方，n从0开始，每次递增1，然后相加即可。

16进制——>2进制，所以1a——>1,10——>11010

2进制——>16进制，11010——>0001,1010——>1,10——>1a

 

十进制的0.1转换成二进制

1. 1. x 2 = 0.2 ——>取出整数部分 0
   2. x 2= 0.4 ——>取出整数部分0
   3. x 2= 0.8 ——>取出整数部分0

0.8 x 2 = 1.6 ——>取出整数部分1

0.6 x 2 = 1.2 ——>取出整数部分 1

……

0.00011……

 

1. 变量

计算机底层处理的数据是二进制、八进制、十六进制，如何输入不同的进制数据？

System.out.println(42); //十进制

042，将一个数值前面加0 代表这个数据是八进制

0x42，将一个数值前面加0x代表一个十六进制

细节：0429，当0在前面指定一个八进制数据时，后面的数值超过7编译报错：过大的整数。

变量名的命名规范：首单词小写，其他单词首字母大写，其他小写。

数据类型，主要有两种：基本数据类型、引用数据类型

八种基本数据类型

1. 整数数据类型：

byte （字节），代表一个字节的大小，8bit（ 8个二进制位），28=256， -128~127（0在java中为正数）

short (短整型)，16bit，216=65536，-32768~32767

int (整型)，32bit，232= 4294967296，-2147483648~2147483647

long (长整型)，64bit，264

选用数据类型的原则：能满足需求的情况下，能小就小

1. 小数数据类型

float(单精度浮点型)   32bit

double(双精度浮点型)   64bit

所精确的小数位不一样，单精度小数位7位，双精度小数位15位。如果一个小数没有加上任何标示符该小数默认是double类型的数据，如果需要表示为float类型，那么需要在小数的后面加上f表示。f不区分大小写。

float a = 3.14f;

1. 布尔类型

boolean  只有两个值true、false；占用内存1个字节或者4个字节。

如果使用boolean声明一个基本类型的变量时，占用4个字节；

如果使用boolean声明一个数组类型的时候，那么每个数组的元素占用一个1个字节。

1. 字符类型

char  2字节（16bit）

注：字符的存储原理
      程序（char c = ‘a’）——>编码表（容纳所有文字，‘a’对应97）——>硬盘（97）。

     字符串类型String(引用数据类型) String str =”aer”;//字符串还是字符?  字符串！，双引号内都是字符串。

变量的声明

数据类型 变量名；

数据类型 变量名1 ,变量名2…

注意：1、变量必须先声明再使用；2、在一个作用域中不能声明同名的变量。

1. 数据类型转换

强制类型转换

byte age = 111; 

short year = age;

int i = year;

long l = i;

小数据类型——>大数据类型        自动类型转换

大数据类型——>小数据类型        强制类型转换（会丢失数据，精度）

    小数据类型 变量名 = （小数据类型）大数据类型变量名

      int i = 128;//4字节，32bit

    byte b = (byte)i;//1字节，8bit

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

128的二进制表达为：0000000010000000

-128的二进制表达为：10000000 byte8bit，8个二进制位，取后8位，即为-128

 

在计算机中如果一个二进制数据的最高位是1，那么该数据肯定是一个负数；

如果一个二进制数据的最高位是0，那么该数据肯定是一个正数；

负数在计算机中存储的是补码。

 

负数的存储过程

 -7——>11111001

1、先去负数的绝对值，求出该绝对值的二进制形式（原码）

2、原码取反得到反码

3、反码+1得到补码

00000111（原码）  反码>> 11111000   +00000001>> =11111001(得到补码)

如何通过补码求出真实的数据?

 

数据类型转换要注意的细节：

1. 凡是byte、short、char数据类型数据在进行运算的时候，都会自动转换成int类型的数据再运算

byte b1 = 1;

byte b2 = 2;

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

System.out.println(‘a’+1);  //Char自动转换成int，字符a在硬盘存储为97

1. 两个不同数据类型的数据在运算的时候，结果取决于大的数据类型

int i = 10;

long h = 20;

i = i +h; //要进行强制转换 i = （int）（i + h ）;

System.out.println(i);

 

 byte b = 10;//一个整数没有加上任何标识的时候，默认是int类型的数据。

//10是一个常量，编译器在编译的时候就能够确认常量的值，JAVA编译器就会检查到10并没有超出byte的表示范围，所以允许赋值

  int i = 10;

byte  b = i; //会报错，因为java编译器在编译的时候并不能确认变量所存储的值，变量存储的值是在运行的时候才在内存中分配空间

1. 运算符

算术运算符

+（整数、加法、连接符：让任务的数据都可以与字符串进行拼接）。

任何类型的数据与字符串使用连接符连接，那么结果都是字符串类型的数据。如果+用于字符串的时候，那么+就是一个字符串，并不是加法功能。

System.out.println(1+2+3+”world”+1+2+3);//6world123

计算机每次运算的时候只能取两个数据运算

-   

*   

 /    

%（取模、取余数） ，做取模运算时，结果取决于被除数。

10%3     1

-10%3   -1

-10%-3   -1

10%-3    1

++自增  

前自增：++位于操作数的前面，++a；先自增，后使用

后自增：a++；先使用，后自增

后自增在JVM中的运行原理：

int i = 0;

i = i++;//i=0

1\因为后自增使用到没有+1之前的值，JVM会先声明一个临时变量保存没有+1之前的值。 int temp = i; //temp=0;

2\自增。i = 1;

3\把 temp的结果用作表达式的结果。

运算符的优先级：

int i=3;

          int j=4;

          int a = i++ + i++;

          int b = ++j + ++j;          

      System.out.printf("%d,%d\n",a,b);//7,11？？？？？？？？？

-- 自减

逻辑运算符

&与       |或       ^异或      !非      &&短路与      ||短路或

位运算符

位运算符是直接操作二进制位，效率相对高一些。

&与     |或    ^异或     ~取反

应用：可以对数据进行加密

1\交换两个变量的值，不准出现第三方变量

int a = 3;

int b = 5;

方式1：定义第三方变量

   int  temp = a;

   a=b;

b=temp;

方式二：相加法，两个int类型的数据相加，有可能会出现超出int的表示范围

a = a + b;

b = a – b;

a = a – b;

方式三：使用异或

a = a^b;    // a=3^5

b = a^b;    // b=(3^5)^5 = 3

a = a^b;    // a=(5^3)^3 = 5

移位运算符

<<左移  >>右移  >>>无符号右移

System.out.println(3<<1) ;//6

运算符的优先级

int a = 1;int b = 2;int c = 3;

int result = a*b+c/2+2(a+b)/c;

System.out.println(“result=”+result);

1*2+c/2+2*3/3

2+c/2+6/3

2+1+2

5

1. 控制流程语句

if

1. 如果符合条件后只有一个代码需要执行，那么可以省略大括号。

int age = 18;

int workyears = 3;

if (age >= 18 & workyears >= 2)

System.out.println("该人符合条件");

局部代码块if(){}

If语句的判断条件后不能添加分号，if语句和后面执行代码没有任何关系

If-else与三元运算符非常像:

1. 1. 布尔表达式？值1：值2；  true返回值1，false返回值2

int a = 3;

String b = a>=3?"23":"2";

System.out.println(b);  //23

1. 1. 三元运算符的优点：结构比较简洁；
   2. 三元运算符的缺点：符合条件必须返回一个结果，不能执行结果。

System.out.println("输入一个分数：");

        Scanner scanner = new Scanner(System.in);

        int num = scanner.nextInt();

     System.out.println(num);

switch

选择判断语句

要注意的事项：

1. Switch语句使用的变量只能是byte\char\short\int\string数据类型，String数据类型是从JDK7.0的时候开始支持的。
2. Case后面跟的数据必须是一个常量。
3. Switch的停止条件：

Switch语句一旦匹配上了其中的一个case，就会执行对应的case语句，执行完毕之后如果没有遇到break关键字或者是结束switch语句的大括号，那么switch语句不会再判断，按照代码顺序从上往下执行所有的代码，直到遇到break或者是结束switch语句的大括号为止。

1. 在switch语句中不管代码顺序如何，永远先执行case语句，没有符合再去执行default语句。

int option =6;

        switch(option){

            case 1:

                System.out.println("java");

                break;

            case 2:

                System.out.println("C#");

                break;

            case 4:

                System.out.println("javas");

                break;

            default:

                System.out.println("选择有无");

             break;

优点：结构清晰

缺点：如果判断条件是一个区间范围，使用比较麻烦，需要列举所有值

        System.out.println("输入月份：");

            Scanner scanner = new Scanner(System.in);

         int num = scanner.nextInt();

           switch(num){

                case 1:

                case 2:

                case 12:

                    System.out.println("冬天");

                    break;

                case 3:

                case 4:

                case 5:

                    System.out.println("春天");

                    break;

                case 6:

                case 7:

                case 8:

                    System.out.println("夏天");

                    break;

                case 9:

                case 10:

                case 11:

                    System.out.println("秋天");

                    break;

                default:

                    System.out.println("请输入正确月份");

                    break;

         }

while

循环语句

实现猜数字游戏，如果没有猜对可以继续输入你猜的数字，如果猜对了停止程序            

       Random random = new Random();

       int randomNum = random.nextInt(10)+1;

//10随机数0-9，+1就是1~10  

       Scanner scanner = new Scanner(System.in);

       boolean tag = true;

       while(true){

           System.out.println("请输入你猜的数字");

           int num= scanner.nextInt();

           if(randomNum>num){

              System.out.println("小了！");

           }

           else if(randomNum<num){

              System.out.println("大了！");

           }  

           else{

              System.out.println("猜对了！");

              tag = false;

           }

}

实现猜数字游戏，如果没有猜对可以继续输入你猜的数字，如果猜对了停止程序;3次机会；如果还剩下最后一次机会的时候要提醒用户。

Random random = new Random();

           int randomNum = random.nextInt(10)+1;

           Scanner scanner = new Scanner(System.in);

           boolean tag = true;

           int i = 0;

           while(tag){

              System.out.println("输入你猜的数字");

              int a = scanner.nextInt();

              if(a>randomNum){

                  System.out.println("大了");

              }

              else if(a<randomNum){

                  System.out.println("小了");           

              }

              else{

                  System.out.println("猜对了");

                  tag = false;

              }

              i++;

              if(i==2){

                  System.out.println("还剩最后一次机会");

              }

              else if(i==3){

                  System.out.println("3次机会已使用完");

                  tag = false;

              }

           }

for

1. 格式：

for(初始化语句;判断语句;循环后的语句){

循环语句；

}

eg:    for(int i=0;i<5;i++){

              System.out.println("hi");

   }

1. 执行顺序：

       int a = 0;

       for(System.out.println("A");a<6;System.out.println("B")){

              System.out.println("C");

              a++;

}

 初始化语句只在第一次循环的时候执行，之后不会再执行；

 ACB(第一次循环) CB CB CB CB CB 。。。

1. 注意事项：

1. for(;;)这种写法是一个死循环语句，相当于while(true);
2. for(int i=0;i<5;i++)

System.out.println(i);

 For循环只有一句的时候可以省略大括号

练习：打印一个5行5列的*

    for(int b = 0 ; b < 5 ; b++){

       for(int a = 0 ; a < 5 ; a++){

           System.out.print("*");

       }

       System.out.println();

}

打印一个正立的直角三角形

 

int x = 1;

    for(int b = 0 ; b < 5 ; b++){

       for(int a = 0 ; a < x ; a++){

           System.out.print("*");

       }

       x++;

       System.out.println();

}

 

    for(int b = 0 ; b < 5 ; b++){

       for(int a = 0 ; a <= b ; a++){

           System.out.print("*");

       }

       System.out.println();}

      打倒立的三角  

              int c = 5;

              for(int b = 0 ; b < 5 ; b++){

                     for(int a = 0 ; a < c ; a++){

                            System.out.print("*");

                     }

                     c--;

                     System.out.println();

              }

 

              for(int a = 0 ; a < 5 ; a++){

                     for(int b = 0 ; b < (5-a) ; b++){

                            System.out.print("*");

                     }

                     System.out.println();

              }  

打印一个九九乘法表

              for(int b = 1; b <= 9;b++){

                     for(int a = 1 ; a<=b ; a++){

                     System.out.print(a + "*" + b + "=" + a*b + '\t');  

                     }

                     System.out.println();

              }

1. 转义字符

特殊字符用“\”把其转化成字符的本身输出，那么使用“\”的字符称作转义字符。

常见的转义字符

\b    Backspace退格键

\t     Tab 制表符（制表符的作用是为了让一列对齐） 一个tab一般等于四个空格

\n    Linefeed换行

\r    回车   把光标移动到以上的首位置上

\\    Backslash 反斜杠

注意：如果在windows系统上操作文件的时候需要换行，是需要\r\n一起使用的。如果在其他操作系统上，只需要\n就可以。

8.break\continue

break使用范围：只能用于switch或者是循环语句中。

作用：1、break用于switch语句的作用是结束一个switch语句

          2、break用于循环语句的作用是结束当前所在的循环语句

？break目前位于内层的for循环，如何让break作用于外层的for循环

        可以标记解决

标记的命名只要符合标识符的命名规则即可。

              outer:for(int i = 0;i<5;i++){

                     inner:for(int j = 0;j<5;j++){

                            System.out.println("huba");

                            break outer;

                 }

 

continue关键字：适用范围，只能用于循环语句。

作用： 跳过本次的循环体内容，继续下一次

注意：1、在一种情况下，continue后面不能跟有其他语句，因为是永远不会执行到。

2、continue也可以配合标志使用的

//计算1-100的偶数总和

              int num = 0;

              for(int a = 1 ; a <= 100 ; a++){

                     if( a%2 != 0){

                            continue;

                     }

                     num = num + a;

              }

        System.out.println(num);

 

9.函数的基本概述

函数的作用：可以提高功能代码的复用性

函数的定义格式：

       修饰符 返回值类型 函数名（形参列表）{

  需要被封装的功能代码；

}

函数的特点及注意事项

1. 函数定义好之后，是需要被调用才会被执行的。但是main函数是由jvm调用，不需要手工调用；
2. 修饰符public static
3. 返回值类型，函数运行完毕后返回的结果的类型
4. 函数名的命名规范，首字母小写，其他单词首字母大写
5. Return，把结果返回给调用者

public class testjava {

public static void main(String args[]){

  int sum = adwd(22,3);

  System.out.print(sum);

}

public static int adwd(int a,int b){

//   int a = 2;

//   int b = 3;

  return a+b;

}

}

1. 某些函数是没有结果返回给调用者的，那么这时的返回值类型必须是void。

练习：定义一个函数做加法功能，不需要返回结果给调用者，直接输出结果即可

public class testjava {

public static void main(String args[]){

      add(22,3);

}

public static void add(int a,int b){

    System.out.println(a+b);

}

}

                            

？如何定义一个函数：

1. 返回值类型
2. 是否存在未知的参数（是否存在要由调用者确定的参数）

练习：定义一个函数比较两个数的大小，把最大值返回给调用者

public class testjava {

public static void main(String args[]){

    int maxnum = getMax(23,22);

    System.out.println(maxnum);

}

public static int getMax(int a,int b){

    int max = 0;

    if(a>b){

       max = a;

    }else{

       max = b;

    }

    return max;

}

}

返回值直接输出：

public class testjava {

public static void main(String args[]){

      getMaxNum(23,24);

}

//不需要返回结果给调用者，直接输出结果

public static void getMaxNum(int a,int b){

int max = 0;  //定义一个变量用来保存最大值

    if(a > b){

       max = a;

    }else{

       max = b;

    }

      System.out.println("最大值是："+max);

}

}

练习：定义一个函数判断一个分数的等级，把分数的等级返回给调用者。

         定义一个函数打印一个乘法表，不需要返回任何数据。

public class testjava{

    public static void main(String args[]){

       multiplicationTable(9,9);

    }

    public static void multiplicationTable(int a,int b){

       for(int i = 1;i <= a;i++){

           for(int j = 1;j<=i;j++){

              System.out.print(i+"*"+j+"="+i*j+'\t');

           }

           System.out.println();

       }

    }

}

 

public class testjava{

    public static void main(String args[]){

       String levels = getLevel(80);

       System.out.print("分数等级为："+levels);

    }

    public static String getLevel(int score){

        String level;

       if(score >= 60 && score <= 100){

           level = "A";

       }else if(score >= 30 && score < 60){

           level = "B";

       }else{

           level = "C";

       }

       return level;

    }

}

1. 如果一个函数的返回值类型是具体的数据类型，那么该函数就必须要在任意情况下都保证有返回值

Return关键字

1. 返回数据给调用者；
2. 函数一旦执行到了return关键字，那么改函数马上结束。（能结束一个函数）
3. break关键字与return关键字的区别：break是结束一个循环、return是结束一个函数。
4. 一个函数的返回值类型是void，那么也可以出现return关键字，但是return关键字后面不能有数据。

       public static void main(String args[]){

              print(4);//小于6可以执行到for循环，到return结束函数，不会打印22；大于6则执行不到for循环，会打印22

       }

       public static void print(int a){

              int b = 0;

              b=a;

              for(a = b ; a< 6;a++){

                     System.out.print("11");

                     return;

              }

              System.out.println("22");

  }

函数的重载

概念：在一个类中出现两个或以上的同名函数

作用：同一个函数名可以出现不同的函数，以应对不同个数或者不同数据类型的参数

使用要求：函数名一致；

            形参列表不一致，或者对应的数据类型不一致；

            与函数的返回值类型没有关系

       public static void main(String args[]){

              add(1,2);

              add(1,2,3);

       }

       public static void add(int a,int b,int c){

              System.out.println(a+b+c);

       }

       public static void add(int a,int b){

              System.out.println(a+b);

       }