Java语言基础

一、Java语言基础

1.1 Java概述

1.1.1 简介

计算机语言(Computer Language)是人与计算机之间通信的语言,它主要由一些指令组成,这些指令包括数字、符号和语法等内容,程序员可以通过这些指令指挥计算机进行工作。计算机语言的种类非常多,总的来说可以分成机器语言、汇编语言、高级语言三大类。

Java是一种高级计算机语言,它是由SUN公司(现已被Oracle公司收购)于1995年5月推出的一种可以编写跨平台应用软件、完全面向对象的程序设计语言。Java语言简单易用、安全可靠,自问世以来,与之相关的技术和应用发展得非常快。在计算机、移动电话、家用电器等领域中,Java技术无处不在。

1.1.2 Java语言特点

  • 简单性

Java语言是一种相对简单的编程语言,它通过提供最基本的方法完成指定的任务。程序设计者只需理解一些基本的概念,就可以用它编写出适用于各种情况的应用程序。Java丢弃了C++中很难理解的运算符重载、多重继承等概念;特别是Java语言使用引用代替指针,并提供了自动的垃圾回收机制,使程序员不必担忧内存管理。

  • 面向对象

Java语言提供了类、接口和继承等原语,只支持类之间的单继承,但支持接口之间的多继承,并支持类与接口之间的实现机制(关键字为implements)。Java语言全面支持动态绑定,而C++语言只对虚函数使用动态绑定。总之,Java语言是一个纯粹的面向对象程序设计语言。

  • 安全性

Java安全可靠,例如,Java的存储分配模型可以防御恶意代码攻击。此外,Java没有指针,因此外界不能通过伪造指针指向存储器。更重要的是,Java编译器在编译程序时,不显示存储安排决策,程序员不能通过查看声明猜测出类的实际存储安排。Java程序中的存储是在运行时由Java解释程序决定。

  • 跨平台性

Java通过JVM(虚拟机)以及字节码实现跨平台。Java程序由javac编译器编译成为字节码文件(.class)文件, JVM中的Java解释器会将.class文件翻译成所在平台上的机器码文件,执行对应的机器码文件就可以了。Java程序只要“一次编写,就可到处运行”。

  • 支持多线程

Java语言支持多线程。所谓多线程可以简单理解为程序中多个任务可以并发执行,多线程可以在很大程度上提高程序的执行效率。

  • 分布性

Java是分布式语言,既支持各种层次的网络连接,又可以通过Socket类支持可靠的流(stream)网络连接。用户可以产生分布式的客户机和服务器,在这个过程中,网络变成软件应用的分布式运载工具。

1.1.3 Java的发展史

几个重要的节点:

1991年 Java的前身"Oak"语言开始着手研发。

1995年5月23日 ,在 Oak 更名为 Java 后,Java 在 Sun world 会议上正式诞生。

2006年11月13日,Sun 公司宣布,它将在 GNU 通用公共许可第二版,类路径例外(即 GNU General Public License, version 2, with the Classpath Exception)下,将Java技术作为免费开源软件对外发布,并陆续开放源代码。

2006年11月 Sun 公司成立了 OpenJDK 开源社区组织,OpenJDK诞生。

2009年,甲骨文(Oracle)公司宣布收购 Sun(Stanford University Network Microsystems)公司。

2010年,Java编程语言的共同创始人之一詹姆斯·高斯林(Java之父)从Oracle公司辞职。 

2011年7月11日,Oracle 发布 Java SE 7 LTS 版本(长久有效版本),代号 Dolphin(海豚)。

 1.1.4 注释的方法

注释,有三种,文档注释,多行注释,单行注释
* 文档注释:/**   */    一般用于类体上面或者是方法上面
* 单行注释://......     一般用于方法里,或者用于变量附近
* 多行注释:/*    */     一般用于方法里

1.2 开发环境搭建

1.2.1 开发环境的介绍

