笔记整理：狂神说Java——Java基础01

@KaiSa

已于 2022-08-26 23:09:44 修改

阅读量1.9k

点赞数 1

分类专栏：笔记整理：JavaSE 文章标签： java

于 2022-04-26 21:00:00 首次发布

本文链接：https://blog.csdn.net/qq_44891883/article/details/124420068

版权

笔记整理：JavaSE 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

笔记整理：狂神说Java——Java基础01

笔记参考：b站狂神说java
视频链接：https://www.bilibili.com/video/BV12J41137hu?p=1
纯手打，边学边写，欢迎浏览和指正

笔记整理：狂神说Java——Java基础01
初识Java
- Java特性和优势
- Java三大版本
- JDK、JRE、JVM
Java开发环境搭建
- 安装JDK
- 卸载JDK
- Helloworld
- 可能遇到的问题
- Java程序运行机制
- - 程序运行机制
- IDEA安装
注释
标识符与关键字
- 关键字
- 标识符注意点
数据类型
- 强数据语言
- 弱类型语言
- Java的数据类型
- 什么是字节
- 类型转换
- 变量
- 变量作用域
- 常量
- 变量的命名规范
运算符
- 二元运算符
- 关系运算符
- 自增自减运算符、初识Math类
- 逻辑运算符、位运算符
- 扩展条件运算符
- 三元运算符
包机制
JavaDoc
Java流程控制（基础阶段）
Scanner对象
顺序结构
选择结构
- if单选泽结构
- if双选择结构
- if多选择结构
- 嵌套的if结构
- Switch多选择结构
循环结构
- while循环
- do……while循环
- for循环
- 增强for循环
- break continue
- 流程控制练习

初识Java

Java特性和优势

简单性、面向对象、可移植性、高性能、分布式、动态性、多线程、安全性、健壮性

Java三大版本

JavaSE：标准版（桌面程序，控制台开发等）
JavaME：嵌入式开发（手机，小家电等）
JavaEE：企业级开发（web端，服务器端）

JDK、JRE、JVM

JDK：Java Development Kit
JRE：Java Runtime Environment
JVM：Java Virtual Machine

百度经验

Java开发环境搭建

安装JDK

1、百度搜索JDK8，找到下载地址
2、同意协议
3、下载电脑对应版本
4、双击安装JDK
5、记住安装路径
6、配置环境变量	
	1、我的电脑——>右键——>属性
	2、环境变量——>JAVA_HOME
7.测试JDK是否安装成功
	win+R——>cmd——>java -version

卸载JDK

1、删除Java安装目录
2、删除JAVA_HOME
3、删除path下关于java的目录
4、java -version

Helloworld

1.随便新建一个文件夹，存放Java文件

2.新建一个java文件

文件后缀名为.java
Hello.java
注意：系统可能没有文件后缀名，需手动打开显示后缀名

3.编写代码

public class Hello{
	public static void main(String[] args){
		System.out.println("Hello,world!");
	}
}

4.编译javac java文件，会生成class文件
5.运行class文件，java class文件
编译运行

可能遇到的问题

每个单词的大小不能出现问题，java是大小写敏感
尽量使用英文
文件名和类名必须保持一致，并且首字母大写
符号使用了中文

Java程序运行机制

编译型
解释型

解释型和编译型语言的区别

程序运行机制

在这里插入图片描述

IDEA安装

下载安装教程

注释

单行注释：只注释一行
多行注释：可多行注释
文档注释

//我是单行注释

/*
我是多行注释
 */

//JavaDoc:文档注释 //*  */
/**
 * @Author no_crush
 * @time 2022-04-26 18:00
 *
 */

