适合零基础Java的精细笔迹-整理不易,请关注并收藏,不足之处还请指正

已于 2023-03-29 20:17:54 修改
阅读量165 收藏
点赞数
文章标签： java 开发语言
于 2023-03-29 15:45:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75726607/article/details/129837917
版权

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. 编译文件

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

在这里插入图片描述

  1. 运行程序

    ​ 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,再将余数倒着拼接起来即可.
在这里插入图片描述

  1. Image图片数据

    显示器的三要素:

    ​ 分辨率

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

    1. 1920*1080

      1. 1998*1080
      2. 2048*1080
      3. 2048*858

    4K屏分辨率大致分为:

     1.  ==3840*2160==

 		2.  3996*2160
             		3.  4096*2160
            		4.  4096*1716

    ​ 像素

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

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

    ​ 三原色

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

  2. 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,将ab的值给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类型的101个字节0000 1010
short类型的102个字节0000 0000 0000 1010
int类型的104个字节0000 0000 0000 0000 0000 0000 0000 1010
long类型的108个字节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之间的随机数字,使用程序实现猜出这个数字是多少?
扩展小需求:加一个保底机制,3次猜不中,直接提示猜中了
获取随机数:
Java帮我们写好一个类叫Random,这个类就可以生成一个随机数
public class LoopTest{
    public static void main(String[]args){
        
        //注意点:
        //1.生成随机数的代码int number = r.nextInt(100)+1;
        //不能写在循环的里面的,否则每一次都会产生一个新的随机数
        
        //2.抽奖机制
        //用点券去抽水晶
        //保底 360次
        
        //计算器
        //用来统计当前已经猜了多少次
        int count=0;
        //分析:
        //1.生成一个1~100之间的随机数字
        Random r = new Random();
       int number = r.nextInt(100)+1;
        //2.猜这个数字是多少?
        Scnaner sc = new Scanner(System.in);
        while(true){
            System.out.println("请输入你要猜的数字");
            int guessNumeber = sc.nextInt();
            count++;
            if(count==3){
                System.out.println("猜中了");
                break;
            }
        //3.判断两个数字给出不同的提示
        //猜的数字大了,提示大了
        //猜的数字小了,提示小了
        //猜的数字一样,提示猜中了
            if(guessNumber>number){
                System.out.println("猜大了");
            }else if(guessNumber<number){
                System.out.println("猜小了");
            }else{
                System.out.println("猜中了");
                break;
            }
        }
    }

在这里插入图片描述

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

public class LoopTest{
    public static void main(String[]args){
        //需求:
        //随机数范围:1~100
        //创建对象
        /*Random random = new Random();
        //生成随机数
        int number = random.nextInt(101);//0~100
        System.out.println(number);*/
        //秘诀
        //可以用来生成任意数到任意数之间的随机数 比如说7~15
        //1.让这个范围头尾都减去一个值,让这个范围从0开始, -7 0~8
        //2.尾巴+1 8+1 =9
        //3.最终的结果,再加上第一步减去的值.
        Random r = new Random();
        int number = r.nextInt(9)+7;//7-15
        
        System.out.println(number);
    }

数组

数组介绍

数组:指的是一种容器,可以用来存储同种数据类型的多个值.

  1. 数组容器在存储数据的时候,需要结合隐式转换考虑.
  2. 例如:int类型的数组容器(byte/short/int)
  3. 例如:double类型的数组容器(byte/short/int/long/float/double)
  4. 建议:容器的类型,和存储的数据类型保持一致

数组的定义与静态初始化

数组的定义:

指的是一种容器,可以用来存储同种数据类型的多个值.

  1. 格式一:数据类型 [] 数组名—推荐使用

    范例: int [] array

  2. 格式二:数据类型 数组名 []

    范例: int array []

数组的初始化:

就是在内存中,为数组容器开辟空间,并将数据存入容器中的过程

静态初始化

就是在内存中,伪数组容器开辟空间,并将数据存入容器中的过程

完整格式:数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3….};

实际开发当中会使用简化格式:数据类型[]数组名={元素1,元素2,元素3….}

范例:int[]array={11,22,33};

范例:double[]array2={11.1,22.2,33.3};

数组的地址值

数组的地址值表示数组在内存中位置

public class ArrayDemo{
    public static void main(String[]args){
        //格式:
        //静态初始化
        //完整格式
        //数据类型[] 数组名=new 数据类型[]{元素1,元素2,元素3...}
        //简化格式:
        //数据类型[] 数组名={元素1,元素2,元素3...}
        
        
        //需求1:定义数组存储5个学生的年龄
        int[] arr1 = new int[]{11,12,13,14,15};
        int[] arr2 = {11,12,13,14,15};
        //需求2:定义数组存储3个学生的姓名
        String[]arr3 = new String[]{"张三","李四","王五"};
        String[]arr4 = {"张三","李四","王五"};
        //需求3:定义数组存储4个学生的身高
        double[]arr5 = new double[]{171.1,175.4,178.3,180.6};
        double[]arr6 = {171.1,175.4,178.3,180.6};
    }
    
