day01_Java基础

day01_Java基础

一、今日课程内容

• 1- Java语言概述（了解）
• 2- Java环境搭建（操作）
• 3- Java的入门案例（熟悉）
• 4- Java的基础语法（掌握）
• 5- 键盘录入操作（熟悉）
• 6- 流程控制（掌握）

二、Java语言概述（了解）

1、Java语言概述

​ 计算机高级语言按照程序执行方式分为解释型语言和编译型语言两种。之前我们学的Python就属于解释型语言，Java等属于编译型语言。

​ 解释型语言是指使用专门的解释器对源程序逐行解释成特定平台的机器码并立即执行的语言。

​ 编译型语言是指使用专门的编译器，针对特定平台（操作系统）将某种高级语言源代码一次性“翻译”成可被该平台硬件执行的机器码（机器指令和操作数），并包装成该平台所能识别的可执行性程序的格式，这个转换过程成为编译。

​ Sun公司(Stanford University NetWork): 美国的斯坦福大学)在1995年推出的高级编程语言.

​ Java之父: 詹姆斯·高斯林(James Gosling)

​ sun公司在2009年被Oracle公司收购了

**
**

2、为什么要学习Java语言

• 使用非常广泛, 相对简单易学
• 能够看得懂大数据框架的源码, 因为大数据中很多框架都是基于Java语言开发的
• 为后续Flink课程打基础

3、Java平台版本说明

• J2SE：标准版，也就是其他两个版本的基础，在JDK1.5的时候，正式更名为 JavaSE
• J2ME：小型版，一般是用于研发嵌入式程序，已经被android替代了，在JDK1.5更为为 JavaME
• J2EE：企业版，一般开发企业级互联网程序，在JDK1.5的时候正式更为为 JavaEE（SpringBoot、SpringCloud、MyBatis。。。）

4、Java特点

• 1- 开源：JAVA源代码是开放的
• 2- 跨平台：
  • 用Java编写的程序，可以在不同的操作系统上运行
  • 原理：由JVM保证Java程序的跨平台性，但是JVM本生并不能跨平台
• 3- 多线程
• 4- 面向对象：继承 多态 接口

三、Java环境搭建（操作）

1、JDK和JRE的概述

• JDK：Java开发工具包(Java Development Kit), 包含开发工具 和 JRE.

  • 常用的开发工具: javac, java

• JRE：Java运行时环境(Java Runtime Environment), 包含运行Java程序时所需的核心类库和 JVM.

  • 核心类库: java.lang, java.util, java.io

• JVM：Java虚拟机(Java Virtual Machine)

  • 作用: 用来保证Java程序跨平台性的, 但是JVM本身并不能跨平台.

  

JRE与JDK区别图解

2、JDK的下载和安装

• 1- 下载JDK:

  • Oracle官网地址: www.oracle.com
  • 直接下载JDK地址: https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html

• 2- 执行安装操作

  • 2.1 傻瓜式安装即可, 一步一步下一步即可安装成功
  • 2.2 安装路径:
    • 不要安装到C盘, 不要用中文空格
  • 2.3 目录说明
    • bin: 存放的是编译器和工具
    • db: 存数数据
    • include: 编译本地方法.
    • jre: Java运行时文件
    • lib: 存放类库文件
    • src.zip: 存放源代码的.

• 3- JDK卸载: 可直接在控制面板中卸载即可

• 4- 配置环境变量:

  

配置后, 一路点击确定退出即可

• 5- 测试操作:
  • 方式一: 在DOS窗口中输入"javac 或者 java", 能看到对应的指令即可.
  • 方式二: 在DOS窗口中输入"java -version", 可以看到当前配置的JDK的版本

3、IDEA的安装

​ IDEA 全称 IntelliJ IDEA，是Java编程语言开发的集成环境。IntelliJ在业界被公认为最好的java开发工具，尤其在智能代码助手、代码自动提示、重构、J2EE支持、各类版本工具(git、svn等)、JUnit、CVS整合、代码分析、 创新的GUI设计等方面的功能可以说是超常的。

​ IDEA是JetBrains公司的产品，这家公司总部位于捷克共和国的首都布拉格，开发人员以严谨著称的东欧程序员为主。它的旗舰版本还支持HTML，CSS，PHP，MySQL，Python等。免费版只支持Python等少数语言。

总结: IDEA这个软件是用Java语言开发的, 所以想使用IDEA, 你电脑上必须安装JRE.

jetbrains公司官网地址: www.jetbrains.com

IDEA下载地址: www.jetbrains.com/idea/download/other.html

安装步骤:

4、IDEA的启动

• 1- 不导入任何配置, 选择Do not import settings, 然后选择OK.
  

• 2- 设置用户界面主题, 可以根据自己的喜好进行设置, 然后选择Next: Default plugins

• 3- 这个界面是告诉我们, 当前的IDEA可以开发哪些程序, 默认这些模块都是选中的, 如果明确知道不需要使用某些模块, 可以通过Disable All禁用掉此模块. 这里我们不需要禁用, 直接选择Next: Featured plugins即可.
  

• 4- 这个界面是JetBrains公司提供给我们的可选择性安装的5个小插件, 我们可以根据需求进行选择, 这里建议安装最后一个插件IDE Features Trainer, 它可以帮助我们快速使用IDEA. 然后选择Start using IntelliJ IDEA即可.
  

• 5- 因为IDEA的旗舰版是收费的, 这里我们选择Evaluate for free(免费试用30天)
  

四、Java入门案例（熟悉）

1、创建项目和模块

或者:

如果有以下界面, 可以参考:

第一次进入项目, 会弹出以下内容:

2、编写代码

• 1- 在src源代码包下创建自定义包 com.itheima.demo01
  
  

• 2- 在com.itheima.demo01包下创建HelloWorld类.
  
  

• 3- 编写代码

package com.itheima.day01;

public class HelloWorld {
    /*
        main方法，程序的入口
        快捷键：输入main，等有下拉框的提升，然后按回车即可
     */
    public static void main(String[] args) {
        // 快捷键：输入sout，等有下拉框的提升，然后按回车即可
        System.out.println("Hello Java");
    }
}

• 4- 运行代码: 然后在代码编辑区右键, 选择Run HelloWorld.main(), 执行程序即可.

目录说明:

3、IDEA常见的快捷键

五、（重要）Java基础语法（掌握）

1、注释

注释常见分类为三种：分别是单行注释、多行注释、文档注释

//单行注释


/*
	多行注释
	多行注释
*/


/**
	文档注释
	文档注释
*/

文档注释的作用: 对代码进行解释用的，例如方法的作用是什么，需要传递什么样的参数

package com.itheima.day01;

public class HelloWorld {
    /*
        main方法，程序的入口
        快捷键：输入main，等有下拉框的提升，然后按回车即可
     */
    public static void main(String[] args) {
        // 快捷键：输入sout，等有下拉框的提升，然后按回车即可
        System.out.println("Hello Java");

        // 单行注释
        System.out.println("单行注释代码");

        /*
            多行注释
            注释1
            注释2
            ....
         */

        System.out.println(myAdd(1, 2));
    }

    /**
     * 实现对两个数据相加的操作
     * @param num1 数字1
     * @param num2 数字2
     * @return 求和的结果
     */
    public static int myAdd(int num1, int num2){
        return num1+num2;
    }
}

2、分隔符

Java 语言里的分号(😉 花括号（{}）、方括号（[]）、圆括号（()）、 圆点（.）都具有特殊的分割作用，被统称为分隔符。

• 分号（;） 是Java语言分隔语句的，每个 Java 语句都是使用分号作为结尾。

• 花括号（{}）作用是定义了一个代码块，一个代码块指的是”{” 和 “}” 所包含的代码片段，代码块逻辑上是一个整体，花括号是成对出现的。

• 方括号（[]）作用是用于访问数组元素，方括号通常跟着数组变量名；

• 圆括号（()) 功能较多，定义方法使用圆括号来包含参数声明；调用方法传递实参值；圆括号可以作为强制类型转换运算符等；

• 圆点（.）作用类/对象和它的成员（包含成员变量、方法和内部类）之间的分隔符，表明调用某个类或某个实例的指定成员。

3、Java关键词

就是被Java语言赋予了特殊含义的单词

特点:

•关键字是由纯英文字母组成的, 而且全部都是小写的.
•常用的开发工具(Notepad++, IDEA)针对于关键字都会高亮显示.

常见的关键词:

• public: 公共的权限, 目前先了解即可.

• class: 表示在创建一个类.

• static: 表示静态的意思.

• void: 表示方法的返回值类型.

其他关键词:

4、标识符

标识符就是用来给类、接口、方法、变量、包等起名字的规则

命名规则:

1.标识符只能包含52个英文字母(区分大小写)、0 ~ 9数字 、$（美元符号）和_（下划线）。  
2.标识符不能以数字开头。
3.标识符不能和Java中的关键字重名。
4.最好做到见名知意.
 	例如: name表示姓名, age表示年龄.

命名规范:

1.类, 接口的命名规范: 每个单词的首字母都大写, 其他字母全部小写(大驼峰命名法)
 	例如: HelloWorld, VariableDemo.
2.变量, 方法的命名规范: 从第二个单词开始, 每个单词的首字母都大写, 其他字母全部小写(小驼峰命名法).
 	例如: zhangSanAge, studentName
3.常量(指的是: 自定义常量)的命名规范: 所有字母都大写, 单词之间用_(下划线)隔开.
 	例如: MAX_VALUE, MIN_VALUE, PI   
 	注意: 目前先了解即可, 面向对象部分详细解释.
4.包的命名规范: 所有字母全部小写, 多级包之间用.(点符号)隔开, 一般是公司的域名反写.
 	例如: cn.itcast、com.itheima

5、变量

在程序的执行过程中，其值可以在某个范围内发生改变的量就叫变量

Java中要求一个变量每次只能保存一个数据，而且必须要明确保存数据的数据类型

格式:

方式一: 声明变量并赋值
数据类型 变量名 = 初始化值;
 
//示例: 声明(定义)一个int类型的变量, 变量名叫a, 初始化值为: 10
int a = 10;

方式二: 先声明, 后赋值
数据类型 变量名;
变量名 = 初始化值;

//示例
//1. 声明(定义)一个int类型的变量, 变量名叫a
int a;						
//2. 把数字10赋值给变量a	  
a = 10;						

示例:

package com.itheima.day01;

public class HelloWorld {
    /*
        main方法，程序的入口
        快捷键：输入main，等有下拉框的提升，然后按回车即可
     */
    public static void main(String[] args) {
        // 变量的定义
        String eatFood;
        String statue = "今天没有上火";
        
        if(statue=="今天上火了"){
            eatFood = "吃清淡的";
        }else{
            eatFood = "吃海底捞火锅";
        }
        System.out.println(eatFood);
    }
}

6、数据类型说明

Java是一种强类型语言, 针对于每一个数据都给出了明确的数据类型

• 基本数据类型(简称: 基本类型)

