JAVA入门

打开CMD

  1. Win+R
  2. 输入cmd.
  3. 按下回车键
  4. Win+E 打开我的电脑

常见CMD命令

  1. 盘符名称+冒号

    说明:盘符切换

    举例:E:回车,表示切换到E盘

  2. dir

    说明:查看当前路径下的内容

  3. cd 目录

    说明:进入单级目录

    举例:cd itheima

  4. cd..

    说明:回退到上一级目录

  5. cd 目录1\目录2...

    说明:进入多级目录

    举例:cd itheima\JavaSE

  6. cd\

    说明:回退到盘符目录

  7. cls

    说明:清屏

  8. exit

    说明:退出命令提示符窗口

配置环境变量

为什么配置环境变量?

我们想要在任意的目录下都可以打开指定的软件。就可以把软件的路径配置到环境变量中。

打开我的电脑-属性-高级系统设置-高级-环境变量-系统变量path-编辑-新建-把软件的完整路径粘贴进去-上移-确定。

Java基础学习

基础语法

jdk

下载网址:http://www.oracle.com

注意:针对不同操作系统,下载对应的安装包。

安装:傻瓜式安装,下一步即可

安装路径中不要包含中文和空格。

所有的开发工具最好安装目录统一。

bin:该路径下存放了各种工具命令。其中比较重要的有javac和java。

conf:该路径下存放了相关配置文件。

include:该路径下存放了一些平台特定的头文件。

jmods:该路径下存放了各种模块。

legal:该路径下存放了各模块的授权文档。

lib:该路径下存放了工具的一些补充JAR包。

Java程序初体验
编写步骤
用记事本写程序
public class HelloWorld{
    public static void main(String[]args){
        System.out.println("HelloWorld");
    }
}
  1. 编译文件

    如何理解编译?相当于翻译文件

  2. 运行程序

    ​ CMD中程序运行步骤:

    1. 切换盘符:要先找到我们刚刚书写的代码
    2. 编译:javac是JDK提供的编译工具,我们可以通过这个工具,把当前路径下的HelloWorld.java文件编译成class文件。
    3. 运行:java也是JDK提供的一个工具。作用就是用来运行代码的。运行当前路径下的HelloWorld.class这个文件。在运行的时候是不加后
案例常见问题

BUG的解决

  1. 具备识别BUG的能力 ———多看!
  2. 具备分析BUG的能力 ———多思考,多查阅资料
  3. 具备解决BUG的能力 ———多尝试,多总结

常见问题

  1. 中英文符号问题
  2. 单词拼写问题
环境变量

配置环境变量安全方式:

点击新建-变量名:JAVA_HOME,变量值:把路径粘贴进去,把bin给删掉。-确定-找到Path-新建-输入%JAVA_HOME%\bin-确定就可以了

步骤:

  1. 先配置JAVA_HOME.(路径不带bin)(E:develop\jdk)
  2. 再配置Path(%JAVA_HOME%\bin)

额外小拓展

部分win10的电脑有一个小bug.

当你重启后,配置的环境变量会失效.

解决方案:

  1. JAVA_HOME还是照样配置
  2. 在path当中,就不要引用JAVA_HOME了.

直接写完整路径.比如:E:develop\jdk\bin

Java 学习
Java能做什么?

Java的三大分类

JavaSE:java语言的(标准版),用于桌面应用的开发,是其他两个版本的基础.—-桌面应用开发.

学习java的目的:

为今后要从是的Java EE开发 ,打基础.

JavaME:Java语言的(小型版),用于嵌入式电子设备或者小型移动设备.

JavaEE:Java语言的(企业版),用于Web方向的网站开发.在这个领域,是当之无愧的NO.1.网站开发:浏览器+服务器

桌面应用开发

​ 各种税务软件,IDEA,Clion,Pycharm

企业级应用开发

​ 微服务,springcloud

移动应用开发

​ 鸿蒙,Android,医疗设备

科学计算

matlab

大数据开发

​ Hadoop

游戏开发

​ 我的世界 MineCraft

Java为什么这么火

主要从四个方面表现

​ 用户量:使用人群

​ 适用面:作用范围

​ 与时俱进:更新速度

​ 自身特点:面向对象/安全性/多线程/跨平台/简单易用/开源

​ Write Once Run Anywhere一次编译,到处运行

高级语言的编译运行方式

编程/编译/运行

编程:Java程序员写的.java代码,c程序员写的.c代码,python程序员写的.py代码

编译:机器只认识0011的机器语言,把.java.c.py的代码做转化让机器认识的过程

运行:让机器执行编译后的指令

语言类型

编译型:

解释性:

混合型:半编译,半解释

JRE和JDK

JVM(Java Virtual Machine):Java虚拟机,整整运行Java程序的地方

JRE(Java Runtime Environment):Java运行环境

​ JVM/核心类库/运行工具

JDK(Java Development Kit):Java开发工具包

​ JVM虚拟机:Java程序运行的地方

​ 核心类库:Java已经写好的东西,我们可以直接用

​ 开发工具:javac/java/jdb/jhat…

三者的包含关系

​ JDK包含了JRE

​ JRE包含了JVM

Java基础语法

注释

单行注释 格式://注释信息

多行注释 格式:/注释信息**/

文档注释 格式:/**注释信息*/

public class HelloWorld{
    //叫做main方法,表示程序的主入口
    public static void main(String[]args){
        /*叫做输出语句(打印语句)
        会把小括号里面的内容进行输出打印*/
        System.out.println("HelloWorld");
    }
}

注释的使用细节:

  1. 注释内容不会参与编译与运行,仅仅是对代码的解释说明
  2. 不管是单行注释还是多行注释,在书写的时候都不要嵌套

关键字

关键字:被Java赋予了特定涵义的英文单词

特点:

关键字的字母全部小写

常用的代码编辑器,针对关键字有特殊的颜色标记,非常直观.

class:用于(创建/定义)一个类;类是Java最基本的组成单元

字面量

告诉程序员:数据在程序中的书写格式

字面量类型 说明 举例
整数类型 不带小数点的数字 666,-88
小数类型 带小数点的数字 13.14,-5.21
字符串类型 用双引号括起来的内容 “HelloWorld”,“张代伟”
字符类型 用单引号括起来的内容 ‘A’,‘O’,’我’
布尔类型 布尔值,表示真假 只有两个值:true,false
空类型 一个特殊的值,空值 值是:null
public class ValueDemo{
    public static void main(String[]args){
        //目标:需要大家掌握常见的数据在代码中如何书写的?
        
        //整数
        System.out.println(666);
        System.out.println(-777);
        //小数
        System.out.println(1.93);
        System.out.println(-3.71);
        //字符串
        System.out.println("刘顺国");
        System.out.println("尼古拉斯阿淮");
        //字符
        System.out.println('A');
        System.out.println('B');
        //布尔
        System.out.println(true);
        System.out.println(false);
        //空
        //细节:null不能直接打印的.
        //如果我们要打印null,那么只能用字符串的形式进行打印
        System.out.println(null); 
    }
}

特殊字符字面量:

\t 制表符

在打印的时候,把前面字符串的长度补齐到8,或者8的整数倍.最少补1个空格,最多补8个空格.

变量

定义

变量:在程序执行的过程中,其值有可能发生改变的量(数据)

变量的使用场景:

​ 当某个数据经常发生改变时,我们也可以用变量存储.当数据变化时,只要修改变量里面记录的值即可.

变量的定义格式:

​ 数据类型 变量名 = 数据值;

