java语言学习-part1
文章目录
- day01
-
- 文件运行过程
-
- 实践
- 一点小trick
- 注意事项
- 注释
-
- 实践
- 注意事项
-
- 文件至多一个public
- 多行注释不可嵌套
- JAVA API
-
- 实践
- day 02
-
- 问题
-
- 问题1
- 问题2
- 问题3
- 问题4
- JAVA语言特点
- 关键字与保留字
- 标识符
-
- 定义合法标识符规则
- 实践
- 标识符命名规范
- 变量
-
- 实践
- 变量分类
-
- 整型变量的使用
-
- 测试
- day 03
-
- 浮点型变量
-
- 实践
- 字符型
-
- 实践
- 布尔型变量
-
- 实践
- 数据类型转换
-
- 实践
- day 04
-
- 强制类型转换
-
- 实践
- String类变量
-
- 实践
- 进制表示方式
-
- 实践
- day 05
-
- 算术运算符
-
- 实践
- 问题
- 比较运算符
- 赋值运算符
-
- 实践
- 小测验
- day 06
-
- 逻辑运算符
-
- 实践
- 位运算符
-
- 实践
- 三元运算符
-
- 实践
- day 07
-
- if - else流程控制
-
- 实践
- scanner
-
- 实践
- day 08
-
- switch - case
-
- 实践
- for循环
-
- 实践
- while循环
-
- 实践
- do -while 循环
-
- 实践
day01
文章同步于个人博客
https://www.quan9i.top/
文件运行过程
首先呢，我们创一个后缀名为java的文件，而后写入内容
其次，我们以管理员身份打开cmd，通过javac运行来得到class文件
最后，通过java命令来将刚刚生成的clss文件运行
这就是整个过程，图示如下图所示
注：首先写的那个java文件称作源文件，通过javac运行后的class文件称为字节码文件
理论是很简单的，下面来以输出
Hello World进行实操
实践
设置一个java文件，这里命名为HelloWold.java
开始写入内容
首先是需要一个类的，我们这个时候就去写类名
class quan9i{
}
这个时候类名写好了，是quan9i，但是运行的话是需要一个主函数的，我们这个时候写入主函数
class quan9i{
public static void main(String[] args){
}
}
注：java语言是严格区分大小写的，我们这里的String中的S是大写，需要注意。
这个时候的话主函数也已经写好了，但是这个时候我们没有写内容，那么它是输出不了HelloWorld的，所以这个时候添上打印一个Helloworld的代码即可
class quan9i{
public static void main(String[] args){
System.out.println("HelloWorld");
}
}
此时源文件就写好了，我们以管理员身份运行cmd，切换到当前路径下，而后javac这个文件即可
此时再去文件夹下看
这个时候就生成了quan9i.clss文件
注：字节码文件是以类名命名的，我们的类名是quan9i，所以这里的字节码文件就是quan9i.class
此时去java这个字节码文件即可
注:在运行java这个指令时，不需要写后缀.class，直接写名字就可以运行这个文件
一点小trick
java语言是严格区分大小写的，但是我们的windows是不区分大小写的，因此我们在将源文件进行编译的时候，其实大写还是小写都是可以成功编译的
但仅仅只是这个编译过程，在运用java指令时它就又属于java层面了，此时就又区分了大小写
注意事项
我们这里的输出语句是这样的
System.out.println("HelloWorld");
但其实它也可以这样写
System.out.print("HelloWorld");
那么这两个有什么区别呢，区别就是前者是先输出数据，后换行，而后者是只输出数据，从拼写也可以看出来，前者多了ln它是line的缩写，我们接下来来测试一下
还有一个小的注意事项就是当一个文件存在多个类时，javac运行后会出现多个字节码文件，这个时候我们去java那个含main方法的就可以了。
注释
java 语言中的注释有三种格式
1、单行注释
2、多行注释
3、文档注释（java独有）
他们的注释方法如下(xxx指的是内容)
1、 //
2、 /*
*/
3、
/**
*/
前两个的作用是相同的，即
对所写的程序进行解释说明，增强代码可读性
可以调试代码(报错时将语句加注释进行排查)
而文档注释的作用不单单是这个，它的注释内容可以被JDK提供的工具javadoc所解析，生成一套网页文件形式体现的该程序的说明文档
实践
创建一个java源文件
上次写的是HelloWorld，那这次写个HelloJava好了
class HelloJava{
public static void main(String[] args){
System.out.println("HelloJava");
}
}
此时内容就写好了，我们开始添加我们的注释
/**
文档注释
@author quan9i
@version 1.0
这是我的第一个java程序
*/
class HelloJava{
/*
多行注释
如下的main方法是程序的入口！
main的格式是固定的
*/
/**
文档注释
如下的方式是main() ,是程序的入口处
*/
public static void main(String[] args){
//单行注释：如下的语句表示输出到控制台
System.out.println("HelloJava");
}
}
此时就完成了，既有单行和多行，又有文档，那么该怎么利用javadoc解析这个文档注释呢，指令如下
javadoc -d 名字 -author -version 文件名
这里的名字是我们自己起的，文件名的话就是我们之前创建的HelloJava.java
但是此时去运行的时候，会发现报错说找不到公共或受保护的类，这是因为我们没有给类添加public，此时在内容中的class前添加public即可
/**
文档注释
@author quan9i
@version 1.0
这是我的第一个java程序
*/
public class HelloJava{
/*
多行注释
如下的main方法是程序的入口！
main的格式是固定的
*/
/**
文档注释
如下的方式是main() ,是程序的入口处
*/
public static void main(String[] args){
//单行注释：如下的语句表示输出到控制台
System.out.println("HelloJava");
}
}
此时就完成了，去文件夹下查看，会发现多了一个名为quan9i的文件夹
里面有很多个文件
我们打开index.html查看
这个时候就可以看到文档注释中的内容输出到了界面中，而单行和多行则不然
注意事项
文件至多一个public
我们刚刚知道了运行javadoc的时候需要一个public，但这个public在一个文件中只能有一个，当出现文件中有多个类名的情况时，它只能添加到与文件名同名的类前面，例如我们上面的代码就是HelloJava类，我们的文件名也是如此，这个时候才可以成功运行
多行注释不可嵌套
多行注释是不可以嵌套使用的
可以看到此时最后一个*/已经不是注释内容了，这是因为它在嵌套使用的时候，把第二个/*当成了文本内容，但遇见*/时就直接闭合，这个注释就已经完成了，而此时多出了*/，导致了这个不能成为注释，由此可知多行注释是不可以嵌套使用的
JAVA API
API，全称为Application Programming Interface，中文名为应用程序编程接口
JAVA语言提供了大量的基础类，因此ORacle也为这些基础类提供了相应的API文档，用于告诉开发者如何使用这些类，以及这些类里包含的方法
API入口
https://itmyhome.com/java-api/index.html?overview-summary.html
打开它之后就可以看见这个结构，它其实就类似于一个字典，我们有不明白的类时，可以在这里面看它的具体含义
它整体的结构如下
实践
我们之前写的代码String[] args中的String就是一个类，我们该如何搜索它呢，我们如果是网页端的话，没有这个搜索框，此时我们就可以借助ctrl+f寻找关键词，我们输入String而后回车即可
点击这个String
此时就可以看到该类的介绍
day 02
问题
问题1
JDK、JRE、JVM三者之间的关系，以及JDK、JRE包含的主要结构有哪些
三者之间的关系是JDK包含JRE，JRE包含JVM，如下图所示
JDK=JRE+开发工具(javac.exe、java.exe、javadoc.exe)
JRE=JVM+Java核心类库
总的来说如下图所示
问题2
为什么要配置path环境变量
为了在cmd中，任何情况下都可调用java命令（即不论在哪个目录下都可以用java指令）
问题3
常用的命令行操作符
cd //切换目录
rd //删除目录
md //创建目录
dir //列出目录
del //删除文件
问题4
创建如下的类，使得运行能够输出
姓名:王大锤
性别：男
住址:花果山
构造java源文件如下
class man{
public static void main(String args[]){
System.out.println("姓名:王大锤");
System.out.println();
System.out.println("性别：男");
System.out.print("住址:花果山");
}
}
而后利用javac进行编译，再用java指令运行字节码文件即可
JAVA语言特点
1、面向对象性
两个要素：类、对象
三个特征：封装、继承、多态
2、健壮性
1、去除了C语言中的指针
2、自动的垃圾回收机制
3、跨平台性
在windows、linux和macos上都可以运行，实现了
一次编译，到处运行
原因是因为有JVM
关键字与保留字
关键字
定义：被JAVA语言赋予了特殊含义，用做专门用途的字符串
特点：关键字中字母都为小写
比如说之前用到的class和public
这里的true、false和null是灰色的，这是因为它的位置比较特殊 ，它不完全属于关键词，这三个是定义值的，但是又是当作关键字来用，类似于公司的外包机制
保留字
Java 保留字列表 (依字母排序 共14组) :
Java保留字是指现有Java版本尚未使用 但以后版本可能会作为关键字使用。
byValue, cast, false, future, generic, inner, operator, outer, rest, true, var， goto ，const,null
标识符
定义：Java对各种变量、方法和类等要素命名时使用的字符序列称为标识符
技巧：凡是可以自己起名字的地方都叫标识符
比如：类名、方法名、变量名、接口名
定义合法标识符规则
1、由26个英文字母大小写、0-9、_或$组成
2、数字不可以开头
3、不可以使用关键字和保留字，但能包含关键字和保留字
4、Java严格区分大小写，长度无限制
5、标识符中不能包含空格
实践
我们新建一个quan9i.java文件，内容如下
class quan9i{
public static void main(String args[]){
}
}
此时去编译一下
此时是可以正常编译的，而当我们这样写的时候
class 1quan9i{
public static void main(String args[]){
}
}
此时就报出了语法错误，这里报错是因为我们的第二个规则，不能以数字开头
此时我们再测试一下第三个规则，内容如下
class void{
public static void main(String args[]){
}
}
此时因为调用了关键字，出现了多个错误，但是第三个规则中还说了可以包含关键字和保留字，这个怎么理解呢，示例如下
class void1{
public static void main(String args[]){
}
}
void1中包含了void关键字，但它不是关键字，因此这里用是没有问题的
此时再测试第四个，代码如下
class Void{
public static void main(String args[]){
}
}
此时有关键字却可以，这是为什么呢，因为Java严格区分大小写，关键字规定都是小写的，这个里面的类名是Void，第一个字母是大写，与关键字不同，所以这里可以正常使用
此时测试最后一个规则
class Void quan9i{
public static void main(String args[]){
}
}
此时就报出了一个错误，这个就是第五个规则，不能包含空格，一般标识符是只有一个字符串的，他这里会将前面的Void视为标识符，后面的无法正常识别，导致了报错
标识符命名规范
包名：多单词组成时所有字母都小写xxyyzz
类名、接口名：多单词组成时，所有单词首字母大写XxYyZz
变量名、方法名：多单词组成时，第一个单词首字母小写，其他首字母大写xxYyZz
常量名：所有字母都大写，多单词时每单词间以下划线连接XX_YY_ZZ
class quan9i{
public static void main(String args[]){
}
}
这个其实是不规范的，因为类名首字母应该大写，我们尝试编译一下
发现可以，这就是命名规则与命名规范的区别
不按照命名规则来会报错，无法编译
不按照命名规范来不会报错，可编译
注：不按这个规范来的话，是可以正常编译的，但不易于区分，因此建议按照这个来进行命名
变量
概念：内存中的一个存储区域
该区域的数据可以在同一类型范围内不断变化
变量是程序中最基本的存储单元。包含变量类型（整型、字符型等）、变量名和存储的值
变量的作用
用于在内存中存储数据
使用变量需要注意的地方
1、Java中每个变量必须先声明，后使用
2、使用变量名来访问这块区域的数据
3、变量的作用域，其定义在所在的一对{}内
4、变量只有在其作用域中才有效
5、同一个作用域内，不能定义重名的变量
实践
/*
变量的使用
1、java定义变量的格式，数据类型 变量名 = 变量值；
*/
class VariableTest{
public static void main(String[] args){
int myAge = 18;
System.out.println(myAge);
}
}
当然，也可以这样写
/*
变量的使用
1、java定义变量的格式，数据类型 变量名 = 变量值；
*/
class VariableTest{
public static void main(String[] args){
int myAge;
myAge = 18;
System.out.println(myAge);
}
}
我们如果这样写呢
class VariableTest{
public static void main(String[] args){
System.out.println(myAge);
}
public void method(){
int myAge = 1;
}
}
试着去编译一下
报错，这个时候就是因为我们的变量作用域是在一对{}内
那么这样可不可以呢
class VariableTest{
public static void main(String[] args){
int myAge = 18;
System.out.println(myAge);
int myAge = 2;
}
}
报错，这是因为同一作用域内不可以定义同名的变量
变量分类
基本数据类型
整型：byte 、short、int、long
浮点型：float、double
字符型：char
布尔型：boolean
引用数据类型
类(class)
接口(interface)
数组(array)
整型变量的使用
整型变量有四种类型
byte
short
int
long
测试
class VariableTest{
public static void main(String[] args){
byte a1=-127;
byte a2=18;
System.out.println(a1);
System.out.println(a2);
}
}
class VariableTest{
public static void main(String[] args){
byte a1=-127;
byte a2=18;
short s1=128;
int i1 = 1234;
long l1 = 321231231L;
System.out.println(i1);
System.out.println(l1);
}
}
仔细看的话这里的long l1赋值时最后有一个L，这个L是声明为long型的，输出时不会输出它
day 03
浮点型变量
浮点型分为两类，float和double型，两者区别简单说就是float占四字节，double占八字节，它的精度是大于float型的，而且float的表示范围比整型中的long还要长
实践
class VariableTest{
public static void main(String[] args){
double d1 = 111.11;
float f1 = 22.22;
System.out.println(d1);
System.out.println(f1);
}
}
这个时候可以发现它报错了，这个是为什么呢，因为float型在结尾需要加上f或者F表示它是一个浮点型，所以我们修改代码如下
class VariableTest{
public static void main(String[] args){
double d1 = 111.11;
float f1 = 22.22f;
System.out.println(d1);
System.out.println(f1);
}
}
通常，我们使用浮点型时用double型
字符型
char（一字符等于两字节）
定义char型时，一般用单引号包裹
表示方式
1、声明一个字符 例 char a1=‘c’;
2、转义字符 例 char a1=‘\n’;
3、Unicode字符集。例 char a1=‘\u0043’;
实践
class VariableTest{
public static void main(String[] args){
char c1 = 'a';
char c2 = '1';
char c3 = '\u0043';//字符c
char c4 = '\n';
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
System.out.print("Hello" + c4);
System.out.println("World");
}
}
布尔型变量
布尔型boolean，只有两个值，一个是true，另一个是false
布尔型常常用于循环结构、条件语句中使用。
实践
class VariableTest{
public static void main(String[] args){
boolean a1=true;
if(a1){
System.out.print("你不可以参加\"单身\"派对了!!!\n很遗憾。");
}
else{
System.out.print("你可以多参加几个\"单身\"派对来交个女朋友！！！");
}
}
}
数据类型转换
转换原则
（1）占用字节较少的数据类型转换成字节数较多的数据类型；
（2）字符类型会转换成int类型；
（3）int类型会转换成float类型；
（4）若表达式中其中一个类型为double，另一个操作数也会转double；
（5）布尔类型不能转换为其它类型；
实践
class VariableTest{
public static void main(String[] args) {
int i = 10;
long a = 3;
float c = i/a;
double d = c + a;
System.out.println(i);
System.out.println(a);
System.out.println(c);
System.out.println(d);
}
}
day 04
强制类型转换
一般默认的整型为int，浮点型为double
实践
如果长度长一点，用long来表示，此时会怎样呢
class VariableTest{
public static void main(String[] args) {
long l = 123123;
System.out.println(l);
long l1 = 21332423235234123;
System.out.println(l1);
}
}
而当我们在long后面加上L
class VariableTest{
public static void main(String[] args) {
long l = 123123;
System.out.println(l);
long l1 = 21332423235234123L;
System.out.println(l1);
}
}
现在来试一下类型转换
class VariableTest{
public static void main(String[] args) {
byte b = 12;
byte b1 = b + 1;
}
}
这里是因为1是整型，默认就是int型，int->byte变小，这种转换不正常，所以报错，浮点型同理
class VariableTest{
public static void main(String[] args) {
float b = 12;
float b1 = b + 12.2;
}
}
默认是double型，double->float不正常，所以报错
但我们可以强制进行转换，如下
class VariableTest{
public static void main(String[] args) {
int a = 1;
short b = (short)a;
System.out.println(b);
}
}
String类变量
字符串型，一般用双引号来包裹
实践
class VariableTest{
public static void main(String[] args) {
String s1="Hello World";
System.out.println(s1);
String s2 = "a";
String s3 = "" ;
int number = 666;
String cj="成绩:";
String grade= cj + number;
System.out.println(grade);
}
}
这里的加号是连接符，为了区分连接符，我们可以多做几个示例来分辨一下
class VariableTest{
public static void main(String[] args) {
char a = 'a';
int b = 10;
String c = "Hello World";
System.out.println(a+b+c);
System.out.println(a+(b+c));
System.out.println((a+b)+c);
}
}
第一个：a与b运算，a是char型的，此时换成ascii码，也就是97，来与b运算，此时就是相加，变107，后面是连接符，所以是107Hello World
第二个：b与c先运算，由于int型与String型是不可以相加的，所以这里为连接符，而后后面变为一个整体与前面进行连接，所以就是a10Hello World
第三个：a和b先运算，与第一个类似，相加后为107，而后进行连接，结果为107 Hello World
练习
class VariableTest{
public static void main(String[] args) {
System.out.println('*'+'\t'+'*');
System.out.println('*'+"\t"+'*');
System.out.println('*'+("\t"+'*'));
}
}
第一个：\t是单引号包裹的，被认为是char型，转换为ascii码与前者的ascii码进行相加，而后再加后者的ascii码，最后得到93。
第二个：\t是双引号包裹的，被认为是String型，它此时的含义就是制表符，前后的+此时就是连接符，输出结果就是* *
第三个：与第二个类似，无论括号在前在后结果都是相同的
进制表示方式
二进制(binary)：0,1，满2进1，以0b或0B开头
十进制(decimal)：0-9，满10进1
八进制(octal):0-7，满8进1，以数字0开头
十六进制(hex)：0-9及A-F，满16进1，以0x或0X开头，此处的A-F不区分大小写
实践
class VariableTest{
public static void main(String[] args) {
int num1 = 0b110;
int num2 = 110;
int num3 = 0110;
int num4 = 0x110;
System.out.println("num1 = "+num1);
System.out.println("num2 = "+num2);
System.out.println("num3 = "+num3);
System.out.println("num4 = "+num4);
}
}
day 05
算术运算符
首先需要说明的就是这个取余运算，它的结果正负是取决于前者的，比如a%b，如果前者是正，结果就是正，前者是负，结果就是负，与后者的正负五关，详情可以看下面的实践
算数运算符有以下几种
实践
class VariableTest{
public static void main(String[] args) {
int a1 = 13;
int a2= 2;
double b1 = 13/2;
System.out.println(a1%a2);
System.out.println(b1);
System.out.println(-13%2);
System.out.println(13%-2);
System.out.println(-13%-2);
}
}
class VariableTest{
public static void main(String[] args) {
int a1 = 10;
int b1 = a1++;//先取值后运算，等同于b1=a1;a1=a1+1;
System.out.println(a1);
System.out.println(b1);
int a2 = 10;
int b2 = ++a2;//先运算后取值，等同于a2=a2+1;b2=a2;
System.out.println(a2);
System.out.println(b2);
int a3 = 10;
int b3 = a3--;
System.out.println(a3);//先取值后运算，等同于b3=a3;a3=a3-1##;
System.out.println(b3);
int a4 = 10;
int b4 = --a4;//先运算后赋值，等同于a4=a4-1;b4=a4;
System.out.println(a4);
System.out.println(b4);
}
}
问题
写一个程序，分别输出187的个位，十位和百位。
代码如下
class VariableTest{
public static void main(String[] args) {
int a = 187;
int bai = a /100;
int shi = a %100 /10;
int ge = a %10;
System.out.println("百位:"+bai);
System.out.println("十位:"+shi);
System.out.println("个位:"+ge);
}
}
比较运算符
这里的注意点的话就是需要知道单个的=是赋值，==才是相等的意思。比较运算符有以下几种
没啥意思，不举例子
赋值运算符
赋值运算符有以下几种
+=
-=
%=
/=
*=
举个简单的例子，a+=b就等同于a=a+b
实践
class VariableTest{
public static void main(String[] args) {
int num1 =10;
num1 +=2;
System.out.println(num1);
int num2 =6;
num2 %= 4;
System.out.println(num2);
int num3 = 3;
num3 *= 3;
System.out.println(num3);
}
}
小测验
class VariableTest{
public static void main(String[] args) {
int i = 1;
i *=0.1;
System.out.println(i);
i++;
System.out.println(i);
}
}
说出第一个和第二个i的值
答案;第一个为0，第二个为1
在计算机语言中，不论是1*0.1还是1*0.9，其结果都是0
下一题
class VariableTest{
public static void main(String[] args) {
short s = 3;
① s = s + 2;
② s+= s+2
System.out.println(s);
}
}
代码中①与②的区别是什么
答案：①是无法编译的，因为+2的话2被视为int型，int型向byte转换，会出现转换错误
②可以正常编译
day 06
逻辑运算符
逻辑运算符有以下几种
&
|
!
&&
||
^
具体如下图
实践
class VariableTest{
public static void main(String[] args) {
boolean b1=false;
int a1=10;
if(b1 & (a1++>0)){
System.out.println("我现在在北京");
}
else{
System.out.println("我现在在南京");
}
System.out.println("a1 = "+a1);
boolean b2=false;
int a2=10;
if(b2 && (a2++>0)){
System.out.println("我现在在北京");
}
else{
System.out.println("我现在在南京");
}
System.out.println("a2 = "+a2);
}
}
从结果可以看出，当第一个是false时，&还会往下继续运行，而&&则直接跳过
第一个正确时，两个都会往后运行
此时再看|和||
class VariableTest{
public static void main(String[] args) {
boolean b1=true;
int a1=10;
if(b1 | (a1++>0)){
System.out.println("我现在在北京");
}
else{
System.out.println("我现在在南京");
}
System.out.println("a1 = "+a1);
boolean b2=true;
int a2=10;
if(b2 || (a2++>0)){
System.out.println("我现在在北京");
}
else{
System.out.println("我现在在南京");
}
System.out.println("a2 = "+a2);
}
}
当第一个正确时，|还会继续往后运行，而||则直接跳过
第一个错误的话，两个都会往后运行
位运算符
简单说一下这个左移右移，用二进制数讲解
12 8 4 2 1 结果
0 0 0 1 1 | 3
左移二位
0 1 1 0 0 | 12
右移一位
0 0 0 0 1 | 1
这个与或亦是如此
12 8 4 2 1 结果
0 0 1 1 0 | 6
0 0 0 1 1 | 3
经过&运算
0 0 0 1 0 | 2
经过|运算
0 0 1 1 1 | 7
经过^运算（相同取0，不同取1）
0 0 1 0 1 | 5
取反运算的话就是符号位相反而后加1，6就变成-7
结论
位运算符操作的都是整型的数据
<<:在一定范围内，每左移1位，相当于 *2
>>:在一定范围内，每右移1位，相当于 /2
实践
class VariableTest{
public static void main(String[] args) {
int i = 20;
System.out.println("i<<2="+(i<<2));
System.out.println("i>>2="+(i>>2));
}
}
三元运算符
a?b:c
当a条件为true时，执行b，否则就执行c
实践
class VariableTest{
public static void main(String[] args) {
int a = 12;
int b = 30;
int c = -40;
int max1 = (a>b)?a:b;
int max2 = (max1>c)?max1:c;
System.out.println("三个数中的最大值为:"+max2);
}
}
day 07
if - else流程控制
两种格式，第一种
if(条件1){
xxx
}
else{
xxx
}
当条件一为true时，就执行if语句里的内容，否则就执行else中的内容
第二种(可以写多个else if 语句，但结尾需要是else)
if(条件1){
xxx
}
else if(条件2){
xxx
}
else{
xxx
}
当条件1满足时，执行if里的语句，当条件1不满足，而条件二满足时，执行else if里的语句，否则执行else里的语句
实践
class VariableTest{
public static void main(String[] args) {
int a = 12;
int b = 30;
if(a>b){
System.out.println("最大值为:" + a);
}
else{
System.out.println("最大值为:" + b);
}
}
}
class VariableTest{
public static void main(String[] args) {
int a = 12;
int b = 30;
if(a>b){
System.out.println("最大值为:" + a);
}
else if(a<b){
System.out.println("最大值为:" + b);
}
else{
System.out.println("两者无法确定最大值");
}
}
}
scanner
如何从键盘获取不同类型的变量，需要使用Scanner类
步骤
1:导包：import java.util.Scanner;
2:Scanner的实例化:Scanner scan = new Scanner(System.in);
3:调用Scanner类的相关方法，来获取指定类型的变量。
从官方文档就可以看见函数的使用方法，如输入int用nextInt部分方法如下图
举个简单的例子
import java.util.Scanner;
class VariableTest{
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int num = scan.nextInt();
System.out.println(num);
}
}
上面是输入，下面是输出
实践
/*
如何从键盘获取不同类型的变量，需要使用Scanner类
步骤
1:导包：import java.util.Scanner;
2:Scanner的实例化:Scanner scan = new Scanner(System.in);
3:调用Scanner类的相关方法，来获取指定类型的变量。
*/
import java.util.Scanner;
class VariableTest{
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入您的姓名");
String name = scan.next();
System.out.println(name);
System.out.println("请输入您的年龄");
int age = scan.nextInt();
System.out.println(age);
System.out.println("请输入您的体重");
double weight = scan.nextDouble();
System.out.println(weight);
System.out.println("你是否对我有好感?(true/false)");
boolean isgood= scan.nextBoolean();
System.out.println(isgood);
//对于char型的获取，Scanner没有提供相关方法，只能获取一个字符串
System.out.println("请输入您的性别(男/女)");
String xingbie = scan.next();
char xb = xingbie.charAt(0);
}
}
day 08
switch - case
格式如下
switch(表达式){
case 常量1:
执行语句1；
//break;(可写可不写，写的话就跳出去了，不写继续往后执行)
case 常量2
执行语句2:
//break;
...
default:(case中没有对应的常量时执行)
执行语句n;
//break;
实践
import java.util.Scanner;
class VariableTest{
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入常量");
int number = scan.nextInt();
switch(number){
case 0:
System.out.println("zero");
case 1:
System.out.println("one");
break;
case 2:
System.out.println("two");
break;
default:
System.out.println("other");
break;
}
}
}
for循环
原理与C相似
for(变量;条件;自增){
循环体
}
实践
class VariableTest{
public static void main(String[] args) {
for(int i=0;i<=3;i++){
System.out.println("quan9i");
}
}
}
while循环
while(循环条件){
循环体
}
实践
设计程序打印100以下的整数
class VariableTest{
public static void main(String[] args) {
int i=1;
while(i<100){
if(i%2==0){
System.out.println(i);
}
i++;
}
}
}
do -while 循环
与while不同点在于它至少会执行一次
do{
循环体
}
while(循环条件);
实践
class VariableTest{
public static void main(String[] args) {
int i=1;
do{
if(i%2==0){
System.out.println(i);
}
i++;
}
while(i<100);
}
}