​ byte, short, char, int, long, float, double, boolean

• 引用数据类型(简称: 引用类型)

​ String, 数组, 类, 接口

图解:

基本类型占用字节大小以及取值范围:

注意事项:

1.变量未赋值，不能使用.
2.变量只在它所属的范围内有效.
3.一行上可以定义多个变量，但是不建议.
4.char类型的注意事项
    4.1- 值只能用单引号包起来
    4.2- 值的内容只能有一个字符

package cn.itcast.base;

public class ArgDemo {
    public static void main(String[] args) {
        // 1-变量的定义方式一：声明变量并且赋值
        int argA = 10;
        System.out.println(argA);

        // 2-变量的定义方式二：先声明变量，再赋值
        double argB;

        if(argA>=10){
            argB = 10.1;
        }else{
            argB = 9.0;
        }

        System.out.println(argB);

//        1.变量未赋值，不能使用.
//        int c;
//        System.out.println(c);

//        2.变量只在它所属的范围内有效.

        if(argA>=10){
            int d = 2;
            System.out.println(d);
        }

//        System.out.println(d);

//        3.一行上可以定义多个变量，但是不建议.
        int e=10,f=11;
        System.out.println(e);
        System.out.println(f);
    }
}

7、数据类型转换

​ 不同类型的数据之间可能会进行运算，而这些数据取值范围不同，存储方式不同，直接进行运算可能会造成数据损失，所以需要将一种类型转换成另外一种类型再进行运算。

注: Java程序中要求参与计算的数据，必须保证数据类型的一致性，如果数据类型不一致将发生类型转换。

类型转换主要有二类: 自动（隐式）类型转换 和 强制（显式）类型转换

7.1 自动(隐式)类型转换

指的是小类型转大类型，会自动提升为大类型，运算结果是大类型.

大白话翻译: 将取值范围小的类型自动提升为取值范围大的类型

例如:

1.定义两个int类型的变量a和b, 分别赋值为10, 20.
int a=10,b=20;

2.通过输出语句打印变量a和b的和.
System.out.println(a+" "+b);
    
3.定义int类型的变量c, 接收变量a和b的和. 
int c=a+b;

4.打印变量c的值.
System.out.println(c);

5.定义两个变量aa和bb, 一个是int类型的数据, 另一个是byte类型的数据.
int aa=1;
byte bb=2;

6.定义变量cc接收 变量aa和bb的和。分别设置变量cc的数据类型为byte类型和int类型, 观察结果并打印.
int cc1 = aa+bb;
System.out.println(cc1);

byte cc2 = aa+bb;
System.out.println(cc2);

演示案例:

public class Demo02_类型转换 {
    // 演示 类型转换:  自动(隐式)类型转换   强制类型转换
    public static void main(String[] args) {
        // 自动(隐式)类型转换
        byte a = 10;
        short b = 15;
        char c = 20;
        int d = 13;
        long e = 50L;
        
        float f = 3.5F;
        double g = 5.5;
        
        
        
        int v1 = a + b;
        int v2 = a + c;
        int v3 = b + c;
        int v4 = a + d;
        int v5 = b + d;
        long v6 = c + e;
        long v7 = d + e;

        float v8 = e + f;
        double v9 = e + g;
        double v10 = f + g;


        System.out.println(v1);
        System.out.println(v2);
        System.out.println(v3);
        System.out.println(v4);
        System.out.println(v5);
        System.out.println(v6);
        System.out.println(v7);
        System.out.println(v8);
        System.out.println(v9);
        System.out.println(v10);
    }
}

转换规则:

1.范围小的类型向范围大的类型提升，byte、short、char 运算时直接提升为int 。
2.boolean类型的数据只有true和false这两个, 所以boolean类型的数据不参与类型转换.

即: byte、short、char --> int --> long --> float --> double

7.2 强制(显式)类型转换

指的是手动将大类型转换成小类型，运算结果是小类型.

大白话翻译: 将取值范围大的类型强制转换成取值范围小的类型.

注意: 在进行大类型转换为小类型的时候, 可能出现数据丢失, 甚至直接报错(可能超过了小类型的范围大小)

格式:

数据类型 变量名 = （数据类型）要被转换的数据值；

示例: 尝试把小数1.5赋值给int类型的变量a, 并打印结果.

public class NarrowConversion{
    private static String main(String[] args) {
        int iValue =232;
        //强制把一个 int 类型的值转换成 byte 类型的值
        byte bValue=(byte)iValue;
        // 将输出-23
        System.out.println(bValue);
        
        
        double dValue=3.98;
        // 强制把一个 double 类型的值转换成 int 类型的值
        int tol = (int)dValue;
        // 将输出 3
        System.out.println(tol);
    }
}

案例演示:

package com.itheima;

public class Demo02_类型转换 {
    // 演示 类型转换:  自动(隐式)类型转换   强制类型转换
    public static void main(String[] args) {
  
        byte a = 10;
        short b = 15;
        char c = 20;
        int d = 13;
        long e = 50L;

        float f = 3.5F;
        double g = 5.5;


        // 强制类型转换
        byte q1 = (byte)(a + d);
        System.out.println(q1);
        short q2 = (short) (a + b);
        System.out.println(q2);
        
        long q3 = (long) (e + f);
        System.out.println(q3);

        byte q4 = (byte) (e +a);
        System.out.println(q4);

    }
}

注意: 将小数强转成整数的时候，会直接将小数位数全部丢弃

8、了解ASCII码表

https://www.zhihu.com/tardis/bd/art/388458283?source_id=1001

观察下述代码, 打印结果是多少呢?

