10-24至10-28第二周总结

10-24  常用的dos命令

1)盘符号的切换
盘符号不区分大小写: 回车即可
C:\Users\Administrator>D:
D:\>
2)进入指定单个文件夹(目录) cd 目录名称
D:\>cd EE_2211
D:\EE_2211>
3)进入多级目录 cd 多级目录的路径
cd 将多级路径的名称复制过来(win10系统/win11系统 在dos窗口直接鼠标右键就粘贴了 )
D:\>cd D:\EE_2211\10_24_am_code_resource\code
D:\EE_2211\10_24_am_code_resource\code>
4)回退上一级目录 cd.. 或者cd ..
D:\EE_2211\10_24_am_code_resource\code>cd..
D:\EE_2211\10_24_am_code_resource>
5)回退盘符根目录 cd \或者cd\
D:\EE_2211\10_24_am_code_resource\code>cd\
D:\>
6)查看(罗列)这个盘符或者目录某个目录的详细信息 dir指令
D:\>dir

7)清除屏幕指令 cls(clear scrren) :当你dos窗口上面有很多信息,将上面的信息不用了,删了,使用这个

8) 要在指定的目录里面创建文件夹(目录)
md (make directory)文件夹名称(目录名称)
D:\EE_2211\10_24_am_code_resource\code>md aaa
D:\EE_2211\10_24_am_code_resource\code>md bbb
D:\EE_2211\10_24_am_code_resource\code>md ccc
D:\EE_2211\10_24_am_code_resource\code>
9)创建文件
copy con 文件名称带上后缀名 ----按回车键---进入编辑模式,书写文件内容,书写完成成之后,按---ctrl+z,编辑完成----回车即可!
D:\EE_2211\10_24_am_code_resource\code\aaa>copy con a.txt
hello,Java 开始了^Z
已复制 1 个文件。
D:\EE_2211\10_24_am_code_resource\code\aaa>copy con hello.txt
正在学习常用的dos指令^Z
已复制 1 个文件。
D:\EE_2211\10_24_am_code_resource\code\aaa>

10)删除指定的文件夹(目录) 注意事项:rd 文件夹名称(目录名称) 只能删除空目录
D:\EE_2211\10_24_am_code_resource\code>rd aaa
目录不是空的。
先通过下面del指令将文件删除了,然后再去使用rd 文件夹名称(目录名称) 删除这个文件夹
D:\EE_2211\10_24_am_code_resource\code\aaa>cd ..
D:\EE_2211\10_24_am_code_resource\code>rd aaa
11) 删除文件 del 指定文件名称 也可以批量删除所有同名的后缀的文件
举例:del *.txt 删除所有带有.txt的文件
D:\EE_2211\10_24_am_code_resource\code\aaa>del *.txt
D:\EE_2211\10_24_am_code_resource\code\aaa>
D:\EE_2211\10_24_am_code_resource\code\aaa>del hello.java
D:\EE_2211\10_24_am_code_resource\code\aaa>
12) rd的扩展指令
在windows系统上,想删除带内容的目录(里面有文件或者子文件夹)
rd /s 文件夹名称(目录) :询问删除删除带内容的目录? y/n 选择y就是删除,n不删除
D:\EE_2211\10_24_am_code_resource\code>rd /s bbb
bbb, 是否确认(Y/N)?
rd /s /q 文件名称(目录) :不询问删除带内容的目录 (属于暴力删除 这个指令慎用!)
D:\EE_2211\10_24_am_code_resource\code>rd /s /q ccc
D:\EE_2211\10_24_am_code_resource\code>windows+r--->输入control
rm -rf :在linux系统 递归删除所有的文件夹以及里面子文件
系统指令
查看ip地址 ipconfig

D:\EE_2211\10_24_am_code_resource\code>ping www.baidu.com
正在 Ping www.a.shifen.com [36.152.44.95] 具有 32 字节的数据:
来自 36.152.44.95 的回复: 字节=32 时间=35ms TTL=54
来自 36.152.44.95 的回复: 字节=32 时间=34ms TTL=54
来自 36.152.44.95 的回复: 字节=32 时间=34ms TTL=54
来自 36.152.44.95 的回复: 字节=32 时间=34ms TTL=54
36.152.44.95 的 Ping 统计信息:
数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，
往返行程的估计时间(以毫秒为单位):
最短 = 34ms，最长 = 35ms，平均 = 34ms
D:\EE_2211\10_24_am_code_resource\code>