/***    
 * 有趣的代码注释 
 *          .,:,,,                                        .::,,,::.          
 *        .::::,,;;,                                  .,;;:,,....:i:         
 *        :i,.::::,;i:.      ....,,:::::::::,....   .;i:,.  ......;i.        
 *        :;..:::;::::i;,,:::;:,,,,,,,,,,..,.,,:::iri:. .,:irsr:,.;i.        
 *        ;;..,::::;;;;ri,,,.                    ..,,:;s1s1ssrr;,.;r,        
 *        :;. ,::;ii;:,     . ...................     .;iirri;;;,,;i,        
 *        ,i. .;ri:.   ... ............................  .,,:;:,,,;i:        
 *        :s,.;r:... ....................................... .::;::s;        
 *        ,1r::. .............,,,.,,:,,........................,;iir;        
 *        ,s;...........     ..::.,;:,,.          ...............,;1s        
 *       :i,..,.              .,:,,::,.          .......... .......;1,       
 *      ir,....:rrssr;:,       ,,.,::.     .r5S9989398G95hr;. ....,.:s,      
 *     ;r,..,s9855513XHAG3i   .,,,,,,,.  ,S931,.,,.;s;s&BHHA8s.,..,..:r:     
 *    :r;..rGGh,  :SAG;;G@BS:.,,,,,,,,,.r83:      hHH1sXMBHHHM3..,,,,.ir.    
 *   ,si,.1GS,   sBMAAX&MBMB5,,,,,,:,,.:&8       3@HXHBMBHBBH#X,.,,,,,,rr    
 *   ;1:,,SH:   .A@&&B#&8H#BS,,,,,,,,,.,5XS,     3@MHABM&59M#As..,,,,:,is,   
 *  .rr,,,;9&1   hBHHBB&8AMGr,,,,,,,,,,,:h&&9s;   r9&BMHBHMB9:  . .,,,,;ri.  
 *  :1:....:5&XSi;r8BMBHHA9r:,......,,,,:ii19GG88899XHHH&GSr.      ...,:rs.  
 *  ;s.     .:sS8G8GG889hi.        ....,,:;:,.:irssrriii:,.        ...,,i1,  
 *  ;1,         ..,....,,isssi;,        .,,.                      ....,.i1,  
 *  ;h:               i9HHBMBBHAX9:         .                     ...,,,rs,  
 *  ,1i..            :A#MBBBBMHB##s                             ....,,,;si.  
 *  .r1,..        ,..;3BMBBBHBB#Bh.     ..                    ....,,,,,i1;   
 *   :h;..       .,..;,1XBMMMMBXs,.,, .. :: ,.               ....,,,,,,ss.   
 *    ih: ..    .;;;, ;;:s58A3i,..    ,. ,.:,,.             ...,,,,,:,s1,    
 *    .s1,....   .,;sh,  ,iSAXs;.    ,.  ,,.i85            ...,,,,,,:i1;     
 *     .rh: ...     rXG9XBBM#M#MHAX3hss13&&HHXr         .....,,,,,,,ih;      
 *      .s5: .....    i598X&&A&AAAAAA&XG851r:       ........,,,,:,,sh;       
 *      . ihr, ...  .         ..                    ........,,,,,;11:.       
 *         ,s1i. ...  ..,,,..,,,.,,.,,.,..       ........,,.,,.;s5i.         
 *          .:s1r,......................       ..............;shs,           
 *          . .:shr:.  ....                 ..............,ishs.             
 *              .,issr;,... ...........................,is1s;.               
 *                 .,is1si;:,....................,:;ir1sr;,                  
 *                    ..:isssssrrii;::::::;;iirsssssr;:..                    
 *                         .,::iiirsssssssssrri;;:.                      
 */			


public class HelloWorld {
    //输出一个Hello，World！
    public static void main(String[] args) {
        System.out.println("Hello,World!");
    }
}

标识符与关键字

关键字

在这里插入图片描述
java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符

标识符注意点

所有标识符都应该以字母（A-Z或者a-z），美元符号（$）、或者下划线（_）开始
首字母之后可以是字母（A-Z或者a-z），美元符号（$）、下划线（_）或任何字符组成
不能使用关键字作为变量名或方法名
标识符是大小写敏感
可以使用中文命名，但是一般不建议这样使用，也不建议使用拼音
合法字符举例：age、$salary、_value、_1_value
非合法字符举例：123abc、-salary、#abc

public class HelloWorld {
    public static void main(String[] args) {
        //正确示范
        String Ahello = "crush";
        String hello = "crush";
        String $hello = "crush";
        String _hello = "crush";
        
        //错误示范
        String _ = "crush";
        String class = "crush";
        String mingzi = "crush";
        String 英雄联盟 = "最强王者";
    }
}

数据类型

强数据语言

要求变量的使用要严格符合规定，所有变量都必须先定义后使用