做java开发,是需要特定环境的,我们称之为java开发环境。

JDK,全称Java Development Kit(Java开发工具包),就是java的开发环境。说的大白话一点,它就是一个资源包,我们只需要把这个资源包安装到你的电脑上,你就可以在这个环境下进行java开发了。

JDK 由两大部分组成,分别为 开发工具运行环境

1)开发工具

1. javac – 编译器,将源程序转成字节码 文件(.class文件)。              
2. jar – 打包工具,将相关的类文件打包成一个文件。
3. javadoc – 文档生成器,从源码注释中提取文档。
4. jdb – debugger,查错工具。
5. java – 运行编译后的java程序(.class后缀的)。 
6. Javap:Java反汇编器,显示编译类文件中的可访问功能和数据,同时显示字节代码含义。

2)运行环境

即Java Runtime Environment,简称JRE。即,Java的运行环境,程序员编写的java程序运行和测试所需要的环境,包含JVM系统类库

JVM(虚拟机):1.是java virtual michine的简写,一个可以模拟计算机能力的程序。

           2.Java程序在编译之后会生成.class字节码文件,这个文件会被加载到JVM虚拟机中运行。

          3.是Java跨平台的最重要的部分。

系统类型:即我们在开发程序时,系统提供给我们的资源(类)库(java.lang,java.math,java.util,java.sql,java.text等)。

3)JDK、JRE、JVM三者之间的关系

jdk里面包含开发工具和jre,jre里面包含jvm和系统类库。

1.2.2 JDK目录的介绍

bin目录:该目录用于存放一些可执行程序,如javac.exe(Java编译器)、java.exe(Java运行工具)、jar.exe(打包工具)和javadoc.exe(文档生成工具)等。

include目录:由于JDK是通过C和C++实现的,因此在启动时需要引入一些C语言的头文件,该目录就是用于存放这些头文件的。

jre目录:此目录是Java运行时环境的根目录,它包含Java虚拟机,运行时的类包、Java应用启动器以及一个bin目录,但不包含开发环境中的开发工具。

legal目录:通常包含了一些法律相关的文档和许可证文件。它主要用于提供有关JDK 8的许可和使用条款的信息。

lib目录:lib是library的缩写,意为Java类库或库文件,是开发工具使用的归档包文件。

javafx-src.zip:该压缩文件内存放的是Java FX(Java图形用户界面工具)所有核心类库的源代码。

src.zip:src.zip为src文件夹的压缩文件,src中放置的是JDK核心类的源代码,通过该文件可以查看Java基础类的源代码。

LICENSE和release:版权、许可文件。

README等说明性文档。

bin目录中

  • javac:编译器,将源程序转成字节码

  • java:打包工具,将相关的类文件打包成一个文件

  • javadoc:文档生成器,从源码注释中提取文档

  • jar:这个工具用于创建、查看和提取Java存档文件(.jar文件)。Java存档文件是一种用于打包Java类、资源文件和其他相关内容的文件格式。

  • jdb:debugger,查错工具

  • javah:产生可以调用Java过程的C过程,或建立能被Java程序调用的C过程的头文件。

  • javap:Java反汇编器,显示编译类文件中的可访问功能和数据,同时显示字节代码含义。

  • keytool:用于管理密钥和证书

  • jps:用于列出正在运行的Java进程

  • jstat:用于监视Java应用程序的统计信息

1.2.3 环境变量的配置

1. 为什么要配置环境变量

在JDK安装完成后, bin目录中存放了若干个对Java程序进行操作的命令,包括javac和java。但是 如果以后每次需要使用到这些命令的时候,都要从磁盘根目录开始找这些命令,会非常的麻烦。因 此,我们需要将bin目录添加到环境变量中,实现在任意的路径下,都可以直接使用相关的命令来 进行对Java程序的处理。

