第一周-Java基础

2022-2-21

非开发工具下运行java文件

第一步：新建Hello.txt文件，并编辑内容

public class Hello{ //public：修饰符，修饰类、方法；class：类声明（类名与文件名称保持一致）；Hello：定义类名（常以大写字母开头）
	public static void main(String[] args){
		System.out.print("Hello World!");
	}
}

第二步：文件扩展名更改.java

第三步：打开cmd切换盘符f:，若并不在根目录下cd所在文件夹

第四步：javac Hello.java编译

在文件夹路径下会有一个新文件（.class）生成->字节码文件

第五步：java Hello运行文件

2022-2-22

编写一个HelloWorld程序

打开Eclipse界面分为三个板块，左侧目录浏览区，中间代码编写区，下面控制台（主要）区

第一步：点击左侧区域Create a project，选择Java Project，点击Next

输入工程名称hello，可小写

第二步：点击next，点击No

显示结果：

注释：

• src：存放java程序源文件
• jre：类库

第三步：创建包

包两个功能：管理、访问限制
命名格式：一个层级，多个层级加.


显示结果：

第四步：创建类

注释：一组共同特征的对象抽象出来就是类，名称大写

注释：

• 修饰符默认public
• 可以默认选择输出主方法，在下图位置✔即可

点击Finish，显示结果：

第五步：输出命令输入sys，使用Alt+/快捷键

并在小括号内输入"Hello World"，显示结果：

第六步：点击最上层三角符号，即运行符号

显示需要保存文件，默认选择Select All，点击OK

显示结果：

代码：

package com; //包
/**
 * Hello类
 * @author Katrina
 */
public class Hello { //class类的修饰符

	/*
	 * Java语法规则：
	 * 代码区分大小写
	 * .java为扩展名
	 * 注释：// /* */ /** */
	public static void main(String[] args) {
		//System系统类，输出语句固定写法
		System.out.print("Hello World"); 
	}

}

新建Demo1类

练习：数值型中整型数据变量的声明和赋值

package com;
//包关键字 名称
/**
 * Demo1类
 * 练习：数值型中整型数据变量的声明和赋值
 * @author Katrina
 */
public class Demo1 { //大括号对应

	//固定写法
	public static void main(String[] args) {
		/*
		 * 八进制特征：0开头，数字不能出现9或以上
		 * 十六进制特征：0x或0X开头
		 */
		//声明一个byte类型的length变量数值为5
		//数据类型 命名 赋值 值
		byte length = 5;
		byte i = 127;
//		byte i = 128; //错误，表示范围-128~127，可变更数据类型进行修改也可直接注释掉
		int num = 0x10;
		int num1 = 010;
		int num3 = 9;
		byte byteNum = 12;
		long l = 100L;
		long l1 = 999999;
//		long l2 = 9999999999; //错误，默认int类型，需要加后缀（超出int32位的范围）
		long l2 = 9999999999l; 
		long l3 = 999999999; //int可以表示9个9的数据
		
		/*
		 * 强制类型转换练习
		 * 从大到小，强制转换
		 * 从小到大，隐式转换
		 */
		byte num4 = 10;
		int b = num4; //自动，隐式数据类型转换
//		byte a = b; //错误，精度丢失
		byte a = (byte) b; //强制数据类型转换
	}

}

新建Demo2类

练习：数值型中浮点型数据变量的声明和赋值

package com;
/**
 * Demo2类
 * 练习：数值型中浮点型数据变量的声明和赋值
 * @author Katrina
 */
public class Demo2 {

	public static void main(String[] args) {
		float f = 1.0f; //不加f，默认double类型
//		float ff = 1.0; //报错，Type mismatch: cannot convert from double to float
		double d = 1.10D;
		double d1 = 1.0;
		double num = 2e3f;
		double num1 = 3.6d;
		float num2 = .4f;
		float num3 = 0f;
		double num4 = 3.84d;
		double num5 = 5.022e+23f;
	}

}

2022-2-23

调整字体大小

Ctrl + “+” 或者 如下：
选择最上方windows选择Preferences，依次选择如图显示，最后点击Edit

选择合适的文字大小

CharDemo类

package day0223;
/**
 * CharDemo类
 * 练习：字符类型（char）声明和赋值
 * @author Katrina
 */
public class CharDemo {