弱类型语言

Java的数据类型

在这里插入图片描述

/**
 * @Author crush
 * @create 2022-04-27 22:14
 */

public class Demo02 {
    public static void main(String[] args) {
        //八大基本数据类型

        //整数
        int num1 = 10;//最常用
        byte num2 = 20;
        short num3 = 30;
        long num4 = 40L;//long类型要在数=字后加L

        //小数，浮点数
        float num5 = 50.1F;
        double num6 = 3.1415926;

        //字符
        char name = 'A';
        //字符串，String不是关键字，类
        //String name1 = "阿巴阿巴";

        //布尔值：是非
        boolean flag = true;
        boolean fLag = false;
    }
}

什么是字节

位（bit）：是计算机内部数据存储的最小单位，11001100是一个8位二进制数
字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示
1B（byte，字节） = 8bit（位）
字符：是指计算机中使用的字母、数字、字和符号
- 1bit表示1位
- 1Byte表示一个字节 1B=8b
- 1024B=1KB
- 1024KB=1M
- 1024M=1G
  数据类型扩展及面试题讲解

/**
 * @Author no_crush
 * @create 2022-04-27 22:14
 */

public class Demo03 {
    public static void main(String[] args) {
        //整数拓展： 进制  二进制  十进制  八进制0  十六进制0X
        int i = 10;
        int i2 = 010;//八进制0
        int i3 = 0X10;//十六进制0X  0~9 A~F 16

        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 b = 1.0/10;//0.1

        System.out.println(f==b); //false
        System.out.println(f);
        System.out.println(b);

        float d1 = 23232323324f;
        float d2 = d1 + 1;

        System.out.println(d1==d2);//true

        //=======================================================================
        //字符拓展？
        //=======================================================================
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int)c1);
        System.out.println(c2);
        System.out.println((int)c2);
        //所有的字符本质还是数字
        //编码 Unicode 2字节  0-65536  Excel

        //U0000 UFFFF

        char c3 = '\u0061';

        System.out.println(c3);//a
        //转义字符
        // \t 制表符
        // \n 换行
        //......

        System.out.println("Hello\tWorld");

        //
        String sa = new String("hello world");
        String sb = new String("hello world");
        System.out.println(sa==sb);

        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc==sd);
        //对象 从内存分析
        
        //布尔值拓展
        boolean flag = true;
        if(flag = true){}//新手
        if(flag){}//老手
        //less is More！ 代码要精简易读
    }
}

类型转换

由于Java是强类型语言，所以在进行有些运算时，需要用到类型转化

低----------------------------------------------------------------------->高
byte，short，char——>int——>long——>float——>double

运算中，不同类型的数据先转化为同一数据类型，再进行运算
- 强制类型转换（高->低）
- 自动类型转换（低->高）

/**
 * @Author crush
 * @create 2022-04-28 09：13
 */

public class Demo04 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i;//内存溢出


        //强制转换 （类名）变量名 高--低
        //自动转换 低--高

        System.out.println(i);
        System.out.println(b);
        /*
        注意点：
        1.不能对布尔值进行转换
        2.不能把对象类型转换为不相干的类型
        3.在把高容量转换为低容量时，强制转换
        4.转换时可能出现内存溢出，或者精度问题！
         */

        System.out.println("========================");
        System.out.println((int)23.7); //23
        System.out.println((int)-45.89f);//-45
        char c = 'a';
        int d = c + 1;
        System.out.println(d);
        System.out.println((char)d);
    }
}

注意溢出

public class Demo06 {
    public static void main(String[] args) {
        //操作数较大时，注意溢出问题
        //JDK7新特性，数字之间可用下划线分割
        int money = 10_0000_0000;
        int year = 20;
        int total1 = money*year;//计算时溢出
        long total2 = money*year;//默认是int，转换之前已存在问题
        long total3 = money*((long)year);//先把一个数值转化为long

        System.out.println(total1);
        System.out.println(total2);
        System.out.println(total3);



    }
}

变量

变量是什么：就是可以变化的量
Java是一种强类型语言，每个变量都必须声明其类型
java变量是程序中最基本的存储单元，其元素包括变量名，变量类型和作用域

