Java基础语法与流程控制

Java基础语法与流程控制

跟着狂神学Java的第二天O(∩_∩)O~，养成一个总结的习惯

志同道合的小伙伴可以一起学习狂神的视频

本节地址：https://www.kuangstudy.com/course/play/1317504142650658818

Java基础语法

1. 注释

​ Java注释有单行注释，多行注释和文本注释三种

• 单行注释：用双斜线//后面跟要注释的内容

  eg：//我是一条注释

• 多行注释：用/*开始，用*/结束，在中间写注释的内容

  eg：

  /*多行注释
  我是一条注释
  我也是一条注释
  我也是一条注释
  */
  

• 文本注释（用于JavaDoc注释）：/** */

  eg:

   /**
   * @Description HelloWorld
   * @Author yl
   */
  

2. 关键字和标志符

• 关键字

• 标志符

  Java的所有组成部分都需要名字。类名、变量名以及方法名都被称之为标志符。

  • 所有的标志符都应该以字母(a-z,A-Z)，美元符($)、或者下划线(_)开头

  • 首字母之后可以是字母，美元符，下划线，数字的*组合

  • 不能使用关键字作为变量名或方法

  • Java对大小写敏感！

3. Java数据类型

• 八大基本类型

  //八大基本类型
  int num1=220000000;	//占4个字节
  byte num2=100;	//占1个字节
  short num3=10000;	//占2个字节
  long num4=234239809L;//long类型要在数字后面加一个L  占8个字节
  
  float num5=30.5F;//float在数字后面加一个F
  double num6=4.14242353423;
  
  char name='狂';  //占1个字节
  boolean flag=true;  //占1个字节
  

• 引用类型

  类，接口，数组

4. 数据类型扩展

//整数拓展： 进制 二进制0b    十进制     八进制0    十六进制0x
int i=10;
int i2=010;//八进制0
int i3=0x10;//十六进制0x 0~9 A~F
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
System.out.println("================================");

//================================
//浮点数拓展 银行业务怎么表示？钱
//BigDecimal 数学工具类
//================================
//float 有限 离散 舍入误差 大约 接近但不等于
//double
//最好完全避免使用浮点数进行比较
float f=0.1f;//0.1
double d=1.0/10;//0.1
System.out.println(f==d);//false

float d1=2342342345823478324234F;
float d2=d1+1;
System.out.println(d1==d2);//true

//================================
//字符拓展
//================================
System.out.println("================================");
char c1='a';
char c2='中';
System.out.println(c1);
System.out.println((int)c1);
System.out.println(c2);
System.out.println((int)c1);

//所有的字符本质还是数字
//编码 Unicode 表：(97=a 65=A)  2字节
//U000 UFFF
char c3='\u0061';
System.out.println(c3);//a

//转义字符
// \t 制表符
// \n 换行
System.out.println("Hello\nWorld!");

5. 类型转换

//强制类型转换  高->低
//自动转换   低->高

/*注意点
* 1.不能对布尔值进行转换
* 2.不能把对象类型转换为不相干的类型
* 3.在把高容量转换到低容量的时候，强制转换
* 4.转换的时候可能存在内存溢出或者精度问题
* */

6. 变量，常量，作用域

​ 变量：会变的量（类变量，实例变量，局部变量）

​ 常量：不会变的量

​ 作用域：作用范围

​ eg：

public class Demo06 {
    //类变量 static
    static double salary = 2500;

    //属性 ：变量

    //实例变量：从属于对象；如果不自行初始化，则为这个类型的默认值 0 0.0 u000
    //布尔值：默认是false
    //除了基本类型，其余的默认值都是null
    String name;
    int age;

    //main方法
    public static void main(String[] args) {
        //局部变量，必须声明和初始化值
        int i=10;
        System.out.println(i);

        //变量类型 变量名字 = new Demo06();
        Demo06 demo06 = new Demo06();
        System.out.println(demo06.age);
        System.out.println(demo06.name);

        //类变量
        System.out.println(salary);
    }
    //其他方法
    public void add(){

    }
}

变量命名规范：