    //扩展:
    //解释一下地址值的格式含义[D@776ec8df
    //[:表示当前是一个数组
    //D:表示当前数组里面的元素都是double类型的
    //@:表示一个间隔符号(固定格式)
    //776ec8df:才是数组真正的地址值(十六进制)
    //平时我们习惯性的会把这个整体叫做数组的地址值.
    
}

数组元素访问

格式:数组名[索引];

索引:也叫做下标,角标.

索引的特点:从0开始,祝哥+1增长,连续不间断

public class ArrayDemo{
    public static void main(String[]args){
        //利用索引对数组中的元素进行访问
        //1.获取数组里面的元素
        //格式:数组名[索引]
        int[]arr = {1,2,3,4,5};
        //获取数组中的第一个元素
        //其实就是0索引上对应的元素
         int num = arr[0];
        System.out.println(num);//1
        //获取数组中1索引上对应的数据,并直接打印出来
        System.out.println(arr[1]);//2
        //2.把数据存储到数组中
        //格式:数组名[索引] = 具体数据/变量;
        //细节:一旦覆盖之后,原来的数据就不存在了
        arr[0] =100;
        System.out.println(arr[0]);
    }

数组遍历

数组遍历:将数组中所有的内容取出来,取出来之后可以(打印,求和,判断….)

注意:遍历指的是取出数据的过程,不要局限的理解为,遍历就是打印.

public class ArrayDemo{
    public static void main(String[]args){
        //1.定义数组
        int[]arr={1,2,3,4,5};
        //2.获取数组里面所有的元素
        //格式:数组名[索引]
        /*
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);
        */
        //利用循环改进代码
        //开始条件:0
        //结束条件:数组的长度-1(最大索引)
       /* for(int i=0;i<5;i++){
            //i:0 1 2 3 4
            System.out.println(arr[i]);
        }*/
        //在Java中,关于数组的一个长度属性.length
        //调用方式:数组名.length
        System.out.println(arr.length);
    }

练习:遍历数组并求和
定义一个数组,存储1,2,3,4,5
遍历数组得到每一个元素,求数组里面所有的数据和
public class ArrayDemo{
    public static void main(String[]args){
        //分析:
        //1.定义一个数组,并添加数据1,2,3,4,5
        int[]arr = {1,2,3,4,5};
        //求和变量
        int sum = 0;
        //2.遍历数组得到每一个数据,累加求和
        for(int i=0;i<arr.length;i++){
            //i 依次表示数组里面的每一个索引
            //arr[i]依次表示数组里面的每一个元素
            sum = sum+arr[i];
        }
        //当循环结束之后,sum的值就是累加之后的结果
        System.out.println(sum);
    }

练习:统计个数;
定义一个数组,存储1,2,3,4,5,6,7,8,9,10;
遍历数组得到每一个元素,统计数组里面一共有多少个能被3整除的数字;
public class ArrayDemo{
    public static void main(String[]args){
        //分析:
        //1.定义一个数组,存储1,2,3,4,5,6,7,8,9,10
        int[]arr={1,2,3,4,5,6,7,8,9,10};
        int count =0;
        //2.遍历数组得到每一个元素
        for(int i=0;i<arr.length;i++){
            //i表示数组里面的每一个索引
            //arr[i]表示数组里面的每一个元素
            //3.判断当前的元素是否为3的倍数,如果是那么统计变量就需要自增一次
            if(arr[i]%3==0){
                //System.out.println(arr[i]);
                count++;
            }
        }
        //当循环结束之后,就表示数组里面所有的数字都判断完毕了,直接打印count即可.
        System.out.println("数组中能被3整除的数字有"+count+"个");
    }  

变化数据;
定义一个数组,存储1,2,3,4,5,6,7,8,9,10;
遍历数组得到每一个元素;
要求:
1.如果是奇数,则将当前数字扩大两倍;
2.如果是偶数,则将当前数字变成二分之一.
public class ArrayDemo{
    public static void main(String[]args){
        //分析
        //1.定义一个数组,存储1,2,3,4,5,6,7,8,9,10
        int[]arr={1,2,3,4,5,6,7,8,9,10};
        //2.遍历数组得到每一个元素
        for(int i=0;i<arr.length;i++){
            //i 依次表示数组里面的每一个索引
            //arr[i]依次表示数组里面的每一个元素
            
            //3.对每一个元素进行判断
            if(arr[i]%2==0){
                //偶数 变成二分之一
                arr[i]=arr[i]/2;
            }else{
                //奇数 扩大两倍
                arr[i]=arr[i]*2;
            }
        }
        //遍历数组
        //建议:一个循环只干一件事
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }

数组动态初始化

动态初始化:初始化时只指定数组长度,由系统为数组分配初始值.

格式:数据类型[]数组名 = new 数据类型[数组长度];

范例:int[]arr=new int[3];

public class ArrayDemo{
    public static void main(String[]args){
        /*定义一个数组,用来存班级中50个学生的姓名
        姓名未知,等学生报到之后,在进行添加.*/
        //格式:
        //数据类型[]数组名=new数据类型[数组的长度];
        //在创建的时候,由我们自己指定数组的长度,由虚拟机给出默认的初始化值
        String[]arr = new String[50];
        //添加学生
        arr[0]="张三";
        arr[1]="李四";
        //获取
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);//null
        