另外,某些IDE是需要读取环境变量中的JDK的路径,来识别Java环境。如果没有配置环境变量,会 导致这些IDE无法正常工作。

2. 如何配置环境变量

我的电脑右键 -> 属性 -> 高级系统设置 -> 环境变量 -> 系统变量

添加变量名:JAVA_HOME

变量值添加JDK的根路径注意,JDK的根路径指的是bin、db、include、lib等一系列目录所在的路径,即java的家。

找到Path变量,添加新值,尽量挪至最前面

%JAVA_HOME%\bin(也可以写具体路径,避免JAVA_HOME的变量值写错,导致Path变量也发生错误。

1.3 标识符

1.3.1 概念

Java语言中,对于变量,常量,函数,语句块来说,都是有名字的,这些名字,我们统统称之为Java标识符。

标识符是用来给类、对象、方法、变量、接口和自定义数据类型命名的。

1.3.2 标识符的命名规则

1)可以由字母,数字,_和$,这四种的任意多个组成,但是数字不能开头

2)大小写字母敏感,需要特别注意(严格区分大小写)。

3)可以使用汉字,但是不建议使用。

4)不能使用关键字,如int,for,if等。

5)尽量做到见名知意,多个单词时需要符合驼峰命名法。

驼峰命名法: 在遵循见名知意的前提下,有些时候一个标识符的命名可能比较长,由多个单词组成。

大驼峰: 组成一个标识符的每一个单词的首字母都是大写的
小驼峰: 首单词除外,从第二个单词开始,每一个单词的首字母都是大写的。

1.3.3 命名约定

1)类和接口名:每个单词的首字母都要大写,其他字符小写。

2)方法名:首字符小写,其余单词的首字母大写,尽量少用下划线。

3)常量名:全部大写字母,单词与单词之间用下划线分隔。

4)变量名:首字符小写,其余单词的首字母大写。不用下划线,少用美元符号。给变量命名是尽量做到见名知义。

如果某一个标识符表示的数据,在程序运行的过程中是可以发生改变的,这样的数据称为变量。 
如果某一个标识符表示的数据,在程序运行的过程中是不能发生改变的,这样的数据称为常量。

1.4 Java的入门案例

格式:
修饰词  关键字   标识符类名:大驼峰命名法
public     class    ClassName{
    
}

 1.程序员编写的文件的扩展名.java 叫java源文件。
 2.源文件中的public修饰的class只能有一个。说明文件中可以有多个class。
 3.public修饰的类的名字要尽量与文件名一模一样。
 4.类名后面的花括号及其里面的内容,称之为类体。
 5.类体的开始符号'{'应该位于类名后;结束符号'}'应该位于开始符号所在行的首字母下面。
 6.被包含的内容应该缩进2个或者是4个空格,也可以是一个tab键。
 7. main方法:固定写法,public static void main(String[] args){}
             作用:程序的入口,即JVM会最先执行main方法
 输出语句:System.out.println():会得到一个输出流,默认指向了控制台,调用流的打印并换行功能,将小括号里的数据打印到控制台,然后插入换行符。
    运行案例:
    1.编译:就是将java源文件使用javac编译器翻译成class文件(字节码文件)
         javac 源文件名称(带上扩展名)
    2.运行 :就是使用java指令启动jvm,让jvm加载class文件并执行里面的main方法
           java class文件名称(不带扩展名)

1.5 变量

1.5.1 变量的语法

语法规则: 1.变量必须先声明和初始化
                    -- 声明: 就是规定该变量要存储的数据类型,也称为定义变量。
                    int myNumber;     注意:一句话说完,使用分号表示结束。英文输入法。
                    -- 初始化: 就是给变量第一次赋值。
                    -- 初始化的时机,分别是声明时直接初始化,和使用时再初始化。 

                    int a; a = 3; 或者int a = 3;   
                   2.变量可以重复的存和取
                   -- 存: 使用等号给变量赋值。
                   -- 取: 使用变量做其他事情都是取。

                  3.变量的操作必须与声明时所强调的类型匹配,否则编译不通过。
                  4.变量是有自己的作用域。  大白话就是变量有自己的使用范围。
                  1)作用域:从声明处开始,一直到它所在的花括号的结束符号位置。
                  2)该作用域内,变量不能重复声明(定义),出了该作用域,需要重新定义(声明)。

