15天基础内容-1

day01 【前言、入门程序、常量】

主要内容

Java语言的发展历史【了解】
Java语言开发环境搭建【重点】
HelloWorld入门程序【重点】
注释和关键字【重点】
常量【重点】

第一章开发前言

1.1 Java语言概述【了解】

Java是一种高级编程语言，而且是面向对象的编程语言。
Java语言是美国Sun公司（Stanford University Network），在1995年推出的高级的编程语言。（2009年，Sun公司被甲骨文公司收购，所以我们现在访问oracle官网即可：https://www.oracle.com Java语言共同创始人之一：詹姆斯·高斯林 （James Gosling），被称为“Java之父”。）
Java语言共同创始人之一：詹姆斯·高斯林 （James Gosling），被称为“Java之父”
Java语言的版本：1.0-1.4，5.0...8.0...13.0
目前我们学习的8.0

1.2 Java语言能做什么

Java语言主要应用在互联网程序的开发领域
网上购物商城
物流
金融
各行各业的门户网站

1.3 Java语言的跨平台实现原理

JVM：Java虚拟机，是专门用来运行java程序的（JVM（Java Virtual Machine ）：Java虚拟机，简称JVM，是运行所有Java程序的假想计算机，是Java程序的运行环境，是Java 最具吸引力的特性之一。我们编写的Java代码，都运行在 JVM 之上。）
跨平台：我们编写一个程序，可以在不同的操作系统上运行一次编译（写），到处运行
说几个问题？
1.Java程序是跨平台的？正确的Java程序只需要编写一次，就可以在不同的操作系统上运行
2.JVM是跨平台的？错误的JVM是不跨平台的，java针对不同的操作系统，提供了不同的JVM
3.Java程序的跨平台，是通过JVM的不跨平台实现的正确的

在这里插入图片描述

1.4 JDK_JRE_JVM的组成和作用

JVM：Java虚拟机，是专门用来运行java程序的，但是不能独立安装。
JRE：Java运行环境，包含JVM和核心类库（Java已经写好的功能）							--普通用户，只需要运行程序
JDK：Java开发工具，包含JRE和开发工具（比如: javac命令,java命令）					--程序开发人员
三者关系： JDK > JRE > JVM

在这里插入图片描述

第二章 Java语言开发环境搭建

2.1 JDK安装

1.jdk下载考虑两个问题(1)操作系统: windows,MacOs,Linux(2)操作系统的位数: 32位,64位
2.要求:安装路径中,一定不能包含中文和空格

2.2 常用DOS命令的使用

如何进入OS命令操作窗口?1.开始/命令提示符2.开始/搜索程序和文件 输入cmd3.windows键 + R --> 输入cmd4.窗口空白处/按住shift键 + 鼠标右键单击/在此处打开命令窗口

在这里插入图片描述

2.3 环境变量JAVA_HOME的配置

记事本软件的启动方式?1.开始/程序/附件/记事本2.C:/windows/找到notepad.exe命令,双击启动3.如果在DOS窗口的命令中:C:\windows> notepad.exe	回车 运行这个命令首先在C:\windows路径下,寻找是否存在notepad.exe,发现有,直接运行D:\abc> notepad.exe	回车 运行这个命令首先:在D:\abc路径下,寻找是否存在notepad.exe,发现没有其次: 如果发现在当前路径D:\abc没有要运行的notepad.exe命令,到系统环境变量path中寻找path:... C:\Windows;...,发现path中配置的路径C:\Windows有该命令,直接运行.如果path中配置的所有的路径中都没有要运行的命令,运行报错了.配置环境变量的目的/作用: 让某些命令可以在任意路径下直接运行(java程序: javac命令,java命令)比如jdk的安装路径: C:\develop\Java\jdk1.8.0_162配置环境变量的步骤:1.创建名称为JAVA_HOME的环境变量,值是 C:\develop\Java\jdk1.8.0_1622.把名称为JAVA_HOME的环境变量添加到系统环境变量path中 path:%JAVA_HOME%\bin;...3.如果在DOS窗口的命令中:C:\develop\Java\jdk1.8.0_162\bin> javac.exe	回车 运行这个命令首先在C:\develop\Java\jdk1.8.0_162\bins路径下,寻找是否存在javac.exe,发现有,直接运行D:\abc> notepad.exe	回车 运行这个命令首先:在D:\abc路径下,寻找是否存在notepad.exe,发现没有其次: 如果发现在当前路径D:\abc没有要运行的notepad.exe命令,到系统环境变量path中寻找path:... C:\Windows;...,发现path中配置的路径C:\Windows有该命令,直接运行.如果path中配置的所有的路径中都没有要运行的命令,运行报错了.D:\abc> javac.exe	回车 运行这个命令首先:在D:\abc路径下,寻找是否存在javac.exe,发现没有其次: 如果发现在当前路径D:\abc没有要运行的javac.exe命令,到系统环境变量path中寻找path:... %JAVA_HOME%\bin;...,发现path中又配置了名称为JAVA_HOM的环境变量,于是乎,找到JAVA_HOM的环境变量对应的路径,把变量名称JAVA_HOM进行替换最终: C:\develop\Java\jdk1.8.0_162\bin 在此路径下找到了javac命令,直接运行

第三章 HelloWorld入门程序

3.1 程序开发的步骤

源程序:程序员编写的程序程序员可以看的懂的程序程序: 字母,数字和其它符号
源程序是给程序员自己看的,本质就是一个文本文件但是扩展名不是.txt而是.java字节码文件:源程序JVM是看不懂的,JVM只认识0和1,JVM能看懂的叫做字节码文件,里面存储的都是0和1字节码文件也是有扩展名的,扩展名为.class如何把源程序(文件)转换成字节码程序(文件)?使用javac命令(编译命令)使用格式:javac 文件名.javajavac HelloWorld.java不管是源程序(.java程序: HelloWorld.java)还是字节码程序(.class程序: HelloWorld.class)都存储在硬盘当中
如何把硬盘中的.class字节码文件交给JVM执行?使用java命令(执行命令)使用格式: java 文件名java HelloWorld

在这里插入图片描述

3.2 HelloWorld案例的编写编译运行

java">步骤:
1.创建HelloWorld.txt文本文件,把扩展名修改给.java,最终文件名称HelloWorld.java
2.用记事本软件打开HelloWorld.java文件,编写如下内容public class HelloWorld {public static void main(String[] args){System.out.println("HelloWorld");}}
3.使用javac命令进行编译格式: javac 文件名.javajavac HelloWorld.java注意:(1)保证该javac命令在当前路径下可以执行(2)保证在当前路径下可以看到被编译的.java文件(3)编译javac命令,后面要跟文件的扩展名.java4.使用java命令执行格式: java 文件名java HelloWorld注意:(1)保证该java命令在当前路径下可以执行(2)保证在当前路径下可以看到被执行的.class文件(3)执行java命令,后面不要跟文件的扩展名.class

3.3 HelloWorld案例的常见问题

非法字符问题。Java中的符号都是英文格式的。
大小写问题。Java语言对大小写敏感（区分大小写）。
在系统中显示文件的扩展名，避免出现HelloWorld.java.txt文件。
编译命令后的java文件名需要带文件后缀.java
运行命令后的class文件名（类名）不带文件后缀.class
不要把main写成mian