        //数组默认初始化值的规律:
        //整数类型:默认初始化值0
        //小数类型:默认初始化值0.0
        //字符类型:默认初始化值'/u0000' 空格
        //布尔类型:默认初始化值false
        //引用数据类型:默认初始化值null
    }

数组静态初始化和动态初始化的区别

  1. 动态初始化:手动指定数组长度,由系统给出默认初始化值.

    只明确元素个数,不明确具体数值,推荐使用动态初始化

    举例:使用数组容器来存储键盘录入的5个整数.

    int[]arr={???};

    int[]arr=new int[5];

  2. 静态初始化:手动指定数组元素,系统会根据元素个数,计算出数组的长度.

    需求中已经明确了要操作的具体数据,直接静态初始化即可.

    举例:将全班的学生成绩存入数组中 11,22,33

    int[]arr={11,22,33};

数组内存图

java内存分配

栈: 方法运行时使用的内存,比如main方法运行,进入方法栈中执行

堆: 存储对象或者数组,new俩创建的,都存储在堆内存

方法区: 存储可以运行的class文件

本地方法栈:JVM在使用操作系统功能的时候使用,和我们开发无关

寄存器:给CPU使用,和我们开发无关

在这里插入图片描述

JDK7之前的内存分配

注意:从JDK8开始,取消方法区,新增元空间.把原来方法区的多种功能进行拆分,有的功能放到了对重,有的功能放到了元空间中.

在这里插入图片描述

总结:

  1. 只要new出来的一定是在对立面开辟了一个小空间
  2. 如果new了多次,那么在对立面有多个小空间,每个小空间中都有各自的数据
  3. 当两个数组指向同一个小空间时,其中一个数组对小空间中的值发生了改变,那么其他数组再次访问的时候都是修改之后的结果了.

数组常见问题

数组常见问题:

当访问了数组中不存在的索引,就会引发索引越界异常.(ArrayIndexOfBoundsException)

public class ArrayDemo{
    public static void main(String[]args){
        //1.定义一个数组
        int[]arr={1,2,3,4,5};
        //长度5
        //最小索引:0
        //最大索引:4(数组的长度-1)
        System.out.println(arr[10]);
        
        
        //小结
        //索引越界异常
        //原因:访问了不存在的索引
        //避免:索引的范围
        //最小索引:0
        //最大索引:4(数组的长度-1)
        
    }

数组常见操作

  1. 求最值

    需求:已知数组元素为{33,5,22,44,55}

    请找出数组中的最大值并打印在控制台

    public class ArrayTest{
    public static void main(String[]args){
        //定义数组最大值:33,5,22,44,55
        
        
        //扩展问题
        //1.根据求最大值的思路,自己写一下最小值
        //2.为什么max要记录arr[0],默认值不能为0吗?
        //不能写0
        //max的初始化值一定要是数组中的值
        //3.循环的开始条件一定是0吗?
        //循环的初始条件如果为0,那么第一次循环的时候是自己跟自己比了一下,对结果没有任何影响,但是效率偏低
        //为了提高效率,减少一次循环的次数,循环开始条件可以写1.
        //1.定义数组用来存储5个值
        int[]arr={33,5,22,44,55};
        //2.定义一个变量max用来存储最大值
        int max= arr[0];
        //3.循环获取数组中的每一个元素
        //拿着每一个元素跟max进行比较
        for(int i=0;i<arr.length;i++){
            //i索引arr[i]元素
            if(arr[i]>max){
               max=arr[i]; 
            }
        }
        //4.当循环结束之后,max记录的就是数组中的最大值
        System.out.println(max);
    }

  2. 求和

    遍历数组并求和

    需求:生成10个1~100之间的随机数存入数组

    1)求出所有数据的和

    2)求所有数据的平均数

    3)统计有多少个数据比平均值小