public static void main(String[] args) {
  //字符类型变量
  char c = 'a';
  int i = 1;
  //字符类型和int类型计算
  System.out.println(c+i);
}

在计算机的内部都是二进制的0, 1数据，如何让计算机可以直接识别人类文字呢？

于是就产生出了编码表的概念。

• 编码表：就是将人类的文字和一个十进制数进行对应起来组成一张表格。 ‘a’ -> 97 char:0-65535

• 存储字符时：需要查找ASCII码表,找到字符对应的数字,将数字转换为二进制数存放到计算机中

• 使用字符时：将对应的二进制数转换为十进制 找到ASCII表中对应的字符 显示出来

• 将所有的英文字母，数字，符号都和十进制进行了对应，因此产生了世界上第一张编码表ASCII码表.

• ASCII（American Standard Code for Information Interchange 美国标准信息交换码）, 规则如下:

注意：

在char类型和int类型计算的过程中，char类型的字符先查询编码表，得到97，再和1求和，结果为98。

char类型提升为了int类型。char类型内存2个字节，int类型内存4个字节。

package com.itheima;

public class Test03_ASCII码 {
    public static void main(String[] args) {
        // 注意 ASCII码 主要针对char类型的数据

        char c1 = 'A';
        System.out.println(c1 + 10); // 75  说明  'A' = 65

        char c2 = 'a';
        System.out.println(c2 + 10); // 107 说明 'a' = 97

        char c3 = 'b';
        System.out.println(c3 + 10); // 108 说明 'b' = 98

        char c4 = '0';
        System.out.println(c4 + 10); // 58 说明 '0' = 48

        // 注意: 其实看到的这些数值 对应的就是ASCII码表中对应字符的十进制的表示内容
    }
}

9、运算符

9.1 分类

• 算术运算符

+, -, *, /, %, ++, --

• 赋值运算符

 =, +=, -=, *=, /=, %=

• 比较(关系)运算符

==, !=, >, >=, <, <=

• 逻辑运算符

&&, ||, !

• 三元(三目)运算符

注意: Java中的运算符绝大多数和Python中的运算符用法都一样, 只有个别运算符的用法不同, 我们主要是学习这些用法不同运算符.

package com.itheima;

public class Test04_运算符 {
    public static void main(String[] args) {

        System.out.println("演示一: 算术运算符  ++ --");
        // 1. 构建一个int类型的变量
        int a = 10;
        System.out.println(a++); //  10
        System.out.println(a); //    11

        int b = 10;
        System.out.println(++b); // 11
        System.out.println(b); //  11

        /*
            说明: ++  -- 是用于对数据进行 +1 或者 -1的操作

            在使用的时候, 都可以在变量的前面和后面设置: a++ 或者  ++a

            区别:
                a++: 先让 a 参与运算, 运算后执行 +1操作
                ++a: 先执行a +1的操作, 然后基于+1后结果参与运算
         */

        System.out.println("演示二: 逻辑运算符 && ||  ! ");
        // 格式:
        //      boolean flag =  条件1  [&&  ||] 条件2  [&&  ||] 条件3 ...
        //      !条件1      用于取反操作

        int c = 10;
        int d = 15;
        int e = 25;

        boolean flag = c > d && c > e;  // 当两个条件都不成立的时候, 结果为False
        System.out.println(flag);
        flag = c < d && c > e;
        System.out.println(flag); // 当其中一个条件不成立的时候, 结果为false
        flag = c < d && c < e;
        System.out.println(flag); // 当所有的条件都成立的时候, 返回true


        flag = c > d || c > e;  // 当两个条件都不成立的时候, 结果为False
        System.out.println(flag);
        flag = c < d || c > e;
        System.out.println(flag); // 当其中一个条件成立的时候, 结果为 true
        flag = c < d || c < e;
        System.out.println(flag); // 当所有的条件都成立的时候, 返回true

        flag = !(c < d);
        System.out.println(flag);


        flag = c < d && e < d || c < e;
        System.out.println(flag);
        /*
            &&:  并且   只有当所有的条件都成立的时候, 才会返回true, 否则均为false
            ||:  或者   只有当所有的条件都不成立的时候, 才会返回false, 否则均为true
            !: 非  取反操作
         */

        System.out.println("演示三: 三元运算符 ");
        // 需求: 当  d > e的时候, 返回 "d比e大" 否则 返回 "d比e小"
        // python:  'd比e大' if d < e else 'd比e小'
        // java 三元表达式格式:  条件 ? true: false
        String s = d > e ? "d比e大" : "d比e小";
        System.out.println(s);

        if (d > e){
            System.out.println("d比e大");
        }else {
            System.out.println("d比e小");
        }


    }
}

package cn.itcast.base;