	public static void main(String[] args) {
		char a = 'A'; //英文字符
		char b = '中'; //中文字符
		char c = '\u0008'; //Unicode字符
		
		int d1 = 'A';
		System.out.println(d1); //65
		int d2 = 'a';
		System.out.println(d2); //97
		
		char num = 5;
		int xx = num;
		System.out.println(xx); //5
		
		char num1 = '1';
		int xx1 = num1;
		System.out.println(xx1); //49，1的Unicode码值
	}

}

BooleanDemo类

package day0223;
/**
 * BooleanDemo类
 * 练习：布尔类型（boolean）声明和赋值
 * @author Katrina
 */
public class BooleanDemo {

	public static void main(String[] args) {
		//数据类型 变量名 = 值（符合这个数据类型的值）
		boolean isStudent = false;
		boolean isDog = true;
	}
	
}

ArithmeticOperatorDemo类

package day0223;
/**
 * ArithmeticOperatorDemo类
 * 练习：算术运算符
 * @author Katrina
 */
public class ArithmeticOperatorDemo {

	public static void main(String[] args) {
		/*自增、自减*/
		int a = 2;
		int b = ++a;
		System.out.println(a + b); //6，加法运算符+，计算结果进行输出
		System.out.println(a + " " + b); //3 3，先进行a++，再赋值，a赋值给b；连接符+，a的结果链接一个空格，再链接b的结果
		
		int a1 = 2;
		int b1 = a1++; 
		System.out.println(a1 + " " + b1); //3 2，先进行赋值，a1赋值给b1，在进行a1++
		
		int a3 = 2;
		int b3 = --a3;
		System.out.println(a3 + " " + b3); //1 1
		
		int a4 = 2;
		int b4 = a3++;
		System.out.println(a4 + " " + b4); //2 1
		
		/*除*/
		int c = 5;
		System.out.println(c/2); //2
		//c%2 = c - (c/2)*2 √
		System.out.println(c%2); //1，5/2余1
		
		/*运算结果的类型*/
		int a5 = 10;
		long b5 = 5;
		//两个不同整数类型的操作时进行数值运算，结果会转换成大的范围的数据类型
		int d1 = (int) (a5 + b5); 
		int d2 = (int) b5 + a1;
		
		float e = 1.0f;
		double f = 1.0;
		//两个不同浮点类型的操作时进行数值运算，结果会转换成大的范围的数据类型
		float g = (float) (e + f);
		float g1 = (float) f + e;
		
		//两个不同整型和浮点型类型的操作时进行数值运算，结果会转换成浮点型的数据类型
		int j = (int) (a5 + e);
		int j1 = (int) e + a5;
		float j2 = a5 + e;
		
		//进行算术运算时，byte、short、char的运算结果自动提升为int类型
		byte m = 5;
		short k = 6;
//		short num = j + k; //short更改为int，或者强制转换short
	}
	
}

AssignmentOperatorsDemo类

package day0223;
/**
 * AssignmentOperatorsDemo类
 * 练习：赋值运算符
 * @author Katrina
 */
public class AssignmentOperatorsDemo {

	public static void main(String[] args) {
		int a = 1;
		int b = 2;
		//b += a 等价于b = b + a
//		b += a;
		b = b + a;
		System.out.println(a + "," + b); //1,3
	}
	
}

RelationalOperatorDemo类

package day0223;
/**
 * RelationalOperatorDemo类
 * 练习：关系运算符
 * @author Katrina
 */
public class RelationalOperatorDemo {

	public static void main(String[] args) {
		int a = 1;
		int b = 1;
		boolean result = a == b; //先机型
		System.out.println(result); //true
		//输出语句里面可以写表达式（输出表达式a!=b的结果）
		System.out.println(a != b); //false
		
		//任意字符串都是String类的对象，可以用instanceof进行比较
		String str = "Hello";
		System.out.println(str instanceof String); //true，前面的对象是不是后面类
	}
	
}

LogicalOperatorDemo类

package day0223;
/**
 * LogicalOperatorDemo类
 * 练习：逻辑运算符
 * @author Katrina
 */
public class LogicalOperatorDemo {