10-25 java环境变量配置  注释 关键字  标识符 常量

配置方式步骤
1)赋值jdk安装目录的路径,不是bin目录 D:\develop_software\Java\jdk1.8.0_162
2)此电脑---->右键---->选择属性---->高级系统设置---->环境变量---->系统变量
系统变量----->新建一个变量名: JAVA_HOME
变量值:就是1)的路径
3)在path里面 引入JAVA_HOME对应的变量值的路径,path环境变量里面的最前面 %JAVA_HOME%\bin ,如果win10/win11 点击path,隔段形式,后面不用分号
如果是在一行上bin后面带上分号;
好处:以后jdk版本升级,需要改动path? 不需要,只需要改动JAVA_HOME变量值里面的路径,

注释

注释:在计算机编程语言为了提高代码阅读性,给某些代码进行标记文字提示,让程序阅读性更高一些,
作为中国人,肯定加入中文字符,但是一般习惯写注释,因为代码给人看的(人:程序员),接手别人的项目,它代码没有注释,
很难受!
注释:一行代码---标记了很多行注释,阅读性比较差!(简单标记)
Java中的注释的分类:
单行注释://书写内容
多行注释:/* 书写内容 */
前面两个普通注释:主要就是来标记代码,提高代码阅读性
文档注释: /** 书写内容 */ :特殊注释,可以被解析.

关键字

Java的关键字:
被Java语言赋予特定含义的单词,叫关键字!
在高级记事本notepad++以及editplus记事本以及开发工具idea(以后用的这个)/eclipse等等
针对关键字有一种颜色标记
package:包名(文件夹/目录结构) :以后在开发中代码分包,分层的 (真实的意义:在面向对象部分讲解)
class:定义类的格式,Java中最基本单元就是类 固定格式 class 类名{}
public:权限修饰符 (公共的/公开的,任何人都可以访问的),访问权限足够大注意事项:
goto/const这两个字 作为"保留字"去使用!

标识符

还有其他权限修饰符private,protected ,具体的讲解在面向对象部分去讲
static:静态修饰符 (面向对象部分讲解,本身的含义被"共享,共用")
变量里面的基本数据类型都是关键字
标识符:(起名字,"见名知意")
对包名,类名,接口名,变量名,方法名,常量名起名字的一个字符序列!
组成规则:
1)有0-9到数字组成
2)字母字符(26个字母)
3)$符号
$)_下划线
对包名(目录结构package) 起名字规范 (面向对象部分讲解 包的含义)
单级包:(字母都是小写) com包名
xx.java
多级包:包名和包名使用.隔开
com.qf
com下面会有一个qf文件夹
xx.java文件
对类名和接口名起名字是同样的:(遵循阿里规范:大驼峰命名法)
定义类的时候:如果类名是单个单词,首字母大写,其余小写
举例
class Hello{}
class Demo{}
如果类名它是多个单词组成,每个单词首字母大写,其余小写
举例:
class HelloWorld{}
class MakeNameDemo{}
class StartGame{}
对变量名和方法名起名字是相同 规范: (遵循小驼峰命名法)
如果变量名是一个单词,那么 单词的字母全部小写
举例: 定义价格
int price = 5;
如果变量名是多个单词,那么第一个单词字母小写,8.常量
分类
从第二个单词开始,每个单词首字母大写 ,其余小写!
举例:
定义苹果价格
int applePrice = 7;
对常量起名字(以后看到java的源码里面常量的格式:使用的多个单词写的)
如果常量名,单个单词 ,字母全部大写
举例 HELLO
如果是多个单词,字母全部大写,单词和单词之间用下划线隔开!
jdk提供的Thread类 :线程
定义线程优先级三个常量:只看格式 (最小优先级,默认优先级,最大优先级)
注意事项:
1)起名字,可以数字,但是不能以数字开头
2)Java严格区分大小写,一定要起名字见名知意
3)标识符不能是Java中的关键字

常量