type varName [=value][{,varName[l=value]}]
//数据类型变量名 = 值；可以用逗号隔开来声明多个同类型变量

注意事项：
- 每个变量都有类型，类型可以是基本类型，也可以是引用类型
- 变量名必须是合法的标识符
- 变量生声明是一条完整的语法，因此，每一个声明都必须以分号结束

/**
 * @Author no_crush
 * @create 2022-04-28 09：45
 */
public class Demo07 {
    public static void main(String[] args) {
        // int a,b,c;可以这样但不建议
        // int a=1,b=2,c=3;  //程序可读性
        String name = "no_crush";
        char x = 'X';
        double pi = 3.14;
    }
}

变量作用域

类变量
实例变量
局部变量

/**
 * @Author no_crush
 */
public class Demo05 {
    static int allClicks = 0; //类变量
    String str = "hello world"; //实例变量
    
    public void method(){
        int i = 0; //局部变量
    }
}

/**
 * @Author no_crush
 */
public class Demo08 {
    //类变量 static
    static double salary = 2500;

    //属性：变量

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

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

        //变量类型 变量名字 = new Demo08（）;
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.age);
        System.out.println(demo08.name);

        //类变量 static
        System.out.println(salary);
    }

    //其他方法
    public void add(){
    }
}

常量

常量（Costant）：初始化（initialize）后不能改变其值！不会变动的值
所谓常量可以理解成一种特殊的变量，它的值被设定后，程序运行过程中不允许被改变
常量名一般使用大写字符

final 常量名 = 值;
final double PI = 3.14;

变量的命名规范

所有变量、方法名、类名：见名知意
类成员变量：首字母小写和驼峰原则：monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMan
方法名：首字母小写和驼峰原则：run（），runRun（）

运算符

Java语言支持如下运算符
- 算术运算符：+，-，*，/，%，++，–
- 赋值运算：=
- 关系运算符：>,<,>=,<=,==,!=instanceof
- 逻辑运算符：&&，||，！
- 位运算符：&，|，^,~,>>,<<,>>>(了解)
- 条件运算符：？：
- 扩展赋值运算符：+=，-=，*=，/=

二元运算符

/**
 * no_crush
 * 2022-4-28 16:43
 */
package operator;

public class Demo01 {
    public static void main(String[] args) {
        //二元运算符
        //ctrl + D:复制当前到下一行
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;

        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);
    }
}

/**
 * no_crush
 * 2022-4-28 16:53
 */

package operator;

public class Demo02 {
    public static void main(String[] args) {
        long a = 1746378131;
        int b = 123;
        short c = 10;
        byte d = 8;

        System.out.println(a+b+c+d);//long
        System.out.println(b+c+d);//int
        System.out.println(c+d);//int

    }
}

关系运算符

/**
 * no_crush
 * 2022-4-28 16:43
 */
package operator;

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回结果正确： 正确，错误  布尔值
        //if

        int a = 10;
        int b =20;
        int c = 21;

        System.out.println(c%a);//c/a   21/20 = 2...1

        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);
    }
}

自增自减运算符、初识Math类

package operator;

public class Demo04 {
    public static void main(String[] args) {
        //++ -- 自增自减 一元运算符
        int a = 3;

        int b = a++;//先赋值，再++
        //a++  a=a+1
        System.out.println(a);
        //a=a+1
        int c = ++a;//先++，再赋值

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

        //幂运算2^3  2*2*2 = 8  很多运算，，我们会使用一些工具类来操作！
        double pow = Math.pow(2,3);
        System.out.println(pow);
    }
}

逻辑运算符、位运算符

逻辑运算

/**
 * no_crush
 * 2022-4-28 17:38
 */

package operator;

public class Demo05 {
    public static void main(String[] args) {
        //与（and）  或（or）  非（取反）
        boolean a = true;
        boolean b = false;

        System.out.println("a && b:"+(a&&b));//逻辑与运算：两个为真，结果为true
        System.out.println("a || b:"+(a||b));//逻辑或运算：两个其中一个为真，结果为true
        System.out.println("!（a && b）:" +!(a&&b));//逻辑非运算：如果为真，则变为假，如果为假，则变为真

        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4);//当前一个条件已经为false，则后面的条件不执行
        System.out.println(d);
        System.out.println(c);
    }
}