    public class ArrayTest{
    public static void main(String[]args){
        //分析
        //1.定义数组
        //动态初始化
        int[]arr=new int[10];
        //2.把随机数存入数组当中
        Random r=new Random();
        for(int i=0;i<arr.length;i++){
            //每循环一次,就会生成一个新的随机数
            int number = r.nextInt(100)+1;
            //把生成的随机数添加到数组当中
            //数组名[索引]=数据;
            arr[i]=number;
        }
        
        //1)求出所有数据的和
        //定义求和变量
        int sum =0;
        for(int i=0;i<arr.length;i++){
            //循环得到每一个元素
            //并把元素累加到sum中
            sum = sum+arr[i];
        }
        System.out.println("数组中所有数据的和为:"+sum);
        
        
        
     //2)求所有数据的平均数
        int avg = sum /arr.length;
        System.out.println("数组中的数据平均数为:"+avg);
        
        
        //3)统计有多少个数据比平均值小
        int count =0;
        for(int i =0;i<arr.length;i++){
            if(arr[i]<arg){
                count++;
            }
        }
        //当循环结束之后,就表示我已经找到了所有的比平均数小的数据
        System.out.println("在数组中一共有"+count+"个数据,比平均数小");
        //遍历数组,验证答案
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"");
        }
    }

  3. 交换数据

    练习:交换数组中的数据

    需求:定义一个数组,存入1,2,3,4,5.按照要求交换索引对应的元素

    交换前:1,2,3,4,5

    交换后:5,4,3,2,1

    public class ArrayTest{
    public static void main(String[]args){
      /*需求:定义两个变量,交换两个变量记录的值*/
        int a=10;
        int b=20;
        /*//把变量b的值,赋值给了变量a,那么变量a原来的值就被覆盖了
        a=b;//a=20,b=20
        //把变量a的值,赋值给了变量b
        b=a;//a=20,b=20
        System.out.println(a);//20
        System.out.println(b);//20*/
        
        //定义一个临时的第三方变量
        //把变量a的值,赋值给了temp
        int temp =a;
        //把变量b的值,赋值给了a,那么变量a原来记录的值就被覆盖了
        a=b;
        //就是把变量a原来的值,赋值给了变量b
        b=temp;
        System.out.println(a);//20
        System.out.println(b);//10
    }

    public class ArrayTest{
    public static void main(String[]args){
        /*需求:定义一个数组,将数组中0索引和最大索引出的值进行交换*/
        //1.定义一个数组
        int[]arr={1,2,3,4,5};
        //2.将数组中0索引和最大索引出的值进行交换
        //也是可以利用第三方变量进行交换
        int temp = arr[0];
        arr[0]=arr[4];
        arr[4]=temp;
        //3.遍历数组
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"");
        }
    }

    public class ArrayTest{
    public static void main(String[]args){
        /*定义一个数组,存入1,2,3,4,5.交换首尾索引对应的元素

交换前:1,2,3,4,5

交换后:5,4,3,2,1*/
        //1.定义数组存储数据
        int[]arr={1,2,3,4,5};
        //2.利用循环去交换数据
        for(int i=0,j=arr.length-1;i<j;i++,j--){
            //交换变量i和变量j指向的元素
            int temp=arr[0];
            arr[i]=arr[j];
            arr[j]=temp;
        }
        //当循环结束之后,那么数组中的数据就实现了头尾交换
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]+"");
        }
    }

  4. 打乱数据

练习:打乱数组中的数据;
需求:定义一个数组,存入1~5.要求打乱数组中的所有数据的顺序
public class ArrayTest{
    public static void main(String[]args){
        //难点:
        //如何获取数据中的随机索引
        /*int[]arr={1,2,3,4,5};
        //索引范围:0,1, 2, 3, 4 
        Random r = new Random();
        int randomIndex = r.nextInt(arr.length);
        System.out.println(randomIndex);*/
        
        //1.定义数组存储1~5
        int[]arr={1,2,3,4,5};
        //2.循环遍历数组,从0开始打乱数据的顺序
        Random r = new Random();
        for(int i=0;i<arr.length;i++){
            //生成一个随机索引
            int randomIndex = r.nextInt(arr.length);
            //拿着随机索引指向的元素i指向的元素进行交换
            int temp =arr[i];
            arr[i]=arr[randomIndex];
            arr[randomIndex]=temp;
        }
        //当循环结束之后,那么数组中所有的数据已经打乱顺序了
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"");
        }
    }

方法

什么是方法?

方法(method)是程序中最小的执行单元.

在实际开发中,什么时候用到方法?

重复的代码,具有独立功能的代码可以抽取到方法中.

实际开发中,方法有什么好处?

可以提高代码的复用性

可以提高代码的可维护性

方法的格式

把一些代码打包在一起,用到的时候就调用

方法定义:

​ 把一些代码打包在一起,该过程称为方法定义

方法的 定义 格式

最简单的方法定义 调用方式

在这里插入图片描述

public class MethodDemo{
    public static void main(String[]args){
        //目标:掌握最简单的方法定义和调用的格式
        //调用方法
        playGame();
    }
    public static void playGame(){
        System.out.println("选人物");
        System.out.println("准备开局");
        System.out.println("对线");
        System.out.println("崩盘");
        System.out.println("骂队友");
        System.out.println("送人头");
        System.out.println("GG");
    }

方法调用:

​ 方法定义后并不是直接运行的,需要手动调用才能执行,该过程称为方法调用

练习:展示女朋友的信息;
需求:定义一个方法,在方法内部打印你女朋友的所有信息;
public class MethodDemo{
    public static void main(String[]args){
        //调用方法
        printGFIbfo();
    }
    public static void printGFInfo(){
        System.out.println("小慧慧");
        System.out.println("萌妹子");
        System.out.println("18岁");
    }

需要掌握的两个核心:

  1. 看到方法进入方法
  2. 执行完毕回到调用处,继续往下执行
带参数的方法定义 调用方式
形参和实参
  1. 形参 :全称形式参数,是指方法定义中的参数.
  2. 实参:全称实际参数,方法调用中的参数.

注意:方法调用时,形参和实参必须一一对应,否则程序将报错.

方法定义的小技巧
  1. 我要干什么?————————————–方法体
  2. 我干这件事情需要什么才能完成?————-形参

在这里插入图片描述

在这里插入图片描述

public class MethodDemo{
    public static void main(String[]args){
        //目标:掌握带参数方法定义的格式和调用的格式
        getSum(10,20);
    }
    public static void getSum(int num1,int num2){
        int result = num1+num2;
        System.out.println(result);
    }

public class MethodDemo{
    public static void main(String[]args){
        //需求:定义一个方法,求长方形的周长,将结果在方法中进行打印.
        //目标:根据不同的需求,选择定义午无参的方法,还是带参数的方法
        getLength(5.2,1.3);
    }
    //1.我要干嘛?求长方形的周长
    //2.我干这件事情,需要什么才能完成?长/宽
    public static void getLength(double len,double width){
        double result = (len+width)*2;
        System.out.println(result);
    }

public class MethodDemo{
    public static void main(String[]args){
        //需求:定义一个方法:求圆的面积,将结果在方法中进行打印.
        //目标:根据不同的需求,选择定义无参的方法,还是带参数的方法
    }
    //1.我要干嘛?求圆的面积
    //2.我干这件事情,需要什么才能完成?半径的平方*π
    //                            半径π
    public static void getArea(double radius){
        double result = radius*radius*3.14;
        System.out.println(result);
    }
带返回值的方法的定义 调用方式

方法的返回值其实就是方法运行的最终结果

  1. 如果在调用处要根据方法的结果,去编写另外一段代码逻辑
  2. 为了在调用处拿到方法产生的结果,就需要定义带有返回值的方法

在这里插入图片描述

在这里插入图片描述

方法的注意事项:

  1. 方法不调用就不执行

  2. 方法与方法之间是平级关系,不能互相嵌套定义

  3. 方法的编写顺序和执行顺序无关,与调用顺序有关

  4. 方法的返回值类型为void,表示该方法没有返回值,

    没有返回值的方法可以省略return语句不写.

    如果要编写return,后面不能跟具体的数据.

  5. return语句下面,不能编写代码,因为永远 执行不到,属于无效的代码.

    1. 方法没有返回值:可以省略不写.如果书写,表示结束方法
    2. 方法有返回值:必须要写.表示结束方法和返回结果.
public class MethodDemo{
    public static void main(String[]args){
       //目标:掌握带返回值方法的定义和调用格式
        //直接调用
        getSum(10,20,30);
        
        //赋值调用
        int sum = getSum(10,20,30);
        System.out.println(sum);
        
        //输出调用
        System.out.println(getSum(10,20,30));
        
        //先计算第一个季度的营业额
        int sum1 = getSum(10,20,30);
        //再计算第二个季度的营业额
        int sum2 = getSum(20,30,40);
        //计算第三个季度的营业额
        int sum3 = getSum(20,30,40);
        //计算第四个季度的营业额
        int sum4 = getSum(20,30,40);
        
        //求全年的总营业额
       int sum = sum1+sum2+sum3+sum4;
        System.out.println(sum);
    }
    public static int getSum(int num1,int num2,int num3){
       int result =num1+num2+num3; 
        return result;//返回给方法的调用处
    }

总结:

  1. 什么时候用到有返回值的方法?

    在调用处要根据方法的结果,去编写另外一段代码.

  2. 有返回值方法的定义格式

    public static 返回值类型 方法名(参数){
    方法体;
    return 返回值;
}

  3. 有返回值方法的调用格式

    直接调用,赋值调用最常用,输出调用

  4. 有返回值方法中参数的运行过程

public class MethodDemo{
    public static void main(String[]args){
        //目标:要能区分出什么时候使用带返回值的方法
        //需求:定义方法,比较两个长方形的面积
        //调用方法获取长方形的面积,在进行比较
        double area1 = getArea(5.3,1.7);
        double area2 = getArea(2.4,2.7);
        if(area1>area2){
            System.out.println("第一个长方形更大");
        }else{
             System.out.println("第二个长方形更大");
        }
    }
    