public class OperatorDemo {
    public static void main(String[] args) {
        /*
         ++ --
         这两个可以放在变量的前面，也可以放在后面，但是两种计算顺序不同
         ++: 对变量值加一
         --: 对变量值减一

         如果将运算符放在变量的后面，是先赋值，再计算。
         int b = a++;
         先将a的值赋值给b，因此b的值是10，再对变量a做加一的操作，因此a变成了11

         int d = ++c;
         先对c做加一的操作，c变成了11，再将c的值赋值给d，因此d的值也是11
         */
        int a = 10;
        int b = a++;

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

        int c = 10;
        int d = ++c;
        System.out.println(c);
        System.out.println(d);


        /*
            逻辑运算符演示
            && || ！

            &&：表达式中全部为true的时候，结果才是true；只要有一个是false，结果就是false
            ||: 表达式中只要有一个是true，结果就是true
         */
        int e = 10;
        int f = 11;
        int g = 12;
        int h = 13;

        boolean flag1 = f>e && g>h;
        System.out.println(flag1);

        boolean flag2 = f>e && h>g;
        System.out.println(flag2);

        boolean flag3 = e>f && h++>g;
        System.out.println(flag3);
        System.out.println(h);

        System.out.println("------------------------------------------");
        boolean flag4 = e>f || h>g;
        System.out.println(flag4);

        boolean flag5 = e>f || g>h;
        System.out.println(flag5);

        boolean flag6 = f>e || g++>h;
        System.out.println(flag6);
        System.out.println(g);

        boolean flag7 = e>f || g++>h;
        System.out.println(flag7);
        System.out.println(g);

        boolean flag8 = e>f;
        System.out.println(flag8);

        System.out.println(!flag8);

        /*
            三元（三目）运算符
            boolean类型的表达式 ? true条件下执行的表达式 : false条件下执行的表达式
         */
        String result = !(e>f) ? "e大于f" : "e小于f";
        System.out.println(result);

    }
}

9.2 算术运算符

自增自减运算符

解释:

++ 运算，变量自己增长1。反之，-- 运算，变量自己减少1，用法与++ 一致, 此处以++举例.

• 独立运算：
  • 变量在独立运算时，前++和后++没有区别 。
  • 变量前++ ：例如 ++i 。
  • 变量后++ ：例如 i++ 。
• 混合运算：
  • 和其他变量放在一起，前++和后++就产生了不同。
  • 变量前++ ：变量a自己加1，将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是2。

public static void main(String[] args) {
    int a = 1;
    int b = ++a;
    System.out.println(a);//计算结果是2
    System.out.println(b);//计算结果是2
}

变量后++ ：变量a先把自己的值1，赋值给变量b，此时变量b的值就是1，变量a自己再加1。a的结果是2，b的结果是1。
public static void main(String[] args) {
    int a = 1;
    int b = a++;
    System.out.println(a);//计算结果是2
    System.out.println(b);//计算结果是1
}

package com.itheima;

public class Demo04_运算符 {
    // 演示运算符
    public static void main(String[] args) {
        //1. 算术运算符:  ++  --
        int a = 10;
        //a++;  // 等于:  a = a + 1 /  a += 1

        // System.out.println(a); // 11
        // System.out.println(a++); // 11
        // System.out.println(a); // 12
        // System.out.println(++a); // 13

        /*
            a++:  先使用 a参与运算, 运算后, 然后对a + 1
            ++a; 先对 a进行 + 1 操作, +1 后, 再参与运算
         */

        //int i1 = 10 + a++;
        int i2 = 10 + ++a;
        //System.out.println(i1); // 20
        System.out.println(i2); // 21
        // 说明  -- 与之类似, 只不过是 -1 操作
        System.out.println(a--); //  11
        System.out.println(--a); // 9
    }
}

9.3 赋值运算符

Java和Python中的赋值运算符用法一致, 只不过默认包含有强制类型转换, 具体如下:

下面的程序有问题吗？

public static void main(String[] args){
  short s = 1;
  s+=1;
  System.out.println(s);
}

分析： s += 1 逻辑上看作是s = s + 1 计算结果被提升为int类型，再向short类型赋值时发生错误，因为不能将取值范围大的类型赋值到取值范围小的类型。但是，s=s+1进行两次运算，+= 是一个运算符，只运算一次，并带有强制转换的特点，也就是说s += 1 就是s = (short)(s + 1)，因此程序没有问题编译通过，运行结果是2.

// 2- 赋值运算符  (底层带有强制转换)
short b = 5;
b = (short) (b + 1);
System.out.println(b);

b +=1; // ==  b = (short) (b + 1);
System.out.println(b);

9.4 关系运算符

​ Java中的关系运算符和Python中的关系运算符用法一致，这里不做过多的介绍了

9.5 逻辑运算符

• 逻辑运算符是用来判断并且, 或者, 除非等逻辑关系的符号.

• 该符号两端一般连接值为布尔类型的关系表达式.

案例演示:

public class OperatorDemo03 {
    public static void main(String[] args) {
        //1. 定义两个int类型的变量a和b, 初始化值分别为: 2, 5
        int a = 2, b = 5;
        //2. 演示逻辑与(&)
       /* System.out.println((a++ > 2) & (b++ < 7)); //两个表达式都会执行.
        System.out.println(a);
        System.out.println(b);*/
        System.out.println("------------------");

        //3. 演示短路与(&&)
        System.out.println((a++ > 2) && (b++ < 7)); //左边表达式结果为false, 右边不执行.
        System.out.println(a);
        System.out.println(b);
    }
}

演示:

int d = 100;
int e = 200;
// &&  两边的条件 如果都成立, 返回true 如果有任意条件不成立, 都会返回false
boolean tmp1 = d >= 100 && e > 200;
// || 两边的条件, 如果都不成立, 返回false, 只要有任意一方成立, 均返回true
boolean tmp2 = d > 100 || e > 200;
// ! 取反操作
boolean tmp3 = !(d > 100);

System.out.println(tmp1);
System.out.println(tmp2);
System.out.println(tmp3);


注意:  && || 都可以支持并联写多个条件 同样也可以混合使用
  	例如:  
		条件1 && 条件2 && 条件3 && ....
        条件1 || 条件2 || 条件3 || ....
        条件1 && 条件2 || 条件3 || .... 
        !条件1 && 条件2 || 条件3...

9.6 三元运算符

格式