位运算

/**
 * no_crush
 * 2022-4-28 17:50
 */
package operator;

public class Demo06 {
    public static void main(String[] args) {
        /*
        A=0011 1100
        B=0000 1101

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

        2*8 = 16  2*2*2*2
        >>
        <<
        
        0000 0000   0
        0000 0001   1
        0000 0010   2
        0000 0011   3
        0000 0100   4
        0000 1000   8
        0001 0000   16
         */
        System.out.println(2<<3);
    }
}

扩展条件运算符

package operator;

public class Demo07 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        a+=b;//a=a+b
        a-=b;//a=a-b

        System.out.println(a);
        
        //字符串连接符  + ,Stirng
        System.out.println(""+a+b);
        System.out.println(a+b+"");//先运算，后连接
    }
}

三元运算符

/**
 * no_crush
 * 2022-04-28 18:00
 */
package operator;

//三元运算符
public class Demo08 {
    public static void main(String[] args) {
        //x?y:z
        //如果x==true,则结果为y，否则结果为z
        int score = 50;
        String type = score<60?"不及格":"及格";//必须掌握
        //if
        System.out.println(type);


    }
}

包机制

为了更好地组织语言，Java提供了包机制，用于区别类名的命名空间
包语句的语法格式为：

package pkg1[.pkg2[,pkg3…]];

一般利用公司域名倒置作为包名； com.baidu.www
为了能够使用一个包的成员，我们需要在Java程序中明确导入该包。使用“import”语句可完成此功能
.*导入这个包下所有的类

import package1[.package2…].(classname|*);

JavaDoc

JavaDoc命令是用来生成自己的API文档的
参数信息
- @author作者名
- @version版本号
- @since指明需要最早使用的jdk版本
- @param参数名
- @return返回值情况
- @throws异常抛出情况

package com.kuang.operator;

/**
 * @author no_crush
 * @version 1.0
 * @since 1.8
 */
public class Doc {
    String name;

