Java语言基础

m0_74846139

已于 2024-07-25 08:20:56 修改

阅读量888

点赞数 7

文章标签： java 开发语言

于 2024-07-23 21:59:01 首次发布

本文链接：https://blog.csdn.net/m0_74846139/article/details/140567326

版权

1.java概述

（1）简介

Java是一种高级计算机语言，它是由SUN公司（现已被Oracle公司收购）于1995年5月推出的一种可以编写跨平台应用软件、完全面向对象的程序设计语言。

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

2009年，甲骨文（Oracle）公司宣布收购 Sun（Stanford University Network Microsystems）公司

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

针对不同的开发市场，SUN公司将Java划分为三个技术平台，它们分别是JavaSE、JavaEE和JavaME。

1. Java SE（Java Platform Standard Edition）标准版

他是三个平台中最核心的部分，其他两个都是在他的基础上开发出来的，JavaSE平台中包括了Java最核心的类库，如集合、IO、数据库连接以及网络编程等。

2.Java EE(Java Platform Enterprise Edition) 企业版

Java EE可以被看作一个技术平台，该平台用于开发、装配以及部署企业级应用程序，主要包括Servlet、JSP、JavaBean、JDBC、EJB、Web Service等技术。

3.Java ME(Java Platform Micro Edition) 小型版

JavaME主要用于小型数字电子设备上软件程序的开发。 Java ME还提供了HTTP等高级Internet协议，使移动电话能以Client/Server方式直接访问Internet的全部信息，提供高效率的无线交

（2）java语言的特点

1.简单性：Java语言是一种相对简单的编程语言，它通过提供最基本的方法完成指定的任务。丢弃了C++中很难理解的运算符重载、多重继承等概念；特别是J Java语言使用引用代替指针，并提供了自动的垃圾回收机制，使程序员不必担忧内存管理

2.面向对象：Java语言提供了类、接口和继承等原语，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为implements）。

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

4.跨平台性：Java通过JVM（虚拟机）以及字节码实现跨平台。Java程序由javac编译器编译成为字节码文件（.class）文件， JVM中的Java解释器会将.class文件翻译成所在平台上的机器码文件，执行对应的机器码文件就可以了。

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

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

2.开发环境搭建（重点）

（1）开发环境介绍（JDK）

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

JDK，全称Java Development Kit（Java开发工具包），就是java的开发环境。

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

1.开发工具

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

2.运行环境JRE（重点）

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

1.JVM

是java virtual michine的简写，一个可以模拟计算机能力的程序。
Java程序在编译（通过javac编译器编译）之后会生成.class字节码文件，这个文件会被加载到JVM虚拟机中运行。
是Java跨平台的最重要的部分。

2.系统类库

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

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

4.JDK目录介绍

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

javac：编译器，将源程序转成字节码（即将.java文件编译成.class文件）

java：打包工具，将相关的类文件打包成一个文件（将.class文件转成所在平台的机器码文件）

javadoc：文档生成器，从源码注释中提取文档

include目录：存放C++的头文件。
jre目录：此目录是Java运行时环境的根目录，它包含Java虚拟机，运行时的类包、Java应用启动器以及一个bin目录，但不包含开发环境中的开发工具。
legal目录：通常包含了一些法律相关的文档和许可证文件。
lib目录：lib是library的缩写，意为Java类库或库文件，是开发工具使用的归档包文件。

3.标识符

（1）标识符的命名规则

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

可以由字母，数字，_和$，这四种的任意多个组成，但是数字不能开头
大小写字母敏感，需要特别注意（严格区分大小写）
可以使用汉字，但是不建议使用
不能使用关键字，如int,for,if等
尽量做到见名知意，多个单词时需要符合驼峰命名法

4.命名约定

1）类和接口名：每个单词的首字母都要大写，其他字符小写。（即大驼峰命名法）

2）方法名：首字符小写，其余单词的首字母大写，尽量少用下划线。（小驼峰命名法）

3）常量名：全部大写字母，单词与单词之间用下划线分隔。

4）变量名：首字符小写，其余单词的首字母大写。不用下划线，少用美元符号。给变量命名是尽量做到见名知义。（小驼峰命名法）

5.java最基础的语法结构

public class MyFirstProgramer{
      //main方法  作用：程序的入口，即jvm会最先执行main方法
      public static void main(String[] args){
          System.out.println("helllo world");
	  }
}