3.4 Notepad++软件的安装和配置

在这里插入图片描述

第四章注释和关键字

4.1 注释

java">1.注释概念：是用来解释说明程序的,是给程序员看的,不参与编译和运行,不影响程序的执行效率。
2.注释分类：(1)单行注释：	// 只能写一行内容(2)多行注释:	/* 可以写多行内容 */(3)文档注释:	/** 可以写多行内容 *//*这里是定义一个类,类的名字叫做Demo01ZhuShi和文件的名字要保持一模一样public class 是一个固定写法,后面学习
*/
public class Demo01ZhuShi {/*这里是定义一个方法,方法的名称叫做mainmain方法是程序的入口,目前public static void main(String[] args) 是固定写法*/public static void main(String[] args){//这里是一条输出语句,其中""中的内容,会被原样输出到控制台System.out.println("注释...");}
}

4.2 关键字

java">邮箱的格式：邮箱当中都有一个@符号，代表邮箱，@符号后面代表的是服务器(你用的是哪个公司的邮箱)举例:zhangsan@163.com			正确的nigulasi@163.com			正确的nigulasi@zhangsan@163.com	错误的,@符号有特殊含义,不让你在用户名中使用1.关键字的概念: 是指在程序中，Java已经定义好的单词，具有特殊的含义和特殊的使用格式【后面学习，今天不要求知道】。   
2.关键字的特点：【能够辨识出程序中的关键字】(1)在高级编辑器中,彩色显示(2)所有字母都是小写的/*有哪些关键字?public,class,static,void
*/
public class Demo02GuanJianZi {public static void main(String[] args){System.out.println("关键字....");}
}

第五章常量

5.1 常量的概念和分类

数学中有常数的概念:y = x + 6;//数字6就是一个常数,值不可以被改变b = a + 6.6;//数字6.6就是一个常数,值不可以被改变数学中的数字(常数)是有分类的:比如数字6: 整数数字6比如数字6.6: 小数数字6整数数字6和小数数字6.6是不可以发生变化的x,y,a,b它们的值是可以发生变化的(变量)java中的数字(常量)是有分类的,比数学中的分类更为丰富1.常量的概念: 在程序的执行过程中,值不可以发生改变的量
2.常量的分类:(1)整数常量: 100,-200(2)小数常量: 6.6,-8.8(3)字符常量: java中规定,字符常量必须使用单引号''引起来,而且单引号''中只能有一个字符(不能没有字符,也不能有2个及以上的字符)举例:A:	'a'			正确的B:  ''			错误的,''中不能没有字符C:  'ab'		错误的,''中不能有2个及以上的字符D:	'好'		   正确的,一个汉字代表一个字符	E:  '女子'	  错误的,''中不能有2个及以上的字符(汉字)(4)字符串常量:java中规定,字符串常量必须使用双引号""引起来,而且双引号""中可以写多个字符(0个,1个,2个...)举例:A:	"a"			正确的B:  ""			正确的C:  "ab"		正确的D:	"好"		   正确的	E:  "女子"	  正确的(5)布尔常量:只有两个取值true:	理解为成立的,对的,正确的,肯定的，成功false:  理解为不成立的,错的,错误的的,否定的，失败(6)空常量: null	【了解】	不能直接打印null值

5.2 打印不同类型的常量

java">            
/*打印6种类型的常量快速复制光标所在的行: ctrl + d
*/
public class Demo03ChangLiang {public static void main(String[] args){//1.整数System.out.println(100);System.out.println(-200);//2.小数System.out.println(6.6);System.out.println(-8.8);//3.字符System.out.println('a');//正确的,''中只能必须有一个字符//System.out.println('');//错误的,''中不能没有字符//System.out.println('ab');//错误的,''中不能有2个及以上字符System.out.println('好');//正确的,一个汉字就是一个字符//System.out.println('女子');//错误的,,一个汉字就是一个字符,这里两个汉字就是两个字符,而''中不允许写2个字符//4.字符串System.out.println("");//正确的,""中可以没有内容System.out.println("a");//正确的,""中可以有一个字符System.out.println("abcd");//正确的,""中可以有多个字符System.out.println("好");//正确的System.out.println("中国好强大");//5.布尔System.out.println(true);System.out.println(false);//6.空常量: 不能直接打印null值//System.out.println(null);}
}

总结

java">能够说出JDK,JRE,JVM各自的作用和关系1.JVM:Java虚拟机,是专门用来运行java程序的,但是不能单独安装2.JRE:Java运行环境,包含JVM和核心类库		如果只是运行Java程序,只需要安装JRE3.JDK:Java开发环境,包含JRE和开发工具		程序开发人员,需要安装JDK总结: 三者关系： JDK > JRE > JVM能够完成HelloWorld案例的编写及运行 1.创建HelloWorld.java文件2.编写内容:public class HelloWorld {public static void main(String[] args) {System.out.println("HelloWorld");}}3.编译: javac HelloWorld.java4.运行: java HelloWorld记住:带c就带扩展名,不带c就不要带扩展名能够使用注释对程序进行说明1.单行注释: //只能写一行内容2.多行注释: /* 可以写多行内容 */3.文档注释: /** 可以写多行内容 */能够知道关键字的特点特点:1.高级编辑器中彩色显示2.所有字母小写识别哪些关键字: public class static void 能够知道常量的分类1.整数常量: 直接写100,2002.小数常量: 直接写6.6,-8.83.字符常量:必须使用单引号''引起来,而且''中只能必须有一个字符(不能没有,也不能有2个及以上的字符)'A': 正确	'': 错误'AB':错误'ABCD':错误4.字符串常量:必须使用双引号""引起来,而且""中可以写多个字符(0个,1个,2个,...)"A": 正确	"": 正确"AB":正确"ABCD":正确5.布尔常量:true: 肯定false: 否定6.空常量: null 【不能直接打印】

day02【进制、变量、类型转换、运算符】

主要内容

进制【理解】
变量【重点】				====先练习====
数据类型转换【理解】
运算符【重点】			====先练习====

第一章计算机中的进制与字节

1.1 进制及转换

进制

进制的概念： 逢几进一，就叫做几进制
进制的分类：十进制：		逢十进一		每位上的数字0-9			二进制：		逢二进一		每位上的数字0-1	八进制：		逢八进一		每位上的数字0-7十六进制：	   逢十六进一	   每位上的数字0-9,10(A),11(B),12(C),13(D),14(E),15(F)

转换

1.十进制转十进制(每位上的数字上隐藏了一个10的多少次方,第一个位(个位)是0次方,第二位(十位)是1次方):十进制数字1234(x^y:表示x的y次方):1234 = 4 + 30 +	200 + 1000= 4*10^0 + 3*10^1 + 2*10^2 + 1*10^32.二进制转十进制(每位上的数字上隐藏了一个2的多少次方,第一个位是0次方,第二位是1次方...)101101 = 1*2^0 + 0*2^1 + 1*2^2 + 1*2^3 + 0*2^4 + 1*2^5 = 1*1 + 0*2 + 1*4 + 1*8 + 0*16 + 1*32= 1 + 4 + 8 + 32= 4511111 = 1 + 2 + 4 + 8 + 16= 31101 =  1*2^0 + 0*2^1 + 1*2^2 =  1 + 0 + 4 =  53.十进制转二进制: 除以2取余数,倒过来写十进制的45转换成二进制:101101

在这里插入图片描述

1.2 计算机中的存储单位(2的10次方就是1024)

位(bit): 存储一个二进制数字0或者1所占用的空间,简写成b
字节(byte): 8位就看成一个字节,简写成B
字节是我们常见的计算机中最小存储单元。
1024B = 1KB
1024KB = 1MB
1024MB = 1GB
1024GB = 1TB
...

在这里插入图片描述

第二章变量和数据类型【重要】

2.1 变量概念及分类

数学中有个常数的概念:
y = x + 10; 	//整数数字10是不可以发生变化的
b = a + 6.6;	//小数数字6.6是不可以发生变化的数学中的数字(常量)是有分类的,对应java中的常量也是有分类的x,y是可以发生变化的x:2,y:12x:8,y:18
x,y里面存储的数据也是有类型的,都是整数a,b是可以发生变化的a:2.2, b:8.8a:3.3, b:9.9
a,b里面存储的数据也是有类型的,都是小数1.变量概念: 在程序的执行过程中,其值可以在一定范围内(每种类型的变量的字节数是确定的)发生改变的量,可以理解为一个小的容器.
2.变量分类(每种分类占用的字节数不同,取值范围也就不同,使用场景也就不同):(1)整数类byte类型			占1个字节		-128到127short类型			占2个字节		正负3万多int类型			占4个字节		正负21亿	整数默认为int类型long类型			占8个字节		大概19位数字		表示long类型的数字后面需要添加字母L(2)小数类float类型			占4个字节		表示float类型的数字后面需要添加字母F注意: 虽然float占4个字节,但是由于内部采用科学计数法,取值范围远远大于占8个字节的long类型double类型		占8个字节		小数默认为double类型  (3)字符类char类型			占2个字节(4)布尔类boolean类型		占1个字节		取值只有两个要么是true要么是false

在这里插入图片描述

2.2 变量定义格式图解分析

java">
变量的理解:1.变量的本质就是内存中的一块空间,空间的大小由数据类型决定。2.要想找到变量对应的内存空间，需要给该内存空间起个名字，叫做变量名称。3.变量的内存空间中没有数据是不能使用的,向变量内存空间中存储数据的过程,叫做赋值或者初始化。
变量的定义格式：1.格式一（先挖坑，再种萝卜）数据类型 变量名称；//先挖坑变量名称 = 数据值;2.格式二(挖坑,同时种萝卜)数据类型 变量名称 = 数据值;3.格式三(先挖多个坑,再分别向每个坑中种萝卜)数据类型 变量名称1, 变量名称2...；//先挖多个坑变量名称1 = 数据值1;变量名称2 = 数据值2;//...4.格式四(挖多个坑,同时向每个坑中中萝卜)数据类型 变量名称1 = 数据值1, 变量名称2 = 数据值2 ...；

在这里插入图片描述

2.3 定义8种变量

java">public class Demo01BianLiang {public static void main(String[] args){/*1.格式一（先挖坑，再种萝卜）数据类型 变量名称；//先挖坑量名称 = 数据值; //再种萝卜*/byte b;//挖了一个byte类型(占1个字节)的坑,给这个坑起了个名字叫bb = 10;//把数字10,放在名称为b的坑中System.out.println(b);//打印名称为b的坑中的内容: 10b = 20;//把数字20,放在名称为b的坑中,原来的数字10被替换掉了System.out.println(b);//打印名称为b的坑中的内容: 20/*		2.格式二(挖坑,同时种萝卜)数据类型 变量名称 = 数据值;*/short s = 30;//挖了一个short类型(占2个字节)的坑,给这个坑起了个名字叫s,并同时把数字30放在坑中System.out.println(s);//打印名称为s的坑中的内容: 30s = 50;//把数字50,放在名称为s的坑中,原来的数字30被替换掉了System.out.println(s);//打印名称为s的坑中的内容: 50/*3.格式三(先挖多个坑,再分别向每个坑中种萝卜)数据类型 变量名称1, 变量名称2...；//先挖多个坑变量名称1 = 数据值1;变量名称2 = 数据值2;//...*/int num1,num2,num3;//同时挖了三个int类型(占4个字节)的坑,分别给每个坑起了个名字叫num1,num2,num3num1 = 60;//把数字60,放在名称为num1的坑中num2 = 70;//把数字70,放在名称为num2的坑中num3 = 80;//把数字80,放在名称为num3的坑中System.out.println(num1);//打印名称为num1的坑中的内容: 60System.out.println(num2);//打印名称为num2的坑中的内容: 70System.out.println(num3);//打印名称为num3的坑中的内容: 80/*4.格式四(挖多个坑,同时向每个坑中中萝卜)数据类型 变量名称1 = 数据值1, 变量名称2 = 数据值2 ...；*///同时挖了三个long类型(占8个字节)的坑,分别给每个坑起了个名字叫num4,num5,num6,并分别存储数据100L,200L,300Llong num4 = 100L,num5 = 200L,num6 = 300L;System.out.println(num4);//打印名称为num4的坑中的内容: 100System.out.println(num5);//打印名称为num5的坑中的内容: 200System.out.println(num6);//打印名称为num6的坑中的内容: 300}
}

java">public class Demo02BianLiang {public static void main(String[] args){//定义float类型//float a = 6.6;//小数默认double类型,占8个字节,float占4个字节,大萝卜不能存储到小坑当中float a = 6.6F;System.out.println(a);//定义double变量d,初始化值8.8double d = 8.8;System.out.println(d);//字符char类型//定义char类型的变量ch1,初始化值'A'char ch1 = 'A';System.out.println(ch1);//char ch2 = 'AB';//''中不能写两个及以上字符//System.out.println(ch2);//布尔boolean类型//定义boolean变量result,初始化值trueboolean result = true;System.out.println(result);//trueresult = false;//把false存储到变量result中,该变量中的原有数据将别替换了System.out.println(result);//flase//错误的//result = 100;//result是boolean类型,需要boolean数据要么是true,要么是false,而100是int数据,类型不匹配}
}