    //定义一个方法求长方形的面积;
    //1.我要干嘛?比较两个长方形的面积
    //2.需要什么?两个长,两个宽
    //3.方法的调用处,是否需要继续使用方法的结果.
    //如果要用,那么方法必须有返回值
    //如果不要用,方法可以写返回值,也可以不写返回值.
    public static double getArea(double len,double width){
        double area = len*width;
        return area;
    }
    //在以后实际开发中,我们一般是把重复的代码或者具有独立功能的代码抽取到方法当中.
    //以后我们直接调用就可以了
    
    //1.我要干嘛?比较两个长方形的面积
    //2.需要什么?两个长,两个宽
    /*public static void compare(double len1,double width1,double len2,double width2){
        double area1 = len1*width1;
        double area2 = len2*width2;
        if(area1>area2){
            System.out.println("第一个长方形更大");
        }else{
            System.out.println("第二个长方形更大");
        }
    }*/

方法的重载

定义:在同一个类中,定义了多个同名的方法,这些同名的方法具有相同的功能.

每个方法具有不同的参数类型或参数个数,这些同名的方法,就构成了重载关系.

简单记忆:同一个类中,方法名相同,参数不同的方法,与返回值无关.

​ 参数不同:个数不同/类型不同/顺序不同

要求:

  1. 会判断方法之间是否构成重载关系

    顺序不同可以构成重载,但是不建议!

  2. 会定义重载的方法

    public class Test{
    public static void main(String[]args){
        /*需求:使用方法重载的思想,设计比较两个整数是否相同的方法.
        要求:兼容全整数类型(byte,short,int,long)*/
        //调用
        compare(10,20);
        
    }
    //会把相同功能的方法名起成一样的名字
    //好处1:定义方法的时候可以不用那么多的单词了
    //好处2:调用方法的时候也不需要那么麻烦了
    public static void compare(byte b1,byte b2){
        System.out.println(b1==b2);
    }
    public static void compare(short s1,short s2){
        System.out.println(s1==s2);
    }
    public static void compare(int i1,int i2){
        System.out.println(i1==i2);
    }
    public static void compare(long n1,long n2){
      System.out.println(n1==n2);  
    }

    练习:数组遍历;
需求:设计一个方法用于数组遍历,要求便利的结果是在一行上的.例如[11,22,33,44,55]
public class Test{
 public static void main(String[]args){
        //1.定义数组
        int[]arr={11,22,33,44,55};
        
        //2.调用方法遍历数组
        ptintArr(arr);
        
        /*System.out.println("abc");//先打印abc,再进行换行;
        System.out.print("abc");//只打印abc,不换行;
        System.out.println();//不打印任何数据,只做换行处理*/
        
    }
    //定义方法用于数组的遍历
    //1.我要干嘛? 遍历数组
    //2.我干这件事情,需要什么才能完成?   数组
    //3.方法的调用处是否需要继续使用结果?不需要返回值
    public static void printArr(int[]arr){
        System.out.println("[");
        for(int i=0;i<arr.length;i++){
            if(i=arr.length-1){
                System.out.print(arr[i]);
            }else{
                System.out.print(arr[i]+",");
            }
        }
        System.out.println("]");
    }

    练习:求数组的最大值;
需求:设计一个方法求数组的最大值,并将最大值返回;
public class Test{
    public static void main(String[]args){
        //1.定义数组
        int[]arr={1,5,7,3,8,10};
        //2.调用方法最大值
        int max = getMax(arr);
        //3.打印
        System.out.println(max);
    }
    //需求:设计一个方法求数组的最大值,并将最大值返回;
    //1.我要干嘛? 求最大值
    //2.我干这件事情,需要什么才能完成?   数组
    //3.方法的调用处是否需要继续使用结果?需要返回值
    public static int getMax(int[]arr){
        int max = arr[0];
        for(int i =1;i<arr.length;i++){
           if(arr[i]>max){
              max=arr[i]; 
           } 
        }
        return max;
    }

    练习:判断是否存在;
定义一个方法判断数组中的某一个数是否存在,将结果返回给调用处;
public class Test{
    public static void main(String[]args){
        //1.定义数组
        int[]arr={1,5,8,12,56,89,34,67};
        //2.判断一个数字在数组中是否存在了
       boolean flag = contains(arr,89);
        System.out.println(flag);
    }
    
    
    //1.我要干嘛? 判断数字在数组中是否存在
    //2.我干这件事情,需要什么才能完成?   数组 数字
    //3.方法的调用处是否需要继续使用结果?返回true false
    public static boolean contains(int[]arr,int number){
        for(int i=0;i<arr.length;i++){
            if(arr[i]==number){
                return true;
            }
        }
        //什么时候才能断定89,在数字中是不存在的?
        //当数组里面所有的数据全部比较完毕之后,才能断定
        return false;
    }
    //return与break关键字的区别
    //return:其实跟循环没有什么关系,它是跟跟方法有关的,表示1结束方法,2返回结果
    //如果方法执行到了return,那么整个方法全部结束,里面的循环也会随之结束了
    //break关键字
    //其实跟方法也没有什么关系,它是跟结束循环和switch有关的.