常量在程序过程中,其值不发生改变的量!
字面值常量
1)字符串常量:使用英文的符号"" 双引号括起来的任何内容都是字符串
举例
"helloworld"
"我爱高圆圆"
"今天天气不好,心情是绿色的!"
2)字符常量:使用英文的'' 单引号阔括起来的单个字符内容
'a' :字符小a
'A' : 字符大A
'0' : 字符0
不能'ab'---jvm在解析的时候,认为这个字符串,不是单个内容,解析错误!
如果字符不参与运算,就是字符本身!
如果字符参与运算的时候,此时 字符(键盘上的每一个按键都是字符)
它就会去找ANSI码表里面的字符对应的值,进行运算;
'a' --- 97
'A' --- 65
'0' --- 48
3)整数常量
100,974)

小数常量
3.14
12.34
5)布尔常量: true/false
6)空常量: 一般不能直接输出null
在引用数据类型(后面讲数组的说),默认值是null

10-26 进制  变量

变量

什么是变量?
定义变量的方式
数据类型有哪些(识记)
在程序过程中,其值发生改变的量;
学习Java编程语言,在Java中,如何定义变量?
变量的三要素
1)数据类型
2)变量名
3)初始化值
1)先定义,然后在赋初始化值
数据类型 变量名;
变量名 = 值; (在使用这个变量之前,必须赋值,否则编译报错!)
2)要么直接定义时候赋初始化值
数据类型 变量名 = 初始化值;
分为两大类

基本数据类型:

基础数据类型

四类八种
1)整数类型: 有四种,默认int (讲课过程,没有明确类型都是int)
byte:字节类型 占1个字节 范围:-128~127(必须记住)
short:短整型 占2个字节
int(默认) 占4个字节
long:长整型 占8个字节
在定义long 的时候,规定,在初始化值加上L或者l
2)浮点类型:默认double
单精度类型 float 在定义float类型后边规定    占4个字节
需要标记,在初始化值的后面加上F或者f
双精度类型duoble: 占8个字节
3)字符类型:
char: 里面的内容'字符' 占2个字节
4)布尔类型:开发中,逻辑判断的true还是false的结果
boolean 一般boolean不参与运算,只是表示true或者false 占1个字节
基本类型里面整数类型开发中:用最多的int,其次long
(long类型定义时间毫秒值,后期通过常用类的功能,将系统时间得到时间毫秒值)6.Java中的隐式类型转换
基本类型里面的浮点类型:使用最多的double(市场价格/商场价格...)

引用数据类型:

数组,类,接口
类(具体类/抽象类)

10-27    运算符 强转  三元运算符

Java中运算符

算术运算符
赋值运算符
比较运算符
逻辑运算符
位运算符(数据在进行 "移位" 高级符号:<<,>>,>>>) 了解即可!
三元运算符

强转类型转换

/显示转换:强转类型转换:就是将大的数据类型---转换成小的数据格式
//目标数据类型 变量名 = (目标数据类型)初始化值;
class DataTypeDemo{
public static void main(String[] args){
//定义两个变量
int a = 4 ;
byte b = 3 ;
//现在使用的接收类型是byte类型
//byte result = a + b ;//不兼容的类型: 从int转换到byte可能会有损失
//(byte,short,char三者之间不转换,一旦参与运算,优先提升int)
// =右边:int类型+byte类型的b,先要将byte类型提升int,结果int类型,
//=左边:byte类型, 无法存储int类型的结果
//目标数据类型 变量名 = (目标数据类型)(初始值在或者表达式);
byte result = (byte)(a+b) ;
System.out.println("结果是:"+result) ;
}
}

扩展的算术运算符