public class VariableDemo{
   public static void main(String[]args){
       //定义变量
       //数据类型 变量名 = 数据值;
       //数据类型:限定了变量能存储数据的类型
       //int(整数)  double(小数)
       //变量名:就是存储空间的名字
       //作用:方便以后调用
       //数据值:真正存在变量中的数
       //等号:赋值. 把右边的数据赋值给左边的变量
       //===================================
       int a = 10;
       System.out.println(a);//10
   }
}

使用方式

注意事项:

  1. 只能存一个值
  2. 变量名不允许重复定义
  3. 一条语句可以定义多个变量
  4. 变量在使用之前一定要进行赋值
  5. 变量的作用域范围
public class VariableDemo{
    public static void main(String[]args){
        //1.基本用法
        //定义变量,再进行输出
        //===================================
        int a = 10;
        System.out.println(a);//10
        System.out.println(a);//10
        System.out.println(a);//10
        //2.变量参与计算
        int b = 20;
        int c = 30;
        System.out.println(b+c);
        //修改变量记录的值
        a = 50;
        System.out.println(a);//50
        //注意事项
        //在一条语句中,可以定义多个变量
        int d = 100,e = 200,f = 300;
        System.out.println(d);
        System.out.println(e);
        System.out.println(f);
        //变量在使用之前必须要赋值
        //int g;
        //g = 50;
        //建议:以后在定义变量的时候,请直接赋值.
        System.out.println(g);
    }
}

变量的练习

package classVariableTest{
    //主入口
    public static void main(String[]args){
        //一开始没有乘客
        int count = 0;
        //第一站:上去一位乘客
        //在原有基础上 + 1
        count = count+1;
        //第二站:上去两位乘客.下来一位乘客
        count = count+2-1;
        //第三站:上来两位乘客,下来一位乘客
         count= count+2-1;
        //第四站:下来一位乘客
          count=count-1;
        //第五站:上去一位乘客
           count= count+1;
        //请问:到了终点站,车上一共几位乘客.
        System.out.println(count);
        
    }
}

计算机的存储规则

三类数据

  1. Text文本数据:数字/字母/汉字

    进制:在计算机中,任意数据都是以二进制的形式来存储的

    不同进制在代码中的表现形式:

    1. 二进制:由0和1组成,代码中以0b开头.
    2. 十进制:由0-9组成,前面不加任何前缀.
    3. 八进制:由0-7组成,代码中以0开头.
    4. 十六进制:由0-9还有a-f组成,代码中以0x开头.

    进制之间的转换

    任意进制转换为十进制

    公式:系数*基数的权次幂 相加

    ​ 系数:就是每一位上的数字

    ​ 基数:当前进制数

    ​ 权:从右向左,依次为0 1 2 3 4 5 …..

    十进制转其他进制

    ​ 除基取余法

    ​ 不断的除以基数(几进制,基数就是几)得到余数,直到商为0,再将余数倒着拼接起来即可.

  2. Image图片数据

    显示器的三要素:

    ​ 分辨率

    ​ 2K屏分辨率大致分为:

    1. 1920*1080
      2. 19981080
      3. 2048
      1080
      4. 2048*858

    4K屏分辨率大致分为:

     1.  ==3840*2160==
     	2.  3996*2160
                		3.  4096*2160
            		4.  4096*1716
    

    ​ 像素

    ​ 黑白图:1是白,2是黑

    ​ 灰度图:0是纯黑,255是纯白

    ​ 三原色

    ​ 彩色图:三原色:红黄蓝也称美学三原色.计算机中采用光学三原色:红绿蓝(RGB),写成十进制(0-255)或十六进制(0-FFFF).

  3. Sound声音数据

数据类型