    /**
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
}

Java流程控制（基础阶段）

Scanner对象

之前学习的基本语法中我们并没有实现程序和人的交互，但是Java给我们提供了这样一个工具类，我们可以获取用户的输入。java.util.Scanner是Java5的新特征，我们可以通过Scanner类来获取用户的输入。
基本语法：

Scanner s = new Scanner(System.in)

通过Scanner类的next（）与nextLine（)方法获取输入的字符串，在读之前我们一般用hasNext（）与hasNextLine（）判断是否还有输入的数据。

package com.kuang.Scanner;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {

        //创建一个扫描对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接收：");

        //判断用户有没有输入字符串
        if (scanner.hasNext()){
            //使用next方式接收
            String str = scanner.next();
            System.out.println("输出的内容为："+str);
        }
        //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
        scanner.close();
    }
}

package com.kuang.Scanner;

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        //从键盘接受数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用nextline方式接收：");

        //判断是否有输入
        if(scanner.hasNextLine()){
            String str = scanner.nextLine();
            System.out.println("输出的内容为："+str);
        }
        scanner.close();
    }
}

next（）：
- 1、一定要读取到有效字符后才可以结束输入
- 2、对输入有效字符之前遇到的空白，next（）方法会将其自动去掉
- 3、只有输入有效字符后才将其后输入的空白作为分隔符或者结束符
- 4、next（）不能得到带有空格的字符串
nextLine（）：
- 1、以Enter为结束符，也就是说nextLine（）方法返回的是输入回车之前的所有字符
- 2、可以获得空白

package com.kuang.Scanner;

import java.util.Scanner;

public class Demo03 {
    public static void main(String[] args) {

        //创建一个扫描对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入数据：");


        String str = scanner.nextLine();

        System.out.println("输出的内容为："+str);

        scanner.close();
    }
}

package com.kuang.Scanner;

import java.sql.SQLOutput;
import java.util.Scanner;

public class Demo04 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        //从键盘接受数据
        int i = 0;
        float f = 0.0f;

        System.out.println("请输入整数：");

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

        System.out.println("请输入小数：");

        if(scanner.hasNextFloat()){
            f = scanner.nextFloat();
            System.out.println("小数数据："+f);
        }else{
            System.out.println("您输入的不是小数数据：");
        }

        scanner.close();
    }
}

package com.kuang.Scanner;

import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {
        //我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果：
        Scanner scanner = new Scanner(System.in);

        //和
        double sum = 0;
        //计算输入了多少个数字
        int m = 0;
        System.out.println("请输入：");
        //通过循环判断是否还有输入，并在里面对每一次进行求和和统计
        while(scanner.hasNextDouble()){
            double x = scanner.nextDouble();
            m++;
            sum = sum + x;
            System.out.println("你输入了第"+m+"个数据，输入的结果为sum="+sum);
        }

        System.out.println(m+"个数和："+sum);
        System.out.println(m+"个数的平均值为："+(sum/m));

        scanner.close();

    }

}

顺序结构

Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行
顺序结构是最简单的算法结构
语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构

package com.kuang.struct;

public class ShunXuDemo {
    public static void main(String[] args) {
        System.out.println("hello1");
        System.out.println("hello2");
        System.out.println("hello3");
        System.out.println("hello4");
        System.out.println("hello5");
    }
}

选择结构

if单选泽结构
if双选择结构
if多选择结构
嵌套的if结构
Switch多选择结构

if单选泽结构

我们很多时候需要判断一个东西是否可行，然后才去执行，这样一个过程在程序中用if语句来表示

语法：

if（布尔表达式）{
//如果布尔表达式为true将执行的语句
}

package com.kuang.struct;

import java.util.Scanner;

public class IfDemo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入内容：");
        String s = scanner.nextLine();

        //equals:判断字符串是否相等
        if(s.equals("Hello")){
            System.out.println(s);
        }
        System.out.println("End");
        scanner.close();
    }
}

if双选择结构

那现在有一个需求，公司要收购一个软件，成功了，支付每人100万元，失败了，自己找人开发。这样的需求用一个if就搞不定了，我们需要有两个判断，需要选择一个双选择结构，所以就有了if-else结构
语法：

> if（布尔表达式）{
> 	//如果布尔表达式的值为true
> }else{
> 	//如果布尔表达式的值为false
> }

package com.kuang.struct;

import java.util.Scanner;

public class IfDemo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入成绩：");
        int score = scanner.nextInt();

        if(score>=60){
            System.out.println("成绩及格");
        }else{
            System.out.println("成绩不及格");
        }
        scanner.close();
    }
}

if多选择结构

我们发现刚才的代码不符合实际情况，真实的情况还可能存在ABCD，存在区间多级判断，在生活中我们很多时候的选择也不只有两个，所以我们需要一个多选择结构来处理这类问题

语法：

> if（布尔表达式 1）{
> 	//如果布尔表达1式的值为true
> }else if（布尔表达式 2）{
>	//如果布尔表达2式的值为true
> }else if（布尔表达式 3）{
> 	//如果布尔表达3式的值为true
> }else{
> 	//如果布尔表达式的值都不为true
> }

package com.kuang.struct;

import java.util.Scanner;

public class IfDemo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        /*
        if语句至多有1个else语句，else语句在所有的else if之后
        if语句可以有多个else if语句，它们必须在else语句之前
        一旦其中一个else if语句为true，其他的else if以及else语句都将跳转过执行
         */
        System.out.println("请输入成绩：");
        int score = scanner.nextInt();

        if(score==100){
            System.out.println("满分！！！");
        }else if (score<70 && score>=60){
            System.out.println("D");
        }else if(score>=70 && score<80){
            System.out.println("C");
        }else if(score>=80 && score<90){
            System.out.println("B");
        }else if(score<100 && score>=90){
            System.out.println("A");
        }else if(score>=0 && score<60){
            System.out.println("不及格哟，可惜可惜");
        }else{
            System.out.println("您输入的成绩有误");
        }
        scanner.close();
    }
}

嵌套的if结构

使用嵌套的if……else语句也是合法的，也就是说你可以在另一个if或者else if语句中使用if或者else if语句。你可以像if语句一样嵌套else if……else。

语法：

if(布尔表达式 1){
	//如果布尔表达式1的值为true执行代码
	if(布尔表达式2){
		//如果布尔表达式2的值为true执行代码
	}
}

思考？我们需要寻找一个数，在1~100之间

Switch多选择结构