修饰词关键字标识符类名：大驼峰命名法
public class className{
}

编写完后执行程序：

1.编译：就是将java源文件使用javac编译器翻译成class文件（字节码文件）
javac 源文件名称（带上扩展名）（如上述的：javac MyFirstProgramer.java)
2.运行：就是使用java指令启动jvm，让jvm加载class文件并执行里面的main方法
java 源文件名称（不带扩展名）(java MyFirstProgramer)

6.变量

1.概念

jvm在其管理的内存中会开辟很多个空间、这些空间用来存储数据，而这些存储空间里的数据也会根据我们不同时间的不同需求而变化，那么，这样的存储空间，我们需要给他们命名，我们可以通过这些名字来操纵(使用)这些存储空间。这些名字就是我们所说的变量。

2.变量必须先声明和初始化

声明的含义：因java是强类型语言，因此在定义变量名时，必须先声明该变量的所属类型，强调该变量要存储的数据类型

语法：数据类型名变量名（小驼峰命名法）；（需要英文输入的分号做结束）
初始化含义：存储空间第一次存储数据。

语法：变量名 = 初始化值。
初始化时机：

1) 使用前进行初始化： int a； a = 3;

2) 声明类型时直接初始化：int a = 3;

只进行了声明，没有初始化就直接打印变量时会出现编译错误的。

public class MyFirstProgramer{
      public static void main(String[] args){
          int   num;
          Sysytem.out.println(num);//编译出错
	  }
}

变量在重复赋值时，后一次赋的值会覆盖掉上一次赋的值的。

public class MyFirstProgramer{
      public static void main(String[] args){
            int a = 10;
		    a = 5;//将5存入a变量里，原有的10被5覆盖掉了。
		    a = 50;//将5存入a变量里，原有的5被50覆盖掉了。
		    a = a + 6;//使用a里的50与6做加法计算，结果56再次存入a中，把之前的50覆盖掉。
            System.out.println(a);
	  }
}

3.变量的操作必须与类型匹配

就是在声明和初始化时，初始化时的数据必须和声明的数据类型一致

public class MyFirstProgramer{
      public static void main(String[] args){
            int a = 10;
		    a = 10.2；
            System.out.println(a);//编译出错
	  }
}

4. 变量的作用域

变量是有自己的作用域。即变量有自己的使用范围
1）作用域：从开始声明处开始，一直到它所在的花括号的结束符号位置。
2）该作用域内，变量不能重复声明（定义），出了作用域，需要重新定义（声明）

public class Draft{
      public static void main(String[] args){
        int a = 10 ;
		if (a > 50){
			int b = a*2;
		}else{
			int c = a-10;
			//long a = 100;//a这个变量已经在改作用域中存在，因此不能重复定义。
		}
		long c = 1000;//该处的c变量是重新定义的，该作用域没有重复的c变量。因此可以使用。
		System.out.println(a);
		System.out.println(b);//b这个变量已经出了它自己的作用域，编译出错
		System.out.println(c);	
	  }
}

5.变量的分类

变量的分类：
1.按照位置分类
   -成员变量：在方法外，类体里定义的变量
       -局部变量：在方法里定义的变量
   2.按照类型分类
   -基本数据类型（原始数据类型）（8种）
-引用数据类型（包括数组）

7.数据类型

基本数据类型的归类：

（1）整数类型

类型名称占用存储空间数值范围

byte 1字节（8位） （-128~127）

short 2字节（16位） （-32768~32767）

int 4字节（32位） （-2147843648~2147483647）

long 8字节（64位） -2^63^ ~ 2^63^-1

1. 赋值时，不能超出各自的范围，否则编译不通过。

2.整数字面量，也叫整数直接量(literal)，就是直接写出来的整数，是int类型。

3.int字面量，只要没有超出byte或者short的范围，是可以直接赋值给byte或short类型的变量的 (自动截断高位的0或1)

4.int字面量，可以直接给long类型的变量赋值。 (自动补全高位的32个0或1)

5.long字面量，需要在整数后面添加小写或者大写的L。