三元运算符也叫三目运算符，即由三部分组成，格式如下：

关系表达式? 表达式1：表达式2；

先执行关系表达式, 看其结果是true还是false.
1.如果是true, 则执行表达式1
2.如果是false, 则执行表达式2

需求

• 1 定义两个int类型的变量a. b, 初始化值分别为10, 20

• 2 通过三元运算符, 获取变量a和b的最大值.

• 3 将结果(最大值)打印到控制台上.

public class OperatorDemo04 {
    public static void main(String[] args) {
        //1. 定义两个int类型的变量a. b, 初始化值分别为10, 20
        int a = 10, b = 20;
        //2. 通过三元运算符, 获取变量a和b的最大值.
        int max = a < b ? b : a;
        //3. 将结果(最大值)打印到控制台上.
        System.out.println(max);
    }
}

package com.itheima.day01;

public class 运算符 {
    public static void main(String[] args) {
        // 算术运算符
        int a = 10;
        // ++/--放在变量后面的情况，先进行赋值操作，再进行加1或者减1的操作
        // ++/--放在变量前面的情况，先进行加1或者减1的操作，再进行赋值操作
//        int b = a++;
//        int b = ++a;
        int b = --a;
        System.out.println(a);
        System.out.println(b);

        // 逻辑运行算
        /*
            &&：与。左右两边全部都成立的时候，最终结果才是true；否则就是false
            ||：或。左右两边只要有任意一个成立，那么最终的结果就是true
            !：非。取反的操作。
         */
        System.out.println(5>6 && 7<8); // false
        System.out.println(5<6 && 7<8); // true
        System.out.println(5>6 || 7<8); // true
        System.out.println(5>6 || 7>8); // false
        System.out.println(!(5>6)); // true
        System.out.println(!(5>6 || 7>8)); // true

        // 三元运算符：是对简单的if判断语句进行了简化
        int age = 100;
        String result = age>=18?"成年了，可以打游戏":"未成年，回去写作业吧";
        System.out.println(result);

        String result2 = age>=18?(age>=90?"别打游戏了，心脏不好":"可以玩点刺激的"):"未成年，回去写作业吧";
        System.out.println(result2);
    }
}

六、键盘录入（熟悉）

类似于Python中的input(),raw_input(), Java中也是支持键盘录入的.

1、使用步骤

• 1 导包。包就是文件夹.

注意:
a) Scanner类是java.util包下的类, 使用之前必须要先导包.
b) 导包的语句是定义在类的上面的, 格式如下:  import java.util.Scanner;

• 2 创建Scanner类的对象, 格式为:

//暂时先理解为固定格式, 也就是必须这么写.
Scanner sc = new Scanner(System.in);

• 3 通过Scanner类的nextInt()方法接收用户录入的数据.

int a = sc.nextInt();

2、Scanner入门案例

需求

1 提示用户录入他/她的年龄.

2 通过键盘录入功能, 接收用户录入的年龄.

3 将用户录入的数据(年龄)打印到控制台上.

package com.itheima.day01;

import java.util.Scanner;

public class 键盘录入 {
    public static void main(String[] args) {
        // 1- 创建Scanner实例对象
        // Java中创建类的实例对象需要用new关键字
        Scanner sc = new Scanner(System.in);

        // 2- 输出提示信息
        System.out.println("请输入您的年龄：");

        // 3- 获取用户输入
        int inputAge = sc.nextInt();
        // Java里面可以直接对字符串与数字进行拼接操作。但是不能同时输出多个变量
        System.out.println("您输入的年龄是："+inputAge);
    }
}

七、（重要）流程控制（掌握）

​ 和Python中一样, Java中也是有分支结构和循环结构的, 它们的用法都一样, 只是写法稍有不同, 接下来, 我们来研究下Java中分支结构和循环结构的格式.

​

1、if语句

如果我们想某些代码是在满足条件的情况下, 才能被执行, 此时就需要用到选择结构了, 选择结构也叫分支结构, 主要分为以下两种:

• if语句, 主要用于范围的判断
• switch case语句, 主要用于固定值的判断.

if语句格式:

单分支格式:
if(判断条件){
    // 满足条件的内容
}

双分支:
if(判断条件){
   // 满足条件的内容
} else {
  // 不满足条件的内容
}

多分支
if(判断条件){
   // 满足条件的内容
} else if (判断条件) {
  // 满足条件的内容
} else if (判断条件) {
  // 满足条件的内容
} else {
   // 不满足条件的内容
}


多分支
if(判断条件){
   // 满足条件的内容
} else if (判断条件) {
  // 满足条件的内容
}

相关的案例:

package com.itheima.day01;

import java.util.Scanner;

public class IF多分支 {
    public static void main(String[] args) {
        // 1- 创建键盘录入的实例对象
        Scanner sc = new Scanner(System.in);

        // 2- 提示用户输入考试分数
        System.out.println("请输入您的考试得分：");

        // 3- 获取用户输入的内容
        double inputScore = sc.nextDouble();
        System.out.println("用户的考试得分是："+inputScore);

        // 4- 判断用户的考试级别
        // 如下的代码逻辑有问题
//        if(inputScore>=60){
//            System.out.println("及格");
//        }else if(inputScore>=70){
//            System.out.println("良好");
//        }else if(inputScore>=90){
//            System.out.println("优秀");
//        }else{
//            System.out.println("没有及格");
//        }

        if(inputScore>=90){
            System.out.println("优秀");
        }else if(inputScore>=70){
            System.out.println("良好");
        }else if(inputScore>=60){
            System.out.println("及格");
        }else{
            System.out.println("没有及格");
        }

    }
}