2.4 变量的注意事项

java">1.变量名称：在同一个大括号范围内，变量的名字不可以相同。
2.变量赋值：定义的变量，不赋值不能使用。
3.定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。因为整数默认是int类型，整数太大可能超出int范围。
4.定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。因为浮点数的默认类型是double，double的取值范围是大于float的，类型不兼容。public class Demo03BianLiangNotice {public static void main(String[] args){//定义int变量a,初始化值10int a = 10;System.out.println(a);//10//错误的,同一个区域,不能定义同名变量//定义int变量a,初始化值100//int a = 100;//System.out.println(a);//定义int变量bint b;//System.out.println(b);//错误的,变量不赋值不能使用b = 200;//把200赋值给变量bSystem.out.println(b);//200//long num = 6000000000;//错误: 整数默认int类型(21亿左右),而6000000000(60亿)已经远远超出int的范围long num = 6000000000L;//正确的System.out.println(num);//float f = 6.6;//错误: 小数6.6默认double类型(8个字节),不能赋值给float类型(4个字节)变量,萝卜大,坑小float f = 6.6F;//正确的,6.6F这个小数就是float类型(4个字节)System.out.println(f);}
}

2.5 标识符的含义及注意事项

java">1.标识符概念：是指在程序中，我们自己起名字的地方(变量名,方法名,类名)
2.命名规则： 硬性要求(1)标识符可以包含 英文字母26个(区分大小写) 、 0-9数字 、 $（美元符号） 和 _（下划线） 。(2)标识符不能以数字开头。(3)标识符不能是关键字。
3.命名规范： 软性建议(1)类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）。(2)方法名规范： 首字母小写，后面每个单词首字母大写（小驼峰式）。(3)变量名规范：首字母小写，后面每个单词首字母大写（小驼峰式）。public class Demo04BiaoShiFu {//Demo04BiaoShiFu: 大驼峰规则public static void main(String[] args){//main: 小驼峰规则int b2;//正确的int b2$_;//正确的//int 2b;//错误的,不能以数字开头//int public;//错误的,不能用关键字作为变量名称//变量名称: 小驼峰规则int ageOfMyGirlFriend = 18;//我的女朋友的年龄System.out.println(ageOfMyGirlFriend);}

第三章数据类型转换【理解】

3.1 自动类型转换

Java程序中要求参与的计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。
1.自动类型转换概念:取值范围小的数据或者变量可以直接赋值给取值范围大的变量(小萝卜可以直接放入大坑中)	2.特点: (1)是自动完成的,不需要代码的特殊处理(2)只要byte/short/char类型的数据参加运算,会自动转换为int类型(3)转换规则: byte、short、char-->int-->long-->float-->double举例:
有一个byte类型(1个字节)的数字5:	00000101
自动类型转换成short类型(2个字节): 	前边(左边)补充1个字节的0,数字的大小没有发生改变,还是500000000 00000101自动类型转换成int类型(4个字节): 	前边(左边)补充3个字节的0,数字的大小没有发生改变,还是5  00000000 00000000 00000000 00000101自动类型转换成long类型(8个字节): 	前边(左边)补充7个字节的0,数字的大小没有发生改变,还是500000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101总结: 所谓的自动类型转换,其实就是根据需求在数字前面补充若干字节的0,但是数字大小没有影响(打肿脸充胖子)

java">public class Demo05Convert {public static void main(String[] args){//int 赋值给 long  从小到大 发生自动类型转换//把int转换成long类型: 在数字左侧补充四个字节的0,对数字大小没有影响  小萝卜可以直接放入大坑中//int --> longlong num = 100;//右侧100: int类型,左边: long类型System.out.println(num);int i = 1; byte b = 2; //byte + int ==> int + int ==> int 结果是int类型(4个字节),不能赋值给byte类型(1个字节)变量x//byte x = b + i;//错误//byte + int ==> int + int ==> int 结果是int类型(4个字节),可以赋值给int类型(4个字节)变量yint y = b + i;//正确System.out.println(y);//3int n = 3;double d = 2.5;//int + double ==> double + double ==> double 结果是double类型(8个字节),可以赋值给int类型(4个字节)变量num2//int num2 = n + d;//int + double ==> double + double ==> double //结果是double类型(8个字节),可以赋值给double类型(8个字节)变量num3double num3 = n + d;System.out.println(num3);}
}

3.2 强制类型转换

1.强制类型转换概念:取值范围大的数据或者变量不能直接赋值给取值范围小的变量,必须进行强制类型转换(大萝卜不能直接放入小坑当中)2.格式:转后类型 变量名称 = (转后类型)转前数据或者变量;3.问题: 会丢失数据或者损失精度举例:
有一个long类型(8个字节)的数字5:	00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101强制类型转换成int类型(4个字节): 砍掉左侧4个字节的数字,都是0,对数字没有影响,还是500000000 00000000 00000000 00000101强制类型转换成short类型(2个字节): 砍掉左侧6个字节的数字,都是0,对数字没有影响,还是500000000 00000101     强制类型转换成byte类型(1个字节): 砍掉左侧7个字节的数字,都是0,对数字没有影响,还是500000101总结: 所谓的强制类型转换,其实就是根据需求砍掉左侧若干字节的数据,如果被砍掉的都是0,对数字没有影响,被砍掉的内容只要包含1,就会影响原数字的大小(缺点: 可能会损失精度)6000000000L:000000000 000000000 000000000 000000001 01100101 10100000 10111100 00000000强制转换成int类型: 砍掉左侧的4个字节,包含了一个数字1(有个2的32次方)01100101 10100000 10111100 00000000: 1705032704  = 6000000000L - 2^32 = 6000000000L - 4294967296 = 1705032704

java">//强制类型转换
public class Demo06Convert {public static void main(String[] args){//定义int变量,表示世界人口: 60亿//int num = 6000000000;//错误: 整数默认int类型: 21亿左右,而6000000000已经远远超出了int的取值范围//int num2 = 6000000000L;//错误: 右侧long类型(8个字节),左侧int类型(4个字节) 大萝卜不能直接放入小坑中//解决方案一: 把坑变大long num3 = 6000000000L;//正确的: 右侧long数据,左侧是long变量System.out.println(num3);//解决方案二: 把萝卜变小(强制类型转换)int num4 = (int)6000000000L;System.out.println(num4);short s = 1;//byte/short/char只要参加运算,会自动转换成int类型//short + int ==> int +int ==> int 结果是int类型(4个字节),不能赋值给short类型(2个字节)的变量s//s = s + 1;//大萝卜不能直接放入小坑中//强制类型转换//short + int ==> int +int ==> int 结果是int类型(4个字节),不能赋值给short类型(2个字节)的变量s//但是可以把结果强制类型转换成short(砍掉左侧的2个字节的数据),这样就可以赋值给左侧的short变量了s = (short)(s + 1);System.out.println(s);}
}

在这里插入图片描述

3.3 ASCII码表

计算机中存储的所有内容,最终都会转换成0和1进行存储
存储字符也不例外,需要包字符转换成二进制的0和1存储问题: 如何把字符转换成对应的二进制呢?
ASCII码表: 存储字符和数字之间对应关系的一张表格存储字符时：需要查找ASCII码表,找到字符对应的数字,将数字转换为二进制数存放到计算机中'A' -->	65 --> 1000001		是连续的	依次+1'a' --> 97 --> 1100001		是连续的	依次+1'0' --> 48 --> 110000		是连续的	依次+1使用字符时：将对应的二进制数转换为十进制 找到ASCII码表中对应的字符1000001 --> 65 --> 'A'1100001 --> 97 --> 'a'110000  --> 48 --> '0'

在这里插入图片描述

3.4 int类型和char类型的运算原理

java">//字符和int数据的运算原理
public class Demo07Char {public static void main(String[] args){//定义字符char变量ch1,初始化值'a'char ch1 = 'a';System.out.println(ch1);//a//char数据只要参加运算,会自动转换成int类型//char + int ==> int + int ==> int 结果是int类型//需要把char变量ch1转换成int数据?如何转换呢?	查看ASCII码表System.out.println(ch1+1);//98//把结果int数字98强制类型转换成字符? 如何转换呢?	查看ASCII码表System.out.println((char)(ch1+1));//b//定义字符char变量ch2,初始化值'A'char ch2 = 'A';System.out.println(ch2);//ASystem.out.println(ch2+1);//66System.out.println((char)(ch2+1));//B//定义字符char变量ch3,初始化值'0'char ch3 = '0';System.out.println(ch3);//字符0,不是数字0//char + int ==> int + int ==> int//需要把char变量ch3转换成int数据?如何转换呢?	查看ASCII码表 '0' 对应的int数字是48System.out.println(ch3+1);//int数字49//把结果int数字49,强制类型转换成char类型?如何转换呢?	查看ASCII码表 49 对应的字符'1'System.out.println((char)(ch3+1));//字符1}
}

第四章运算符

4.1 算术运算符加减乘除

java">运算符：对常量或者变量进行操作的符号
表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。
不同运算符连接的表达式体现的是不同类型的表达式。
+: 数学中的加法运算	5 + 3 结果是8
-: 数学中的减法运算	5 - 3 结果是2
*: 数学中的乘法运算 5 * 3 结果是15
/: 数学中的法法运算 5 / 3 结果是1数学中的除法:被除数 ÷ 除数 = 商(数学运算符中的/: 取的是商) ... 余数
//算术运算符加减乘除
public class Demo08Operator {public static void main(String[] args){//定义int变量a和b,初始值分别为20和10int a = 20,b = 10;System.out.println(a + b);//20 + 10: 30System.out.println(a - b);//20 - 10: 10System.out.println(a * b);//20 * 10: 200System.out.println(a / b);//20 / 10: 商是2,余数是0  /取的就是商		System.out.println(a*1.0 / b);//2.0		//int/int 结果必然是int数据System.out.println(10/4);//2 //double/int ==> double/double ==> 结果就是double类型System.out.println(10.0/4);//2.5 }
}

4.2 算术运算符%

java">算术运算符%: 取模或者余数运算符
数学中的除法:被除数 ÷ 除数 = 商(数学运算符中的/: 取的是商) ... 余数(数学运算符中的%: 取的是余数)
作用:1.判断数字的奇偶性:偶数: 数字%2的结果是0奇数: 数字%2的结果是1(不是0)2.判断一个数字能否被另外一个数字整除结果为0: 说明能够被整除结果为1: 说明不能够被整除3.使用/和%可以计算一个数字每位上的数字举例:十进制数字num: 1234个位: 4	num%10十位: 3	num/10%10百位: 2	num/100%10千位: 1	num/1000%10
//取模运算符: %
public class Demo09Operator {public static void main(String[] args){//1.判断数字的奇偶性:System.out.println(8%2);//0,偶数System.out.println(9%2);//1,奇数//2.判断一个数字能否被另外一个数字整除System.out.println(30%15);//0,	30能被15整除System.out.println(30%16);//14,	30不能被16整除//3.使用/和%可以计算一个数字每位上的数字//定义int变量num,初始化值1234int num = 1234;//输出个位:System.out.println(num%10);//个位: 4//输出十位: System.out.println(123%10);//十位: 3//num/10结果: 123//System.out.println(num/10);//123System.out.println(num/10%10);//十位: 3//输出百位System.out.println(12%10);//百位: 2		//num/100结果: 12System.out.println(num/100);//12System.out.println(num/100%10);//百位: 2//输出千位: num/1000%10System.out.println(num/1000%10);//千位: 1}
}

在这里插入图片描述

4.3 算术运算符+的特殊用法

java">/*+的用法1.代表数学中的加法运算: 要求+的左右两边必须都是数字2.代表字符的相加: char和数字,char和char3.代表字符串的连接(拼接): +的两边只有有""参加运算就代表字符串的拼接
*/
public class Demo10Operator {public static void main(String[] args){System.out.println('a'+1);//97 + 1 结果98System.out.println('a'+'b');//97 + 98 结果195System.out.println("5+5="+5+5);//"5+5=5"+5 ==> 5+5=55//从左向右计算,但是有()要先计算System.out.println("5+5="+(5+5));//"5+5="+10 ==> 5+5=10int a = 10, b = 20;//输出结果: 10+20=30System.out.println(a + "+" + b +"="+a+b);//10+20=1020System.out.println(a + "+" + b +"="+(a+b));//10+20=30}
}

4.4 赋值运算符

java">基本赋值运算符=: 就是把数据存储到变量的内存空间中  注意: ==是比较是否相同的意思
扩展(复合)赋值运算符:
+=:	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;//复合赋值运算符
public class Demo11Operator {public static void main(String[] args){int a = 20,b = 10;a -= b;// a =  a - b;System.out.println("a="+a);//10System.out.println("b="+b);//10int c = 30,d = 15;c /= d;//c = c / d;System.out.println("c="+c);//2System.out.println("d="+d);//15int e = 50,f = 20;e %= f;//e = e % f = 50 % 20 = 10System.out.println("e="+e);//10System.out.println("f="+f);//20}
}

4.5 赋值运算符的特点

java">/*复合赋值运算符的特点1.整数常量只要不超过所赋值的变量的取值范围,就可以直接赋值,因为内部隐藏强制类型转换2.复合赋值运算符如果左右两边的数据类型不一致,隐藏进行强制类型转换
*/
public class Demo12Operator {public static void main(String[] args){//按照前面的知识,大萝卜不能存入小坑当中,应该报错//此处并没有报错,原因: 影藏了强制类型转换//等价于: short s = (short)1;short s = 1;//右侧1是int类型的常量(4个字节),左侧变量s是short类型(2个字节)//short + int ==> int + int ==> int 结果是int类型(4个字节),不能赋值给左侧short类型(2个字节)的变量s//s = s + 1;//解决方案: 把结果数据进行强制类型转换//s = (short)(s + 1);s += 1;//等价于(short)(s + 1);System.out.println(s);}
}

4.6 自增自减运算符

java">/*自增(++)自减(--)运算符:1.作用: 让变量的值增加1(++)或者减少1(--)2.使用格式:(1)写在变量的前面: ++a/--a(2)写在变量的后面: a++/a--3.使用方式:(1)单独使用: 不和其它操作混合在一起						我们以后最常用的前 ++  和后++ 没有任何区别,都是让变量的值增加1前 --  和后-- 没有任何区别,都是让变量的值减少1(2)混合使用: 和其它操作混合在一起用,将产生重大区别前++/--: 先进行++/--的操作,再使用变量后++/--: 先使用变量,再进行++/--的操作
*/
public class Demo13Operator {public static void main(String[] args){int a = 2;a++;//a = a + 1System.out.println(a);//3int b = 2;++b;//b = b + 1System.out.println(b);//3System.out.println("--------------");int c = 2;/*d = ++c: 是把表达式++c的结果赋值给变量d所以需要先计算++c的结果,但是发现++在c的前面,应该先给c的值+1,c变成3,再使用把3作为++c表达式的结果(3)来用++c表达式的结果3赋值给变量d,d的值就是3*/int d = ++c;//简单理解:先把c的值增加1(3),再把c的值赋值给d(3)System.out.println(c);//3System.out.println(d);//3System.out.println("--------------");int e = 2;/*f = e++: 是把表达式e++的结果赋值给变量f所以需要先计算e++表达式的结果,但是发现++在e的后面,先使用e的值(2),作为e++表达式的值(2),之后e的值增加1(3)最后把e++表达式的值2赋值给f,f的值2*/int f = e++;//简单理解: 先使用e的值(2)赋值给变量f(2),然后e的值增加1System.out.println(e);//3System.out.println(f);//2System.out.println("--------------");int x = 2;//3 4 5int y = x++ + ++x + x++;//		2  +  4  + 4System.out.println(x);//5System.out.println(y);//10}
}

总结

能够说出8种基本数据类型1.整数:(1)byte类型			1个字节		-128到127(2)short类型			2个字节		正负3万多(3)int类型			4个字节		正负21亿	整数默认是int类型(4)long类型			8个字节		19位数字   表示long数据,后面加L2.小数:(1)float类型			4个字节		内部采用科学计数法,取值范围远远大于long类型  表示float数据,后面加F(2)double类型			8个字节		小数默认double类型3.字符:char类型				2个字节4.布尔:boolean类型			1个字节		取值只有true或者false能够完成变量的定义及输出//1.定义一个并赋值int a = 10;//2.定义多个并同时赋值int b = 20,c = 30,d = 50;//3.先定义一个变量,再赋值int e;e = 60;//4.先定义多个变量,再分别赋值int f,g,h;f = 70;g = 80;h = 90;能够知道类型转换的格式和顺序 一.自动类型转换: 1.概念: 取值范围小的数据或者变量可以直接赋值给取值范围大的变量 小萝卜可以直接放入大坑中2.特点:(1)代码自动完成(2)byte/short/char只要参加运算,会自动转换成int类型(3)转换规则:byte/short/char --> int --> long --> float --> double总结: 根据需求,在数据的前面(左侧)添加若干字节的0二.强制类型转换 1.概念: 取值范围大的数据或者变量不能直接赋值给取值范围小的变量 大萝卜不能直接存入小坑中2.强制类型转换:转后类型 变量名称 = (转后类型)转前数据或者变量3.问题:损失精度总结:根据需求,砍掉前面若干个字节的数据,如果被砍掉的都是0,对数字没有影响,只要包含数字1,就会影响原有数字的大小能够说出常见的运算符有哪几种1.数学运算符:2.赋值运算符能够知道除法和取余的区别 /: 求的是商%: 求的是余数  判断奇偶性,能否被数字整除,获取个位十位百位千位的数字能够完成字符和字符串的加+的作用:1.数学中的加法运算: +的左右两侧都是数字或者字符 或者一个数字一个字符2.字符串的连接: + 的左右两侧只要有一个是字符串,那么+就代表字符串的连接(拼接)

day03 【IDEA、运算符、数据输入】

主要内容

DEA【重点】
运算符【重点】
数据输入【重点】
练习【重点】常用快捷键1.main方法: psvm2.输出语句: sout3.快速复制一行: ctrl + d4.删除一行: ctrl + y5.单行注释: ctrl + /6.多行注释: ctrl + shift + /7.格式化代码: ctl + alt + L8.移动代码: alt + shift + ↑/↓9.自动导包: alt + 回车10.idea中选择矩形(垂直区域):alt + 按住鼠标左键拖动

第一章开发工具IntelliJ IDEA

1.1 IDEA开发工具的安装

在这里插入图片描述

1.2 IDEA的首次驱动

第一步:
第二步:启动IDEA
第三步:

在这里插入图片描述

第四步:

在这里插入图片描述

第五步:
第六步:
第七步:

在这里插入图片描述

第八步(类的创建和运行):
第九步:
第十步:

在这里插入图片描述

第十一步:
第十二步:
第十三步:

1.3 IDEA的包和类的创建

一、包的创建

包的创建
发现硬盘中多了一个文件夹

在这里插入图片描述

发现硬盘上的com文件夹下多了一个itheima文件夹
也可以一次创建多级包: 公司网址倒过来写,全部用小写字母
包的删除:
包的重命名:

二、类的操作
类(HelloWorld)的创建
类(HelloWorld)的运行

在这里插入图片描述

类(HelloWorld)的删除

1.4 IDEA字体的设置和快捷键的修改

一. 字体设置
在这里插入图片描述
二. 按住ctrl键滚动滚轮(放大缩小字体)

三. 快捷键的修改
Ctrl + 空格: 在IDEA中默认设置为自动补全代码功能
而该快捷键已经被输入法占用(输入法中ctrl+空格中英文的切换)
需要把IDEA中的Ctrl + 空格修改为alt + /
第一步:
在这里插入图片描述
第二步:

第三步

第四步

第五步:

第六步
删除快捷键后效果如下:

第七步:

第八步

第九步

第十步

1.5 IDEA快捷键的使用

1.main方法: psvm
2.输出语句: sout
3.快速复制一行: ctrl + d
4.删除一行: ctrl + y
5.单行注释: ctrl + /
6.多行注释: ctrl + shift + /
7.格式化代码: ctl + alt + L
8.移动代码: alt + shift + ↑/↓
9.自动导包: alt + 回车
10.idea中选择矩形(垂直区域):alt + 按住鼠标左键拖动

1.6 IDEA创建模块和删除模块

一. 模块的创建
在这里插入图片描述
第一步:

或者

第二步:

第三步:

第四步:
查看IDEA中产生了新的模块day02 同时在windows系统中多了个day02文件夹

二. 导入模块(把已经存在的模块导入到IDEA中)

三. 删除模块

但是在windows中还有:
在这里插入图片描述
所以如果需要彻底删除模块:

先从IDEA中执行以上删除模块操作
在windows系统中删除文件夹

1.7 IDEA导入项目和删除项目

一. 项目的创建
在这里插入图片描述

比如:

以下对话框根据需求选择,都可以:

以上对话框不管选择哪一项,接下来都会进入模块的操作,创建/导入模块:

后面就是创建/导入模块的操作前面已经讲过,不再重述(建立一个新的模块day01)
…
在这里插入图片描述
二. 关闭项目(无法从IDEA中删除项目,只能选择关闭,后从硬盘中删除)

三. 导入项目

或者:

---------------------下面是以上两种进入导入项目的入口后的共同操作--------------------------------

四. 打开已经存在的项目
在这里插入图片描述
选择This Window后,发现IDEA中已经切换到javase0207项目了

打开项目方式二:

第二章运算符

2.1 关系运算符

java">作用： 是用来比较两个数据的大小关系的。
注意： 1.关系表达式的最终结果只有两个，要么是true（关系表达式是成立的），要么是false（关系表达式是不成立的）2.==: 用来比较是否相同的 =: 用来赋值的
== 		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
//关系运算符
public class Demo01GuanXi {public static void main(String[] args) {//定义2个int变量a和b,并分别初始化int a = 10,b = 20;//判断a和b的值是否相同boolean result = (a == b);//10 == 20: falseSystem.out.println(result);//false//直接输出表达式的结果System.out.println(a == b);//falseSystem.out.println(a = b);//把变量b的值赋值给a,最终再打印a的值20System.out.println("--------------");System.out.println(a != b);//10 != 20: trueSystem.out.println(a > b);//10 > 20: falseSystem.out.println(a >= b);//10 >= 20: 10既不大于20 又不等于20 falseSystem.out.println(a < b);//10 < 20:  trueSystem.out.println(a <= b);//10 <= 20: true}
}

2.2 逻辑运算符

java">场景: 长大以后,你是想在老家发展,还是出去闯一闯	需要把多个条件连接在一起使用,需要逻辑运算符
作用: 是用来连接布尔表达式的,最终的结果也只有两个,要么是true,要么是false场景: 你呢? 必须要有房,而且 还必须要有车
1.&(shift+7)【有false，则false】: 逻辑与,并且 表示多个条件必须同时成立注意:(1)只有多个条件都成立(true),最终的结果才是成立的(true)(2)只要有一个条件不成立(false),最终的结果就是不成立的(false)场景: 你呢? 要么有房, 要么有车          
2.|(shif+\)【有true，则true】: 逻辑或,或者 表示多个条件只要有一个成立就可以注意:(1)只要多个条件中有一个成立(true),最终的结果就是是成立的(true)(2)只有所有的条件都是不成立的(false),最终的结果才是不成立的(false)3.^(shift+6): 逻辑异或 相同为false,不同为true		了解即可4.!(shift+1): 逻辑取反 !true就是false,!false就是true
//逻辑运算符
public class Demo02LuoJi {public static void main(String[] args) {//定义3个int变量a和b和c,并分别初始化int a = 10,b = 20,c = 30;System.out.println(a > b & a > c);//10 > 20 & 10 > 30 ==> false & false ==> falseSystem.out.println(a < b & a < c);//10 < 20 & 10 < 30 ==> true & true ==> trueSystem.out.println(a > b & a < c);//10 > 20 & 10 < 30 ==> false & true ==> falseSystem.out.println(a < b & a > c);//10 < 20 & 10 > 30 ==> true & false ==> falseSystem.out.println("-----------------");System.out.println(a > b | a > c);//10 > 20 | 10 > 30 ==> false | false ==> falseSystem.out.println(a < b | a < c);//10 < 20 | 10 < 30 ==> true  | true ==> trueSystem.out.println(a > b | a < c);//10 > 20 | 10 < 30 ==> false | true ==> trueSystem.out.println(a < b | a > c);//10 < 20 | 10 > 30 ==> true  | false ==> trueSystem.out.println("-----------------");System.out.println(a > b ^ a > c);//10 > 20 ^ 10 > 30 ==> false ^ false ==> falseSystem.out.println(a < b ^ a < c);//10 < 20 ^ 10 < 30 ==> true  ^ true ==> falseSystem.out.println(a > b ^ a < c);//10 > 20 ^ 10 < 30 ==> false ^ true ==> trueSystem.out.println(a < b ^ a > c);//10 < 20 ^ 10 > 30 ==> true  ^ false ==> trueSystem.out.println("-----------------");boolean result = true;System.out.println(result);//trueSystem.out.println(!result);//false/*System.out.println(!!result);//trueSystem.out.println(!!!result);//false*/}
}

2.3 逻辑运算符的短路效果

java">1.短路的逻辑运算符:(1)&&: 左侧为false,右侧不进行计算(2)||: 左侧为true,右侧不进行计算
2.特点:(1)&&和&: 运算结果是相同的,但是&&的效率高(2)||和|: 运算结果是相同的,但是||的效率高 
//短路逻辑运算符
public class Demo03DuanLu {public static void main(String[] args) {int a = 2;/*表达式 (3<2) && (++a>2) 从左向右计算先计算 3<2 的结果为false,此时对于 && 运算符而言已经决定了最终的结果为false右侧的表达式 ++a>2 是true,还是false,已经无法改变&&的最终结果了,所以 就不需要计算&&右侧的表达式 ++a>2好处: 提高效率*/System.out.println((3<2) && (++a>2));//falseSystem.out.println(a);//2/*表达式 (3<2) & (++b>2) 从左向右计算先计算 3<2 的结果为false,此时对于 & 运算符而言不管左侧的结果是true还是false,都会计算右侧的表达式++b>2的结果,从而让b的值增加1,变为3*/int b = 2;System.out.println((3<2) & (++b>2));//falseSystem.out.println(b);//3System.out.println("----------------");int c = 2;/*表达式 (3 > 2) || ((++c)>3) 从左向右计算先计算 3 > 2 的结果为true,此时对于 || 运算符而言已经决定了最终的结果为true右侧的表达式 (++c)>3 是true,还是false,已经无法改变||的最终结果了,所以 就不需要计算||右侧的表达式 (++c)>3好处: 提高效率*/System.out.println((3 > 2) || ((++c)>3));//trueSystem.out.println(c);//2int d = 2;/*表达式 (3 > 2) | ((++d)>3) 从左向右计算先计算 3 > 2 的结果为true,此时对于 | 运算符而言不管左侧的结果是true还是false,都会计算右侧的表达式(++d)>3的结果,从而让d的值增加1,变为3*/System.out.println((3 > 2) | ((++d)>3));//trueSystem.out.println(d);//3}
}

2.4 三元运算符格式

1.格式数据类型 变量名称 = 布尔表达式1 ? 表达式2 : 表达式3;
2.执行流程(1)计算布尔表达式1的结果,看是true还是false(2)如果布尔表达式1的结果为true,把表达式2的结果赋值给左侧的变量(3)如果布尔表达式1的结果为false,把表达式3的结果赋值给左侧的变量

在这里插入图片描述

2.5 三元运算符代码演示

java">//利用三元运算符判断一个int数据是否是偶数
//利用三元运算符判断一个int数据(成绩)是否及格
//三元运算符的基本使用
public class Demo01SanYuan {public static void main(String[] args) {//利用三元运算符判断一个int数据是否是偶数int num = 15;boolean result = (num%2 == 0) ? true : false;System.out.println(num+"是偶数吗? "+result);//利用三元运算符判断一个int数据(成绩)是否及格int score = 59;String str = (score >= 60) ? "及格" : "不及格";System.out.println("成绩 "+score+" 是 "+str+" 的");}
}

2.6 三元运算符的练习之两只老虎(相等)

java">需求：动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同。实现步骤:1.定义两个int变量w1和w2,分别代表两只老虎的体重,初始化值为180和2002.使用三元运算符判断w1和w2两个变量的值是否相同,把结果保存到boolean变量result中3.打印结果了
public class Demo02SanYuanLaoHu {public static void main(String[] args) {//1.定义两个int变量w1和w2,分别代表两只老虎的体重,初始化值为180和200int w1 = 180, w2 = 200;//2.使用三元运算符判断w1和w2两个变量的值是否相同,把结果保存到boolean变量result中boolean result = (w1 == w2) ? true : false;//3.打印结果了System.out.println("两只老虎的体重相同吗? "+result);String str = (w1 == w2) ? "相等" : "不相等";System.out.println("两只老虎的体重相同吗? "+str);}
}

2.7 三元运算符的练习之两只老虎(最大值)

java">需求：动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现计算两只老虎的体重的最大值。实现步骤:1.定义两个int变量w1和w2,分别代表两只老虎的体重,初始化值为180和2002.使用三元运算符计算w1和w2的最大值,保存到int变量max中3.打印max的值
public class Demo03SanYuanLaoHu {public static void main(String[] args) {//1.定义两个int变量w1和w2,分别代表两只老虎的体重,初始化值为180和200int w1 = 1800, w2 = 200;//2.使用三元运算符计算w1和w2的最大值,保存到int变量max中int max = (w1 >= w2) ? w1 : w2;//3.打印max的值System.out.println("两只老虎的最大体重: "+max);}
}

在这里插入图片描述

2.8 三元运算符的练习之三个和尚

java">需求：一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三个和尚的最高身高。
实现步骤:1.定义三个int变量h1,h2,h3分别代表三个和尚的身高,初始化值分别为150,210,1652.使用三元运算符求出第一个和尚h1和第二个和尚h2的最大身高,保存到int变量temp中3.再使用三元运算符求出temp和第三个和尚h3的最大身高,保存到int变量max中4.打印max中的值
public class Demo04SanYuanHeShang {public static void main(String[] args) {//1.定义三个int变量h1,h2,h3分别代表三个和尚的身高,初始化值分别为150,210,165int h1 = 150, h2 = 210, h3 = 165;//2.使用三元运算符求出第一个和尚h1和第二个和尚h2的最大身高,保存到int变量temp中int temp = (h1 >= h2) ? h1 : h2;System.out.println("temp="+temp);//3.再使用三元运算符求出temp和第三个和尚h3的最大身高,保存到int变量max中int max = (temp >= h3) ? temp : h3;//4.打印max中的值System.out.println("三个和尚的最大身高: "+max);}
}

在这里插入图片描述

第三章数据输入（应用）

3.1 键盘录入的基本使用

java">数据输出: 把结果输出到控制台,并显示在屏幕上
数据输入: 获取从键盘录入的数据,存入到程序当中,并按照要求进行相关的处理
像键盘录入数据这样的功能,jdk的开发人员已经帮助我们实现好了,该功能被放在java.util包中的Scanner类中
数据类型分为: 基本类型和引用类型java中的引用数据类型使用有固定的步骤:
而键盘录入Scanner类就是一个引用类型,使用也有固定的步骤: 3个步骤1.导包(告诉JVM我们使用的东西在哪里)格式:import 包名.类名;		写代码时,class关键字后面的名称2.创建对象(面向对象中学习)格式:类名 对象名 = new 类名(参数...);键盘录入对象:Scanner sc = new Scanner(System.in);//目前是固定写法3.使用sc.nextInt(): 获取键盘录入的一个int数字import java.util.Scanner;//导包
public class Demo01Scanner {public static void main(String[] args) {//2.创建对象Scanner sc = new Scanner(System.in);System.out.println("请输入一个整数: ");int num = sc.nextInt();//程序运行到这里,会等待我们键盘录入整数数字,回车换行代表录入的结束System.out.println("您输入的整数是: "+num);}
}

在这里插入图片描述

3.2 键盘录入改写三个和尚案例

java">需求：一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，身高需要使用键盘录入请用程序实现获取这三个和尚的最高身高。
实现步骤:1.要使用Canner进行键盘录入数据,首先要导包2.创建键盘录入Scanner对象3.使用键盘录入Scanner对象获取三个int数字分别代表3个和尚的身高,保存到3个int变量h1,h2,h3当中4.使用三元运算符计算h1和h2的最大值,保存到int变量temp中5.再使用三元运算符计算temp和h3的最大值,保存到int变量max中6.打印max的值
public class Demo02ScannerHeShang {public static void main(String[] args) {//2.创建键盘录入Scanner对象Scanner sc = new Scanner(System.in);//3.使用键盘录入Scanner对象获取三个int数字分别代表3个和尚的身高,保存到3个int变量h1,h2,h3当中System.out.println("请输入第一个和尚的身高(int数字): ");int h1 = sc.nextInt();System.out.println("请输入第二个和尚的身高(int数字): ");int h2 = sc.nextInt();System.out.println("请输入第三个和尚的身高(int数字): ");int h3 = sc.nextInt();//4.使用三元运算符计算h1和h2的最大值,保存到int变量temp中int temp = (h1 >= h2) ? h1 : h2;//5.再使用三元运算符计算temp和h3的最大值,保存到int变量max中int max = (temp >= h3) ? temp : h3;//6.打印max的值System.out.println("三个和尚的最大身高: "+max);}
}

3.3 键盘录入学生成绩

java">需求：键盘录入一个int数字,代表学生的成绩,判断成绩是否及格,输出结果实现步骤:1.要使用Canner进行键盘录入数据,首先要导包2.创建键盘录入Scanner对象3.获取键盘录入的一个int数字代表学生成绩,保存到int变量score中4.使用三元运算符对score中的数字进行判断,获取结果保存到String变量result中5.打印结果
public class Demo03ScannerChengJi {public static void main(String[] args) {//2.创建键盘录入Scanner对象Scanner sc = new Scanner(System.in);//3.获取键盘录入的一个int数字代表学生成绩,保存到int变量score中System.out.println("请输入一个整数代表学生成绩:");int score = sc.nextInt();//4.使用三元运算符对score中的数字进行判断,获取结果保存到String变量result中String result = (score>=60) ? "及格" : "不及格";//5.打印结果System.out.println("成绩 "+score+" 是 "+result+" 的!!!!!");}
}

3.4 键盘录入两个int数字并求和

java">/*//1.导包//2.创建键盘录入Scanner对象//3.获取键盘录入的2个int数字,保存到int变量a和b中//4.使用+求出a和b的和,保存到int变量sum中//5.打印sum的值*/
public class Demo04ScannerSum {public static void main(String[] args) {//2.创建键盘录入Scanner对象Scanner sc = new Scanner(System.in);//3.获取键盘录入的2个int数字,保存到int变量a和b中System.out.println("请输入第一个整数: ");int a = sc.nextInt();System.out.println("请输入第二个整数: ");int b = sc.nextInt();//4.使用+求出a和b的和,保存到int变量sum中int sum = a + b;//5.打印sum的值System.out.println(sum);}
}

总结

java">能够知道&&和&的区别	1.计算结果是相同的2.&&具有短路的效果: 左侧为false,右侧不进行计算&没有短路的效果: 不管左侧是false还是true,右侧都进行计算能够使用三元运算符完成获取两个数中较大值int a = 20, b = 10;int max = (a >= b) ? a : b;sout(max);能够使用键盘录入数据并完成两个数据求和//1.导包import java.util.Scanner;//2.创建键盘录入Scanner对象Scanner sc = new Scanner(System.in);//3.获取键盘录入的2个int数字,保存到int变量a和b中System.out.println("请输入第一个整数: ");int a = sc.nextInt();System.out.println("请输入第二个整数: ");int b = sc.nextInt();//4.使用+求出a和b的和,保存到int变量sum中int sum = a + b;//5.打印sum的值System.out.println(sum);	能够使用IDEA完成HelloWorld案例
能够知道IDEA的项目结构
能够使用IDEA完成模块的导入