1.5.2 变量的分类

 1.按照位置分类
      -成员变量:在方法外,类体里定义的变量。
      -局部变量:在方法里定义的变量。
   2.按照类型分类
      -基本数据类型(原始数据类型)(8种)。
      -引用数据类型*(包括数组)。

下面案例中,第10行到23行之间,是类体里面,第12行到17行之间是main方法里面,第20行到22行之间属于run方法里面。

1.6 数据类型

java语言中的数据类型可以概括为两大类:基本数据类型和引用数据类型。

1.基本数据类型中共有八种: byte,short,int,long,double,float,char,boolean。

2.其他的都是引用数据类型。

1.6.1 整数类型

类型名称占用存储空间数值范围使用场景
byte1字节(8位)-2^7^~2^7^-1(-128 ~ 127)存储字节数据(较常用)
short2字节(16位)-2^15^ ~ 2^15^ -1(-32768-32767)兼容性考虑(很少使用)
int4字节(32位)-2^31^ ~ 2^31^-1(-2147483648~2147483647)存储普通整数(常用)
long8字节(64位)-2^63^ ~ 2^63^-1(正负922亿亿,也就是19位的十进制数)存储长整数(常用)

1. Java各整数类型都有固定的表数值范围和字段长度,这样不受具体OS的影响,保证了java的可移植性。

2.赋值时,不能超出各自的范围,否则编译不通过。
3. 整数字面量,也叫整数直接量(literal),就是直接写出来的整数,是int类型。

4.int字面量,只要没有超出byte或者short的范围,是可以直接赋值给byte或short类型的变量的。      (自动截断高位的0或1)
5.int字面量,可以直接给long类型的变量赋值。     (自动补全高位的32个0或1)
6. long字面量,需要在整数后面添加小写或者大写的L

1.6.2 浮点数类型

类型名称占用内存大小数值范围使用场景
float4字节(32位)-3.403*E^38^ ~ 3.403*E^38^存储单精度(较常用)
double8字节(64位)-1.79*E^308^ ~ 1.79*E^308^

存储双精度(常用)

float: 单精度类型,能精确表示到小数点后6~7位。
            能表示的整数部分的范围在38位     long的整数范围最大是19位。

double:双精度类型,能精确到小数点后15~16位。
            能表示的整数部分的范围在308位。    
    -浮点数的字面量默认是double类型。如果想要float字面量,需要添加F/f
    -浮点数字面量后面也可以添加d/D,也可以省略。
    -浮点数的写法:    比如   5.12   3.12F    0.34     或者.34

计算误差:

二进制系统中无法精确的表示1/10,就好像十进制系统中无法精确表示1/3一样。所以,2进制表示十进制会有一些舍入误差,对于一些要求精确运算的场合会导致代码的缺陷。

1.6.3 字符类型

char类型用来表示字符。字符字面量必须用单引号(‘ ’)括起来,且只能有一个字符,涵盖世界上所有书面语的字符。除了赋值字符本身外,还可以赋值字符对应的数字,也就是0~65535中的任意一个数字。

java字符类型采用了Unicode字符集编码。Unicode是世界通用的定长字符集,所有的字符都是16位。每个字符都对应一个16位的二进制的数(每个字符占用2个字节空间大小)。
这些数的范围使用10进制表示就是0~65535。

48表示字符0在unicode的编码集里面对应的二进制数
57表示字符9在unicode的编码集里面对应的二进制数