    练习:复制数组;
需求:定义一个方法copyOfRange(int[]arr,int form,int to);
功能:将数组arr中从索引from(包含from)开始.
到索引to结束(不包含to)的元素赋值到新数组中,将新数组返回;
public class Test{
    public static void main(String[]args){
        //1.定义原始数组
        int[]arr={1,2,3,4,5,6,7,8,9};
        
        //2.调用方法拷贝数组
       int[]copyArr = copyOfRange(arr,3,7);
        //3.遍历copyArr
        for(int i=0;i<copyArr.length;i++){
            System.out.println(copyArr[i]+"");
        }
    }
    
    //将数组arr中从索引from(包含from)开始,到索引to结束(不包含to)的元素赋值到新数组中
    public static int[]copyOfRange(int[]arr,int from,int to){
        //1.定义数组
        int[]newArr=new int[to-from];
        //把原始数组arr中的from到to上对应的元素,直接拷贝到newArr中
        //伪造索引的思想---在代码中没有一个变量能表示当前索引变化的范围时用
        int index=0;
        for(int i=from;i<to;i++){
            //格式:数组名[索引]=数据值;
            newArr[index]=arr[i];
            index++;
        }
        //3.把新数组返回
        return newArr;
    }

方法的内存

JAVA内存分配

  • 栈 方法运行时使用的内存,方法进栈运行,运行完毕就出栈

    方法被调用之后就会进栈执行

    栈内存先进后出

  • 堆 new出来的,都在堆内存中开辟了一个小空间.

  1. 方法调用的基本内存原理

  2. 方法传递基本数据类型的内存原理

    基本数据类型中:变量中存储的是真实的数据

    从内存的角度去解释:

    ​ 基本数据类型:数据值是存储在自己的空间中

    ​ 特点:赋值给其他变量,也是赋的真是的值

  3. 方法传递引用数据类型的内存原理

    引用数据类型中:只要是new出来的都是引用数据类型

    变量中存储的是地址值

    引用:使用了其他空间中的数据

    引用数据类型:数据值是存储在其他空间中,

    自己空间中存储的是地址值.