/**变量命名规范
 *所有变量、方法、类名：见名知意
 *类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写
 *局部变量：首字母小写和驼峰原则
 *常量：大写字母和下划线：MAX_VALUE
 * 类名：首字母大写和驼峰原则：Man，GoodMan
 * 方法名：首字母小写和驼峰原则：run(),runRun()
 */

7. 基本运算符

• 算术运算符：+，-，*，、，%，++，--

• 赋值运算符：=

• 关系运算符：>,<,>=,<=,==,!=instanceof

• 逻辑运算符：&&，||，！

• 位运算符：&，|，^，~，>>，<<

• 条件运算符：？：

• 扩展赋值运算符：+=，-=，*=，/=

  需要注意的是除法/，整数的除法是向下取整的

  int a=5/3;
  System.out.println(a);//输出的是1
  

8. 自增自减运算符

//++ --  自增，自减  一元运算符
int a = 3;

int b = a++;
int c = ++a;

System.out.println(a);//a=5
System.out.println(b);//b=3
System.out.println(c);//c=5

​ 拿上面的代码进行说明：

​ ++表示自增即自己+1，但是放在前面和放在后面效果是不一样的：

​ int b=a++;其实相当于int b=a;a=a+1; ，也就是先把a的值赋给b，再把a的值增加1；

​ int c=++a;其实相当于a=a+1; int c=a;，因此是先把a的值加1，然后再赋给c；

​ 那么上面的代码转化一下就是：

int a = 3;

int b = a;//此时b=3;
a=a+1;//此时a=4;

a=a+1;//此时a=5;
int c = a;//此时c=5;
System.out.println(a);//a=5
System.out.println(b);//b=3
System.out.println(c);//c=5

因此会输出5 3 5

9.逻辑运算符与位运算符

• 逻辑运算符：&&，||，！（与，或，非）

  &&：逻辑与，二者同时成立结果为真，否则为假

  ||：逻辑或，只要有一个为真结果就为真，否则为假

  ！：逻辑非：对原来的结果取反，真变假，假变真

  特别注意：&&和||都具有短路运算的性质

  所谓短路性质：例如A&&B，当A已经判断出是假了，就不会再判断B了，因为不管B是真是假，结果都是假，同理A||B，当A判断为真也不会再判断B了，因为只要有一个为真结果就是真。

  eg：

  //短路运算
  int c = 5;
  boolean d= (c<4) && (c++<5);//因为前面已经判断为false了，&&的结果肯定为false，后面的条件不用再判断
  System.out.println(d);//false
  System.out.println(c);//5
  
  //下面同理短路运算
  int e = 5;
  boolean f = (e<6) || (e++<7);
  System.out.println(f);//true
  System.out.println(e);//5
  

• 位运算符：&，|，^，~，<<，>>，

  位运算符都是对二进制位进行操作的。

  &：按位与：两个数逐位进行与运算，每一位的规则为二者都为1结果为1，否则为0

  |：按位或：两个数逐位进行或运算，每一位的规则为二者至少有1个1结果为1，否则为0

  ^：按位异或：两个数逐位进行异或运算，每一位的规则为相同为0，不同为1

  ~：按位非：二进制每一位0变1,1变0

  A = 0011 1100
  B = 0000 1101
  
  A&B =0000 1100
  A|B =0011 1101
  A^B =0011 0001
  ~B = 1111 0010
  

  <<：左移

  左移n位相当于乘以2的n次方

  >>：右移

  右移n位相当于除以2的n次方

  位移操作会比乘除法效率高很多

10. 三元运算符

​ "? :"是一个三元运算符，相当于if else

eg: int c=a>b?a:b;的意思相当于以下语句：

if(a>b){
    c=a;
}
else{
    c=b;
}

Java流程控制

1. 用户交互Scanner(输入)

​ System.out.println()可以实现输出到控制台，但是如何进行输入呢？Java提供了Scanner方法，先new一个Scanner对象，这个对象你自己起个名。

eg：Scanner s = new Scanner(System.in);

（举个可能不太恰当的比喻，假设你现在需要写字，Scanner就相当于文具店，System.in就相当于是笔，你new一个Scanner(System.in)就相当于你买了一只笔，这个s就相当于你给自己的笔起了一个名字：xxx的专属神笔，接下来你可以用你的神笔写字了。。。）