	public static void main(String[] args) {
//		int a = 1;
//		int b = 2;
//		boolean result = a > b;
//		boolean result1 = a < b;
//		boolean result2 = a + 2 > b;
//		System.out.println(result); //false
//		System.out.println(result1); //true
//		System.out.println(result2); //true
		
//		System.out.println();
		
		/*&&、||：会造成短路*/
		//&&前后表达式都为true，结果为true，否则结果为false
		//||前后表达式任意一个为ture，结果为true，否则结果为false
//		System.out.println(result && result1); //false
//		System.out.println(result2 && result1); //ture
//		System.out.println(result || result1); //true
//		System.out.println(result2 || result1); //true
		
//		System.out.println(!result); //true
//		System.err.println(!result1); //false
//		System.err.println(!result2); //false
		
		int i = 10;
//		boolean result = i++ > 0 || i-- > 0; //改为&&，i的值为10
//		System.out.println(i); //11
//		System.out.println(result); //true
		
		boolean re = i > 10 && i++ > 10;
		System.out.println(i); //10
		boolean re1 = i > 10 || i++ > 10;
		System.out.println(i); //11
		System.out.println(re1); //false
		
		System.out.println((1 > 2) && (2 > 3)); //false
		System.out.println((1 < 2) || (2 < 3)); //true
	}

}

TernaryOperatorDemo类

package day0223;
/**
 * TernaryOperatorDemo类
 * 练习：三元运算符
 * @author Katrina
 */
public class TernaryOperatorDemo {

	public static void main(String[] args) {
		//三元运算符：条件 ？ 表达式1 ：表达式2
		//条件为true，运行表达式1；条件为false，运行表达式2
		int score = 81;
		char result = score > 80 ? 'A' : 'B'; 
		System.out.println(result); //A
		
		int score1 = 76;
		char result1 = score1 > 60 ? 'B' : 'C';
		System.out.println(result1); //B
	}
	
}

ExerciseDemo1类

package day0223;
/**
 * 练习：各种类型相互转换、定义常量
 * @author Katrina
 */
public class ExerciseDemo1 {

	//属性
	public static final int COLOR_BLACK = 2; //类中定义的常量
	
	//行为
	public static void main(String[] args) {
//		int x = 34.5; //34.5浮点型，int整型
//		int x1 = 34;
//		boolean boo = x1; //boolean不能与其他基本类型进行转换
		int g = 17;
		int y = g;
		y = y + 10;
		short s;
//		s = y; //报错，从大到小，需要强制转换
		byte b = 3;
		byte v = b;
		short n = 12;
//		v = n; //报错，从大到小，需要强制转换
//		byte k = 128; //报错，byte取值范围最大127
		int p = 3*g + y; //51+27=78
		System.out.println(p); //78
		
		byte a;
		int b1 = 4660;
		a = (byte) b1;
		System.out.println(a); //52
		short c = (short) b1;
		System.out.println(c); //4660
		
		boolean isOK = false;
		System.err.println(isOK); //没有初始化为空，需要进行初始化默认为false
		//方法定义变量不需要写修饰符（例如：public），在类里面定义常量写修饰符
		final int COLOR_RED = 1; //方法里面的常量
	}
	
}

ExerciseDemo2类

package day0223;
/**
 * ExerciseDemo2类
 * 练习：运算结果类型的转换及其转换顺序
 * @author Katrina
 */
public class ExerciseDemo2 {

	public static void main(String[] args) {
		byte b = 50;
		char c = 'a';
		short s = 1024;
		int i = 50000;
		float f = 5.67f;
		double d = .1234; //0.1234
		double result = (f * b) + (i / c) - (d * s);
		System.out.println((i / c)); //515
		System.out.println((f * b) + " + " + (i / c) + " - " + (d * s)); //283.5 + 515 - 126.3616
		System.out.println("result = " + result); //result = 672.1384
	}
	
}

作业

数据类型和运算符作业

一、 填空题

1. Java语言规定标识符由字母、下划线、美元符号和数字组成，并且第一个字符不能是 数字 。
2. Java中整型变量有byte、short、int和long四种，不同类型的整数变量在内存中分配的字节数不同，数值范围也不同。对于int型变量，内存分配 4 个字节。
3. 在Java中浮点型变量有float和double两种，对于float型变量，内存分配4个字节，尾数可精确到7位有效数字，对于double型变量，内存分配 8 个字节。
4. char c=’a’;System.out.println(c+1);运行结果为: 98 。
5. _&&_是短路与运算符，如果左侧表达式的计算结果是false，右侧表达式将不再进行计算。
6. 下面的语句是声明一个变量并赋值：boolean b1=5!=8； b1的值是_true_。
7. 使用位运算符来实现运算效率最高，所以最有效率的方法算出2乘以8等于多少的语句是 。
8. 基本数据类型的类型转换中，要将double类型的常量3.14159赋给为整数类型变量n的语句是_(int) 3.14159_。
9. 八进制整数012表示十进制的_10_，十六进制数0x3C表示十进制的_60_。
10. 一个十进制整数转换成八进制数后是1234，则它转为十六进制数后是 29C 。