多选择结构还有一个实现方法就是switch case语句
switch case语句判断一个变量与一系列值中某个值是否相等，，每个值成称为一个分支
switch语句中的变量类型可以是：
- byte、short、int或者char
- 从Java SE 7开始
- switch支持字符串String类型了
- 同时case标签必须为字符串常量或者字面量

switch(expression){
	case value:
	//语句
		break;//可选
	case value:
	//语句
		break;//可选
	//你可以有任意数量的case语句
	default://可选
		//语句		
}

package com.kuang.struct;

public class SwitchDemo01 {
    public static void main(String[] args) {
        //case穿透 //switch匹配一个未知的值
        char grade = 'C';

        switch (grade){
            case'A':
                System.out.println("优秀");
                break;//可选
            case'B':
                System.out.println("良好");
                break;
            case'C':
                System.out.println("及格");
                break;
            case'D':
                System.out.println("再接再厉");
                break;
            case'E':
                System.out.println("挂科");
                break;
            default:
                System.out.println("未知等级");
                break;

        }
    }
}

package com.kuang.struct;

public class SwitchDemo02 {
    public static void main(String[] args) {
        String name = "卡莎";
        //JDK7的新特性，表达式结果可以是字符串！！！
        //字符的本质还是数字

        //反编译 java---class（字节码文件）---反编译（IDEA）

        switch(name){
            case "kaisa":
                System.out.println("kaisa");
                break;
            case "卡莎":
                System.out.println("卡莎");
                break;
            default:
                System.out.println("弄啥嘞！");
        }
    }
}

反编译
- 百度百科
- IDEA反编译class文件

循环结构

while循环
do……while循环
for循环
在java5中引入了一种主要用于数组的增强型for循环

while循环

while循环是最基本的循环，它的结构为：

while(布尔表达式){
		//循环表达式
}

只要布尔表达式为true，循环就会一直执行下去
我们大多数情况是会让循环停下来的，我们需要让一个表达式失效的方式来结束循环
少部分情况下需要循环一直执行，比如服务器请求响应监听等
循环条件一直为true就会造成无限循环【死循环】，我们正常的业务编程中应该尽量避免死循环。会影响程序性能或造成程序卡死崩溃！
思考：计算1+2+3+……+100=？

package com.kuang.struct;

public class WhileDemo01 {
    public static void main(String[] args) {
        //输出1~100
        int i = 0;
        while(i<100){
            i++;
            System.out.println(i);
        }
    }
}

package com.kuang.struct;

public class WhileDemo02 {
    public static void main(String[] args) {
        while(true){
            //等待客户端连接
            //定时检查
        }
    }
}

package com.kuang.struct;

public class WhileDemo03 {
    public static void main(String[] args) {
        //计算1+2+3+……+100=？

        //高斯的故事

        int i = 0;
        int sum = 0;

        while(i<=100){
            sum = sum + i;
            i++;
        }
        System.out.println(sum);
    }
}

do……while循环

对于while语句而言，如果不满足条件，则不能进入循环。但有时我们需要即使不瞒满足条件，也至少执行一次
do……while循环和while循环相似，不同的是，do……while循环至少会执行一次

do{
	//代码语句
}while（布尔表达式）;

while和do……while的区别：
- while先判断后执行。dowhile先执行后判断！
- do……while总是保证循环体至少执行一次！这是他们的区别

package com.kuang.struct;

public class DoWhileDemo01 {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;

        do{
            sum = sum + i;
            i++;
        }while(i<=100);

        System.out.println(sum);
    }
}

package com.kuang.struct;

public class DoWhileDemo02 {
    public static void main(String[] args) {
        int a = 0;
        while(a<0){
            System.out.println(a);
            a++;
        }
        System.out.println("==============");
        do{
            System.out.println(a);
            a++;
        }while(a<0);
    }
}

for循环

虽然所有循环结构都可以用while或者do……while表示，但Java提供了另一种语句——for循环，使一些循环结构变得更加简单
for循环语句支持迭代的一种通用结构，最有效、最灵活的循环结构
for循环执行的次数是在执行前确定的。语法格式如下：

for(初始化;布尔表达式;更新){
	//代码语句
}

练习

计算0到100之间所有奇数偶数的和

package com.kuang.struct;