​ (如果你没有作业要写你也不会拿笔写字对吧，所以你可以先判断一下你需不需要写字)

​ 可以用hasNextLine()或者hasNext()方法判断一下还有没有输入，eg：if(s.hasNextLine())

​ 如果有的话，可以用一个变量来接收输入的数据，eg:String str = s.nextLine();//能接收空格（不用nextline()用next()也可以，但是无法接收空格）

​ 然后还有个特别重要的事情！！输入完一定要关闭Scanner，否则会一直占用资源！！！(就像你写完作业了总要把笔帽盖上，不然你的墨就没了。。)可以使用close()进行关闭，eg：s.close();

​ 完整示例如下：

public static void main(String[] args) {
    //创建一个扫描器对象，用于接收键盘数据
    Scanner s = new Scanner(System.in);
    System.out.println("使用next方式接收：");
    //判断用户有没有输入字符串
    if(s.hasNextLine()){
        //String str = s.next();//不能接收空格
        String str = s.nextLine();//能接收空格
        System.out.println("输出内容为：\n"+ str);
    }
    //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯
    s.close();
}

2. Scanner进阶

​ 上面的Scanner只是学习了字符串(文本)的输入，如果要输入整数，浮点数之类的怎么办呢？

​ 同样的道理，先new一个Scanner（相当于拿一支笔出来），Scanner s = new Scanner(System.in);

​ 然后可以用s.nextInt();输入int类型的整数，或者用s.nextFloat();输入float类型的浮点数。

​ 当然肯定不止这些啦，还有nextLong(),nextDouble()等等很多种输入方法，需要什么就用什么。

​ eg：

public static void main(String[] args) {
    Scanner s = new Scanner(System.in);
    //从键盘接收数据
    int i = 0;
    float f = 0.0f;

    System.out.println("请输入整数：");
    if(s.hasNextInt()){
        i = s.nextInt();
        System.out.println("整数数据："+i+"\n");
    }else{
        System.out.println("输入的不是整数");
    }

    System.out.println("请输入小数：");
    if(s.hasNextFloat()){
        f = s.nextFloat();
        System.out.println("小数数据："+f+"\n");
    }else{
        System.out.println("输入的不是小数");
    }
    s.close();//千万不要忘记关掉
}

3. 顺序结构

​ 挺简单，Java的基本结构就是顺序结构，除非特别指明，不然就是从上往下依次执行。

4. If选择结构*

​ 很重要，后面会用的很多。If选择结构有If单选择结构，If双选择结构，If多选择结构和If嵌套结构。

• If单选择结构

  

  很好理解，如果条件成立就执行，不然不执行，使用if语句（假如你考了90分，就可以玩游戏，否则免谈）

  eg：

  if(score>=90){
      System.out.println("你可以玩游戏");
  }
  

  关于条件判断，if会总是判断条件是不是成立（是不是true），那么对于一个boolean类型的变量，可以两种方式：

  boolean flag=true;
  if(flag == true){...}
  //也可以直接写 if(flag){...}
  

• If双选择结构

如果条件成立就执行语句1，否则执行语句2，使用if...else语句（上面说的假如你考了90分，就可以玩游戏，但是没考到呢？那就乖乖做家务~）

if(score>=90){
    System.out.println("你可以玩游戏");
}
else{
    System.out.println("乖乖做家务");
}

• If多选择结构

生活中肯定会遇到不止两种选择的情况啦，就像你扔一个骰子，都有六种情况对吧。（次次都要考90分以上，鸭梨山大有木有啊~所以呢你亲爱的mother决定改进一下，如果你考到80分了， 可以给你玩一小会游戏）采用if...else if...else语句

if(score>=90){
    System.out.println("你可以玩游戏");
}
else if(score<90 && score>=80){
    //其实也可以直接写成else if(score>=80)，因为上一个if不满足就相当于满足它的反面，也就是已经满足了score<90
    System.out.println("你可以玩游戏");
}
else{
    System.out.println("乖乖做家务");
}