++或者--
1)场景--->统计场景(统计用户的登录次数,猜数字游戏,统计用户多少次猜中了)
2)流程控制语句循环结构语句中---++或者--使用方式
1)不参与运算,单独使用
a)在数据的前面
b)在数据的后面
结论:
无论++或者--在数据的前面还是后面,都是对当前数据进行自增1或者自减1
2)参与运算
a)在数据的前面
结论:
++或者--在数据的前面,先进行增1或者自减1,然后参与运算!
b)在数据的后面
++或者--在数据的后面,先运算,然后进行自增1或者自减1 !
class OperatorDemo2{
public static void main(String[] args){
//定义两个变量
int a = 4 ;
int b = 3 ;
System.out.println("原数据是:") ;
System.out.println("a:"+a+",b:"+b) ;
System.out.println("--------------++或者--在数据的前面或者后面------------------") ;
//++a ;
//--b ;
a++;
b-- ;
System.out.println("a:"+a+",b:"+b) ;
System.out.println("------------------------------------------------" ) ;
//定义两个变量
int x = 3 ;
int y = 6 ;
System.out.println("x:"+x) ;
System.out.println("y:"+y) ;
//++或者--,参与运算,在数据的前面
//int m = ++x ;
//int n = --y ;
//++或者--,参与运算,在数据的后面
int m = x ++ ;
int n = y -- ;
System.out.println("x:"+x) ;
System.out.println("y:"+y) ;
System.out.println("m:"+m) ;
System.out.println("n:"+n) ;5.赋值运算符的面试题
6.逻辑运算符(扩展逻辑运算符的面试题)
}
}
/*面试题:
short s = 1 ;
1)s = s + 1 ;
2)s +=1;
这个1),2)两段代码,哪一个会编译失败,哪一个成功,为什么?
1)这个代码会编译报错,因为存在Java隐式类型转换
byte,shor char 三者不转换,一旦参与运算,优先提升为int,所以
s = s + 1 ;s先提升int和1相加,结果是int类型,而s类型short,无法接收int类型结果
2)s +=1 ; 会成功,
因为扩展赋值运算符+=,-=,*=,/=,%=,有一个特点:隐藏了强转类型转换
s +=1 此时等价于s = (short)(s+1) ;
*/
面试题:
逻辑双与&&和逻辑单与&有什么区别?
共同点:
无论是逻辑单与&还是逻辑双与&&都是表达并列关系,
而且都是有fasle则false!
不同点:
逻辑单与&,对多个并列条件在执行的时候,效率比较低,因为都
需要将这个符号左边的表达式和右边的表达式都需要执行一遍!
逻辑双与&& ,
连接的表达式如果左边为false,则右边不执行(具有短路效果)
开发中扩展的逻辑运算符,代替基本的运算符,执行效率高!
/*

扩展的逻辑运算符

逻辑双与&& 和逻辑双或||
逻辑双与&&:
连接的表达式如果左边为false,则右边不执行(具有短路效果)
逻辑双或||:
连接的表达式如果左边为true,则右边不执行(具有短路效果)
*/
class OperatorDemo2{
public static void main(String[] args){
//定义三个变量
int a = 3 ;
int b = 4 ;
int c = 5 ;
//逻辑双与&& 满足基本特点:有false,则false
System.out.println((a>b) && (a>c)) ;//false && false = false ;
System.out.println((a>b) && (a<c)) ;//false && true = false ;
System.out.println((a<b) && (a>c)) ;//true && false = false ;
System.out.println((a<b) && (a<c)) ;//true && true = true ;
System.out.println("-----------------------------------------------------") ;
//定义两个变量
int x = 3 ;
int y = 4 ;
System.out.println("x:"+x) ;
System.out.println("y:"+y) ;
System.out.println("-----------------------------------------------------") ;
//逻辑单与&
//System.out.println(((++x)==3) & ((--y)==4)) ;//false
//System.out.println("x:"+x) ;//4
//System.out.println("y:"+y) ;//3
//逻辑双与&&
System.out.println(((++x)==3) && ((--y)==4)) ;//false
System.out.println("x:"+x) ;
System.out.println("y:"+y) ;
}
}
/*

三元运算符(三目运算符)

格式:(表达式)?执行true的结果:执行false的结果;
执行流程:
表达式可以简单可以复杂,如果结果是true成立,则执行成立的结果
否则不成立,则执行false的结果
需求:
定义变量,求两个变量最大值(没有提示,都是int类型)
三个数据比较最大值?
*/
class OperatorDemo{
public static void main(String[] args){
//定义两个
int a = 10 ;
int b = 5 ;
//套用格式
//(表达式)?执行true的结果:执行false的结果;
//定义变量max
int max = (a>b)?a:b ;
System.out.println("两个数据中的最大值是:"+max) ;
System.out.println("---------------------------------------") ;
//定义三个变量
int x = 20 ;
int y = 50 ;
int z = 30 ;
//方式1:使用中间变量的方式 (推荐)
//使用中间变量的方式记录一下x和y的最大值
int temp = (x>y)? x:y;
//使用中间变量的结果和z进行比较
int max2 = (temp > z)? temp : z ;
System.out.println("三个数据中的最大值是:"+max2) ;
System.out.println("---------------------------------------") ;
//方式2:不建议(使用括号标记,格式好看,否则没有括号,不好看)三元运算符的嵌套
int max3 = (x>y)?((x>z)?x:z):((y>z)?y:z) ;
//int max3 = x>y?x>z?x:z:y>z?y:z ; //不带括号,阅读性很差
System.out.println("三个数据中的最大值是:"+max3) ;
}
}