2、switch语句

switch语句, 一般是用于做固定值判断的。适合值是离散。

格式:

switch(表达式) {  
    case 值1: 	
        语句体1;
        break;
    case 值2:
        语句体2;
        break;
    case 值3:
        语句体3;
        break;
    ...    //根据需求, 可以写多组case.
    default:	
        语句体n;
        break;
}

示例:

1 一年有12个月, 分属于春夏秋冬4个季节, 键盘录入一个月份, 请用程序实现判断该月份属于哪个季节, 并输出。

2 具体标准如下:

1 输入： 1、2、12 输出：冬季

2 输入： 3、4、5 输出：春季

3 输入： 6、7、8 输出：夏季

4 输入： 9、10、11 输出：秋季

输入：其它数字 输出：数字有误

代码实现:

package com.itheima;

import java.util.Scanner;

public class Test02_switch {
    public static void main(String[] args) {
        //1. 创建键盘录入的对象
        Scanner scanner = new Scanner(System.in);

        //2. 获取教案录入的月份信息(1~12)
        // ln  是用于换行的
        //System.out.println("请输入一个月份, 判断属于哪个季节(1~12):");
        System.out.print("请输入一个月份, 判断属于哪个季节(1~12): ");

        int month = scanner.nextInt();

        // 3. 根据输入的月份信息, 进行判断
        switch (month){
            case 12:
                System.out.println("冬季");
                break;
            case 1:
                System.out.println("冬季");
                break;
            case 2:
                System.out.println("冬季");
                break;

            case 3:
                System.out.println("春季");
                break;
            case 4:
                System.out.println("春季");
                break;
            case 5:
                System.out.println("春季");
                break;

            case 6:
                System.out.println("夏季");
                break;
            case 7:
                System.out.println("夏季");
                break;
            case 8:
                System.out.println("夏季");
                break;

            case 9:
                System.out.println("秋季");
                break;
            case 10:
                System.out.println("秋季");
                break;
            case 11:
                System.out.println("秋季");
                break;

            default:
                System.out.println("您输入的数字有误, 请重新输入...");
                break;
        }
    }
}

注意:

​ 在switch语句中，如果case的后面不写break，将出现case穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。

所以以上代码可以优化为:

package com.itheima;

import java.util.Scanner;

public class Test03_switch {
    public static void main(String[] args) {
        //1. 创建键盘录入的对象
        Scanner scanner = new Scanner(System.in);

        //2. 获取教案录入的月份信息(1~12)
        // ln  是用于换行的
        //System.out.println("请输入一个月份, 判断属于哪个季节(1~12):");
        System.out.print("请输入一个月份, 判断属于哪个季节(1~12): ");

        int month = scanner.nextInt();

        // 3. 根据输入的月份信息, 进行判断
        switch (month){
            case 12:
            case 1:
            case 2:
                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;

        }
    }
}

3、for循环

​ for循环是我们在实际开发中应用到的最多的循环, 它一般适用于循环次数固定的情况.

格式:

for(初始化条件1; 判断条件2; 控制条件3) {
    //循环体;
}

说明:

1 初始化条件: 用来记录 循环的初始状态的. 即: 从哪开始循环.

2 判断条件: 用来决定循环是否继续执行的, 条件成立, 则循环继续执行, 条件不成立, 整个循环就结束了.

3 控制条件: 用来控制初始化条件变化的, 一般是每循环一次, 初始化条件+1.

4 循环体: 需要用来重复做的事情(代码).

案例1:

1 通过for循环, 打印1~5之间的数字.

2 通过for循环, 打印5~1之间的数字.

package com.itheima;

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

        // 需求: 通过 for循环, 打印 1~5之间的数字
        for(int i = 1; i <=5; i++){
            System.out.println(i);
        }

        System.out.println("------------------");

        // 需求2: 通过for循环, 打印 5~1之间的数字
        for(int i = 5; i >=1 ; i--){
            System.out.println(i);
        }

    }
}

案例二: 求偶数和

求1-100之间的偶数和，并把求和结果打印到控制台上

package cn.itcast.base;

public class ForDemo {
    public static void main(String[] args) {
        // 通过for循环, 打印1~5之间的数字.
        for(int i=1;i<=5;++i){
            System.out.println(i);
        }

        // 通过for循环, 打印5~1之间的数字.
        for(int i=5;i>=1;i--){
            System.out.println(i);
        }

        // 求1-100之间的偶数和，并把求和结果打印到控制台上
        /*
            1-打印1-100之间的数字
            2-筛选出偶数
            3-求偶数的和
            4-打印最终的结果
         */
        // 偶数的中间临时聚合结果
        int sum = 0;

        for(int i=1;i<=100;i++){
            if(i%2==0){
                // sum = sum + i;
                sum += i;
            }
        }

        System.out.println(sum);
    }
}

4、while循环

​ while循环也是我们在实际开发中应用到的比较多的循环, 它一般适用于循环次数不固定的情况.

格式:

初始化条件1;
while(判断条件2) {
    //循环体3;
    //控制条件4;
}

案例：在控制台打印10次HelloWorld.

// 需求1: 在控制台打印10次HelloWorld
int i = 1;
while(i<=10){
    System.out.println("Hello World");

    i++;
}

案例: 求和

获取1~100之间所有偶数和, 并将结果打印到控制台上.

// 需求2: 求和 获取 1~100之间所有偶数和 并将结果打印到控制台上
int j = 1;
int sum = 0;
while( j <= 100) {

    if(j % 2 == 0){
        sum += j;
    }

    j++;
}