数据类型的分类

  1. 基本数据类型

    注意事项:

    long类型变量:需要加入L标识(大小写都可以)

    float类型变量:需要加入F标识(大小写都可以)

    public class VariableTest{
        public static void main(String[]args){
           //定义变量记录姓名
            String name = "张代伟";
            //定义变量记录年龄
            int age = 18;
            //定义变量记录性别
            char gender = '男';
            //定义变量记录身高
            double height = 180.1;
            //定义变量记录是否单身
            //true 单身 false 不是单身
            boolean flag = true;
            //输出变量的值
            System.out.println(name);
            Systrm.out.println(age);
            System.out.println(gender);
            System.out.println(height);
            System.out.println(flag);
        }
    }
    
    public class VariableTest{
        public static void main(String[]args){
            //定义变量记录电影的名字
            String name = "送初恋回家";
            //定义变量记录主演的名字
            String tostar = "刘鑫 张雨提 高媛";
            //定义变量记录电影的年份
            int year = 2020;
            //定义变量记录电影的评分
            double grade = 9.0;
            //输出所有变量的值
            System.out.println(name);
            System.out.println(tostar);
            System.out.println(year);
            System.out.printlan(grade);
        }
    
    public class VariableTest{
        public static void main(String[]args){
            //定义变量记录手机的价格
            double price = 5299.0;
            //定义变量记录手机的品牌
            String name = "华为";
            //输出结果
            System.out.println(name);
            System.out.println(price);
        }
    
  2. 引用数据类型

标识符

标识符:就是给类,方法,变量等起的名字.

标识符命名规则—硬性要求

  1. 由数字、字母、下划线(_)和美元符($)组成
  2. 不能以数字开头
  3. 不能是关键字
  4. 区分大小写

标识符的命名规则—软性建议

命名要做到:见名知意

小驼峰命名法:适合变量和方法 大驼峰命名法:适合类名
规范1:标识符是一个单词的时候,全都小写. 规范1:标识符是一个单词的时候,首字母大写.
范例1:name 范例1:Student
规范2:标识符由多个单词组成的时候,第一个单词首字母小写,其他单词首字母大写. 规范2:标识符由多个单词组成的时候,每个单词的首字母大写.
范例2:firstName 范例2:GoodStudent

键盘录入

为什么要有键盘录入?

键盘录入介绍

​ Java帮我们写好一个类叫Scanner,这个类的功能就可以接收键盘输入的数字等数据.

使用步骤:

  1. 导包——Scanner这个类在哪

    import java.util.Scanner;导包的动作必须出现在类定义的上边.

  2. 创建对象——表示我要开始用Scanner这个类了

    Scanner sc = new Scanner(System.in)

    上面这个格式里面,只有sc是变量名,可以改变,其他的都不允许变.

  3. 接受数据——真正开始干活了

    int i = sc.nextInt();左面这个格式里面,只有i是变量名,可以变,其他的都不允许变.

//导包,找到Scanner这个类在哪
//书写要注意:要写在类定义的上面
import java.util.Scanner;

public class ScannerDemo{
    public static void main(String[]args){
        //2.创建对象,表示我现在准备要用Scanner这个类
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入整数:");
        //3.接收数据
        int i = scanner.nextInt();
        System.out.println();
    }
}

练习:键盘输入数字求和

需求:键盘录入两个整数,求出他们的和并打印出来

//导包
import java.util.Scanner;

public class ScannerTest{
    public static void main(String[]args){
        //2.创建对象
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入整数:");
         //3.接收数据
        int num1 = scanner.nextInt();
        //再次接收第二个数据
        int num2 = scanner.nextInt();
        System.out.println(num1+num2);
    }
}

IDEA

IDEA概述

全称IntelliJ IDEA,是用于Java语言开发的集成环境,它是业界公认的目前用于Java程序开发最好用的工具.

集成环境:把代码编写,编译,执行,调试等多种功能综合到一起的开发工具.

IDEA下载和安装

  1. 下载安装包:https://www.jetbrains.com/idea/
  2. 安装:傻瓜式安装,建议修改安装路径.

IDEA中的第一个代码

IDEA项目结构介绍:

  1. 项目(project)
  2. 模块(module)
  3. 包(package)
  4. 类(class)

大小排列:项目-模块-包-类

右键-open in-Exploer(在本地打开文件件)

IDEA的项目和模块操作

项目(project)

修改主体:(更换背景)

File-settings-Appearance & Bahavior-Appearance-Theme(主题)

修改字体:

File-settings-Editor-font-选择喜欢的字体(Consolas—程序员最喜欢的字体)

修改颜色:什么颜色都可以,但绝不能设置成红色,跟bug冲突.

File-settings-Editor-Color Scheme-Language Defaults-comments

键盘录入时自动导包:

File-settings-General-Auto Import-选择Add…+Optimize…两项确定即可

设置背景照片:

File-settings-Appearance-UI Options-Background Image…

IDEA中类的相关操作:

  1. 新建类

    选中包-右键点击包-new-java class

  2. 修改类名

    选中类-右键点击类-Refactor-Rename(快捷键:shift+f6)

  3. 删除类

选中类-右键点击类-delete

IDEA中项目的相关操作

  1. 关闭项目

    File-Close Project

  2. 新建项目

    New Project-Empty Project

  3. 打开项目

  4. 修改项目

模块(module)

IDEA中模块的相关操作

  1. 新建模块

    File-Project Stucture- Module-+-New Module-java(根据需要选择需要的类型)

  2. 删除模块

  3. 修改模块

  4. 导入模块

运算符

运算符和表达式

运算符:对字面量或者变量进行操作的符号

表达式:

运算符把字面量或者变量连接起来,符合Java语法的式子就可以称为表达式.

不同运算符连接的表达式体现的是不同类型的表达式.

算数运算符

public class ArithmeticoperatoeDemo{
    public static void main(String[]args){
        //+
        System.out.println(1+2);
         //-
        System.out.println(5-2);
         //*
        System.out.println(2*5);
        
        //如果在计算的时候有效数参与
        //结论:
        //在代码中,如果有小数参与计算,结果有可能不精确的.
        //为什么呢?
        //暂时只要知道这个结论就可以了.
        //具体的原因,我们到了Java进阶的时候,会详细的讲解.
        System.out.println(1.1+1.01);
        System.out.println(1.1-1.01);
        System.out.println(1.1*1.01);
        
        //除法
        //结论:
        //1.整数参与计算,结果只能得到整数
        //2.小数参与计算,结果有可能是不精确的,如果我们需要精确计算,需要用到后面的知识点.
        System.out.println(10/2);//5
        System.out.println(10/3);//3
        System.out.println(10.0/3);//3.333333335
        //取模,取余.实际上也是做除法运算,只不过得到的是余数而已.
        System.out.println(10%2);//0
        System.out.println(10%3);//1
       //应用场景:
        //1.可以用取模来判断:A是否可以被B整除
        //A%B 10%3
        //2.可以判断A是否为偶数
        //A%2 如果结果为0,那么证明A是一个偶数.如果结果为1,那么证明A是一个奇数
        //3.在以后,斗地主发牌
        //三个玩家
        //把每一张牌都定义一个序号
        //拿着序号%3如果结果为1,就发给第一个玩家
        //如果结果为2,就发给第二个玩家
        //如果结果为0,就发给第三个玩家
        
    }
}

练习:数值拆分

需求:键盘录入一个三位数,将其拆分为个位/十位/百位后,打印在控制台

运行结果

公式总结:

个位:数值%10

十位:数值/10%10

百位:数值/100%10

千位:数值/1000%10

public class Test{
   public static void main(String[]args){
      //键盘录入一个三位数,将其拆分为个位/十位/百位
       
       //1.键盘录入
       Scanner sc = new Scanner(System.in);
       System.out.println("请输入一个三位数");
       int number = sc.nextInt();
       //2.获取个位/十位/百位
       //公式:
       //个位:数值%10
       //十位:数值/10%10
       //百位:数值/100%10
       //..........
       int ge = number%10;
       int shi = number/10%10;
       int bai = numeber/100%10;
       System.out.println(ge);
       System.out.println(shi);
       System.out.println(bai);
   } 
}

算术运算符的高级用法:

“+”操作的三种情况

  1. 数字相加:数字进行运算时,数据类型不一样不能运算,需要转成一样的,才能运算.

    类型转换的分类:

    隐式转换(自动类型提升):取值范围小的数值–>取值范围大的数值—->把一个取值范围小的数值,转成取值范围大的数据.

    隐式转换的两种提升规则:

    1. 取值范围小的,和取值范围大的进行运算,小的会先提升为大的,再进行运算.
    2. byte short char 三种类型的数据在运算的时候,都会直接先提升为int,然后在进行运算.

    隐式转换小结:

    1. 取值范围:

      byte<short<int<long<float<double

    2. 什么时候转换?

      数据类型不一样,不能进行计算,需要转成一样的才可以进行计算.

    3. 转换规则:

      1. 取值范围小的,和取值范围大的进行运算,小的会先提升为大的,再进行运算.
      2. byte short char 三种类型的数据在运算的时候,都会直接先提升为int,然后在进行运算.

    练习:请问最终的运算结果是什么类型的?

    byte b1 = 10;

    byte b2 = 20;

    int=数据类型 result = b1+ b2;

    int i = 10;

    long n =100L;

    double d = 20.0;

    double=数据类型 result = i+n+d;

    byte b = 10;

    short s = 20;

    long n = 100L;

    long数据类型 result = b+s+n;

    强制转换:取值范围大的数值–>取值范围小的数值

    如果把一个取值范围大的数值,赋值给取值范围小的变量.

    是不允许直接赋值的.如果一定要这么做就需要加入强制转换

    格式:目标数据类型 变量名 = (目标数据类型)被强转的数据;

    练习:强制转换

    byte b1 = 10;

    byte b2 = 20;

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

  2. 字符串相加

    当“+”操作中出现字符串时,这个“+”是字符串连接符,而不是运算符了.它会将前后的数据进行拼接,并产生一个新的字符串.例:”123”+123

    连续进行“+”操作时,它是从左到右逐个执行.例:1+99+”“年达内”

  3. 字符相加

    当字符+字符时,会把字符通过ASCII码表查询到对应的数字再进行计算.

    当字符+数字时,会把字符通过ASCII码表查询到对应的数字再进行计算.

算术运算符小结:

自增自减运算符

基本用法:

符号 作用 说明
++ 变量的值加1
- - 变量的值减1

注意事项:

++和- -既可以放在变量的前边,也可以放在变量的后边.

两种用法:

单独使用:++和 - -无论是放在变量的前边还是后边,单独写一行结果是一样的.

参与计算:

1.先用后加:a++

2.先加后用:++a

public class ArithmeticoperatoeDemo{
    public static void main(String[]args){
        int x = 10;
        //++在后,先用后加.
        //先把x变量中的值拿出来用,赋值给y,然后再进行自增.
        //赋值给y的值是自增前的.
        int y = x+1;//x=11,y=10
        //++在前,先加后用
        //先把x进行自增,然后把自增后的结果赋值给左边的变量
        //先把x自增,编程12,然后再把自增之后的12赋值给z.
        int z = ++x;//x=12,z=12
        System.out.println();
        System.out.println();
        System.out.println();  
    }
}

赋值运算符

分类

符号 作用 说明
= 赋值 int a =10,将10赋值给变量a
+= 加后赋值 a+=b,将a+b的值给a
-= 减后赋值 a-=b,将a-b的值给a
*= 乘后赋值 a*=b,将a*b的值给a
/= 除后赋值 a/=b,将a/b的值给a
%= 取余后赋值 a%=b,将a%b的值给a

关系运算符

(关系运算符/比较运算符)的分类

符号 说明
== a==b,判断a和b的值是否相等,成立true,不成立为false
!= a!=b,判断a和b的值是否不相等,成立为true,不成立为false
> a>b,判断a是否大于b,成立为true,不成立为false
>= a>=b,判断a是否大于等于b,成立为true,不成立为false
< a<b,判断a是否小于b,成立为true,不成立为false
<= a<=b,判断a是否小于等于b,成立为true,不成立为false.

注意事项:关系运算符的结果都是boolean类型,要么是true,要么是false.千万不要把“==”误写成“=”.

练习:约会

public class test{
    public static void main(String[]args){
        /*需求:您和您的相亲对象在餐厅里面正在约会.

键盘录入两个整数,表示你和你约会对象衣服的时髦度.(手动录入0-10之间的整数,不能录其他)

如果你的时髦程度大于你对象的时髦程度,相亲就成功,输出true.否则输出false.*/
        //1.键盘录入两个整数表示衣服的时髦度
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入我们自己的衣服时髦度");
        int myfashion = sc.nextInt();
        System.out.println("请输入相亲对象衣服的时髦度");
        int girlfashion = sc.nextInt();
        //2.把我衣服的时髦度跟女朋友的时髦度进行对比就可以了
        boolean result = myfashion >girlfashion;
        //打印结果
        Sysstem.out.println(result);
    }
}

逻辑运算符

在数学中,一个数据x,大于5,小于15,我们可以这样来进行表示:5<x<15.

在Java中,需要把上面的式子先进行拆解,在进行合并表达.

拆解为:x>5和x<15

合并后:x>5&x<15

分类:

符号 作用 说明
& 逻辑与(且) 并且,两边都为真,结果才是真
| 逻辑或 或者,两边都为假,结果才是假
^ 逻辑异或,用的很少 相同为false,不同为true
! 逻辑非 取反
public class LogicoperatorDemo{
    public static void main(String[]args){
        //1.& 并且
        //两边都为真,结果才是真
        System.out.println(true&true);
        System.out.println(false&false);
        System.out.println(true&false);
        System.out.println(false&true);
        //使用场景1:登录.用户名正确并且密码正确
        
        //2.| 或者
        //两边都为假,结果才是假
        System.out.println(true|true);
        System.out.println(false|false);
        System.out.println(true|false);
        System.out.println(false|true);
        //使用场景2:满足其中一个条件时
        
        //3.^ 异或
        //相同为false,不同为true
        //了解即可
        System.out.println(true ^ true);
        System.out.println(false ^ false);
        System.out.println(true ^ false);
        System.out.println(false ^ true);
        
        //! 逻辑非 取反
        //提示:
        //取反的感叹号不要写多次,要么不写,要么只写一次
        System.out.println(!false);//true
        System.out.println(!true);//false
    }
}

短路逻辑运算符

符号 作用 说明
&& 短路与 结果和&相同,但是有短路效果
|| 短路或 结果和|相同,但是有短路效果
public class LogicoperatorDemo{
    public static void main(String[]args){
        //1.&&
        //运行结果跟单个&是一样的
        //表示两边都为真,结果才是真
        System.out.println(true&&true);
        System.out.println(false&&false);
        System.out.println(false&&true);
        System.out.println(true&&false);
        
        //2.||
        //运行结果跟单个|是一样的
        //表示两边为假,结果才是假
        System.out.println(true||true);
        System.out.println(false||false);
        System.out.println(false||true);
        System.out.println(true||false);
        
        //3.短路逻辑运算符局有短路效果
        //简单理解:当左边的表达式能确定最终的结果,那么右边就不会参与运行了
        int a = 10;
        int b = 10;
        boolean result = ++a<5&&++b<5;
        System.out.println(result);
        System.out.println(a);
        System.out.println(b);
    }

注意事项:

  1. &or|,无论左边true orfalse,右边都要被执行
  2. &&or||,如果左边能确定整个表达式的结果,右边不执行.
  3. &&:左边为false,右边不管是真是假,整个表达式的结果一定是false.
  4. ||:左边为true,右边不管是真是假,整个表达式的结果一定是true.

这两种情况下,右边不执行,提高了效率.

以后最常用的逻辑运算符:&&,||,!.

练习:数字6

数字6是一个伟大的数字,键盘录入两个整数.

如果其中一个为6,最终结果输出true.

如果他们的和为6的倍数.最终结果输出true.

其他情况都是false.

public class test{
    public static void main(String[]args){
      /*  数字6是一个伟大的数字,键盘录入两个整数.

如果其中一个为6,最终结果输出true.

如果他们的和为6的倍数.最终结果输出true.

其他情况都是false.*/
        //分析
        //1.键盘录入两个整数
        //变量a  变量b
        
        //2.a==6  b==6  (a+b)%6==0
        //如果满足其中一个,那么就可以输出true
        
        //
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int num1 = sc.nextInt();
        System.out.println("请输入一个整数");
        int nim2 = sc.nextInt();
        
        //可以短路逻辑运算符去连接三个判断
        boolean result = num1==6||num2==6||(num1+num2)%6==0;
        System.out.println(result);
    }

三元运算符

需求:定义一个变量记录两个整数的较大值

作用:可以进行判断,根据判断的结果得到不同的内容

(三元运算符/三元表达式)格式

  1. 格式:关系表达式?表达式1:表达式2;

  2. 范例:求两个数的较大值.

    a>b?a:b;

    System.out.println(a>b?a:b);

    public class test{
        public static void main(String[]args){
            //需求:使用三元运算符,获取两个数的较大值
            //分析:
            //1.定义两个变量记录两个整数
            int number1 = 10;
            int number2 = 20;
            //2.使用三元运算符获取两个整数的最大值
            //格式:关系表达式?表达式1:表达式2;
            //整个三元运算符的结果必须要被使用
            number1>number2?number1:number2;
            System.out.println(max);
            System.out.println(number1>number2?number1:number2);  
        }
    

练习1:两只老虎

需求:动物园里有两只老虎,体重分别为通过键盘录入获得,请用程序实现判断两只老虎的体重是否相同.

public class test1{
    public static void main(String[]args){
        /*需求:动物园里有两只老虎,体重分别为通过键盘录入获得,请用程序实现判断两只老虎的体重是否相同.*/
        //分析:
        //1.键盘录入两只老虎的体重
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一只老虎的体重");
        int weight1 = sc.nextInt();
        System.out.println("请输入第二只老虎的体重");
        int weight2 = sc.nextInt();
        //2.比较
        String result = boolean weight1>weight2?相同:不同;
        System.out.println(result)
    }

练习2:三元运算符练习2

需求:一座寺庙里住着三个和尚,已知他们的身高分别为150cm,210cm,165cm.请用程序实现获取这三个和尚的身高.

public class test2{
    public static void main(String[]args){
        /*需求:一座寺庙里住着三个和尚,已知他们的身高分别为150cm,210cm,165cm.请用程序实现获取这三个和尚的身高.*/
        //1.定义三个变量记录三个和尚的身高
        int height1 = 150;
        int height2 = 210;
        int height3 = 165;
        //2.拿着第一个和尚和第二个和尚进行比较
        //再拿着结果跟第三个和尚进行比较即可
        int temp = height1>height2?height1:height2;
        int max = temp>height3?temp:height3;
        //ctrl+alt+L代码对齐快捷键
        System.out.println(max); 
    }

运算符优先级

小括号()优先于所有

原码、反码、补码

原码

原码:十进制数据的二进制表现形式,最左边是符号位,0为正,1为负。

原码的弊端:

利用原码对正数进行计算的时候,如果是整数是完全不会有问题的。

但是如果是负数计算,结果就出错,实际运算的结果,跟我们预期的结果是相反的。

反码

反码:正数的补码反码是其本身,负数的反码是符号位保持不变,其余位取反。

反码:为了解决原码不能计算负数的问题而出现的。

计算规则:正数的反码不变,负数的反码在原码的基础上,符号位不变,数值取反,0变1,1变0.

反码的弊端:负数运算的时候,如果结果不跨0,是没有任何问题的,但是如果结果跨0,跟实际结果会有1的偏差。

补码

补码:正数的补码是其本身,负数的补码是在其反码的基础上+1.

补码出现的目的:

为了解决负数计算时跨0的问题而出现的。

补码的计算规则:

正数的补码不变,负数的补码在反码的基础上+1.

另外补码还能多记录一个特殊的值-128,改数据在1个字节下,没有源码和反码。

补码的注意点:

计算机中的存储和计算都是以补码的形式进行的。

基本数据类型

基本类型 字节数 二进制
byte类型的10 1个字节 0000 1010
short类型的10 2个字节 0000 0000 0000 1010
int类型的10 4个字节 0000 0000 0000 0000 0000 0000 0000 1010
long类型的10 8个字节 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1010

其他的运算符

运算符 含义 运算规则
& 逻辑与 0为false 1为true
| 逻辑或 0为false 1为true
<< 左移 向左移动,低位补0,规则:移一位*2
>> 右移 向右移动,高位补0或1规则:移一位/2
>>> 无符号右移 向右移动,高位补0
public class Test{
    public static voidmain(String[]args){
        int a = 200; 
        int b = 10;   
        System.out.println(a|b);
         0000 0000 0000 0000 0000 0000 1100 1000
         0000 0000 0000 0000 0000 0000 0000 1010
         =======================================
         0000 0000 0000 0000 0000 0000 1100 1010
         =======================================
             								202
    }
}

流程控制语句

顺序结构

public class OrderDemo{
    public static void main(String[]args){
        System.out.println("好好学习Java");
        System.out.println("早日掌握一门技术");
        System.out.println("为国家崛起而奋斗");
        System.out.println("赚大钱");
    }
}

分支结构

if语句
第一种格式:
if(关系表达式){		if(酒量>2){System.out.println():}	
   语句体; 
}
if的注意点:
	1.大括号的开头可以另起一行书写,但是建议写在第一行的末尾;

	2.在语句体中,如果只有一句代码,大括号可以省略不写;建议:大括号不要省略.

	3.如果对一个布尔类型的变量进行判断,不要用==号;直接把变量写在小括号中即可

public class IfDemo{
    public static void main(String[]args){
        //需求:键盘录入女婿的酒量,如果大于2,老丈人给出回应,反之不回应.
        //if格式
        //if(关系表达式){
           //语句体;
    	//}
        
        //分析:
        //1.键盘录入女婿的酒量
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入女婿的酒量");
        int wine = sc.nextInt();
        
        //2.对酒量进行判断
        if(wine>2){
            System.out.println("小伙子,不错呦!");
        }
    }
}
public class Test{
    public static void main(String[]args){
        //小红:如果你这次考试全班第一,我就做你女朋友
        
        //分析:
        //1.定义变量记录小明的名次
        int ranking =1;
        //2.对小明的名次进行判断
        if(ranking==1){
            System.out.println("小红成为了小明的女朋友");
        }
    }
}

自动驾驶

public class Test{
    public static void main(String[]args){
        //汽车无人驾驶会涉及到大量的判断
        //当汽车行驶的时候遇到了红绿灯,就会进行判断
        //如果红灯亮,就停止
        //如果黄灯亮,就减速
        //如果绿灯亮,就行驶
        
        
        
        //1.定义三个变量,表示灯的状态
        //true 亮  false 关
        boolean isLightGreen = false;
        boolean isLightYellow = false;
        boolean isLightRed = true;
        
        //2.判断
        //红灯亮,就停止
        //黄灯亮,就减速
        //绿灯亮,就行驶
        if(isLightGreen){
            System.out.println("GoGoGo!");
        }
        if(isLightYellow){
            System.out.println("slow!");
        }
        if(isLightRed){
            System.out.println("stop!");
        }
        
    }
第二种格式:
if(关系表达式){
    语句体1;
}else{
    语句体2;
}
执行流程:
1.首先计算关系表达式的值
2.如果关系表达式的值为true就执行语句体1
3.如果关系表达式的值为false就执行语句体2
4.继续执行后面的其他语句

练习:吃饭

public class Test{
    public static void main(String[]args){
        /*需求:键盘录入一个整数,表示身上的钱
        如果大于100块,就是网红餐厅
        否则,就吃经济实惠的沙县小吃
        
        //分析
        //1.键盘录入一个整数,表示身上的钱
        Scanner scanner = new Scanner(System.in);
        System.out.println("请录入身上的钱:");
        int money = scanner.nextInt();
        //2.对钱进行判断
        if(money>=100){
        System.out.println("吃网红餐厅!");
        }else{
        System.out.println("吃经济实惠的沙县小吃");
        }
    }
}
练习:商品付款
在实际开发中,如果要根据两种不同的情况来执行不同的代码,就需要用到if的第二种格式.
需求:
假设,用户在超市实际购买,商品总价为:600元.
键盘录入一个整数表示用户实际支付的钱.
如果付款大于等于600,表示付款成功.否则付款失败
public class Test{
    public static void main(String[]args){
        //分析:
        //1.键盘录入一个整数表示用户实际支付的钱
        Scanner cc = new Scanner(System.in);
        System.out.println("请录入一个整数表示用户实际支付的钱");
        int money = cc.nextInt();
        //2.判断
        if(money>=600){
            System.out.println("付款成功");
        }else{
            System.out.println("付款失败");
        }
    }
}
在实际开发中,电影院选座也会使用到if判断.
假设某影院售卖了100张票,票的序号为1-100.
其中奇数票号坐左侧,偶数票号坐右侧.
键盘录入一个整数表示电影票的票号
根据不同的情况,给出不同的提示;
如果票号为奇数,那么打印坐在左边;
如果票号为偶数,那么打印坐在右边.
public class Test{
    public static void main(String[]args){
        //分析
        //1.键盘录入一个整数表示电影票的票号
        Scanner sc = new Scanner(System.in);
        System.out,println("请录入一个票号");
        int ticket = sc.nextInt();
        //只有当ticket在0-100之间,才是真实有效的票
        if(ticket>0&&ticket<=100){
            //2.判断票号是奇数还是偶数
            if(ticket%2==1){
                System.out.println("坐左边");
            }else{
                System.out.println("坐右边");
            }
        }
    }
第三种格式

在实际开发中,如果是多情况判断,会用到if的第三种形式.

格式:
if(关系表达式1){
    语句体1;
}else if(关系表达式2){
    语句体2;
}
..........
    else{
        语句体n+1;
    }
执行流程:
1.首先计算关系表达式1的值;
2.如果为true就执行语句体1;如果为false就计算关系表达式2的值;
3.如果为true就执行语句体2;如果为false就计算关系表达式3的值;
4.........;
5.如果所有关系表达式结果结果都为false,就执行语句体n+1.
练习:小明的礼物;
public class Test{
    public static void main(String[]args){
        /*
        根据不同的分数送不同的礼物
        如果是95-100分,送自行车一辆
        如果是90-94分,游乐场玩一天
        如果是80-89分,送变形金刚一个
        如果是80分,揍一顿*/
        
        //分析:
        //1.键盘录入小明的考试成绩
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个整数表示小明的成绩");
        int score = sc.nextInt();
        //对异常数据进行判断校验
        //0-100合理数据
        if(score>0&&score<=100){
            //2.根据不同的考试成绩,给出不同的奖励;
            if(score>=95&&score<=100){
                System.out.println("送自行车一辆");
            }else if(score>=90&&score<=94){
                System.out.println("游乐场玩一天");
            }else if(score>=80&&score<=89){
                System.out.println("送变形金刚一个");
            }else{
                System.out.println("揍一顿");
            }
        }else{
                Syetem.out.println("成绩不合法");
            }
    }
练习:自动驾驶;
public class Test{
    public static void main(String[]args){
        boolean isLightGreen = false;
        boolean isLightYellow = false;
        boolean isLightRed = true; 
        if(isLightGreen){
            Syetem.out.println("GoGoGo!!");
        }else if(isLightYellow){
            Syetem.out.println("Slow!!!!");
        }else if(isLightRed){
            Syetem.out.println("Stop!!!!");
        }  
    } 
switch

Switch语句格式

Switch(表达式){
    case 值1:
    	语句体1;
    	break;
    case 值2:
    	语句体2;
    	break;
    case 值3:
    	语句体3;
    	break;
    .....
    default:
    	语句体n+1;
    	break;
}
执行流程:
1.首先计算表达式的值;
2.依次和case后面的值进行比较,如果有对应的值,就会执行相应的语句,在执行的过程中,遇到break就会结束;
如果所有的case后面的值和表达式的值都不匹配,就会执行default里面的语句体,然后结束整个Switch语句.
    
格式说明:
1.表达式:(将要匹配的值)取值为byte/short/int/char.JDK5以后可以是枚举,JDK7以后可以是String.
2.case:后面跟的是要和表达式进行比较的值(被匹配的值);
3.break:表示中断,结束的意思,用来结束Switch语句;
4.default:表示所有情况都不匹配的时候,就执行该处的内容,和if语句的else相似;
5.case后面的值只能是字面量,不能是变量;
6.case给出的值不允许重复.

Switch其他知识点
    default的位置和省略
    case穿透
    Switch新特性
    Switch和if第三种格式各自的使用场景
练习:吃面
public class Test{
    public static void main(String[]args){
        //兰州拉面,武汉热干面,北京炸酱面,陕西油泼面
        
        //1.定义变量记录我心里想吃的面
        String noodles = "兰州拉面";
        //2.拿着这个面利用Switch跟四种面条匹配
        Switch(noodles){
            case  "兰州拉面":
            System.out.println("吃兰州拉面");
            break;
            case "武汉热干面":
            System.out.println("吃武汉热干面");
            break;
            case "北京炸酱面":
            System.out.println("吃北京炸酱面");
            break;
            case "陕西油泼面":
            System.out.println("吃陕西油泼面");
            break;
            default:
            System.out.println("吃方便面");
            break;
        }
    }
练习:运动计划;
需求:键盘录入星期数,显示今天的减肥活动;
周一:跑步;
周二:游泳;
周三:慢走;
周四:动感单车;
周五:拳击;
周六:爬山;
周日:好好吃一顿;
public class Test{
    public static void main(String[]args){
        //分析:
        //1.键盘录入星期数
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入星期");
        int week = sc.nextInt();
        //2.利用Switch对星期进行匹配;
        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;
        default:
        System.out.println("没有这个星期");
        break;   
    }
public class Test{
    public static void main(String[]args){
        //default的位置和省略;
        //1.位置:default不一定是写在最下面的,我们可以写在任意位置,只不过习惯会写在最下面.
        //2.省略:default可以省略,语法不会有问题,但是不建议省略.
        int number = 100;
        switch(number){
            case 1:
                System.out.println("number的值为1");
                break;
            case 20:
                System.out.println("number的值为20");
                break;
            case 100:
                System.out.println("number的值为100");
                break;
            default:
                System.out.println("number的值不是1,20和100");
                break;
        }
        
    }
public class Test{
    public static void main(String[]args){
        /*
        	case穿透
        		就是语句体中没有写break导致的
        	执行过程:
        		首先还是会拿着小括号中表达式的值跟下面每一个case进行匹配.
        		如果匹配上了,就会执行对应的语句体,如果此时发现了break,那么结束整个Switch语句.如果没有发现break,那么程序会继续执行下一个case的语句体,一直到遇到break或者右大括号为止.
        	使用场景:
        		如果多个case的语句体重复了,那么我们考虑用case穿透去简化代码.
        */
         int number = 1;
        switch(number){
            case 1:
                System.out.println("number的值为1");
               // break;
            case 20:
                System.out.println("number的值为20");
                //break;
            case 100:
                System.out.println("number的值为100");
                //break;
            //default:
               // System.out.println("number的值不是1,20和100");
               // break;
        }
    }
public class Test{
    public static void main(String[]args){
        /*
        	Switch新特性
        	JDK12
        */
        //需求:
        //1 2 3
        /*int number = 1;
        Switch(number){
            case 1:
            System.out.println("一");
            break;
            case 2:
            System.out.println("二");
            break;
            case 3:
            System.out.println("三");
            break;
            default:
            System.out.println("没有这种选项");
            break;
        }*/
        int number = 10;
        Switch(number){
            case 1->System.out.println("一");
            case 2->System.out.println("二");
            case 3->System.out.println("三");
            default->System.out.println("没有这种选项");
        }
    }
 /*
     Switch和if第三种格式各自的使用场景
     if的第三种格式,一般用于对范围的判断
      Switch:把有限个数据一一列举出来,让我们任选其一
        
 */
public class Test{
    public static void main(String[]args){
        /*需求:键盘录入星期数,输出工作日,休息日
        (1-5)工作日,(6-7)星期日*/
        //分析:
        //1.键盘录入星期数
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个整数表示星期");
        int week = sc.nextInt();
        //2.利用Switch语句来进行选择
        Switch(week){
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
            System.out.println("工作日");
            break;
            case 6:
            case 7:
            System.out.println("休息日");
            break;
            default:
            System.out.println("没有这个星期");
            break;
        }
             Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个整数表示星期");
        int week = sc.nextInt();
        //2.利用Switch语句来进行选择
        Switch(week){
            case 1,2,3,4,5->System.out.println("工作日");
            case 6,7->System.out.println("休息日");
          
            default->System.out.println("没有这个星期");
        }
        
    }
public class Test{
    public static void main(String[]args){
        /*在实际开发中,如果我们需要在多种情况下选择其中一个,就可以使用Switch语句.
        当我们拨打了某些服务电话时,一般都会有按键选择.
        假设现在我们拨打了一个机票预订电话
        电话中语音提示:
        1.机票查询
        2.机票预订
        3.机票改签
        4.退出服务
        其他按键也是退出服务,请使用Switch模拟该业务逻辑*/
        
        //分析:
        //1.键盘录入一个整数,表示我们的选择
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的选择");
        int choose = sc.nextInt();
        //2.根据选择执行不同的代码
        switch(choose){
            case 1->System.out.println("机票查询");
                
            case 2->System.out.println("机票预订");
                
            case 3->System.out.println("机票改签");
                
            //case 4->System.out.println("退出服务");
                
            default->System.out.priln("退出服务");
        }
    }

循环结构

什么是循环?

​ 重复的做某件事情

​ 具有明确的开始和停止标记

循环的分类:

for循环——重点
格式:
for(int i=1;i<=0;i++){
    System.out.println("HelloWorld");
}
执行流程:
1.执行初始化语句                          
2.执行条件判断语句,看其结果是true还是false
    如果是false,循环结束
    如果是true,执行循环体语句
3.执行条件控制语句
4.回到2继续执行条件判断语句

public class ForDemo{
    public static void main(String[]args){
        //1.需求:打印5次HelloWorld
        
        //分析:
        //i 1~5
        /*for(初始化语句;条件判断语句;条件控制语句){
            循环体;
        }*/
        for(int i= 1;i<=5;i++){
            System.out.println("HelloWorld");
        }
    }
public class Test{
    public static void main(String[]args){
        //需求1:打印1~5
        
        //分析:
        //开始条件:1
        //结束条件:5
        for(int i=1;i<=5;i++){
            //第一次循环:i=1
            //第二次循环:i=2
            //i:1 2 3 4 5
            System.out.println(i);
        }
        
        //需求2:打印5~1
        //分析:
        //开始条件:5
        //结束条件:1
        for(int i=5;i>.=1;i--){
            System.out.println(i);
        }     
    }
练习:断线重连
在实际开发中,需要重复执行的代码,会选择循环实现.
比如:如作图所示.玩游戏的时候,如果网不好那么会经常断线重连.
那么断线重连这个业务逻辑就需要重复执行.
假设现在公司要求,断线重连的业务逻辑最多只能写5次.
请用代码实现.
备注:断线重连的业务逻辑可以用输出语句替代.
public class Test{
    public static void main(String[]args){
        /*在实际开发中,需要重复执行的代码,会选择循环实现.
		比如:如作图所示.玩游戏的时候,如果网不好那么会经常断线重连.
		那么断线重连这个业务逻辑就需要重复执行.
		假设现在公司要求,断线重连的业务逻辑最多只能写5次.
		请用代码实现.
		备注:断线重连的业务逻辑可以用输出语句替代.*/
        //分析:
        //1.因为我们需要重复执行某段代码,所以需要用循环解决
        //循环的次数5次
        //开始条件:1
        //结束条件:5
        for(int i=1;i<=5;i++){
            System.out.println("第"+i+"次执行断线重连的业务逻辑");
        }
    }   
练习:求和
需求:在实际开发中,如果要获取一个范围中的每一个数据时,也会用到循环.
比如:求1~5之间的和.
public class Test{
    public static void main(String[]args){
         /*需求:在实际开发中,如果要获取一个范围中的每一个数据时,也会用到循环.
         比如:求1~5之间的和*/
        //分析:
        //1.循环1~5得到里面的每一个数字
        //开始条件:1
        //结束条件:5
        
        //用来进行累加的
        //int sum = 0;
        for(int i=1;i<=5;i++){
            //1.求和的变量不能定义在循环的里面,因为变量只在所属的大括号中有效.
            //2.如果我们把变量定义在循环的里面,那么当前变量只能在本次循环中有效.
            //当本次循环结束之后,变量就会从内存中消失.
            //第二次循环开始的时候,又会重新定义一个新的变量.
            //如果以后我们要写累加求和的变量,可以把变量定义在循环的外面.
            int sum = 0;
            System.out.println(i);
            //可以把得到的每一个数字累加到变量sum当中
            sum=sum+i;//sum +=i;
        }
        //当前循环结束之后,表示已经把1~5累加到变量sum当中了
        System.out.println(sum);
    }
练习:求和2
需求:在实际开发中,如果要获取一个范围中的每一个数据时,会用到循环;
但是此时,大多数情况下,不会获取所有的数据,而是获取其中符合要求的数据.
此时就需要循环和其他鱼护结合使用了.
比如:求1~100之间的偶数和.
public class Test{
    public static void main(String[]args){
        //分析:
        //1.获取1~100之间的每个数
        int sum = 0;
        for(int i=1;i<=100;i++){
            //2.累加求和(先判断,再求和)
            if(i%2==0){
                sum=sun+i;
            }
            //打印sum
            System.out.println(sum);
        }
    }
练习:统计满足条件的数字;
需求:键盘录入两个数字,表示一个范围.统计这个范围中,既能被3整除,又能被5整除的数字有多少个?
public class Test{
    public static void main(String[]args){ 
        //分析:
        //1.键盘录入两个数字
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数字表示范围的开始");
        int start = sc.nextInt();
        System.out.println("请输入一个数字表示范围的结束");
        int end= sc.nextInt();
        //统计变量
        //简单理解,统计符合要求的数字的个数
        int count =0;
        //2.利用循环获取这个范围中的每一个数字
        //开始条件:start
        //结束条件:end
        for(int i=start;i<=end;i++){
            //3.对每一个数字进行判断,统计有多少可满足要求的数字
            if(i%3==0&&i%5==0){
                //System.out.println(i);
                count++;
            }
        }
        System.out.println(count);
        
    }    
##### while循环—-重点 #####
格式:
初始化语句;
while(条件判断语句){
    循环体语句;
    条件控制语句;
}
初始化语句只执行一次;
判断语句为true,循环继续;
判断语句为false,循环结束

public class Test{
    public static void main(String[]args){
        //需求:利用while循环打印1~100
        //分析:
        //开始条件:1
        //结束条件:100
        int i= 1;
        while(i<=100){
            System.out.println(i);
            i++;
        }
    }
for和while的对比

相同点:运行规则都是一样的.

区别:

  1. for循环中,控制循环的变量,因为归属for循环的语法结构中,在for循环结束后,就不能再次被访问到了.
  2. while循环中,控制循环的变量,对于while循环来说不归属其语法结构中,在while循环结束后,该变量还可以继续使用.
练习:打印折纸的次数
需求:世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米),假如我有一张足够大的纸,它的厚度是0.1毫米.请问我折叠多少次,可以折成珠穆朗玛峰的高度?
public class Test{
    public static void main(String[]args){
        //分析:折叠纸张:每一次折叠纸张的厚度都是原先的两倍
        //double a = 0.1;
        //a = a*2;或者a *=2;
        //1.定义一个变量用来记录山峰的高度
        double height = 8844430;
        //2.定义一个变量用来记录纸张的初始厚度
        double paper = 01.;
        //3.定义一个变量用来统计次数
        int count=0;
        //4.循环折叠纸张,只要纸张的厚度小于山峰的高度,那么循环就继续
        while(paper<height){
            //折叠纸张
            paper = paper*2;
            //折叠一次,++一次;
            count++;
        }
        //当循环结束之后,count记录的值就是折叠的次数
        System.out.println(count);
    }    
练习:回文数;
需求:给你一个整数X;
如果x是一个回文整数,打印true,否则,则返回false.
解释:回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数
例如121是回文,而123不是
public class Test{
    public static void main(String[]args){
        //核心思路:把狮子倒过来跟原来的数字进行比较
        
        //1.定义数字
        int x = 12345;
        //定义一个临时变量用于记录X原来的值,用于最后进行比较
        int temp =x;
        //记录倒过来之后的结果;
        int num = 0;
        //2.利用循环从右往左获取每一位数字
        while(x!=0){
            //从右往左获取每一位数字
            int ge = x%10;
            //修改一下x记录的值
            x = x/10;
            //把当前获取到的数字拼接到最右边
            num = num*10+ge;
        }
        //3.打印num
        System.out.println(num);
        //4.比较
        System.out.println(num==temp)
        
        //1.定义数字;
        int x =12;
        //2.获取个位;
        int ge = x%10;//2
        //获取十位;
        int shi = x/10%10;//1
        //拼接
        int result =ge*10+shi;
        System.out.println(result);
        
    }
练习:求商和余数
需求:给定两个整数,被除数和除数(都是正数,且不超过今天的范围).
将两数相除,要求不使用乘法/除法和%运算符.
得到商和余数.
public class Test{
    public static void main(String[]args){
        /*分析:
        被除数/除数 = 商...余数
        int a = 100;
        int b = 10;
        100-10=90
        90-10=80
        80-10=70
        70-10=60
        ...
        10-10=0(余数)
        */
        //1.定义变量记录被除数
        int dividend = 10;
        //2.定义变量用来记录除数
        int divisor = 3;
        //3.定义一个变量用来统计相减了多少次
        int count = 0;
        //4.循环while
        //在循环中,不断的用被除数-除数
        //只要被除数是大于除数的,那么就一直循环
        while(dividend>=divisor){
            dividend = dividend-divisor;
            //只要减一次,那么统计变量就自增一次
            count++;
        }
        //当循环结束之后dividend变量记录的就是余数
        System.out.println("余数为:"+dividend);
        //当循环结束之后,count记录的值就是商
        System.out.println("商为:"+count)   
    }
##### do…while—以后几乎不用 #####
格式:
初始化语句;
do{
    循环体语句;
    条件控制语句;
}while(条件判断语句);

循环高级
无限循环

无限循环:循环一直停不下来.

注意事项:无限循环的下面不能再写其它代码了,因为循环永远停不下来,那么下面的代码永远执行不到.

for(;;){
    System.out.println("学习");
}
while(true){
    System.out.println("学习");
}
do{
    System.out.println("学习");
}while(true);
跳转控制语句

跳转控制语句:在循环的过程中,跳转到其他语句上执行.

public class Test{
    public static void main(String[]args){
       //1.跳过某一次循环
        for(int i=1;i<=5;i++){
            if(i==3){
              //结束本次循环,继续下次循环.
                continue;
            }
            System.out.println("小老虎在吃第"+i+"个包子");
        }
    }
public class SkiploppDemo{
    public static void main(String[]args){
        //2.结束整个循环
        for(int i=1;i<=5;i++){
            System.out.println("小老虎在吃第"+i+"个包子");//这样可以吃三个
            if(i==3){
                //结束整个循环
                break;
            }
           // System.out.println("小老虎在吃第"+i+"个包子");这样只能吃两个
        }
    }

小结:

  1. continue:跳过本次循环,继续执行下次循环
  2. break:结束整个循环.
练习
案例1:逢7过
朋友聚会的时候可能会玩一个游戏:逢7过;
游戏规则:从任意一个数字开始,当你要报的数字是包含7或者是7的倍数时都要说过:过;
需求:使用程序在控制台打印出1!100之间的满足逢7必过规则的数据
public class LoopTest1{
    public static void main(String[]args){
        //分析:
        //个位是7 十位是7 7的倍数
        //1 2 3 4 5 6 过 8 9 10 11 12 13 过.......
        //69 过 过过.....80
        //1.得到1~100之间的每一个数字
        //开始条件:1
        //结束条件:100
        for(int i=1;i<=100;i++){
            //2.判断每一个数字,如果符合规则,就打印过.如果不符合规则就打印真实的数字
            if(i%10==7 || i/10%10 || i/10/10%10){
                System.out.println("过");
                count;
            }
            System.out.println(i);
        }
        
    }
案例2:求平方根   win+R 输入calc计算器快捷键
需求:键盘录入一个大于等于2的整数x,计算并返回x的平方根.
结果只保留整数部分,小数部分将被舍去.
public class LoopTest1{
    public static void main(String[]args){
        //分析:
        //平方根  16的平方根4
        //       4的平方根2
        
        //10
        //1*1=1<10
        //2*2=4<10
        //3*3=9<10
        //4*4=16>10
        //推断:10的平方根在3-4之间
        
        //20
        //1*1=1<20
        //2*2=4<20
        //3*3=9<20
        //4*4=16<20
        //5*5=25>20
        //推断:20的平方根在4-5之间
        
        //在代码当中
        //从1开始循环,拿着数字的平方跟原来的数字进行比较
        //如果是小于的,那么继续往后判断
        //如果相等,那么当前数字就是平方根
        //如果是大于的,那么前一个数字就是平方根的整数部分
        
        //1.键盘录入一个整数
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int number = sc.nextInt();
        //2.从1开始循环
        //开始:1 结束:number
        for(int i=1;i<=number;i++){
            //用i*i再跟number进行比较
            if(i*i==number){
                System.out.println(i+"就是"+num+"的平方根");
                //一旦找到了,循环就可以停止了.后面的数字就不需要再找了,提高代码的运行效率.
                break;
            }else if(i*i>num){
              System.out.println((i-1)+"就是"+num+"的平方根的整数部分");
                break;
            }
        }
        
    }
案例3:求质数;
需求:键盘录入一个正整数X,判断该整数是否为一个质数.
public class LoopTest1{
    public static void main(String[]args){
        //质数:
        //如果一个数只能被1和本身整除,那么这个数就是质数,否则这个数就叫做合数.
        //例如7 = 1*7 质数
        //例如8 = 1*8 2*4 合数
        
        //分析:
        //1.键盘录入一个正整数
        //number
        
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个正整数");
        int number = sc.nextInt();
        //定义一个变量,表示标记
        //标记number是否为一个质数
        //true:  是一个质数
        //false: 不是一个质数
        //表示最初就认为number是一个质数
        boolean flag = true;
        
        //2.判断
        //写一个循环,从2开始判断,一直判断到number-1为止
        //看这个范围之内,有没有数字可以被number整除
        for(int i = 2;i<=number-1;i++){
            //i依次表示这个范围之内的每一个数字
            //看number是否被1整除就可以了.
            if(number%1==0){
                System.out.println(number+"不是一个质数");
                break;
            }else{
                    System.out.println(number+"是一个质数");
            }
            //只有当这个循环结束了,表示这个范围之内所有的数字都判断完毕了
            //此时才能断定number是一个质数
            if(flag){
                    System.out.println(number+"是一个质数");
            }else{
                    System.out.println(number+"不是一个质数");
            }
        }
    }
暂作了解---后期补充

public class LoopTest{
    public static void main(String[]args){
        //100000
        //2~99999
        //循环的次数:将近10万次
        //推荐一个简化的思路
        //81
        //1*81
        //3*27
        //9*9
        
        //以81的平方根9,为中心
        //而且假设a*b=81
        //那么a和b中,其中有一个必定是小于等于9的
        //另一个是大于等于9的
        
        //假设,都是大于9---9.1*9.1>81
        //假设,都是小于9---8.9*8.9<81
        //其中一个数字一定是小于等于平方根
        //另外一个数字一定是大于等于平方根
        int number =100;
        //如果这个范围之内,所有的数字都不能被number整除
        //那么number就一定是一个质数
        for(int i=2;i<=number的平方根;i++){
            
        }
    }
案例四:猜数字小游戏
需求:程序自动生成一个1~100之间的随机数字,使用程序实现猜出这个数字是多少?
获取随机数:
Java帮我们写好一个类叫Random,这个类就可以生成一个随机数
    

public class LoopTest{
    public static void main(String[]args){
        //先获取一个随机数
        //范围0~10
        
        //1.导包
        //2.创建对象
        Random r = new Random();
        //3.生成随机数
      	//判断技巧:
        //在小括号中,书写的是生成随机数的范围
        //这个范围一定是从0开始的
        //到这个数-(减)1结束
        //口诀:包头不包尾,包左不包右
        int number = r.next(10);//0~9
        System.out.println(number)
    }