10-28  位运算符  键盘录入if循环

1.位异或特点
让我们书写程序的时候,更加灵活----通过键盘录入数据
Scanner类就提供了很多功能(方法)--->快速键盘录入一些int类型,来进行运算或者写具体的逻辑!
顺序结构语句
选择结构语句
if语句(三种格式if/if...else/if ...else if...else)
switch语句(考点)
循环结构语句
for循环:开发中常用的
while循环:
do-while循环: java源码里面使用多一些 (工程上使用的比较少)
一个数据被另一个数据位异或两次,其值是它本身
/*
编程题:将两个变量的数据进行交换(运算符的时候讲一下,先写)
int a = 10 ;
int b = 20 ;
最终a是20,b是10
*/
class OperatorTest{
public static void main(String[] args){
//方式1:中间变量
int a = 10 ;2.键盘录入数据的操作步骤
int b = 20 ;
System.out.println("a:"+a) ;
System.out.println("b:"+b) ;
System.out.println("-------------------------------------");
//定义中间变量 (开发中,使用中间变量的方式)
/*
int temp = a ;
a = b ;
b = temp ;
*/
//方式2:位异或的特点:一个数据被另一个数据位异或两次,其值是它本身
//左边:a,b,a
//右边:a^b
a = a ^ b ; //在a变量进行 赋值为 a^b
b = a ^ b ; // a ^ b ^b ;
a = a ^ b ; //a ^ b ^a ;
System.out.println("a:"+a) ;
System.out.println("b:"+b) ;
}
}
/*
为了进行数据逻辑判断操作的时候,程序更灵活一些
Jdk提供了类供我们使用----->文本扫描器 java.util.Scanner类
在Java中,只要我们用的其他类,只要不是java.lang.xxx类都需要导包
java.lang.String
java.lang.Integer
java.lang.Math
.....
使用步骤:
1)导包 :位置是在class的上面
import java.util.Scanner ; //用谁导谁
2)创建文本扫描器 ----java中的关键字 new 创建对象(具体在面向对象中讲)
Scanenr 变量名(称为"键盘录入对象名") = new Scanner(System.in) ; 固定格式 变量名 ,自己起名字
3)友情提示 "请输入一个数据:"
4)通过文本扫描器录入数据 (整数默认int)
使用2)的变量名3.顺序结构语句
int 结果变量名= 变量名.nextInt() ; //.nextInt() :调用文本扫描器的提供功能,录入int类型
5)使用这个结果变量名来进行操作
昨天的题:
键盘录入两个数据,比较是否相等
键盘录入三个数据,比较三个数据最大值
*/
//1)导包
import java.util.Scanner ;
class ScannerDemo{
public static void main(String[] args){
//2)创建文本扫描器(创建Scanner类对象) 固定写法,变量名自己起
Scanner sc = new Scanner(System.in) ;
//3)友情提示
System.out.println("请您输入一个数据(int):") ;
//4)录入int类型数据
int result = sc.nextInt() ; //.nextInt() :调用文本扫描器的提供功能 (固定写法)
//5)输出或者使用
//使用这个结果变量完成其他逻辑操作
System.out.println("录入的数据是:"+result);
}
}
/*
流程控制语句
顺序结构语句 :比较简单,所有程序都是通过jvm调用main进行的(入口)
代码右上而下依次加载,除非在加载后面代码之前,jvm退出了!
选择结构语句
if
switch
循环结构语句
for4.if语句格式2
while
dowhile
*/
class OrderDemo{
public static void main(String[] args){
//代码由上而下依次加载
System.out.println("程序开始了...") ;
System.out.println("helloworld") ;
System.out.println("程序结束了....") ;
//jdk提供了System类有一个功能,exit(0),参数为0,正常终止jvm
System.exit(0) ;//固定格式先记住:可以终止jvm
System.out.println("over") ;
}
}
/*
if格式2:
if(表达式){
语句1;
}else{
语句2;
}
场景:针对两种情况进行判断 (开发中使用最多的格式)
完成"登录"/"注册"
执行流程:
表达式成立,则执行语句1;
否则,执行语句2;
注意事项:
无论if格式哪一种,不能再if后面来一个;
记住:有{大括号的地方,不能有分号,有分号地方不能有左{
使用格式2:完成简单模拟"登录"
String:Java中的类,代表字符串 (后面常用类里面说)5.if语句格式2的应用
字符串进行比较: String类的 字符串值1.equals(字符串值2) ,是比较字符串内容是否相同
*/
class IfDemo2{
public static void main(String[] args){
//定义变量
int x = 10 ;
//if(x>=10); //没有意义
//{} 称为"代码块"
//{
//System.out.println("x大于等于10") ;
//}
if(x>=10){
System.out.println("x大于等于10") ;
}else{
System.out.println("x小于10") ;
}
}
}
/*
使用格式2:完成简单模拟"登录"
提示:
String:Java中的类,代表字符串 (后面常用类里面说)
字符串进行比较: String类的 字符串值1.equals(字符串值2) ,
是比较字符串内容是否相同
已知:
String username = "admin" ; 用户名
String password = "123456" ; 密码
键盘录入用户名和密码和已知的用户名和密码都已知,才能提示"登录成功",
否则"用户名或者密码错误"
*/
//导包
import java.util.Scanner;
class IfTest{
public static void main(String[] args){
//已知6.if语句格式3
//用户名
String username = "admin" ;
//密码
String password = "123456" ;
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入用户名:") ; //用户名录入的字符串
// 键盘录入对象名.nextLine() 固定写法
String inputUserName = sc.nextLine() ;
System.out.println("请您输入密码:") ; //用户名录入的字符串
// 键盘录入对象名.nextLine() 固定写法
String inputPwd = sc.nextLine() ;
//if格式2 使用它完成逻辑判断
/*
字符串进行比较: String类的 字符串值1.equals(字符串值2) ,
是比较字符串内容是否相同
*/
//录入的用户名和已知的存在的用户名对比,如果一致,并且录入的密码和已知的密码一致,登录成功
if(inputUserName.equals(username) && inputPwd.equals(password)){
System.out.println("恭喜您,登录成功") ;
}else{
System.out.println("对不起,用户名或者密码输入错误!") ;
}
}
}
/*
if语句格式3
格式3:
if(表达式1){
语句1;
}else if(表达式2){
语句2;
...
...
...
}else{
语句n;
}
场景:针对多情况进行判断执行流程:
首先,判断表达式1是否成立,成立,则执行语句1;
否则,不成立,继续判断表达式2是否成立,成立,执行语句2;
否则,不错成立...依次判断
....
....
如果上面都没有匹配的结果, 执行else中的语句n;
没有提示数据类型,都是int
需求
键盘录入学生成绩(满分100分),判断该学生成绩的等级的划分
90-100 "优秀"
80-90 "较优"
70-80 "良好"
60-70 "及格"
60以下 "不及格"
*/
//导包
import java.util.Scanner;
class IfDemo3{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入的学生的成绩: ") ;
int socre = sc.nextInt() ;
/*
if(表达式1){
语句1;
}else if(表达式2){
语句2;
...
...
...
}else{
语句n;
}
*/
/*
if(socre>=90 && socre<=100){
System.out.println("优秀") ;
}else if(socre>=80 && socre<90){
System.out.println("较优") ;
}else if(socre>=70 && socre<80){
System.out.println("良好") ;}else if(socre>=60 && socre<70){
System.out.println("及格") ;
}else{
System.out.println("不及格") ;
}
*/
//测试程序:
//测试正确数据:正常范围内的数据
//测试边界数据:边界数据的是否在我们指定范围内
//测试错误数据:超了范围,不满足,应该也要包含进去
if(socre<0 || socre>100){
System.out.println("您输入的数据有误!") ;
}else if(socre>=90 && socre<=100){
System.out.println("优秀") ;
}else if(socre>=80 && socre<90){
System.out.println("较优") ;
}else if(socre>=70 && socre<80){
System.out.println("良好") ;
}else if(socre>=60 && socre<70){
System.out.println("及格") ;
}else{
System.out.println("不及格") ;
}
}
}