二、 选择题

1. 在Java中，以下错误的变量名是（D）。（选择一项）

   A Constant
   B. Flag
   C. a_b
   D. Final

2. 以下选项中属于合法的Java标识符的是（CD）。（选择两项）

   A. public
   B. 3num
   C. name
   D. _age

3. 在Java中，byte数据类型的取值范围是（A）。（选择一项）

   A -128 ~ 127
   B. -228 ~128
   C. -255 ~ 256
   D. -255 ~ 255

4. 下面的代码段中，执行之后i和j的值是（C）。（选择一项）
   int i=1; int j;
   j=i++;

   A 1，1
   B. 1，2
   C. 2，1
   D. 2，2

5. 下面Java代码的执行结果是（A）。（选择一项）
   public class Test {
   public static void main(String args[]) {
   System.out.println(100 % 3);
   System.out.println(100%3.0);
   }
   }

   A 1 1.0
   B. 1 1
   C. 1.0 1.0
   D. 33 33.3

6. 下面的赋值语句中错误的是（A）。（选择一项）

   A float f = 11.1;
   B. double d = 5.3E12;
   C. double d = 3.14159;
   D. double d = 3.14D;

7. 在Java中，下面（AC）语句能正确通过编译。（选择两项）

   A System.out.println(1+1);
   B. char i =2+‘2’;
   System.out.println(i);
   C. String s=“on”+‘one’;
   D. int b=255.0;

8. 以下Java运算符中优先级别最低的两个选项是（AB）。（选择二项）

   A 赋值运算符=
   B. 条件运算符 ?=
   C. 逻辑运算符|
   D. 算术运算符+

9. 有以下方法的定义，请选择该方法的返回类型（D）。（选择一项）
   method(byte x, double y) {
   return (short)x/y*2;
   }

   A byte
   B. short
   C. int
   D. double

10. 关于以下Java程序中错误行的说明正确的是（B）。（选择一项）
    public class Test2 {
    public static void main(String[] args) {
    short s1=1; //1
    s1=s1+1; //2
    s1+=1; //3
    System.out.println(s1);
    }
    }

    A 1行错误
    B. 2行错误
    C. 3行错误
    D. 1行，2行，3行都错误

三、 判断题
11. Java中变量名不区分大小写，number和NuMbEr代表同一个变量。（×）
12. 在编译Java源程序时，计算机根本不会去识别各个变量名的具体含义，因此命名规范对编写Java程序而言不是必要的，而且有可能会降低编写Java源程序的效率。（×）
13. Java语言中不同数据类型的长度是固定的，不随机器硬件不同而改变。（×）
14. char类型变量可以存储一个Unicode字符，在内存中占2个字节，该字符可以是一个汉字。（√）
15. 运算符||和&&既是逻辑运算符，也是位运算符。根据两侧操作数的类型判断是逻辑运算符还是位运算符。（×）
16. ^ 是异或位运算符，运算规则是如果两个操作数相同，结果是0，否则结果是1。(√)
17. 赋值运算符优先级别低于条件运算符，条件运算符优先级别低于算术运算符。(√)
18. 赋值和条件运算符是运算级别最低的两种运算符，都具有自右向左的结合性。（×）
19. 整型常量的默认类型是int类型，浮点常量的默认类型是float类型。（×）
20. 00101010 & 00010111语句的执行结果为00111111（√）

四、 简答题
21. Java是一种强类型语言，说明Java的数据类型分类。
数值型 整数型 byte short int long 浮点型 float double
字符型 char
布尔型 boolean
22. i++和++i的异同之处
i++：先进行运算后++
++i：先++后进行运算
23. 运算符||和|的异同之处
||包含短路的情况，|不包含短路的情况
24. Java中基本数据类型转换的规则
byte型可以转换short、int、long、float、double
short型可以转换int、long、float、double
char可以转换int、long、float、double
int可以转换long、float、double
long可以转换float、double
float可以转换double

五、 编码题
25. 输入自己的名字，年龄和性别，分别用不同的变量接收，并将输入的信息做输出。

public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.print("Please input your name here:");
		String name = sc.next();
		System.out.print("Please input your age here:");
		int age = sc.nextInt();
		System.out.print("Please input your gender here:");
		String gender = sc.next();
		System.out.println("The computer recorded that:");
		System.out.println("Your name is:" + name);
		System.out.println("Your age is:" + age);
		System.out.println("Your gender is:" + gender);
	}