public class TypeDemo01{
	public static void main(String[] args){
		byte  b1=10;
		//byte  b2=128;//编译出错。byte的最大值127.
		int n1=2147483647;//int的最大值2147483647
		//int n2=2147483648;//编译出错。int的最大值2147483647.
		
		
		short s1=10;//10是int类型，因为没有超出short的范围，因此可以直接赋值给short。
		long  lo1=1000;//1000是字面值，是int类型，因为没有超出long的范围，因此可以直接赋值给long。
		long  lo2=10L;//10L是long类型，直接就是64位的二进制数
		System.out.println(b1);
		System.out.println(n1);
		System.out.println(s1);
		System.out.println(lo1);
		System.out.println(lo2);
		//long lo3 = 2200001111;//编译出错，因为字面量就是int类型，因此不可以超出int类型的范围。
		long lo4 = 2200001111L;
		//System.out.println(lo3);
		
		
	}
}

（2）浮点类型（浮点数的字面量默认是double类型。）

类型名称占用存储空间数值范围

float 4字节(32位) 单精度类型，能精确表示到小数点后6~7位
能表示的整数部分的范围是38位

double 8字节(64位) 双精度类型能精确表示到小数点后15~16位
能表示的整数部分的范围是308位

1.-浮点数的字面量默认是double类型。

如果想要float字面量，需要添加F或f。 -浮点数字面量后面也可以添加D/d，也可以省略。

public class Draft{
      public static void main(String[] args){
        float f1 = 3.14;//字面量是double类型的，在后面加上F或者f，就变成float的字面量。
		System.out.println(f1);
	  }
}

2.赋值时，小数点后面的位数过多时，打印出来的结果不是原原来的值。

public class Draft{
      public static void main(String[] args){
        float  f10=0.123456789f;//将小数存入float类型的变量空间f10里面
		double  d10=0.1234567890123456789;//将小数存入double类型的变量空间d10里面
		System.out.println(f10);//取出来的值，发现不是原来的值
		System.out.println(d10);//取出来的值，发现不是原来的值
	  }
}

3. 在计算时会出现误差

二进制系统中无法精确的表示1/10,就好像十进制系统中无法精确表示1/3一样。

public class Draft{
      public static void main(String[] args){
        double  d101=3.0;
		double  d102=2.9;
		System.out.println(d101-d102);//计算时有误差，并不精确。
	  }
}

（3）字符类型

类型名称占用内存大小范围

char 2字节（16位）书面上所有的字符（如：‘中’，’a’，‘A’，‘0’，‘^’）

char类型用来表示字符。字符字面量必须用单引号(‘ ’)括起来，且只有一个字符，涵盖世界上所有书面语的字符。

1.转义字符‘\’

对于不方便输出的字符，采用转义字符来表示，例如：

\n : 表示回车符号 \t:表示空格 \r :表示换行符 \\: 表示反斜杠 \':表示单引号

2.字符集

char也是一个16位无符号整数，整数范围为0~65535。每个整数都是对应字符的编码。

java字符类型采用了Unicode字符集编码。Unicode是世界通用的定长字符集，所有的字符都是16位。

常见的赋值方式：

可以赋值字符，使用单引号，能且只能是一个字符
可以赋值十进制整数，范围为0~65535。

注意：因为char可以表示0~65535这个范围内的整数（无符号整数），
因此也可以参与运算。

public class Draft{
      public static void main(String[] args){
        char  c21='a';
		char   c22=(char)(c21+7);
		/*将取出c21里面的数据与7做加法运算，运算时字符对应的数字97
		参与运算。结果104是int类型的，存入char类型的变量里时，需要进行强转，
		如果打印，应该是104对应的字符h
		
		*/
		System.out.println(c22);
	  }
}

(4)布尔类型

类型名称占用内存大小值

boolean 1字节（8位） true/flase

boolean 类型适于逻辑运算，表示某个条件是否成立。一般用于程序流程控制：

分支控制结构语句
循环控制结构语句

boolean类型数据只允许取值true和false，true表示条件成立，false表示条件不成立。

boolean类型变量经常用于存储关系运算的结果，所谓关系运算就是比较两个变量的大小相等等关系。

public class Draft{
      public static void main(String[] args){
        boolean f1 = true;
		boolean f2 = false;
		System.out.println(f1);
		System.out.println(f2);
		boolean  f3 = 1<2;
		System.out.println(f3);
	  }
}

（5）字符串类型（String）

字符串类型的名字String，是最常用的引用类型。

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

字符串可以做拼接，用+号无缝拼接