65表示字符A在unicode的编码集里面对应的二进制数
90表示字符Z在unicode的编码集里面对应的二进制数
97表示字符a在unicode的编码集里面对应的二进制数

122表示字符z在unicode的编码集里面对应的二进制数

注意:因为char可以表示0~65355这个范围内的整数(无符号整数),因此也可以参与运算。

1.6.4 布尔类型

    类型名:boolean 占用1个字节(8位)
    值:true或false
    作用:通常用于逻辑运算,true表示正确,false表示错误
    逻辑运算:一般用于流程控制语句中(分支结构语句,循环控制结构语句),表示条件是否成立。

1.6.5 字符串类型

字符串类型的名字是String,是最常用的引用数据类型之一。

赋值的特点是,使用双引号引起来,双引号里可以有0个以上的任意多个字符。

字符串可以做拼接操作:使用+号,    即+号前后只要有一个是字符串类型,那就一定是做拼接操作,拼接的结果是字符串的类型。

1.7 类型转换

1.7.1 什么是数据类型的转换

一个变量声明完成后,已经在内存上开辟好了空间,此时这个空间大小是不允许改变的。也就是说一个 变量的类型是不允许改变的。数据类型转换,其实就是定义一个新的指定类型的变量,然后将原来的变量的值给这个新的变量进行赋值。赋值完成后,新的变量和原来的变量值基本相同,并且类型也发生了改变,因此,这个过程就被称为数据类型转换。

在数据类型转换中,分为两种转型:自动类型转换 和 强制类型转换。

int a =10;在内存中: a的空间就是 32bit 固定不变。

long b = a; 新开辟了一个空间b,64bit。 b=a :将a的值放入b里。

1.7.2 自动类型转换(隐式类型转换)

取值范围小的数据类型向取值范围大的类型转换,是自动发生的, 不需要我们进行任何操作。
取值范围从小到大: byte-->short(char)-->int-->long-->float-->double

1.7.3 强制类型的转换

在进行赋值的时候,需要额外的操作来辅助完成。常见于取值范围大的数据类型向取值范围小的数据类型转型。

注意:转换过程中,有可能发生精度损失或者是溢出。
语法:     小范围类型名     变量  =(小范围类型名)大范围变量

1.8 常用运算符

在java运算过程中,无论是什么运算,都应该遵循以下三种形式:

1.多种类型的数据进行混合运算时,都是先自动转成其中取值范围最大的那种类型,再做运算。

2.byte,short,char在做运算时不会相互转换,他们三个会优先转成int类型做运算。
 如果有其他取值范围大的类型,会选择范围最大的那种类型转换。

3.有可能会发生溢出现象(封闭式运算)

最大值+1 就变成了最小值

最小值-1 就变成了最大值

1.8.1 算术运算符

(1)自增自减运算符

++:
        符号在变量前:先加后赋值
                                 变量先自增1,然后将变量的新值赋值给表达式。
        符号在变量后:先赋值再加
                                 先将变量的值赋值给表达式,然后变量再增1。
 --:符号在变量前:先减后赋值
                                变量先加1或减1,然后将变量的新值赋值给表达式。
        符号在变量后:先赋值再减
                                 先将变量的值赋值给表达式,然后变量再减1。 

简而言之:
        符号在前:先运算后赋值
                          变量先+1或者-1,再将新值赋值给表达式。
        符号在后:先赋值后运算
                          现将变量的值赋值给表达式,变量再加1或减1。

(2)+  -  *  /  %

1. %:取模运算符,即求余数。比如:  5 % 3 = 2;
2. /:整数与整数的计算结果,还是整数。最终除如果得到一个浮点型的结果,那么这个浮点型的数字会自动的转成整数,浮点型转整数,舍去小数点后面所有的内容,直接保留整数部分。

比如:11 / 10 = 1;

1.8.2 赋值运算符

有以下几种:

=:   最简单的赋值运算符,将等号后的表达式的结果或者是变量的值赋值给等号前面的变量
+=:   如: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;