System.out.println("偶数之和为:"+ sum);

5、死循环

​ 所谓的死循环指的是永不会结束的循环, 也就是循环的判断条件永远为true。在Java中, 死循环的写法格式常用有以下2种:

• for(;😉 { }
• while(true){ }：推荐使用

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

        while(true) {
            System.out.println("Hello World!");
        }
    }
}

package com.itheima.day01;

import java.util.Scanner;

public class 死循环结合switch案例 {
    public static void main(String[] args) {
        // 1- 创建Scanner实例对象
        Scanner sc = new Scanner(System.in);

        while(true){
            // 2- 提示用户输入
            System.out.println("请输入月份：");

            // 3- 获取用户输入的月份
            int inputMonth = sc.nextInt();
            System.out.println("用户输入的月份是："+inputMonth);

            // 4- 判断月份属于哪个季节
            switch (inputMonth){
                // case后面必须要有空格
                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;
            }
        }
    }
}

6、循环跳转

​ 有些时候, 我们想提前终止循环的执行, 或者跳过循环的某一次执行, 例如: 打印1~10之间, 所有不是3倍数的数字, 或者采用死循环让用户不断的录入他/她的账号和密码, 直到用户录入正确, 再终止循环. 这些都要用到循环控制跳转知识点.

break: 是用来终止整个循环, 循环不再继续执行.
continue: 用来结束本次循环, 进行下一次循环的, 循环还会继续执行.

例如:

package cn.itcast.base;

public class BreakAndContinueDemo {

    public static void main(String[] args) {
        // 打印1-10的数字，如果遇到3的倍数，就进行特殊处理

        /*
            break: 用来结束整个循环（for/while）
            continue：用来结束当前循环（for/while），进入到下个循环中
         */
        for(int i=1;i<=10;i++){
            if(i%3==0){
                System.out.println("3的倍数"+i);
//                break;
                continue;
            }

            System.out.println(i);
        }
    }
}

演示:

package com.itheima;

public class Test06_break和continue {
    public static void main(String[] args) {

        // 演示 for循环的break和continue
        // 需求: 通过 for循环, 打印 1~5之间的数字
        for(int i = 1; i <=5; i++){
            System.out.println(i);
            // 当i等于3的时候, 跳出整个循环
            if(i == 3){
                break;
            }

			System.out.println(i);
        }

        System.out.println("------------------");

        // 需求2: 通过for循环, 打印 5~1之间的数字
        for(int i = 5; i >=1 ; i--){
            // 当 i等于3的时候, 跳出本次循环
            if(i == 3) {
                continue;
            }

            System.out.println(i);
        }

        // 演示在while循环中:
        // 需求1: 在控制台打印10次HelloWorld
        int i = 1;
        while(i<=10){
            System.out.println(i);

            // 当i等于3的时候, 跳出整个循环
            if(i == 3){
                break;
            }

            i++;
        }
        System.out.println("------------------");

        // 需求1: 在控制台打印10次HelloWorld
        int j = 1;
        while(j<=10){

            // 当 i等于3的时候, 跳出本次循环
            if(j == 3) {
                j++;
                continue;
            }

            System.out.println(j);

            j++;
        }


    }
}

7、循环嵌套

所谓的循环嵌套指的是循环结构中还包裹着循环结构, 外边的循环结构叫外循环, 里边的循环结构叫内循环.

for循环和while循环，可以任意组合。工作中，一般推荐就2层循环。如果你的代码的循环嵌套层数>3层，一定要重新思考你的实现思路。

循环嵌套用的最多的就是for循环的嵌套, 具体格式如下:

for(初始化条件; 判断条件; 控制条件) {		//外循环
   for(初始化条件; 判断条件; 控制条件) {		//内循环
   	  //循环体;
   }
}

八、作业

1、需求：打印99乘法表，格式如下。尝试实现正着的、while嵌套实现

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
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*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25
1*4=4	2*4=8	3*4=12	4*4=16	
1*3=3	2*3=6	3*3=9	
1*2=2	2*2=4	
1*1=1

package com.itheima.day01;

public class 倒着的99乘法表 {
    public static void main(String[] args) {
        for (int line = 1; line <= 9 ; line++) {
            // 外层循环控制层数

            for (int j = 1; j <= 10-line; j++) {
                // 内层循环控制每行的内容
                System.out.print(j + "*" + (10-line) + "=" + (j*(10-line)) + "\t");
            }

            // 输出一个回车换行
            System.out.println();
        }
    }
}

2、打印如下图形

  *
 ***
*****
 ***
  *

package com.itheima.day01;

import java.util.Scanner;

public class 打印菱形 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要打印的层数：");
        int lineCount = sc.nextInt();

        // 先打印上半部分
        for(int line=1;line<=lineCount;line++){
            // 外层循环控制行号

            for (int i = 1; i <= lineCount-line; i++) {
                // 负责打印每行的空格
                System.out.print(" ");
            }

            for (int i = 1; i <= 2*line-1; i++) {
                // 负责打印每行的星星
                System.out.print("*");
            }

            // 打印每行的回车换行
            System.out.println();
        }


        // 先打印下半部分
        for(int line=lineCount-1;line>=1;line--){
            // 外层循环控制行号

            for (int i = 1; i <= lineCount-line; i++) {
                // 负责打印每行的空格
                System.out.print(" ");
            }

            for (int i = 1; i <= 2*line-1; i++) {
                // 负责打印每行的星星
                System.out.print("*");
            }

            // 打印每行的回车换行
            System.out.println();
        }
    }
}