public class Draft{
      public static void main(String[] args){
        System.out.println("---字符串的拼接---");
		String s1="中";
		String s2= "国";
		String s3 = s1 + s2;//"中国"
		System.out.println(s3);
		String s4 = s3 + "是最棒的";//"中国是最棒的"
		System.out.println("s4的值:"+s4);
	  }
}

注意：+号前后只要有一个是字符串，做的就是拼接操作，
结果是字符串类型。

public class Draft{
      public static void main(String[] args){
        System.out.println("---字符串的拼接---");
		String r1 = 1 + 1 + "2" + 3 + 4;
		System.out.println("r1的结果是:"+r1);//结果是2234
		
		String r2 = 1 + 2 + "3" + (5 + 4)+5*6;
		System.out.println("r2的结果是:"+r2);//结果是33930
	  }
}

8.类型转换

在数据类型转换中，分为两种转型：自动类型转换和强制类型转换

1.自动类型转换（隐式类型转化）

其实，就是一个直接的赋值操作，不需要进行任何额外的操作。常见于取值范围小的数据类型转换为取值范围大的数据类型。例如： byte（8位）转型为int（32位）。

int类型的字面量，如果没有超出byte，short，char的范围时，是可以直接给这些类型的变量进行赋值。因为底层会自动将前面的0或1截断。

取值范围从小到大排序
byte-->short(char)-->int-->long-->float-->double

public class Draft{
      public static void main(String[] args){
        byte b1 = 10;
		//b1变量里存入的是8位二进制的10，存入s1时，自动变成16位二进制的10
		short  s1 = b1;
		System.out.println(s1);
		//b1变量里存入的是16位二进制的10，存入s1时，自动变成32位二进制的10
		int n1 = s1;
		System.out.println(n1);
		//32位的int变成了64位的long
		long n2 = n1;
		System.out.println(n2);
		double  d1 = n2;//long类型的10转成double类型的10.0
		System.out.println(d1);
	  }
}

2.强制类型转换

取值范围大的数据类型向取值范围小的数据类型转型。
   注意：转换过程中，有可能发生精度损失或者溢出。

   语法：小范围类型名变量 = (小范围类型) 大范围变量;

public class Draft{
      public static void main(String[] args){
        System.out.println("---强制类型转换---");
		double  d10 = 3.14;
		long n10 = (long)d10;//强制转换，精度损失。转成3.
		System.out.println(n10);
		
		int  n12 = 32767;
		short s11 = (short)n12;
		//编译期间，编译器的工作就是只做语法检查，不考虑变量的值
		System.out.println("-short类型的s11的值："+s11);
		
		int n13 = 32768; 
		short s12 = (short)n13;//发生了溢出（值改变了）转成-32768.//1000 0000 0000 0000
		System.out.println("-short类型的s12的值："+s12);
		
		byte b11 = (byte)s12;//
		System.out.println("b11的值："+b11);
		
		//注意：int类型的字面量，如果没有超出byte，short，char的范围时，
		//是可以直接给这些类型的变量进行赋值。因为底层会自动将前面的0或1截断。
		short  b = 25;
		System.out.println(b);
		
		byte  b101=(byte)128;//超范围了，需要强制转换。
		System.out.println(b101);
	  }
}

9.常用运算符

（1）算术运算符（+ - * / % ++ --）

1.当有多种类型的数据混合运算时，系统首先自动将所有数据转换成其中取值范围最大的那种数据类型，然后再进行计算，结果的类型就是取值范围最大的类型。

2.byte,short,char之间不会相互转换，在做运算时，会优先转成int类型做运算。

加法运算（+）

public class SymbolDemo01{
	public static void main(String[] args){
		byte b1 = 10;
		byte b2 = 20;
		int b3 = b1+b2;//b1 和 b2 都转成int，然后在做运算。
		byte b4 = (byte)b3;//计算结果是int类型，将结果进行强转。
		System.out.println(b4);
    }
}

3.运算时，有可能是溢出运算。（封闭式运算）（最大值+1，就变成最小值
最小值-1，就变成最大值）

乘法运算（*）

public class Draft{
      public static void main(String[] args){
        byte num1 = 2;
		byte num2 = 127;
        byte num3 = (byte)(num1*num2);//溢出了
		System.out.println("num3:"+num3);//-2。
	  }
}

4.除法运算（/）

两个整数在做除法运算时，实际上是结果值取整数部分，去掉小数部分。

除法运算时，只要有一个是浮点数时，那就是正真的除法运算。