26. 输入圆形半径，求圆形的周长和圆形的面积,并将结果输出。
    

public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入圆的半径：");
		double r = sc.nextDouble();
		System.out.println("该圆的半径为：R = " + r);
		System.out.println("该圆的周长为：C = " + 2 * 3.14 * r);
		System.out.println("该圆的面积为：S = " + 2 * 3.14 * r * r);
	}

27. 银行利率表如下表所示，请计算存款10000元，活期1年、活期2年，定期1年，定期2年后的本息合计。
    结果如下图所示。（结果四舍五入，不保留小数位。使用Math.round(double d)实现）
    

public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.print("本金：");
		int num = sc.nextInt();
		int sum1 = (int) Math.round(num * (1+0.0035));
		System.out.println("活期1年本金总计：" + sum1);
		int sum2 = (int) Math.round(num * (1+0.015));
		System.out.println("定期1年本金总计：" + sum2);
		int sum3 = (int) Math.round(num * (1+0.0035) * (1+0.0035));
		System.out.println("活期2年本金总计：" + sum3);
		int sum4 = (int) Math.round(num * 0.021 * 2 + 10000);
		System.out.println("定期2年本金总计：" + sum4);
	}

28. 某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。结果如图所示。
    

public static void main(String[] args) {
			Scanner sc = new Scanner(System.in);	
			System.out.print("请输入一个4位正整数：");
			int num = 0;
			num = sc.nextInt();
			int num1 = (num/1000+5)%10;
			int num2 = (num/100%10+5)%10;
			int num3 = (num%100/10+5)%10;
			int num4 = (num%10+5)%10;
			System.out.printf("加密后和数字为：%d%d%d%d",num4,num3,num2,num1);

	}

六、 可选题

29. 网上查询资料，了解如下内容

1. ASCII、ISO8859-1、GB2312、GBK、GB18030、BIG5、UNICODE、ANSI等字符集的特点
2. 常用进制（二进制、八进制、十六进制、十进制）的特点及其转换
3. 源码、反码、补码含义、作用及其转换

30. 利用”异或”运算的性质,对几个字符进行加密并输出密文,然后再解密。加密算法是：密钥是字符’8’，明文的每个字符和密钥进行异或运算，得到密文。密钥和密文的每个字符再次进行异或运算，重新得到明文。结果如图所示。
    

public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.print("输入密文：");
		String a = sc.next();
		char[] a1 = new char[4];
		a1 = a.toCharArray();
		char secret='8';
		System.out.print("输出密文：");
		for (int i = 0; i < a.length(); i++) {
			a1[i] = (char) (a1[i]^secret);
			System.out.print(a1[i]);
		}
	}

2022-2-24

debug调试

第一步：双击左侧，断点

第二步：选择小虫子按钮debug，使用快捷键F6进行调试，依次执行，不满足条件的跳过

SequentialStructure类

package day0324;
/**
 * SequentialStructure类
 * 练习：顺序结构
 * @author Katrina
 */
public class SequentialStructureDemo {

	public static void main(String[] args) {
		/*顺序执行*/
		int a = 5;
		System.out.println(a); //2
		a++;
		System.out.println(a); //6
		a = a - 2;
		System.out.println(a); //4
	}
	
}

SelectStructureDemo类

package day0324;
/**
 * SelectStructure类
 * 练习：选择结构
 * @author Katrina
 */
public class SelectStructureDemo {