    特点:赋值给其他变量,赋的地址值.

有你不孤单啊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
阿里十年架构师纯手写的Java核心知识笔记限时分享，全程无废话
aa119101的博客
01-05 279
这本Java岗必备核心笔记，对于程序员来说真是一大福音，不管是初学者，还是资深架构师相信都能让你受益匪浅。此笔记不但内容覆盖面广， 条理清晰，而且图文并茂，使读者更易懂。
Java 学习笔记(手写版)
心海非海_のBlog
10-25 2475
Java 学习笔记(手写版) 文章目录Java 学习笔记(手写版)变量控制流程包机制 & 用户交互 Scanner方法（函数） & 驼峰命名法递归 & 数组OOP & 构造器封装继承 （super & this）方法重写 静态方法 & 非静态方法多态 & instance of & 类型转换static 关键字抽象类接口 & 实现类内部类正则表达式异常注解反射//..多线程基本概念线程创建静态代理模式 & 函数式接口 &amp
全套java笔记0002oracle简价
10-24
全套的开发笔记，是按小节分的，分的很详细.可分开下载的，挑你需要的下就行。
0基础java笔记（自记）
02-21
自己记得笔记，完全手写，0基础中的零基础，小白中的小白
javaweb博客系统(纯手写，无框架)
07-08
本人2年前手写的web博客系统，功能简单，可以发布文章、添加好友、发表评论、上传照片等，可供学习javaweb的初级程序员参考，内附数据库脚本文件blogs.sql，使用mysql数据库，不使用任何框架，由servlet完成功能跳转
行业分类-设备装置-手写笔迹的处理方法及装置.zip
09-02
手写笔迹的处理方法及装置是信息技术领域中一个重要的细分方向，主要涉及人机交互、数字信号处理、模式识别等多个技术领域。在现代社会，随着移动设备和智能硬件的普及，手写输入作为一种自然且直观的交互方式，被...
行业分类-设备装置-笔迹校验装置和笔迹校验方法.zip
08-23
《笔迹校验装置和笔迹校验方法》是一份深度探讨笔迹识别技术的资料，主要关注在设备装置和方法层面的应用。该文件可能涵盖了以下几个重要的知识点： 1. **笔迹识别技术基础**：笔迹识别是生物特征识别技术的一种，...
行业分类-设备装置-笔迹数据生成系统以及笔迹数据生成方法.zip
08-23
《行业分类-设备装置-笔迹数据生成系统以及笔迹数据生成方法》 笔迹数据生成系统和方法是信息技术领域中的一个重要组成部分，特别是在生物识别、人机交互和数字签名等应用中发挥着至关重要的作用。这类系统的主要...
行业分类-设备装置-笔迹识别工具.zip
08-23
笔迹识别技术，作为一种生物特征识别方法，近年来在设备装置领域中得到了广泛的关注与应用。这一技术基于个人独特的书写习惯和笔迹特征，通过计算机算法进行分析和比对，实现对书写者身份的自动识别。在行业分类中，...
行业文档-设计装置-笔迹练习系统及练习笔迹自动评测方法.zip
08-21
《笔迹练习系统及练习笔迹自动评测方法》是一份深入探讨如何利用现代技术来提升书写技能和评估书写效果的专业文档。在这个数字化时代，虽然键盘输入已成为主流，但良好的手写能力仍然在很多领域，如教育、签名验证、...
java上课笔记
04-10
面向对象，封装，继承，多态，重载和重写的区别。接口，final关键字等笔记
关于手写笔记、电子笔记、摘录的思考
caishu1995的博客
10-09 1784
    技术类的，很多可能学习的时候了解的不够深刻，只能是真正用到了，才会深入的了解，理解的深刻。那他只能用摘录的方式咯。     思维类的，摘录就没意思了，可能会因为一句话有一些别的感慨。或者一堆。相对于电子笔记，我还是更喜欢手写（顺便欣赏和练练我的字，(〃'▽'〃)啦啦啦，自恋会）但如果感慨太多，还是电子版的版，哈哈，懒！！...
java手写版笔记
bing__x的博客
03-22 2050
java手写操作日志功能:切面实现及验证(四)
绅士jiejie的博客
08-08 1523
直接贴代码，干脆利落 Aspect @Component public class OperationLogAspect { /** * 修改内容汇总 */ private List<Map<String, List<Map<String, Object>>>> mapArrayList = new ArrayList<>(); /*...
java手写版笔记_自己手写理解这些String类的常用方法，评论和笔记有字数上限，大家可以复制到eclipse中学习下哦...
weixin_31614747的博客
02-26 217
源自：2-3 Java 中 String 类的常用方法 Ⅰ自己手写理解这些String类的常用方法，评论和笔记有字数上限，大家可以复制到eclipse中学习下哦import java.util.Arrays;public class Best {public static void main(String[] args){String i = " Hello 。World！ 你好 。世界";St...
阿里P8大牛手写的源码笔记：Java集合+Java多线程+MyBatis+Spring
一入Java深似海
05-07 2247
Java集合源码笔记 Java集合是我认为在Java基础中最最重要的知识点了，Java集合是必须掌握的。我在实习/秋招面试的时候，只要是面到Java，那一定是少不了Java集合。 如何入门Java集合以及每个常用的子类我在PDF整理好了，这份PDF绝对令你满意。 内容介绍 学习指南 Collection List集合 Map集合 HashMap LinkedHashMa...
黑马程序员_java加强手写笔记
u012573336的专栏
01-12 827
---------------------- ASP.Net+Android+IOS开发、href="http://edu.csdn.net"target="blank">.Net培训、期待与您交流！ ---------------------- ---------------------- ASP.Net+Android+IOS开发、
java学习笔记.10——书写格式
qq_14926317的博客
11-05 518
书写格式看过不少书和视频了，时常能够看见这些提示：书写代码最好规范，当你与他人共同编码是更是如此。规范的代码能够迅速获取信息，减少时间成本。所以今天来总结一下java中一种阅读方便，排版清晰的规范格式。基本格式就不作赘述，比如缩进 花括号另起一行，上下对齐。（代码呈块状，不用担心漏写了花括号） class Demo { public method() { ...
01背包问题详解Java(手写笔记)(超详细)
qq_45818845的博客
04-16 864
有 NN 件物品和一个容量是 VV 的背包。每件物品只能使用一次。 第 ii 件物品的体积是 vivi，价值是 wiwi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行两个整数，N，VN，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 NN 行，每行两个整数 vi,wivi,wi，用空格隔开，分别表示第 ii 件物品的体积和价值。 输出格式 输出一个整数，表示最大价值。 数据范围 0<N,V≤10000<N,V≤1000 0
java 多笔迹中提取相似笔迹
最新发布
06-02
Java 多笔迹中提取相似笔迹可以通过计算笔迹的相似度来实现。以下是一个基于笔迹点集的相似度计算示例： ```java public class Stroke { private List<Point> points; public Stroke(List<Point> points) { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

有你不孤单啊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值