• If嵌套结构

  也很好理解，就是相当于有很多个不同的事情要去判断嘛（假如你的语文成绩xxx，你的数学成绩xxx，以及你的xx成绩xxx）

  if(chineseScore>=90){
      if(mathScore>=90){
          if(englishScore>=90){
              ...
          }
          else{
              ...
          }
      }
      else{
          ...
      }
  }
  

5. switch语句

​

​ switch也是一种选择语句，里面的expression就是待判断的表达式（可以是一个变量），对于每个case，如果满足就执行下面的语句。

​ 举个例子，假设现在要根据分数的等级(ABCD)输出不同的评语：

public static void main(String[] args) {
    char score = 'A';
    switch (score){
        case 'A':
            System.out.println("NB Plus!");
            break;
        case 'B':
            System.out.println("good!");
            break;
        case 'C':
            System.out.println("not so bad!");
            break;
        case 'D':
            System.out.println("Come on!");
            break;
        default:
            System.out.println("未知等级，输入错误！");
            break;
    }
}

​ 此时switch对score进行判断，满足了case 'A'因此执行完输出语句后break退出switch。那么不写break会怎样呢。如果把里面所有的break都去掉的话，会执行所有的语句，如下所示：

因为case语句具有穿透性，通俗来说就是没有break它不会停，会一直往后执行，因此要加上break。关于default，可写可不写，写了方便自己调错，不写也无碍。

关于case还有一个小技巧，假设要有多个case里面的语句一样，可以简写。例如判断月份天数，你可以老老实实的写12个case，12个输出语句。也可以这样写：

int month=10;
switch (month){
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12:
        System.out.println("31天");
        break;
    case 4:
    case 6:
    case 9:
    case 11:
        System.out.println("30天");
        break;
    case 2:
        System.out.println("28天");//当然可以加个判断闰年29天，此处省略
        break;
    default:
        System.out.println("未知月份，输入错误！");
        break;
}

最后switch和if选择结构有啥区别呢？case的每个value都是固定的一个值，是离散的，而if判断的括号里面可以是连续的。举个例子吧，假设要判断分数，对于0_{59判定为不及格,60}100判定为及格，if只需要写if(score<60){...} else{...}就行了，但是switch要写101个case才行。如果分数里面还有小数的话，switch就做不到了。所以离散的判断二者都可，连续的判断只能用if。

6. while循环和do while循环*

​ while循环是最简单的循环。

while(布尔表达式){
   要执行的语句；
}

​ 举个例子（开个玩笑）：

boolean keJin=true;
while(keJin){
    //等价于while(keJin==true)，道理同if
    System.out.println("爽");//氪金一时爽，一直氪金一直爽
}

只要while括号里面的条件满足，就会一直执行里面的语句，上述例子里面的keJin的值为true，一直满足，所以会一直输出爽

do while循环的话其实用的很少，了解一下就行了。

do{
	要执行的语句；
}while(布尔表达式);//特别注意这儿有个分号

while和do while的区别就在于while是条件满足才执行，do while是先执行一次再判断是否满足条件，不满足就不再执行了。举个例子，你喜欢玩游戏，但是你妈不在家，while就相当于你先问你妈可不可以玩游戏，她同意了你就再一直玩；do while就相当于你不管三七二十一，直接开玩，玩了一会你才想起来要问你妈可不可以玩，她同意了你继续一直玩，不同意就不玩了。所以不管她同不同意，do while都能玩一会。

7. for循环*

​ for循环挺好用，很灵活，但是也那么一丢丢复杂。

for(初始值;布尔表达式;更新){//注意有两个分号
	要执行的语句;
}
//eg:
for(int i=0;i<10;i++){
    System.out.println("已经跑了"+i+"圈");
}

什么意思呢，假设你要去跑步，跑10圈，你的小伙伴帮你计圈，需要一个计圈的工具呀，你可以int i来当计圈工具，那么从第几圈开始计呢？还没开始跑呢肯定是从0开始啊，所以i的初始值就是0(当然其他情况不一定是0)，需要计几次呢？他告诉你你已经跑了几圈了，所以当他告诉你已经跑了9圈的时候，你就知道你要冲刺了对吧，所以计到9就可以了，也就i<10就行了（当然你硬要i<=10也行，这里只是举个例子），这就是布尔表达式的意义，就是一个判断条件。当然，你每跑一圈，计数器得变对吧，不然每次都是第0圈，人傻掉，所以得i++;，每次加1，当然也不一定每次都是i++，i+=2,i+=3也可以啊，具体情况具体分析。