	public static void main(String[] args) {
		/*成绩*/
//		int score = 65;
//		//语法：if（条件表达式）{条件为true时需要执行的语句}
//		if (score > 80) {
//			System.out.println("成绩为优秀");
//		}
//		if (score < 60) {
//			System.out.println("成绩为不及格");
//		}
//		//if流程需要执行的语句仅有一句的时候，{}省略，直接书写条件为真时执行的语句
//		if (score >= 60 && score <= 80) System.out.println("成绩为良好");
//		if (score > 80) {
//			System.out.println("优秀");
//		} else {
//			System.out.println("达不到优秀");
//		}
		/*案例：3种判断4种结果
		 * 语法：if（条件1）{条件1为true时执行的语句}
		 * 		else if（条件2）{条件1不成立执行的语句，条件2成立执行的语句}
		 * 		else if（条件3）{条件1，2都不成立时执行的语句，条件3成立执行的语句}
		 * 		else {上述条件都不成立时执行的语句}
		 * 某一条件为true执行对应的语句后，后面的判断（包含最后的else部分）不再执行
		 */
//		if (score >= 80) {
//			System.out.println("优秀");
//		} else if(score >= 70) {
//			System.out.println("良好");
//		} else if(score >= 60) {
//			System.out.println("及格");
//		} else {
//			System.out.println("不及格");
//		}
		/*不及格到优秀*/
//		if (score < 60) {
//			System.out.println("不及格");
//		} else if(score < 70) {
//			System.out.println("及格");
//		} else if(score < 80) {
//			System.out.println("良好");
//		} else {
//			System.out.println("优秀");
//		}
		
		/*评价*/
//		char re = 'A';
//		//语法：if（条件表达式）{条件为true时需要执行的语句} else {条件为false时需要执行的语句}
//		if (re == 'A') { //条件为true时执行的部分 
//			System.out.println("评价为A");
//		} else { //条件为false时执行的部分
//			System.out.println("评价不为A");
//		}
//		
//		/*学生老师*/
//		String person = "学生";
//		if (person == "学生") {
//			System.out.println("学生");
//		} else {
//			System.out.println("老师");
//		}

		/*switch结构*/
		/**
		 * switch（表达式）{
		 * 		case 值:
		 * 			语句（组）
		 * 			break;
		 * 		case 值:
		 * 			语句（组）
		 * 			break;
		 * 		···
		 * 		···
		 * 		default:
		 * 			语句（组）
		 * 			break
		 * }
		 * break 匹配到以后跳出之后的选择部分不再执行
		 */
//		int month = 1;
//		switch (month) {
//			//Ctrl + Alt + ↓ 整块代码复制
//			case 1:
//				System.out.println("1月的天数是31");
//				break;
//			case 2:
//				System.out.println("2月的天数是28");
//				break;
//			case 3:
//				System.out.println("3月的天数是31");
//				break;
//			case 4:
//				System.out.println("4月的天数是30");
//				break;
//			case 5:
//				System.out.println("5月的天数是31");
//				break;
//			case 6:
//				System.out.println("6月的天数是30");
//				break;
//			case 7:
//				System.out.println("7月的天数是31");
//				break;
//			case 8:
//				System.out.println("8月的天数是31");
//				break;
//			case 9:
//				System.out.println("9月的天数是30");
//				break;
//			case 10:
//				System.out.println("10月的天数是31");
//				break;
//			case 11:
//				System.out.println("11月的天数是30");
//				break;
//			case 12:
//				System.out.println("12月的天数是31");
//				break;
//			default:
//				System.out.println("月份不对");
//				break;
//		}
		
		/**
		 * 不加break，即使匹配到以后还是会继续进行下一个选择判断，
		 * 如果匹配，继续执行
		 */
//		int x = 1;
//		switch (++x) {
//			case 1:
//				System.out.println(x); 
//			case 2:
//				++x;
//				System.out.println(x); //3
//			case 3:
//				++x;
//				System.out.println(x); //4
//			case 4:
//				++x;
//				System.out.println(x); //5
//			case 5:
//				++x;
//				System.out.println(x); //6
//			default:
//				++x;
//				System.out.println(x); //7
//		}
//		int count = 4;
//		switch (count) {
//			case 1:
//				System.out.println("点数为1");
//				break;
//			case 2:
//				System.out.println("点数为2");
//				break;
//			case 3:
//				System.out.println("点数为3");
//				break;
//			case 4:
//				System.out.println("点数为4");
//				break;
//			case 5:
//				System.out.println("点数为5");
//				break;
//			default:
//				System.out.println("点数为6");
//				break;
//		}
		
		/*匹配成绩*/
//		char r = 'C';
//		if (r == 'A') {
//			System.out.println("优秀");
//		} else if (r == 'B') {
//			System.out.println("良好");
//		} else if (r == 'C') {
//			System.out.println("还行");
//		}
		
//		char r = 'C';
//		switch (r) {
//			case 'A':
//				System.out.println("优秀");
//				break;
//			case 'B':
//				System.out.println("良好");
//				break;
//			case 'C':
//				System.out.println("还行");
//				break;
//			default:
//				break;
//		}
		
		int score = 58;
		score/=10;
		switch (score) {
			case 6:
				System.out.println('C');
				break;
			case 7:
				System.out.println('B');
				break;
			case 8:
				System.out.println('A');
				break;
			case 9:
				System.out.println('A');
				break;
			default:
				System.out.println('D');
				break;
		}
	}
	
}