public class Draft{
      public static void main(String[] args){
        long  num4 = 10;
		int  num5 = 4;
		//两个整数在做除法运算时，实际上是结果值取整数部分，去掉小数部分。
		long num6 = num4/num5;
		System.out.println(num6);
		
		double num7 = 10.0;
		int num8 = 4;
		//除法运算时，只要有一个是浮点数时，那就是正真的除法运算。
		double num9 = num7/num8;
		System.out.println(num9);
	  }
}

5. %：取模运算（求模，求余数）

public class Draft{
      public static void main(String[] args){
        long num10 = 20;
		int num11 =  6;
		long num12 = num10%num11;
		System.out.println("num12:"+num12);//2
	  }
}

6.自增自减：++ --

算数运算符之自增自减运算符
   ++：
   符号在变量前：先加后赋值
   变量先自增1，然后将变量的新值赋值给表达式
   符号在后：先赋值后加。
       先将变量的值赋值给表达式，然后再加1.
--：符号在变量前：先减后赋值
   变量先自减1，然后将变量的新值赋值给表达式
   符号在后：先赋值后减。

public class Draft{
      public static void main(String[] args){
        int x = 1;
		int m = x++;
		int y = ++x;
		System.out.println("x的值"+x);//3
		System.out.println("m的值"+m);//1
		System.out.println("y的值"+y);//3
		
		int  a = 2;
		int  n = a--;
		int  z = --a;
		System.out.println("a的值"+a);//0
		System.out.println("n的值"+n);//2
		System.out.println("z的值"+z);//0
	  }
}

（2）赋值运算符

=：是一个赋值运算符，将等号右边的值给左边的变量进行赋值。是最近简单的赋值运算

将一个变量，在现有值的基础上，对一个数字进行运算

+=：a += 3; 相当于 a = a + 3;

-=： a -= 3; 相当于 a = a - 3;

*= ：a *= 3; 相当于 a = a * 3;

/= ： a /= 3; 相当于 a = a / 3;

%=：a %= 3; 相当于 a = a % 3;

public class AssignSymbol01 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        a += b;  // 相当于 a = a + b
        System.out.println(a);// 30
       //现a的值是30
        System.out.println(b);// 20
        a -= b; // 相当于 a = a - b
        System.out.println(a); // 10

        int c = 3;
        int d = 6;
        c *= d;
        System.out.println(c);//18

        c = 15;
        c /=d;  // 注意： 两个整数做除法运算，是取整操作
        System.out.println(c); //2

        int x = 15;
        int y = 6;
        x %= y;
        System.out.println(x);// 3

    }
}

（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
    }
}

（4）逻辑运算符

对两个boolean类型的变量或者表达式，进行的运算

&：与，两真即为真，有任意一个为假，结果就是假。（全真为真，有假即假）
|：或，两假即为假，有任意一个为真，结果就是真。（全假为假，有真即真）
!：非，非真即假，非假即真。（不是真的，就是假的）
^：异或，两个相同为假，两个不同为真。

在使用逻辑运算的时候，如果没有特殊的需求，尽量使用短路操作。

&&：短路与，（全真为真，有假即假）在运算时，如果前面的条件为flase时，则后面的条件不执行

||：短路或。（全假为假，有真即真）在运算时，如果前面的条件为true时，则后面的条件不执行

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;
        System.out.println("f的值: "+f);  // false
        f = a > b && c++ < d;
        System.out.println("f的值："+f);  // false
        System.out.println("c的值："+c);  //c是3，表示第二个条件根本没有执行。
        f = a > b && c > d++;
        System.out.println("f的值："+f); // false
        System.out.println("d的值："+d);  // d是4，表示第二个条件根本没有执行

        // 验证短路||

        int m = 1,n = 2,x = 3,y = 4;
        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 =  !(1 > 2);
        System.out.println("f的值："+f); //true
        f = !f;
        System.out.println("f的值："+f); //false
    }
}

（5）三元运算

语法：

boolean变量或者boolean结果的表达式?值1:值2

比如： a>b?a:b

执行逻辑：

当？前的式子或变量返回true时，则使用值1，即a的值

当？前的式子或变量返回false时，则使用值2，即b得值

注意：1.符合运算规则，多种类型的数据混合时，系统首先自动将所有数据转换成取值范围 * 最大的那种数据类型，然后再进行计算。

        int m =10;
        int n = 15;
        long result = n%m==1?n:m;//m和n在三目运算里都已经是long类型
        System.out.println(result);//10

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

        int x=10;
        int y=15;
        int c=x>y?x+y:y-x;
        System.out.println(c);//5

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