1.8.3 关系运算符

>, >=, <=, ==, !=,就是对两个数据进行大小比较。关系运算的结果一定是boolean类型。

public class RelationSymbolDemo01 {
    public static void main(String[] args) {
        int x = 10;
        int y = 20;
        System.out.println(x>y);//false
        System.out.println(x>=y);//false
        System.out.println(x<y);//true
        System.out.println(x<=y);//true
        System.out.println(x==y);//false
        System.out.println(x!=y);//true
    }
}

1.8.4 逻辑运算符

在java中,一般研究的是短路逻辑运算符。
短路逻辑运算符的特点:第一个条件如果已经可以确定最终结果,那么第二个条件就不再执行,节省时间。 短路与(&&) : 一假则假,全真为真。
              true&&true ==>  true
              true&&false ==> false
              false&&true ==> false
              false&&false ==> false
针对于短路与来说,第一个条件是false时,不再执行第二个条件,不用管他是true还是false。
public class LogicSymbolDemo01 {
    public static void main(String[] args) {
        //验证短路与
        int a = 1, b = 2, c = 3, d = 4;
        boolean f = a < b && c < d;
        System.out.println("f的值:" + f);//true
        f = a < b && c > d;//false
        System.out.println("f的值:" + f);//false
        f = a > b && c++ < d;//false
        System.out.println("f的值:" + f);
        System.out.println("c的值:" + c);//如果c的值是3,表示第二个条件根本没有执行。
        f = a > b && c > d++;//false
        System.out.println("f的值:" + f);
        System.out.println("d的值:" + d);//如果d的值是4,表示第二个条件根本没有执行。
    }
}
f的值:true
f的值:false
f的值:false
c的值:3
f的值:false
d的值:4

Process finished with exit code 0
短路或(||) : 一真则真,全假为假。
              true||true ==>  true
              true||false ==> true
              false||true ==> true
              false&&false ==> false