for循环的话还有很多的变式写法都是可以的：

for(int i=0;i<10;i++)//最标准的写法

int i;
for(i=0;i<10;i++)//把i的定义放在外面，赋值放在里面

int i=0;
for(;i<10;i++)//把i的定义和赋值都放在外面，但是分号不能省

int i=0;//把i的定义和赋值都放在外面，i的变化放在了括号里面，分号不能省
for(;i<10;){//其实把这俩分号去掉，for改成while，就是while循环的写法了
    要执行的语句;
    i++;
}

for(;;)//死循环，无限执行

之前看到语法不过关的表白横幅Orz，可以看看运行结果是怎样的：

for(; ;);{System.out.println("I Love You!");}

8. for循环嵌套*

​ for循环嵌套也是很重要的，相当于把里层循环重复执行多次。

for(int i=0;i<2;i++){
	for(int j=0;j<3;j++){
		System.out.println("i="+i+" j="+j);
	}
}

​ 输出结果如下：

​

​ 练习：输出九九乘法表

​

​ 参考代码如下：

for(int i=1;i<=9;i++){
    for(int j=1;j<=i;j++){
    	System.out.print(i+"*"+j+"="+i*j+"\t");//\t是制表符Tab，用于对齐
    }
    System.out.println();//每输出完一行，进行换行
}

9. break和continue

​ break在switch中的作用已经说了，在循环中的作用呢？

• break：退出本次循环并结束掉当层循环（不执行本层后面剩余循环）

• continue：退出本次循环，执行下一次循环

  打个可能不太恰当的比喻，循环相当于大家排队买奶茶，到break的时候奶茶店没有原材料了，那break买不了，后面的人也买不了吧，排队结束。

  continue相当于到他的时候他不想买了，那么他没买，他后面的人还是会买的吧。

  eg：

  public static void main(String[] args) {
      for(int i=1;i<=10;i++){
          if(i==5){
              continue;
          }
          System.out.println("i="+i);
      }
  }
  

  输出的结果为：

  

  把上面代码中的continue改为break后，结果为：

  

  特别注意，break只是结束当层循环，不是所有的循环：

  eg：

  public static void main(String[] args) {
      for (int i = 0; i < 4; i++) {
          for (int j = 0; j < 5; j++) {
              if(j==3){
                  break;
              }
          }
      }
  }
  

  上面例子中在里层for循环写了一个if(j==3) break;，只会结束里层j循环，不会结束外面的i循环，所以对于每次i循环，j循环到3的时候就会break，因此对于每个i，j只会输出0，1，2。
  
  

10. 增强for循环

//增强for循环，用于循环数组和集合
int []numbers = {10,20,30,40,50};//定义了一个数组
for(int x:numbers){
	System.out.println(x);//输出结果为10 20 30 40 50
}

11. 关于循环的练习

• 计算0~100奇数和，偶数和（结果为2500,2550）

  int oddSum = 0;//奇数和
  int evenSum = 0;//偶数和
  for(int i=0;i<=100;i++){
      if((i%2)==1) oddSum+=i;	//这里也可以用位运算&来判断奇偶：if((i&1)!=0) 偶数&1的结果是0
      else evenSum+=i;
  }
  System.out.println("奇数和为："+oddSum+"\n偶数和为："+evenSum);
  

• 用while或者for循环输出1-1000之间能被5整除的数，并且每行三个

int count=0;
for(int i=1;i<=1000;i++){
    if(i%5==0){
        System.out.print(i+" ");
        count++;
        if(count%3==0){//或者这里不用count，直接用if(i%15==0)也可以
            System.out.println();
        }
    }
}

• 输出如图所示的五行的三角形（拓展：n行三角形）

public static void main(String[] args) {
    for(int i=1;i<=5;i++){
        for(int j=1;j<=5-i;j++){
            System.out.print(" ");//输出前面的空格
        }
        for(int j=1;j<=2*i-1;j++){
            System.out.print("*");//输出*号
        }
        System.out.println();
    }
}