public class ForDemo02 {
    public static void main(String[] args) {
        //练习1：计算0~100之间奇数和偶数的和

        int oddsum = 0;
        int evensum = 0;

        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                oddsum+=i;
            }else{
                evensum+=i;
            }
        }
        System.out.println("奇数的和："+oddsum);
        System.out.println("偶数的和："+evensum);
    }
}

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

package com.kuang.struct;

public class ForDemo03 {
    public static void main(String[] args) {
        //练习2：用while或for循环输出1~1000之间能被5整除的数，并且每行输出3个

        for (int i = 0; i <= 1000; i++) {
            if(i%5==0){
                System.out.print(i+"\t");
                int j = 0;
                //方法1
//                j++;
//                if(j%3==0){
//                    System.out.println("\n");
                }
            //方法2（狂神的方法）
                if(i%(5*3)==0){
                    System.out.println();
                   // System.out.println(\n);
                }
            }
        //println 输出完全换行
        //print 输出不会换行

        }
    }

打印九九乘法表

package com.kuang.struct;

/*
1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81	
 */

public class ForDemo04 {
    public static void main(String[] args) {
        //练习3：打印九九乘法表
        //1.先打印第一列，这个大家应该都会
        //2.我们把固定的1再用一个循环包起来
        //3.去掉重复项，i<=j
        //4.调整样式

        for (int j = 1; j <= 9; j++) {  //j=1
            for (int i = 1; i <= j; i++) {
                System.out.print(i+"*"+j+"=" +(j*i) +"\t");
            }
            System.out.println("\n");
        }
    }
}

增强for循环

这里我们只是先见一面，做个了解，之后数组我们重点使用
Java引入了一种主要用于数组或集合的增强型for循环
Java增强for循环语法格式如下：

for(声明语句:表达式)
{
	//代码句子
}

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等
表达式：表达式是要访问的数组名，或者是返回值为数组的方法

package com.kuang.struct;

public class ForDEmo05 {
    public static void main(String[] args) {
        int[] numbers = {10,20,30,40,50};//定义一个数组

        for(int i = 0;i < 5; i++){
            System.out.println(numbers[i]);
        }
        System.out.println("===================");
        
        //遍历数组的元素
        for(int x :numbers){
            System.out.println(x);
        }
    }
}

break continue

break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环,不执行循环中剩余的语句。(break语句也在switch语句中使用)
continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句,接着进行下一次是否执行循环的判定。
关于goto关键字：
- goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字，但并未在语言中得到正式使用;Java没有goto。然而，在break和continue这两个关键字的身上，我们仍然能看出一些goto的影子–带标签的break和continue.
- "标签” 是指后面跟-个冒号的标识符,例如: label:
- 对Java来说唯–用到标签的地方是在循环语句之前。而在循环之前设置标签的唯-理由是:我们希望在其中嵌套另-个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方
break

package com.kuang.struct;

public class BreakDemo {
    public static void main(String[] args) {
        int i = 0;
        while(i<100){
            i++;
            System.out.println(i);
            if(i==30){
                break;
            }
        }
        System.out.println("123");
    }
}

continue

package com.kuang.struct;

public class ContinueDemo {
    public static void main(String[] args) {
        int i = 0;
        while(i<100){
            i++;
            if(i==10){
                System.out.println("==================");
                continue;
            }
            System.out.println(i);
        }
        //break在任何语句中的主体部分，均可用吧break控制循环的流程
        //break用于强行退出循环，不执行循环中剩余的语句。（break语句也在switch语句中使用）；
        //continue语句用在循环体语句中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判断
    }
}

goto关键字

package com.kuang.struct;

public class LabelDemo {
    public static void main(String[] args) {
        //大莹101~150之间的所有质数
        //质数是指在大于1的自然数中，除了1和他本身以外不再有其他因数的自然数

        int count = 0;
        
        //不建议使用
       outer: for(int i = 101;i<150;i++){
            for(int j = 2;j < i/2;j++){
                if(i % j == 0){
                    continue outer;
                }
            }
           System.out.println(i+" ");
        }
    }
}

流程控制练习

打印三角形

package com.kuang.struct;

public class TestDemo01 {
    public static void main(String[] args) {
        //打印三角形 5行

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

        }

    }
}