针对于短路或来说,第一个条件是true时,不再执行第二个条件,不用管他是true还是false。
public class LogicSymbolDemo01 {
    public static void main(String[] args) {

// 验证短路||

        int m = 1,n = 2,x = 3,y = 4;
        boolean f = m < n || x < y;
        System.out.println("f的值:"+f); // true
        f = m < n || x > y++;
        System.out.println("f的值:"+f); // true
        System.out.println("y的值:"+y); // 4  , 第一个条件为true,就可以确定最终答案, 因此没有执行自增运算,可以证明短路了。
        f = m > n || x < y;
        System.out.println("f的值:"+f); // true
        f = m > n || x > y++;
        System.out.println("f的值:"+f); // false
        System.out.println("y的值:"+y); // 5  , 因为第一个条件式false,不能立即决定最终结果,所以会执行第二个条件,
    }
}
f的值:true
f的值:true
y的值:4
f的值:true
f的值:false
y的值:5
!: 非真即假,非假即真。
public class LogicSymbolDemo01 {
    public static void main(String[] args) {
        boolean f =  !(1 > 2);
        System.out.println("f的值:"+f); //true
        f = !f;
        System.out.println("f的值:"+f); //false
f的值:true
f的值:false

1.8.5 三目运算符

三目运算符,也称为三元运算符,是条件运算符。

语法格式:boolean类型的变量或者是 表达式?值1:值2

执行逻辑: 1. 当?前的式子或变量返回true,则使用值1。

                   2. 当?前的式子或变量返回false,则使用值2。

注意:1. 该运算,依然遵循混合运算时转成取值范围最大的那种类型。

           2. 值1和值2,可以是变量,也可以是具有返回值的表达式

           3. 值1和值2的最终类型,需要能自动类型转换。

           4. 通常三目运算的最终结果,需要使用一个变量来接受,该变量的类型应该是值1或者值2中的一个。

public class ThreeEyeSymbolDemo01 {
    public static void main(String[] args) {
        int a = 1,b = 2;
        String str = a > b  ? "是a大于b" : "a不大于b";
        System.out.println(str);
        int m = 10;
        long n = 15;
        long result = n%m==1?n : m;//注意需要考虑m和n在三目运算里都已经是long类型
        System.out.println("result:"+result);
    }
}
a不大于b
result:10

1.8.6 运算符的优先级

1.运算符根据操作数的不同,可以分为:一元运算符、二元运算符、三元运算符。

一元运算符:只能操作一个操作数, ++ -- ! ~ + - (此时的+和-代表的是正负) 
二元运算符:只能操作两个操作数,
三元运算符:只能操作三个操作数,三目运算符。

2.运算符的优先级

1. 一元运算符  > 二元运算符  > 三元运算符
2. 算术运算:乘除模  > 加减
3. 逻辑运算:与  > 或
4. 赋值运算符的优先级是最低的
5. 小括号的优先级是最高的

1.9 Scanner,Random,Math常用类的使用

1.9.1 Scanner

scanner类的使用步骤:

步骤1:  导包       import java.util.Scanner;
        位置:在类的上面,package下面
步骤2:  创建扫描器对象,并使用扫面器的变量引用该对象
        Scanner  scan = new Scanner(System.in);
步骤3:使用变量调用类里提供好的方法。  通常在调用前都会使用输出打印语句来进行友好提示。
      System.out.println("请在控制台上输入一个年龄:");
      int age = scan.nextInt();
步骤4:最后,如果后续代码不再使用扫描功能,需要关闭扫描器  scan.close()
常用方式:

    基本数据类型相关方法:
         nextInt();     :扫描控制台输入的int类型的数字
         nextByte();    :扫描控制台输入的byte类型的数字
         nextShort();   :扫描控制台输入的short类型的数字
         nextLong();    :扫描控制台输入的long类型的数字
         nextFloat();  :扫描控制台输入的float类型的数字
         nextDouble();  :扫描控制台输入的double类型的数字
         nextBoolean(); :扫描控制台输入的boolean类型的数字
         next();      :扫描控制台上输入的字符串,默认以空格表示扫描结束。
         nextLine();  :扫描控制台上输入的字符串,默认以回车表示扫描结束。
注意:所有的nextxxx方法,都有阻塞效果,即阻止程序向下执行,除非扫描到数据并结束扫描,
      阻塞效果才会消失。
package com.basic.day04.scanner;
//导包
import java.util.Scanner;

public class ScannerDemo01 {
    public static void main(String[] args) {
        //步骤2:  创建对象并引用
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入几个单词,用空格隔开,这几个单词被扫描到一个变量里");
        //String words = sc.next();//扫描到空格后,表示要扫描的内容结束了。
        String words = sc.nextLine();//该方法可以扫描空格,但是尽量不要和其他扫面功能在一起使用,可能出现bug,不能扫描,直接结束。
        System.out.println("words:"+words);
        //关闭扫描器
        sc.close();
    }
}
请输入几个单词,用空格隔开,这几个单词被扫描到一个变量里
I Love You
words:I Love You

1.9.2 Random

该类型一般用于产生随机数。比如随机一个范围的整数,或者小数。
使用步骤:步骤1:导包       import java.util.Random;
                位置:在类的上面,package下面
          步骤2:创建对象,  Random r = new Random();
          步骤3:调用相关功能
                 r.nextInt(number): 产生一个[0,number)范围内的任意一个整数。
                 r.nextDouble():产生一个[0,1)范围内的任意一个小数。
扩大随机小数范围公式:
闭区间[n,m]的公式    r.nextDouble()*(m+1-n)+n;
开区间[n,m)的公式    r.nextDouble()*(m-n)+n;     可以使用int强转为随机整数范围。
public class RandomDemo01 {
    public static void main(String[] args) {

        Random r = new Random();
        //产生一个[0,10)区间的一个整数
        int i = r.nextInt(10);
        System.out.println("i=" + i);
        //产生一个[0,10]区间的一个整数
        int i1 = r.nextInt(11);
        System.out.println("i1=" + i1);
        //产生一个[-5,5]区间的一个整数
        int i2 = r.nextInt(11)-5;
        System.out.println("i2=" + i2);
        //产生一个[0,1)区间的任意一个小数
        double v = r.nextDouble();
        System.out.println("v=" + v);
    }
}
i=3
i1=0
i2=-5
v=0.866234787606376
public class RandomDemo02 {
    public static void main(String[] args) {
         Random rd = new Random();
         //随机[0,10)以内的任意小数
         double num = rd.nextDouble()*10;
         //随机[0,10)以内的任意整数
        int n1 = (int)(rd.nextDouble()*10);
        System.out.println("n1 = " + n1);
        //随机[-6,6]以内的任意整数
        int n2 = (int)(rd.nextDouble()*13-6);
        System.out.println("n2 = " + n2);
        //随机[5,15]以内的任意整数   [5,16)  *11+5
        int n3 = (int)(rd.nextDouble()*11+5);
        System.out.println("n3 = " + n3);
    }
}
n1 = 9
n2 = 0
n3 = 7

1.9.3 Math

Math: 数学工具类,里面提供了很多关于数学方面的功能方法。
使用方式:  直接使用类名,具体方法名
里面的内容分类:
    静态常量: E(自然对数)   PI(圆周率)
    常用函数:
    max():取最大值
    min():取最小值
    random():取随机数,范围[0,1)    与Random的nextDouble()效果一样
    abs(): 取绝对值
    取整函数:
    ceil(): 向上取整(大于等于某一个数的最小整数)  比如:ceil(3.4)  得到4
    floor():向下取整(小于等于某一个数的最大整数)  比如:floor(3.4) 得到3
    rint(): 返回离该数最近的整数   比如:rint(3.7)  得到4
            如果离两侧距离一致,返回偶数那侧。比如:rint(3.5) 得到4
    round(): 四舍五入
    指数函数:
    pow(): 幂函数   底数在前,指数在后
    sqt(): 平方根
    cbrt():立方根
    三角函数:
    sin()
    cos()
    asin()
    acos()
    tan()
    atan()
public class MathDemo01 {
    public static void main(String[] args) {
        System.out.println("自然对数:"+Math.E);
        System.out.println("圆周率:"+Math.PI);
        System.out.println("3和5比较,其中最大值:"+Math.max(3,5));
        System.out.println("3和5比较,其中最小值:"+Math.min(3,5));
        System.out.println("-3的绝对值:"+Math.abs(3));
        //使用Math.random()产生一个随机数,默认是[0,1)区间内的小数
        //[5,10]
        int i = (int)(Math.random() * 6 + 5);
        System.out.println("产生的随机整数:"+i);
        System.out.println("3.4向上取整:"+Math.ceil(3.4));
        System.out.println("3.4向下取整:"+Math.floor(3.4));
        System.out.println("离3.4最近的整数:"+Math.rint(3.4));
        System.out.println("3.4四舍五入后:"+Math.round(3.4));
        System.out.println("3的4次方:"+Math.pow(3,4));
        System.out.println("8的平方根:"+Math.sqrt(8));
        System.out.println("8的立方根:"+Math.cbrt(8));
    }
}
自然对数:2.718281828459045
圆周率:3.141592653589793
3和5比较,其中最大值:5
3和5比较,其中最小值:3
-3的绝对值:3
产生的随机整数:6
3.4向上取整:4.0
3.4向下取整:3.0
离3.4最近的整数:3.0
3.4四舍五入后:3
3的4次方:81.0
8的平方根:2.8284271247461903
8的立方根:2.0

  • 24
    点赞
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值