4.值1和值2的最终类型（用来接受的那个变量的类型），需要能自动类型转换

（6）运算符的优先级

1. 一元运算符（只能操作一个操作数） > 二元运算符（只能操作两个操作数） > 三元运算符（只能操作三个操作数）
2. 算术运算：乘除模 > 加减
3. 逻辑运算：与 && > 或 ||
4. 赋值运算符的优先级是最低的
5. 小括号的优先级是最高的

10.Scanner类

Scanner类的使用步骤：

步骤1：导包 import java.util.Scanner; idea中导包快捷键：Alt+enter

位置：在类的上面，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(); :扫描控制台上的字符串,默认空格或回车表示结束

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入几个单词用空格隔开，这几个单词被扫描到一个变量里");
        String words = sc.next();//扫描到空格后，表示要扫描的内容结束了
        System.out.println(words);
        sc.close(); //关闭扫描器

nextLine();扫描控制台上的字符串，可以识别空格,默认回车表示结束

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入几个单词用空格隔开，这几个单词被扫描到一个变量里");
        String words = sc.nextLine();//该方法可以扫描空格，但是尽量不要和其他扫描功能在一起使用，可能出现bug，直接结束了。
        System.out.println(words);

        //关闭扫描器
        sc.close();

注意：所有nextXXX方法，即阻止程序向下执行，除非扫描到数据并结束扫描，阻塞效果才会消失。

11.Random类

使用步骤：

1.导包操作 import java.util.Random; idea中导包快捷键：Alt+enter

2.创建对象 random r = new Random();

3.调用相关功能

r.nextInt(number):产生一个[0,number)范围内的任意一个整数

注意：区间是左闭右开的区间，即不包括右边的值。

        Random r = new Random();
        //产生一个[0,10]区间内的一个整数
        int i1 = r.nextInt(11);
        System.out.println("i1="+i1);

        //产生一个[-5,5]区间的任意一个整数  [0,11)
        int i2 = r.nextInt(11)-5;
        System.out.println("i2="+i2);

r.nextDouble();产生[0，1）区间内的任意一个小数

        Random r = new Random();
        //产生一个[0，1）区间内的任意一个小数
        double v = r.nextDouble();
        System.out.println("v="+v);

对于产生[n,m]的任意一个整数的书写方法

闭区间： rd.nextDouble()*(m+1-n)+n

开区间： rd.nextDouble()*(m-n)+n

    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]以内的任意整数  要的[0,12]   需写的[0,13)
        int n2 = (int) (rd.nextDouble() * 13 - 6);

        //随机[5,15]以内的任意整数  [5,16)   [0,11)
        int n3 = (int) (rd.nextDouble() * 11 + 5);

    }

12. math类

使用方式：

直接用类名.具体方法名

里面的内容分类：

静态常量：自然对数 E 圆周率 PI

常用函数：max():取最大的数

min():取最小的数

random():随机数，范围[0,1) 与Random的nextDouble()效果一样

abs():取绝对值

取整函数： ceil():向上取整数(取得的值是大于该数的最小整数)

floor():向下取整（取得的值是小于等于该数的最大整数）

rint():最近的整数比如 rint(3.7)得到4

round():四舍五入

指数函数： pow():幂函数 pow(底数，指数)

sqrt():平方根

cbrt():立方根

三角函数： sin() 、cos() 、asin() 、acose() 、tan() 、atan()

    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.5向上取整："+Math.ceil(3.5));
        System.out.println("3.4向下取整："+Math.floor(3.4));
        System.out.println("3.5向下取整："+Math.floor(3.5));
        System.out.println("里3.4最近取整："+Math.rint(3.4));
        System.out.println("里3.5最近取整："+Math.rint(3.5));//如果离两边一样近的时候，取是偶数的整数
        System.out.println("里4.5最近取整："+Math.rint(4.5));
        System.out.println("3.5四舍五入："+Math.round(3.5)); //3自动转成double类型

        System.out.println("3的四次方："+Math.pow(3,4));
        System.out.println("8的平方根："+Math.sqrt(8));
        System.out.println("8的立方根："+Math.cbrt(8));
        System.out.println("8的立方根："+Math.cbrt(2));