1. 初识Java

1.1 程序和指令

1.1.1 程序

计算机程序:为了完成某件事或执行某些操作而编写的一系列有序指令的集合。

1.1.2 指令

指令: 命令

1.2 字节

1.2.1 字节转换

1. 1 KB = 1024 byte
2. 1 MB = 1024 KB
3. 1 GB =  1024 MB
4. 1 TB  = 1024 GB

1.3 开发程序

1.3.1 使用记事本开发小程序

步骤

1.3.2 使用MyEclipse开发小程序

步骤:

  1. 新建项目
  2. 编写程序
  3. 编译程序
  4. 运行
1
2
3
4
5
public class TestManager {
public static void main(String[] args) {
System.out.println("HelloWorld");
}
}

1.4 JDK

作用:开发java程序的安装包
配置环境变量:为了在任何一个盘符位置下进行开发,需要配置环境变量

方式一:
>1.找到jdk的安装目录:D:\Program Files\Java\jdk1.8.0_141\bin
>2. windows键搜索高级系统设置 –> 高级中的环境变量–>系统变量中找Path–>编辑—>新建–>将jdk路径粘贴到此处。
方式二:
配置JAVA_HOME

  1. windows键搜索高级系统设置 –> 高级中的环境变量–>系统变量–>新建 JAVA_HOME 变量–>变量值填写jdk的安装目录(例如 D:\Program Files\Java\jdk1.8.0_141\bin)
  2. 系统变量→寻找 Path 变量→编辑
    在变量值最后输入 %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
  3. 系统变量→新建 CLASSPATH 变量
    变量值填写 .;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar(注意最前面有一点)

安装位置:一般安装到c盘

检测环境变量配置的代码:

1
2
3
1. java
2. javac
3. java -version 检测安装的版本

1.5 注释和转义符

1.5.1 注释

作用:解释说明某段代码

  1. 单行注释: //

  2. 多行注释: /**/

  3. 文档注释:

​ /**

​ */

1.5.2 转义符

​ 也称为:制表符

1.  \n :  表示换行
 2.  \t  : 表示空格

1.6 Java领域的相关技术

  1. JavaSE:

    ​ Java语言的基础和核心

    ​ 使用场景:适用于开发桌面应用程序

  2. JavaEE:

    ​ Java的企业级开发

    ​ 使用场景:适用于大型互联网电商

1.7 输出内容和快捷键

1.7.1 输出内容

1
2
3
4
public static void main(String[] args) {	
System.out.println("可以自动换行");
System.out.print("不换行");
}

1.7.2 快捷键

  1. 保存:Ctrl + s
  2. 复制:Ctrl+ c
  3. 粘贴: Ctrl +v
  4. 撤回: Ctrl+z
  5. 前进: Ctrl+y
  6. 剪切: Ctrl+x
  7. 全选: Ctrl + a
  8. 向后缩进: Tab
  9. 向前缩进:shift+Tab
  10. 切换屏幕:Tab+Alt
1
2
3
4
5
6
7
8
9
10
MyEclipse中的快捷键:
1. 删除:Ctrl+d
2. 补充内容: Alt + /
例如: 输出 syso
main方法 main
扫描仪: scanner
3. 注释:
单行注释: ctrl + /
多行注释: ctrl + shift + /
解开注释: ctrl + shift + \

2. 变量、运算符和数据类型

2.1 变量

2.1.1 概念

​ 变量:用来存储数据

2.1.2 命名规则

  1. 首字母不能使用数字

  2. 不能使用java中的关键字

  3. 组成:字母、下划线_ 、 数字 、 $

  4. 规范:驼峰命名法

    ​ 首字母小写,后面的每个单词的首字母都大写

    1
    2
    3
    例如: 
    合法:name myClassName user_Id $score_ str1
    不合法:1name name。 YourName int double my age

2.2 数据类型

八大基本数据类型

  1. 整型: byte short int long

  2. 浮点型: float double

  3. 布尔型: boolean

  4. 字符型: char

    1
    2
    3
    4
    5
    6
    1.  long num = 10L;
    2. int score = 90;
    3. float f = 3.5f;注:f必须有
    4. double d = 5.6d;注:d可有可无
    5. boolean flag = true;//当某个操作最终只有两个结果时,最好使用boolean,效率最高。
    6. char ch = '开';

引用数据类型

  1. 字符串:String

    1
    2
    3
    4
    1. 方式一:
    String str = "教育改变生活";
    2. 方式二:
    String str1 = new String("生活");

2.3 运算符和扫描仪

2.3.1 运算符

  1. 算术运算符 : + - * /(取商) %(取余数)

  2. 关系运算符(比较运算符) : > < >= <= == !=

  3. 逻辑运算符 : &&(并且) ||(或者) ! (非 取反)

  4. 赋值运算符 : =

优先级顺序: () ! 算术运算符 关系运算符 && || =

1
2
3
4
5
6
7
8
9
10
11
示例:
需求是获取一个千位数字中每一个位置上的值
int number = 3124;
//获取个位
int geWei = number % 10;
//获取十位
int shiWei = number / 10 % 10;
//获取百位
int baiWei = number / 100 % 10;
//获取千位
int qianWei = number / 1000;

2.3.2 扫描仪

作用:可以在控制台进行键盘输入内容

1
2
import java.util.Scanner;  //导入包
Scanner input = new Scanner(System.in);

2.4 数据类型转换

规则:转换的两种数据类型要兼容

​ 例如: int和double

2.4.1 自动类型转换

​ 源类型、目标类型

​ 要求:目标类型范围大于源类型,简称:小转大

1
2
3
double score = 91;
System.out.println(score);
结果是:91.0

2.4.2 强制类型转换

​ 要求:目标类型范围小于源类型,简称:大转小

1
2
3
4
5
double score = 95.5;
int score1 = (int)score;
System.out.println(score1);
结果是:95
枪支类型转换的问题是会丢失精度

2.5 == 和 = 的区别

== : 表示判断等号两边的数值是否相等。

= : 表示将等号右边的值赋值给左边。

3. 选择结构(一)

3.1 if选择结构

语法:

​ if(条件判断){

​ //条件判断成立后的操作

​ }

1
2
3
4
5
6
7
8
9
10
11
public class Test02 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入数字");
int score = input.nextInt();
//条件判断
if(score>90){
System.out.println("奖励笔记本电脑");
}
}
}

3.1 if-else选择结构

语法:

​ if(条件判断){

​ //条件判断成立后的操作

​ } else{

​ //条件不成立后的操作

​ }

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Test02 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入数字");
int score = input.nextInt();

if(score>90){
System.out.println("奖励笔记本电脑");
}else{
System.out.println("惩罚去种地");
}
}
}

3.3 多重if选择结构

语法:

​ if(条件判断){

​ }else if(){

​ }else{

​ }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Test02 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入分数");
int score = input.nextInt();

if(score>90){
System.out.println("奖励去夏令营");
}else if(score>80){
System.out.println("奖励笔记本电脑");
}else if(score>60){
System.out.println("奖励休息一天");
}else{
System.out.println("惩罚去种地");
}
}
}
注意:else if之间可以任意调换位置,但要注意是否符合逻辑

3.4 嵌套if选择结构

语法:

​ if(条件判断){

​ if(条件判断){

​ }else{

​ }

​ }else{

​ }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Test02 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入分数");
int score = input.nextInt();

if(score<=12){
System.out.println("恭喜你进入决赛");
System.out.println("请输入性别");
String sex = input.next();
if(sex.equals("男")){
System.out.println("进入男子组决赛");
}else if(sex.equals("女")){
System.out.println("进入女子组决赛");
}
}else{
System.out.println("对不起,您被淘汰了");
}
}
}

3.4.1 == 和 equals

== : 用来判断两个数值类型的值是否相等

equals: 判断两个字符串是否相等。

3.5 随机数

  1. 方式一:通过Math.Random得到随机数,范围是0~1

    1
    2
    int i = (int)(Math.random()*10);
    System.out.println(i);
  2. 方式二: 通过创建Random,得到随机数

1
2
3
4
5
//创建Random
Random random = new Random();
//生成一个0~100的随机数,不包含100
int a = random.nextInt(100);
System.out.println(a);

3.6 流程图

  1. 矩形: 计算步骤
  2. 椭圆: 开始和结束
  3. 平行四边形: 输入和输出
  4. 菱形: 判断条件
  5. 圆和箭头: 连接符
  6. 箭头:流程线

4. 选择结构(二)

4.1 switch选择结构

语法:

​ 表达式:可以是整型、字符串、枚举、字符型

​ switch(表达式){

​ case “案例1”:

​ break;

​ case “案例2”:

​ break;

​ default:

​ break;

​ }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Test02 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入");
int week = input.nextInt();
switch(week){
case 1:
System.out.println("第一名");
break;
case 2:
System.out.println("第二名");
break;
case 3:
System.out.println("第三名");
break;
default:
System.out.println("输入错误");
break;
}
}
}
注意:多个case之间也可以调换顺序
break 表示结束这个选择结构,如果不写,则无法结束选择结构,除非执行完最后一条
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
经典案例:商品换购
package cn.jbit.output02;
import java.util.Scanner;
/**
* System.out.println("是否参加优惠换购活动:");
System.out.println("1.满50元,加2元换购百事可乐1瓶");
System.out.println("2.满100元,加3元换购500ml可口可乐1瓶");
System.out.println("3.满100元,加10元换购5公斤面粉");
System.out.println("4.满200元,加10元换购一个苏泊尔炒菜锅");
System.out.println("5.满200元,加20元换购欧莱雅爽肤水1瓶");
System.out.println("0.不换购");
* @author Lenovo
*
*/
public class Test01 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入消费金额");
double money = input.nextDouble();
double extra = 0;
int choose = 0;
//50元是临界点
if(money>50){
System.out.println("是否参加优惠换购活动:");
System.out.println("1.满50元,加2元换购百事可乐1瓶");
System.out.println("2.满100元,加3元换购500ml可口可乐1瓶");
System.out.println("3.满100元,加10元换购5公斤面粉");
System.out.println("4.满200元,加10元换购一个苏泊尔炒菜锅");
System.out.println("5.满200元,加20元换购欧莱雅爽肤水1瓶");
System.out.println("0.不换购");
if(input.hasNextInt()){
choose = input.nextInt();
switch(choose){
case 1:
if(money>=50){
extra = 2;
}
break;
case 2:
if(money>=100){
extra = 3;
}
break;
case 3:
if(money>=100){
extra = 10;
}
break;
case 4:
if(money>=200){
extra = 10;
}
break;
case 5:
if(money>=200){
extra = 20;
}
break;
default:
System.out.println("您输入的数字有误");
break;
}
}else{
System.out.println("对不起,您输入的不是数字");
}
}else{
System.out.println("您的消费金额不支持换购");
}

//结算
double sum = money + extra;
System.out.println("本次消费总金额是:"+sum);
if(choose == 1 && money>=50){
System.out.println("成功换购,百事可乐1瓶");
}else if(choose == 2 && money>=100){
System.out.println("成功换购,500ml可口可乐1瓶");
}else if(choose == 3 && money>=100){
System.out.println("成功换购,5公斤面粉");
}else if(choose == 4 && money>=200){
System.out.println("成功换购,一个苏泊尔炒菜锅");
}else if(choose == 5 && money>=200){
System.out.println("成功换购,欧莱雅爽肤水1瓶");
}else{
System.out.println("消费金额不足,不能换购");
}
}

1
2
3
4
5
6
7
8
9
10
11
12
hasNextInt() -- 判断输入的是不是数字,如果是数字,返回true,否则返回false
public class Test02 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入");
if(input.hasNextInt()){
int week = input.nextInt();
}else{
System.out.println("输入的不是数字");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
经典案例:
package cn.jbit.output;
import java.util.Scanner;
/**
* @author Lenovo
* 3、生成一个随机数(10以内),并且控制台输入一个4位会员号,要求必须是4位会员号否则提示输入的数字无效,如果输入的不是数字造成异常,给出友好提示,请输入数字。当输入的4位会员号中百位数字等于产生的随机数,则中奖100万,或者当输入的4位会员号每一个位置上的数字之和等于随机数的4倍,则中奖500万。
注意点:
(1)、输入的必须是数字。
(2)、必须是4位会员号。
(3)、随机生成一个数字。
(4)、4位会员号每一个位置上的数字之和(指的是个位、十位、百位、千位四个数之和)

*/
public class Test01 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);

//生成一个随机数
int random = (int)(Math.random()*10);
System.out.println(random);
System.out.println("请输入四位会员号");
//判断输入的是否是数字
if(input.hasNextInt()){
//判断输入的数字是不是四位
int number = input.nextInt();
if(number>999&&number<10000){
//获取会员号每一个位置上的值
int geWei = number %10;
int shiWei = number / 10 %10;
int baiWei = number /100%10;
int qianWei = number / 1000;

int sum = geWei + shiWei + baiWei + qianWei;
if(random == baiWei){
System.out.println("恭喜你中奖100万");
}else if(random*4 == sum){
System.out.println("恭喜你,中奖500万");
}else{
System.out.println("对不起,您没中奖");
}

}else{
System.out.println("对不起,您输入的不是4位");
}

}else{
System.out.println("对不起,您输入的不是数字");
}
}
}

5. 循环结构(一)

5.1 循环

概念:大量的重复操作,例如:跑圈、打印100份试卷、做100道编程题

5.2 while循环

组成:循环条件、循环操作

特点 : 先判断、在执行

语法:while(循环条件){

​ //循环操作

​ }

当循环条件判断结果为true时,则执行循环操作。
当循环条件判断结果为false时,则不再执行循环才做。

步骤:

1.  声明变量并赋值
 2.  执行循环条件的判断
 3.  执行循环操作
 4.  迭代,修改变量
1
2
3
4
5
6
7
8
9
//1. 声明变量并赋值
int count = 1;
//2. 执行循环条件的判断
while(count <= 50){
//3. 执行循环操作
System.out.println("正在打印第"+count+"份试卷");
//4. 迭代,修改变量
count++;//count = count + 1
}

5.3 do-while循环

组成:循环条件、循环操作

特点 : 先执行一次,在判断

语法:do{

​ //执行循环操作

​ //迭代、修改变量

​ }while(条件判断);

当循环条件判断结果为true时,则执行循环操作。
当循环条件判断结果为false时,则不再执行循环才做。

步骤:

 1.  声明变量并赋值
 2.  执行一次循环操作
 3.  执行循环条件的判断
 4.  迭代,修改变量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
* 先做作业,然后老师检查,问是否合格
*/
public class Test02 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
//1、声明变量并赋值
String answer = "";
do{
//执行循环操作
System.out.println("上午做上机练习,下午写简答题");
System.out.println("问老师,合格了吗?");
//4、迭代,修改变量
answer = input.next();

}while(answer.equals("n"));//执行循环条件的判断
System.out.println("放学回家了");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
经典案例:
public class Test03 {
public static void main(String[] args) {
System.out.println("华氏温度\t\t摄氏温度");
//1、声明变量并赋值
double sheShi = 0;//摄氏温度
double huaShi = 0;//华氏温度
int count = 1;//条目
do{
//3、循环操作
huaShi = sheShi * 9 / 5.0 + 32;
System.out.println(huaShi +"\t\t"+sheShi);
//4、迭代,修改变量
sheShi = sheShi + 20;
count++;
}while(sheShi<=250 && count<=10);//2、循环条件的判断
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
经典案例2
public class Test02 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("*******************************************");
System.out.println("请选择要购买的商品编号");
System.out.println("1.T 恤衫\t2.网球鞋\t3.网球拍");
System.out.println("*******************************************\n");

//1、声明变量并赋值
double sum = 0;//定义所有商品的总价
String answer = "";
do{
System.out.println("请输入商品编号");
int choose = input.nextInt();
System.out.println("请输入购买数量");
int number = input.nextInt();

//定义商品单价
double price = 0;
//定义每件商品总价
double sumPrice = 0;
//定义商品名称
String name = "";

switch(choose){
case 1:
name = "T 恤衫";
price = 245;
sumPrice = price * number;
break;
case 2:
name = "网球鞋";
price = 300;
sumPrice = price * number;
break;
case 3:
name = "网球拍";
price = 520;
sumPrice = price * number;
break;
default:
System.out.println("输入错误,请重新输入");
break;
}

System.out.println(name+" ¥"+price+"\t数量"+number+"\t合计"+sumPrice);
sum = sum + sumPrice;//每次循环把所有商品的总价钱累加
//4、迭代,修改变量
System.out.println("是否继续(y/n)");
answer = input.next();

}while(answer.equals("y"));

System.out.println();
double zheKou = 0.8;
System.out.println("折扣:"+zheKou);
System.out.println("应付金额:"+sum*zheKou);
System.out.print("实付金额:");
double money = input.nextDouble();
System.out.println("找钱:"+(money - sum*zheKou));
}
}

5.4 断点调试

  • 目的:可以观察变量的变化过程,找到问题所在
  • 按钮:F5、F6、F8
    1. F5 单步执行
    2. F6 单步跳过
    3. F8 一次性执行完毕
  • 步骤:
    1. 设置断点
    2. 单步运行
    3. 观察变量
    4. 发现问题
    5. 解决问题

6. 循环结构(二)

6.1 for循环

组成:循环条件、循环操作

特点 : 先判断,在执行

使用场景: 适用于循环次数固定的情况

语法:

​ for(表达式1;表达式2;表达式3){

​ //循环操作

​ }

表达式1:参数初始化
表达式2:条件判断
表达式3:更新循环变量

注意 :

  1. 3 个表达式都可以省略,省略后相当于死循环。
  2. 两个分号不能省略

当循环条件判断结果为true时,则执行循环操作。
当循环条件判断结果为false时,则不再执行循环才做。

步骤:

 1.  声明变量并赋值
 2.  执行循环条件的判断
 3.  执行一次循环操作
 4.  迭代,修改变量
1
2
3
for(int i = 0;i < 50;i++){
System.out.println("正在打印"+(i+1)+"份试卷");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
经典案例:
public class Test02 {
public static void main(String[] args) {
//循环输入某同学S1结业考试的5门课成绩,并计算平均分
Scanner input = new Scanner(System.in);
System.out.print("请输入学生姓名:");
String name = input.next();
//1、声明变量并赋值 avg、sum、i
double avg = 0;
double sum = 0;
//2、执行循环条件的判断 i<=5
//4、迭代、修改变量 i++
for(int i = 1;i <= 5;i++){
//3、执行循环操作
System.out.print("请输入5门功课中第"+i+"门课的成绩:");
int score = input.nextInt();
sum = sum + score;
}
//求平均分
avg = sum / 5;
System.out.println(name+"的平均分是:"+avg);
}
}

6.2 break和continue

  • break:中断,可以用于任何的循环操作中,也可以使用switch选择结构
    当循环的过程中执行了break,则会退出整个循环。
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Test05 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入学生姓名");
String name = input.next();

for (int i = 1; i <= 5; i++) {
System.out.print("请输入第"+i+"门成绩:");
int score = input.nextInt();
if(score<0){
System.out.println("对不起,您输入的分数有误,请重新运行");
break;
}
}
}
}
  • continue:
    1. 跳过循环,执行下一次循环。
    2. 只能用于循环中。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Test02 {
public static void main(String[] args) {
//循环录入Java课的学生成绩,统计分数大于等于80分的学生比例
Scanner input = new Scanner(System.in);
System.out.println("请输入学生姓名:");
String name = input.next();

int count = 0;//80分以上的人数
for(int i = 1;i<=5;i++){
System.out.print("请输入第"+i+"门课程的分数:");
int score = input.nextInt();
if(score<80){
continue;//分数小于80的时候,则不再执行count++这次循环
}
count++;
}
System.out.println("80分以上的学生人数是:"+count);
System.out.println("80分以上的学生人数比例是:"+count * 100 / 5 +"%");
}
}

6.3 循环总结

  • 语法
    1. while(循环条件){循环操作}
    2. do{循环操作}while(循环条件);
    3. for(初始部分;循环条件;迭代更新变量){循环操作}
  • 执行循环
    1. while:先判断,再执行
    2. do-while:先执行,再判断
    3. for:先判断,再执行
  • 适用场景
    1. 循环次数确定的情况,通常选用for循环
    2. 循环次数不确定的情况,通常选用while或do-while循环

7. 循环结构综合实战

7.1 上机编程

  1. switch和if综合
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class Test01 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("易众游戏平台 > 游戏币支付");
System.out.println();

System.out.println("请选择您玩的游戏类型:");
System.out.println("\t\t1.牌类");
System.out.println("\t\t2.休闲竞技类");
int type = input.nextInt();

System.out.println("请输入您的游戏时长");
int times = input.nextInt();

double zhekou = 0;//先声明变量表示折扣
String typeName = "";//声明变量表示游戏类型
int youXiBi = 0;//游戏币个数
switch(type){
case 1:
typeName = "牌类";
youXiBi = 10;
break;
case 2:
typeName = "休闲竞技类";
youXiBi = 20;
break;
default:
System.out.println("输入错误");
break;
}
if(times>10){//时长超过10小时,折扣是0.5
zhekou = 0.5;
}else{//时长没有超过10小时,折扣是0.8
zhekou = 0.8;
}
System.out.println("您玩的是"+typeName+"类游戏,时长是:"+times+",可以享受"+zhekou*10+"折优惠");
double money = youXiBi * times * zhekou;//计算总的游戏币数量
System.out.println("您需要支付"+(int)money+"个游戏币");
}
}
  1. 循环和选择综合
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public class Test02 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("青鸟游戏迷你平台 > 游戏晋级");
System.out.println();

//1、声明变量并赋值
int count = 1;//局数
int number = 0;//80分以上的次数
do{

System.out.println("您正在玩第"+count+"局游戏,成绩为:");
int score = input.nextInt();
if(score >= 80){
number++;
}
count++;
if(count>5){
System.out.println("游戏结束了");
}else{
System.out.println("继续玩下一句游戏吗?");
String answer = input.next();
if(answer.equals("no")){
System.out.println("对不起,您中途退赛,不能晋级");
break;
}else{
System.out.println("进入下一局");
}
}

}while(count<=5);
//计算比例
double rate = number / 5.0;
if(rate>=0.8){
System.out.println("恭喜你,晋级一级");
}else if(rate>=0.6){
System.out.println("恭喜你,晋级二级");
}else{
System.out.println("对不起,您未能晋级");
}
}
}
  1. 循环选择,会员积分
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class Test03 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("易众游戏平台 > 添加用户信息");
System.out.println();

System.out.println("请输入人要录入用户的数量");
int number = input.nextInt();

for (int i = 0; i < number; i++) {
System.out.println();
System.out.println("请输入用户编号(<4位整数>):");
int customer = input.nextInt();
//判断输入的是否是4位整数
if(customer<1000 || customer>9999){
System.out.println("对不起,您输入的不是4位整数");
}
System.out.println("请输入用户年龄");
int age = input.nextInt();
//判断年龄是否符合要求
if(age<10){
System.out.println("对不起,年龄不够");
}
System.out.println("请输入会员积分");
int jiFen = input.nextInt();
System.out.println("您录入的会员信息是:");
System.out.println("用户编号:"+customer+"\t年龄:"+age+"\t积分:"+jiFen);
}
}
}

7.2 课后习题

数的阶乘

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package KeHou;

import java.util.Scanner;

/**
* 八种基本数据类型
* 1.整型:byte short int long
* 2.浮点型:float double
* 3.布尔型:boolean
* 4.字符:char
* -----------------------------
* 字符串:String
*
* @author Lenovo
* 4!=1*2*3*4;
*/
public class Test02 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入一个数字");
int number = input.nextInt();

if(number>10){
System.out.println("无效数据");
}else{
System.out.print(number+"!=");
int sum = 1;
for (int i = 1; i <= number; i++) {
sum = sum*i;
if(i == number){
System.out.print(i);
}else{
System.out.print(i+"*");
}
}
System.out.print("="+sum);
}
}
}
  1. 1~100之间不能被7整除的数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package KeHou;

/**
* 1-100之间不能被7整除的数,求和
* @author Lenovo
*
*/
public class Test03 {
public static void main(String[] args) {
int sum = 0;//定义和
int count = 0;//计数,每4个换行
for (int i = 1; i <= 100; i++) {
if(i % 7 == 0){//取余7,跳过
continue;
}

System.out.print(i+"\t");
count++;//每循环一次,计数加1

if(count == 4){//当计数count == 4,换行
System.out.println("\n");
count = 0;//计数归0
}
sum = sum + i;//求和
}
System.out.println(sum);
}
}

8. 数组

8.1 概念

数组:是一个变量,存储相同数据类型的一组数据

声明一个变量就是在内存空间划出一块合适的空间

声明一个数组就是在内存空间划出一串连续的空间

8.2 数组四要素

  1. 标识列:数组名称,用来区分不同的数组。
  2. 数组元素:向数组中存放的数据。
  3. 数组下标:对数组元素进行编号,从0开始,数组中的每个元素都可以通过下标来访问。
  4. 元素类型:数组元素的数据类型。

8.3 如何使用数组

  1. 声明数组 : int[] num;
  2. 分配空间 : num = new int[5];
  3. 赋值 : num[0] = 10;
  4. 处理数据 : num[0] * 2;

8.4 创建数组的方式

8.4.1 语法:

方式一: 数据类型[] 数组名 = new 数据类型[长度];

1
2
3
4
5
6
int [] array = new int[5];
array[0] = 90;
array[1] = 98;
array[2] = 92;
array[3] = 80;
array[4] = 88;

方式二: 数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3……};

1
String[] str = new String[]{"张三","李四","王五"};

方式三: 数据类型[] 数组名 = {数据1,数据2,数据3……};

1
double[] score = {98.5,78.6,88.9};

8.4.2 数组的长度和排序

语法:

​ 数组长度:数组名.length

​ 排序:Arrays.sort(数组名)

注意:对数组中进行排序,升序排序。

8.4.3 循环读取数组中元素

  1. for循环:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
* java.lang.ArrayIndexOutOfBoundsException:数组下标越界异常
* @author Lenovo
*
*/
public class Test01 {
public static void main(String[] args) {
//1、定义数组方式一: 数据类型[] 数组名= new 数据类型[长度];
//声明数组并开辟空间
int[] score = new int[5];
//赋值
score[0] = 89;
score[1] = 91;
score[2] = 99;
score[3] = 78;
score[4] = 85;
//使用数组,使用循环的方式输出
for(int i = 0;i < 5; i++){
//从数组中获取某个元素,数组名[下标]
System.out.println(score[i]);
}
}
}
  1. 向数组中键盘录入数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
经典案例:
public class Test05 {
public static void main(String[] args) {
// 8 4 2 1 23 344 12
//循环输出这一组数
//声明数组并分配空间
int[] number = new int[]{8,4,2,1,23,344,12};
for(int i = 0;i < number.length ; i++){
System.out.print(number[i]+" ");
}
System.out.println("-----------------------------------");
//求数列中所有数值的和
int sum = 0;
for (int i = 0; i < number.length; i++) {
sum = sum + number[i];
}
System.out.println("总和是:"+sum);
System.out.println("--------------------------------------");
//猜数游戏:从键盘中任意输入一个数据,判断数列中是否包含此数
//思路:把输入的数据,跟数组中的每一个值做比较,通过循环,每次得到数组中的一个值,依次比对。
Scanner input = new Scanner(System.in);
System.out.println("请输入一个数字");
int num = input.nextInt();

//声明一个标识列
boolean flag = false;
for (int i = 0; i < number.length; i++) {
if(number[i] == num){
flag = true;
}
}
if(flag == true){
System.out.println("该数字存在");
}else{
System.out.println("不存在");
}
}
}

  1. 降序排序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//格式化代码:全选--->右键找source-->Format
public class Test06 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int[] score = new int[5];
//循环录入5名同学的成绩
for (int i = 0; i < score.length; i++) {
System.out.println("请输入第"+(i+1)+"个学生成绩");
score[i] = input.nextInt();
}
System.out.println("--------------------排序前--------------------");
//通过循环输出学生分数
for (int i = 0; i < score.length; i++) {
System.out.print(score[i]+" ");
}
//排序:Arrays.sort(数组名);,升序排序,从小到大
Arrays.sort(score);
System.out.println("\n--------------------排序后--------------------");
//循环输出排序后的结果
for (int i = 0; i < score.length; i++) {
System.out.print(score[i]+" ");
}

System.out.println("\n--------------------降序排序后--------------------");
//i++ 自身加1,i= i + 1,i--自身减1,i=i-1;
for(int i = score.length - 1;i>=0;i--){
System.out.print(score[i]+" ");
}
}
}
  1. 求最大值和最小值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Test07 {
public static void main(String[] args) {
//求一组数中的最大值
int[] score = new int[]{67,88,45,55,98};

//1、先选一个数作为最大值
int max = score[0];
for (int i = 0;i<score.length;i++){
if(max < score[i]){
max = score[i];
}
}
System.out.println("最大值是:"+max);
//作业问题:求最小值?
System.out.println("------------------------------");
int min = score[0];
for (int i = 0; i < score.length; i++) {
if(min > score[i]){
min = score[i];
}
}
System.out.println("最小值是:"+min);
}
}
  1. 插入排序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class Test09 {
public static void main(String[] args) {
//声明一个长度位6的数组
int[] nums = new int[6];
//赋值赋5个,留一个给录入的数字
nums[0] = 98;
nums[1] = 88;
nums[2] = 83;
nums[3] = 77;
nums[4] = 60;
//循环读取数组中的数据
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i]+" ");
}
Scanner input = new Scanner(System.in);
System.out.println("\n请输入要插入的数字");
int number = input.nextInt();

//先任意定义一个下标
int index = nums.length - 1;
//通过循环比较新插入的数字应该放到哪个位置
for(int i = 0;i<nums.length;i++){
if(number > nums[i]){
index = i;
break;
}
}
//通过循环,让后面的数字往后移动一个位置
for(int i = nums.length-1;i>index;i--){
//把前一个位置上的值赋给后一个位置上。
nums [i] = nums[i-1];
}
//把新录入的数字赋值给下标index
nums[index] = number;
//重新循环读取
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i]+" ");
}
}
}

9. 循环结构进阶

9.1 基础内容

概念

  • 任意两个循环都可以相互嵌套

  • 多个循环相互嵌套

  • for与for、while与while、do-while与do-while等。

执行流程

  • 外层循环执行一次,内层循环执行完整的一遍

注意:

​ break如果出现在内层循环,只能中断内层循环,对外层循环没有影响。

9.2 代码

  1. 录入3个班,每个班4个学生的成绩,求平均分
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package cn.jbit.output01;
import java.util.Scanner;
/**
* 双重循环(二重循环):while do-while for
* 任意两种循环间都可以相互嵌套
* 执行循环
* 1、外层循环执行一次,内层循环执行一轮
* @author Lenovo
*
*/
public class Test02 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
//声明变量
double sum = 0;
for (int i = 0; i < 3; i++) {
sum = 0;//每次计算完一个班级成绩后,让总和sum清0。
System.out.println("请输入第"+(i+1)+"个班级的成绩");
for (int j = 0; j < 4; j++) {
System.out.println("第"+(j+1)+"个学生的成绩");
int score = input.nextInt();//输入每一个学生的成绩
sum = sum + score;//求和
}
double avg = sum / 4;
System.out.println("第"+(i+1)+"个班的学生平均分是:"+avg);
}

}
}
  1. 打印三角形
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Test04 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入行数");
int row = input.nextInt();

for (int i = 1; i <= row; i++) {
for(int j = 1;j<=2*i-1;j++){
System.out.print("*");
}
System.out.println();
}

}
}
  1. 九九乘法表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
* 打印九九乘法表
* @author Lenovo
*
*/
public class Test05 {
public static void main(String[] args) {
//i表示行数,j表示个数
//每行出现的个数,不能超过行数
for (int i = 1; i <=9; i++) {
for(int j=1;j<=i;j++){
System.out.print(j+"*"+i+"="+(j*i)+"\t");
}
System.out.println();
}
}
}
  1. 商店买商品
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package cn.jbit.output01;

import java.util.Scanner;
/**
* 如果break出现在内层循环中,只能中断内层循环, 对外层循环没有影响
* @author Lenovo
*
*/
public class Test07 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int count = 0;//统计购买的衣服总量
for(int i = 1;i<=5;i++){
System.out.println("欢迎来到第"+i+"家店");
for(int j = 1;j<=3;j++){
System.out.println("是否离开(y/n)?");
String answer = input.next();
if(answer.equals("y")){
break;
}
System.out.println("买了一件衣服");
count++;
}
System.out.println();
}
System.out.println("一共买了"+count+"件衣服");
}
}

5、打印倒三角形

1
2
3
4
5
6
7
8
9
10
11
public class Test02 {
public static void main(String[] args) {
int row = 5;
for(int i = 1;i<=row;i++){
for(int j = 1;j<=row-i+1;j++){
System.out.print("*");
}
System.out.println();
}
}
}

6、打印等腰三角形

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Test03 {
public static void main(String[] args) {

for(int i = 1;i<=5;i++){
for(int k = 1;k<=5-i;k++){
System.out.print(" ");
}
for(int j = 1;j<=2*i-1;j++){
System.out.print("*");
}
System.out.println();
}
}
}

10. 幸运抽奖

10.1 知识点

  1. 变量、数据类型、运算符
  2. 选择结构if和switch
  3. 循环结构while、do-while、for
  4. 数组
  5. 双重循环结构

10.2 经典案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
public class Test03 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String answer = "";//是否继续
String name = "";//用户名
String password = "";//密码
do{
System.out.println("**************欢迎进入抽奖系统****************");
System.out.println("\t\t1.注册");
System.out.println("\t\t2.登录");
System.out.println("\t\t3.抽奖");
System.out.println("********************************************");
System.out.print("请选择菜单:");
int choose = input.nextInt();
switch(choose){
case 1:
System.out.println("【奖客富翁系统 > 注册】");
System.out.println("请输入个人注册信息:");

System.out.print("用户名:");
name = input.next();

System.out.print("密码:");
password = input.next();
System.out.println();
//生成会员卡号
int cusNo;
do{
//通过循环,得到一个四位的会员号,如果不是四位,重新循环生成,直到是4位为止
cusNo = (int)(Math.random()*10000);
}while(cusNo<1000 || cusNo>10000);

System.out.println("注册成功,请记好您的会员卡号");
System.out.println("用户名\t密码\t会员卡号");
System.out.println(name+"\t"+password+"\t"+cusNo);
break;
case 2:
System.out.println("【抽奖系统 > 登录】");
boolean flag = true;//定义一个标识列
for(int i = 2;i>=0;i--){
System.out.print("请输入用户名:");
String uName = input.next();
System.out.print("请输入密码:");
String pwd = input.next();
//判断用户名和密码是否正确
if(uName.equals(name) && pwd.equals(password)){
System.out.println();
System.out.println("欢迎您"+uName);
flag = true;
break;
}else{
flag = false;
System.out.println("用户名或密码错误,您还有"+i+"次机会");
}
}
if(flag == false){
System.out.println("对不起,三次机会都错误,系统退出");
return;//退出整个循环
}
break;
case 3:
System.out.println("【抽奖系统 > 抽奖】");
System.out.println("请输入您的卡号");
int num = input.nextInt();

//声明一个数组,存储5个幸运会员号
int[] huiYuan = new int[5];
for(int i = 0;i<5;i++){
int number;
do{
//通过循环,得到一个四位的会员号,如果不是四位,重新循环生成,直到是4位为止
number = (int)(Math.random()*10000);
}while(number<1000 || number>10000);
huiYuan[i] = number;
}

//通过循环,将输入的会员卡号与数组中的会员卡号做对比
boolean isok = false;
for (int i = 0; i < huiYuan.length; i++) {
System.out.print(huiYuan[i]+"\t");
if(num == huiYuan[i]){
isok = true;
break;
}else{
isok = false;
}
}
if(isok == true){
System.out.println("\n恭喜您,成为本日幸运用户");
}else{
System.out.println("\n对不起,您不是本日的幸运会员");
}

break;
default:
System.out.println("输入错误,请重新输入");
break;
}
System.out.println("继续吗?(y/n)");
answer = input.next();
System.out.println();
}while(answer.equals("y"));
System.out.println("系统退出,谢谢使用");
}
}

11.类和对象

11.1 面向对象思想概述

11.11 概述

1
2
3
4
5
	Java语言是一种面向对象的程序设计语言,而面向对象思想是一种程序设计思想,我们在面向对象思想的指引下,
使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物,每种事物都具备自己的属性和行为。面
向对象思想就是在计算机程序设计过程中,参照现实中事物,将事物的属性特征、行为特征抽象出来,描述成计算
机事件的设计思想。 它区别于面向过程思想,强调的是通过调用对象的行为来实现功能,而不是自己一步一步的去
操作实现。

11.12 举例

洗衣服:

  • 面向过程:把衣服脱下来 –>找一个盆–>放点洗衣粉–>加点水–>浸泡10分钟–>揉一揉–>清洗衣服–>拧干–>晾
    起来。
  • 面向对象:把衣服脱下来 –>打开全自动洗衣机–>扔衣服–>按钮–>晾起来。

区别 :

  • 面向过程:强调步骤。
  • 面向对象:强调对象,这里的对象就是洗衣机。

11.13 特点

1
2
面向对象思想是一种更符合我们思考习惯的思想,它可以将复杂的事情简单化,并将我们从执行者变成了指挥者。
面向对象的语言中,包含了三大基本特征,即封装、继承和多态。

11.2 类和对象

环顾周围,会发现很多对象,比如桌子,椅子,同学,老师等。桌椅属于办公用品,师生都是人类。那么什么是类呢?什么是对呢?

11.21 什么是类

分类,是一组相关属性和行为的集合。可以看成是一类事物的模板,使用事物的属性特征和行为特征来描述该类事物。

​ 类是一个抽象的概念,现实中是不存在的。

现实中,描述一类事物:

  • 属性 :就是该事物的状态信息。

  • 行为 :就是该事物能够做什么。

例如:小猫。

属性:名字、体重、年龄、颜色。

行为:走、跑、叫

11.22 什么是对象

对象 :是一类事物的具体体现,用来描述客观事物的一个实体。对象是类的一个实例,必然具备该类事物的属性和行为。

对象是由一组属性和方法组成

  • 属性:静态特征,用来描述该对象。
  • 方法:动态特征,表示该对象能完成的功能,能做的事,执行的操作。

现实中,一类事物的一个实例:

例如:一只小猫。

  • 属性:姓名、体重、年龄、毛色。
  • 行为:溜墙根走、蹦跶的跑、喵喵叫。

11.23 类与对象的关系

  • 类是对一类事物的描述,是 抽象的。
  • 对象是一类事物的实例,是 具体的。
  • 类是对象的抽象,对象的模板,对象是类的具体实例。

11.3 定义类和对象

11.31 类的定义格式

1
2
3
4
public class ClassName {
  //成员变量
  //成员方法
}
  • 定义类 :就是定义类的成员,包括成员变量和成员方法。
  • 成员变量 :和以前定义变量几乎是一样的。只不过位置发生了改变。在类中,方法外。
  • 成员方法 :和以前定义方法几乎是一样的。只不过把static去掉,static的作用在面向对象后面课程中再详细讲解。

案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Student{
//成员变量
String name;//姓名
int age;//年龄
//成员方法
//自我介绍的方法
public void show(){
System.out.println("我叫"+name+",今年"+age+"岁。");
}
//学习的方法
    public void study() {
     System.out.println("好好学习,天天向上");
   }
}

11.32 对象的定义格式

对象的使用格式

  1. 创建对象:
1
类名 对象名 = new 类名();
  1. 使用对象访问类中的成员:
1
2
对象名.成员变量;
对象名.成员方法();
  1. 对象的使用格式举例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Test01_Student {
  public static void main(String[] args) {
    //创建对象格式:类名 对象名 = new 类名();
    Student s = new Student();
    System.out.println("s:"+s); //cn.itcast.Student@100363
    //直接输出成员变量值
    System.out.println("姓名:"+s.name); //null
    System.out.println("年龄:"+s.age); //0
    System.out.println("‐‐‐‐‐‐‐‐‐‐");
    //给成员变量赋值
    s.name = "赵丽颖";
    s.age = 18;
    //再次输出成员变量的值
    System.out.println("姓名:"+s.name); //赵丽颖
    System.out.println("年龄:"+s.age); //18
    System.out.println("‐‐‐‐‐‐‐‐‐‐");
    //调用成员方法
    s.study(); // "好好学习,天天向上"
    s.eat(); // "学习饿了要吃饭"
  }
}

11.33 类与对象的练习

定义手机类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Phone {
  // 成员变量
  String brand; //品牌
  int price; //价格
  String color; //颜色
  // 成员方法
  //打电话
  public void call(String name) {
    System.out.println("给"+name+"打电话");
  }
  //发短信
  public void sendMessage() {
    System.out.println("群发短信");
  }
}

定义测试类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Test02Phone {
  public static void main(String[] args) {
    //创建对象
    Phone p = new Phone();
    //输出成员变量值
    System.out.println("品牌:"+p.brand);//null
    System.out.println("价格:"+p.price);//0
    System.out.println("颜色:"+p.color);//null
    System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐");
//给成员变量赋值
    p.brand = "锤子";
    p.price = 2999;
    p.color = "棕色";
    //再次输出成员变量值
    System.out.println("品牌:"+p.brand);//锤子
    System.out.println("价格:"+p.price);//2999
    System.out.println("颜色:"+p.color);//棕色
    System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐");
    //调用成员方法
    p.call("紫霞");
    p.sendMessage();
  }
}

12. 类的无参方法

12.1 类的方法

12.1.1 定义类的方法

语法

1
2
3
public   返回值类型  方法名()  {
//方法的主体
}

两种情况

  • 如果方法具有返回值,方法中必须使用关键字return, 返回该值,返回值类型为该返回值的类型
  • 如果方法没有返回值,返回值类型为void

例如:

1
2
3
4
5
6
7
8
9
1.有返回值
public String show(){
String ball = "篮球";
return ball;
}
2.无返回值
public void shows(){
System.out.println("今天阳光明媚");
}

:返回值的类型由返回值类型来决定

例如:

​ 如果返回值类型是String,返回值必须是字符串 String类型。

​ 如果返回值类型是int,返回值必须是整型int类型。

12.12 方法调用

方法是个“黑匣子”,完成某个特定的应用程序功能,并返回结果

方法调用:执行方法中包含的语句

语法:对象名.方法名()

  • 方法之间允许相互调用,不需要知道方法的具体实现,实现重用,提高效率
情 况 举 例
Student类的方法a( ),调用Student类的方法b( ),直接调用 public void a( ) { b( ); //调用b( ) }
Student类的方法a( )调用Teacher类的方法b( ),先创建类对象,然后使用 . 调用 public void a( ) { Teacher t = new Teacher( ); t.b( ); //调用Teacher类的b() }

案例1:定义狮子类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class AutoLion {  
String color = "黄色"; //颜色
/*跑*/
public void run(){
System.out.println("正在以0.1米/秒的速度向前奔跑。");
}
/*抢球*/
public String robBall(){
String ball = "球" ;
return ball;
}
/*获得颜色*/
public String getColor(){
return color;
}
/*显示狮子特性*/
public String showLion(){
return "这是一个" + getColor() + "的玩具狮子!";
}
}

定义测试类

1
2
3
4
5
6
7
8
9
public class TestLion {
public static void main(String[ ] args) {
AutoLion lion = new AutoLion();
String info = lion.showLion();
System.out.println(info);
lion.run();
System.out.println("抢到一个"+lion.robBall());
}
}

案例2:定义电脑类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class Computer {
//属性
double number1;
double number2;
//方法:得到运算结果
public double getResult
Scanner input = new Scanner(System.in);
System.out.println("请输入第一个数字");
number1 = input.nextDouble();
System.out.println("请输入第二个数字");
number2 = input.nextDouble();

System.out.println("请输入运算符");
String option = input.next();
double result = 0;//定义结果
switch(option){
case "+":
result = number1 + number2;
break;
case "-":
result = number1 - number2;
break;
case "*":
result = number1 * number2;
break;
case "/":
result = number1 / number2;
break;
}
return result;
}
}

定义测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class TestComputer {
public static void main(String[] args) {
//搭桥:创建Computer对象
Computer com = new Computer();
com.show();
double result = com.getResult();
System.out.println("结果是:"+result);

if(result != 3.0){
System.out.println("你很优秀");
}else{
System.out.println("你需要再接再厉");
}
}
}

12.2 成员变量和局部变量

12.2.1 基本内容

定义:变量根据定义位置的不同,我们给变量起了不同的名字,成员变量和局部变量。

概念:

  • 成员变量:在类中直接声明的变量。
  • 局部变量:在方法中或者代码块中声明的变量。

区别:

  • 在类中的位置不同

    • 成员变量:类中,方法外
    • 局部变量:方法中或者方法声明上 (形式参数)
  • 作用域(作用范围)不一样

    • 成员变量:类中
    • 局部变量:方法中
  • 初始化值的不同

    • 成员变量:有默认值
    • 局部变量:没有默认值。必须先定义,赋值,最后使用
  • 在内存中的位置不同

    • 成员变量:堆内存
    • 局部变量:栈内存
  • 生命周期不同

    • 成员变量:随着对象的创建而存在,随着对象的消失而消失
    • 局部变量:随着方法的调用而存在,随着方法的调用完毕而消失。

注意:

    1. 在同一个方法中,不允许有同名局部变量,在不同的方法中,可以有同名局部变量。
      2. 在同一个类中,成员变量和局部变量同名时,局部变量具有更高的优先级

12.2.2 成员变量默认值

数据类型 默认值
基本类型 整型(byte,short,int,long) 0
浮点型(float,double) 0.0
字符(char) ‘\u0000’
布尔(boolean) false
引用类型 String,数组,类,接口 null

12.3 JavaDoc注释

12.3.1 注释种类

  1. 单行注释://
  2. 多行注释:/**/
  3. JavaDoc注释:使用“/******“开始和“*/“结束,用来注释类、属性和方法等。

12.3.2 作用

JavaDoc能够从源代码中抽取类、属性、方法等的注释,形成一个配套的API帮助文档。

12.3.3 生成JavaDoc方式

  1. 使用命令行方式生成
  2. 使用MyEclipse工具生成

课后题:

需求:随机给出一个商品名称,猜测价格,共3次机会。

猜测商品类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class QuessMachine {
//属性
String shopName;//商品名称
double shopMoney;//商品价格

Scanner input = new Scanner(System.in);
//方法
public void initial(){
//声明一个数组,存商品名称
String[] shop = new String[]{"34寸大彩电","美的冰箱","格力空调"};
//声明一个数组,存商品价格
double[] money = {3000,2000,5000};
//声明一个(1~3)随机数
int random = (int)(Math.random()*3);
//每调用一次方法,生成一个商品名称和单价
shopName = shop[random];//名称
shopMoney = money[random];//价格

System.out.println("请猜测"+shopName+"的价格:");
double guessMoney = input.nextDouble();

for (int i = 0; i < 3; i++) {
if(i == 2){
break;
}
if(guessMoney > shopMoney){
System.out.println("再小点\n");
}else if(guessMoney<shopMoney){
System.out.println("再大点\n");
}else{
System.out.println("猜对了");
break;
}
System.out.println("在猜一次吧");
guessMoney = input.nextDouble();
}
}
}

测试类

1
2
3
4
5
6
public class TestQuessMachine {
public static void main(String[] args) {
QuessMachine m = new QuessMachine();
m.initial();
}
}

13.人机猜拳

13.1 技能点

  • 类和对象
  • 类的无参方法

13.2 案例

任务:完成人机猜拳互动游戏的开发

主要功能

  • 选取对战角色

  • 猜拳

  • 记录分数

类图

用户类
名字、积分
出拳
计算机类
名字、积分
出拳
游戏类
甲方玩家、乙方玩家、对站次数
初始化、开始游戏、计算对战结果、显示对战结果

定义人类Person:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class Person {

//属性
String name;//姓名
int score;//分数
//方法:出拳
public int personResult(){
Scanner input = new Scanner(System.in);
System.out.println("请选择出拳结果(1、石头 2、剪刀 3、布)");
int choose = input.nextInt();
switch(choose){
case 1:
System.out.println(name+"出拳结果是石头");
break;
case 2:
System.out.println(name+"出拳结果是剪刀");
break;
case 3:
System.out.println(name+"出拳结果是布");
break;
default:
System.out.println("输入错误");
break;
}
return choose;
}
}

定义电脑类Computer:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Computer {

String name;
int score;

public int computerResult(){
//通过随机数产生一个数字,对应一个出拳结果,随机数是1到3
int choose = (int)(Math.random()*3)+1;
switch(choose){
case 1:
System.out.println(name+"出拳结果是石头");
break;
case 2:
System.out.println(name+"出拳结果是剪刀");
break;
case 3:
System.out.println(name+"出拳结果是布");
break;
}
return choose;
}
}

定义游戏类Game:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
public class Game {

Person per;//声明一个人类
Computer com;//声明一个电脑类
int count;//对战次数
boolean flag;
Scanner input = new Scanner(System.in);
/**
* 初始化数据
*/
public void initial(){
per = new Person();//创建人类对象
com = new Computer();//创建电脑类对象
count = 0;//对战次数
flag = false;//标识列
}

/**
* 项目启动的方法
*/
public void start(){
//先调用初始化的方法,然后在开始流程
initial();
System.out.println("*****************欢迎进入游戏世界***************");
System.out.println();
System.out.println("**************************");
System.out.println("**\t猜拳,开始\t**");
System.out.println("**************************");
System.out.println();
System.out.println("出拳规则:1、石头 2、剪刀 3、布");
System.out.println("请选择对方角色(1:刘备 2:孙权 3、曹操)");
int choose = input.nextInt();
switch(choose){
case 1:
com.name = "刘备";
break;
case 2:
com.name = "孙权";
break;
case 3:
com.name = "曹操";
break;
}
System.out.println("请输入您的名字");
per.name = input.next();
System.out.println();
System.out.println("要开始吗?(y/n)");
String answer = input.next();
while(answer.equals("y")){
count++;//对战次数加1;
//调用人类和电脑类的出拳,得到一个int类型的结果
int perResult = per.personResult();
int comResult = com.computerResult();
//将结果做比较
if(perResult == comResult){
System.out.println("本轮结果是平局");
}else if((perResult == 1 && comResult==2)||(perResult == 2 && comResult == 3)||(perResult == 3 && comResult == 1)){
per.score++;
System.out.println("恭喜您,本轮您赢了");
}else{
com.score++;
System.out.println("嘿嘿,电脑赢了");
}
System.out.println("是否进入下一轮比赛。(y/n)");
answer = input.next();
if(answer.equals("n")){
result();
break;
}
}
}
public void result(){
System.out.println("-----------------------------------");
System.out.println(per.name + "\tVS\t"+com.name);
System.out.println("对战次数"+count);
System.out.println();
System.out.println("姓名\t得分");
System.out.println(per.name+"\t"+per.score);
System.out.println(com.name+"\t"+com.score);
System.out.println();
if(per.score>com.score){
System.out.println("恭喜"+per.name+"\t获得了最终的胜利");
}else if(per.score<com.score){
System.out.println("恭喜"+com.name+"\t获得了最终的胜利");
}else{
System.out.println("握手言和");
}
}
}

定义测试类Test

1
2
3
4
5
6
public class Test {
public static void main(String[] args) {
Game game = new Game();
game.start();
}
}

14. 类的带参方法

14.1 带参方法

14.1.1 定义带参数的方法

语法:

1
2
3
<访问修饰符>   返回值类型  方法名(形式参数列表){
//方法主体
}

两种情况

  • 如果方法具有返回值,方法中必须使用关键字return, 返回该值,返回值类型为该返回值的类型
  • 如果方法没有返回值,返回值类型为void

例如:

定义榨汁机类

1
2
3
4
5
6
7
8
9
10
public class ZhaFruit {
//方法
//功能:榨汁
public String zhazhi(String fruit){
return fruit+"汁";
}
public String playBean(String bean){
return bean+"汁";
}
}

定义测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Test {
public static void main(String[] args) {
//创建对象
ZhaFruit zha = new ZhaFruit();

Scanner input = new Scanner(System.in);
System.out.println("请放入水果");
String fruit = input.next();

//将准备好的参数(变量)放入到方法中。
String r = zha.zhazhi(fruit);
System.out.println(r);

String bean = "黑豆";
zha.playBean(bean);
}
}

:返回值的类型由返回值类型来决定

例如:

​ 如果返回值类型是String,返回值必须是字符串 String类型。

​ 如果返回值类型是int,返回值必须是整型int类型。

14.1.2 方法调用

语法:

1
对象名.方法名(参数1,参数2,......,参数n)

案例

定义学生类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Student {

//1、定义一个字符串类型的数组
String[] names = new String[5];
// ___ ___ ___ ___ ___
//2、定义一个方法,功能是通过循环的方法向数组中--添加--姓名
public void addName(String name){
for (int i = 0; i < names.length; i++) {
//如果这个位置为空,则将姓名添加到数组中
if(names[i] == null){
names[i] = name;//将传过来的姓名添加到数组中。
break;//将姓名保存到数组后,中断循环。
}
}
}
//3、再定义一个方法,功能是从数组中读取姓名并展示。
public void showName(){
for (int i = 0; i < names.length; i++) {
System.out.print(names[i]+"\t");
}
}
}

定义测试类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Test {
public static void main(String[] args) {
//创建Student对象
Student stu = new Student();
Scanner input = new Scanner(System.in);
System.out.println("Student类中数组的长度是"+stu.names.length);
for (int i = 0; i < stu.names.length; i++) {
System.out.println("请输入第"+(i+1)+"个学员姓名:");
String name = input.next();
stu.addName(name);
}
//去Student类中调用showName方法,展示所有的学生姓名
stu.showName();
}
}

14.1.3 形参和实参

  • 形参:形式上的参数,参数前有数据类型,位于方法的括号中。
  • 实参:实际意义上的参数,参数前没有数据类型,位于方法的括号中,一般是被调用的时候写实参。
1
2
3
4
5
public String zhazhi(String fruit){//String fruit 是形参
return fruit+"汁";
}

zha.zhazhi(fruit);//括号内是实参

注意:

  1. 调用方法时不能指定实参类型。
  2. 形参和实参数据类型必须一致。
  3. 形参和实参数量必须一致。
  4. 调用方法后要对返回值作处理,例如,输出,计算等等。

14.2 带多个参数的方法

14.2.1 需求分析

1
2
问题:在保存了多个学生姓名的数组中,指定查找区间,查找某个学生姓名并显示是否查找成功 ?
分析:设计方法,通过传递三个参数(开始位置、结束位置、查找的姓名)来实现。

案例1

定义狗狗类

1
2
3
4
5
6
public class Dog {
//定义方法
public void show(String name,int age,String sex){
System.out.println("昵称是:"+name+"\t年龄是:"+age+"\t性别是:"+sex);
}
}

定义测试类

1
2
3
4
5
6
7
8
9
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();
String name = "哈士奇";
int age = 1;
String sex = "小公狗";
dog.show(name, age, sex);
}
}

案例2

定义学生类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class Student {
//1、定义一个字符串类型的数组
String[] names = new String[5];
// ___ ___ ___ ___ ___
//2、定义一个方法,功能是通过循环的方法向数组中--添加--姓名
public void addName(String name){
for (int i = 0; i < names.length; i++) {
//如果这个位置为空,则将姓名添加到数组中
if(names[i] == null){
names[i] = name;//将传过来的姓名添加到数组中。
break;//将姓名保存到数组后,中断循环。
}
}
}
//3、再定义一个方法,功能是从数组中读取姓名并展示。
public void showName(){
for (int i = 0; i < names.length; i++) {
System.out.print(names[i]+"\t");
}
}
/**
* 4、定义一个方法,可以从数组中查询某个学生姓名
* 形参和实参的数据类型,顺序,个数必须一一对应
*/
public boolean searchName(String name,int start,int end){
boolean flag = false;
//从数组中每次循环取一个值与name作比较
for (int i = start; i <= end; i++) {
if(names[i].equals(name)){
flag = true;
break;//如果找到了,就不用再循环查找了。
}else{
flag = false;
}
}
return flag;
}
}

定义测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class TestStudent {
public static void main(String[] args) {
//创建Student对象
Student stu = new Student();

Scanner input = new Scanner(System.in);
System.out.println("Student类中数组的长度是"+stu.names.length);
for (int i = 0; i < stu.names.length; i++) {
System.out.println("请输入第"+(i+1)+"个学员姓名:");
String name = input.next();
stu.addName(name);
}
System.out.println("********************************");
System.out.println("请输入您要查询的学生姓名:");
String search = input.next();

System.out.println("请输入开始位置");
int start = input.nextInt();
System.out.println("请输入结束为止");
int end = input.nextInt();

boolean isok = stu.searchName(search, start, end);
if(isok == true){
System.out.println("找到了");
}else{
System.out.println("NONONO!!!!");
}
}
}

14.3 数组作为参数的方法

14.3.1 需求分析

1
2
3
问题:有5位学员参加了Java知识竞赛的决赛,输出决赛的平均成绩和最高成绩?
分析:将5位学员的决赛成绩保存在数组中
设计求平均成绩、最高成绩的方法,并把数组作为参数。

案例

定义学生类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Student {
//1、定义一个方法,实现求平均分的功能
public double calcAvg(int[] score){
int sum = 0;
for (int i = 0; i < score.length; i++) {
//每循环一次,从数组中取一个值进行累加
sum = sum + score[i];
}
double avg = sum / score.length;
return avg;
}
//2、定义一个方法,实现求最大值的功能
public int calcMax(int[] score){
int max = score[0];
for (int i = 0; i < score.length; i++) {
if(score[i] > max){
max = score[i];
}
}
return max;
}
}

定义测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class TestStudent {
public static void main(String[] args) {
Student stu = new Student();
//定义一个数组
int[] num = new int[5];
Scanner input = new Scanner(System.in);
for (int i = 0; i < num.length; i++) {
System.out.println("请输入第"+(i+1)+"个分数");
num[i] = input.nextInt();
}
//调用计算平均分的方法
double avg = stu.calcAvg(num);
System.out.println("平均分是:"+avg);

int max = stu.calcMax(num);
System.out.println("最大值是:"+max);
}
}

14.4 对象作为参数的方法

14.4.1 需求分析

1
2
3
4
问题:在实现了增加一个学生姓名的基础上,增加学生的学号、年龄和成绩,并显示这些信息,如何实现?
分析:方式一:设计带四个参数(学号、姓名、年龄、成绩)的方法
方式二:将学生学号、姓名、年龄、成绩封装在学生对象中,设计方法,以学生对象作为参数
决策:可以将多个相关的信息封装成对象,作为参数传递,避免方法有太多的参数!采用方式二!

对象数组

1
2
3
4
5
//数据类型[]  数组名 = new 数据类型[];
//int[] num = new int[5];
//类和对象的关系:类是对象的数据类型
//对象数组:对象类型的数组,数组中存放的是一个个的对象
Student[] students = new Student[3];

案例1:

定义学生类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Student {

String name;
String sex;
double score;
//对象数组:对象类型的数组,数组中存放的是一个个的对象
Student[] students = new Student[3];
//方法的作用是:向数组中添加对象
public void addStudent(Student stu){
for (int i = 0; i < students.length; i++) {
//判断该位置是否为空,如果为空,将传过来的对象放在该位置
if(students[i] == null){
students[i] = stu;
break;
}
}
}
}

定义测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class TestStudent {
public static void main(String[] args) {
//批量创建多个对象
Student stu1 = new Student();
stu3.name = "张妍";
stu3.sex = "女";
stu3.score = 80;

Student stu2 = new Student();
stu4.name = "李嘉伟";
stu4.sex = "男";
stu4.score = 90;

Student stu3 = new Student();
stu5.name = "孙紫薇";
stu5.sex = "女";
stu5.score = 100;
//搭桥,创建对象
Student s = new Student();
s.addStudent(stu1);
s.addStudent(stu2);
s.addStudent(stu3);
}
}

四种访问修饰符

  • 公开的:public
  • 受保护的:protected
  • 默认的:default
  • 私有的:private

案例2:

定义学生类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Student {
//属性
public String name;
String sex;
double score;
int age;
//定义方法:自我展示的功能
public void showInfo(){
System.out.println("大家好,"
+ "我叫"+name+"\t性别"
+ "是:"+sex+""
+ "\t年龄是:"+age+"\t分数是:"+score);
}
}

定义学生管理类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package cn.jbit.output06;
/**
* 学生管理类:负责管理学生信息
* 功能:
* 1、定义一个对象类型的数组,将传过来的对象保存在数组中
* 2、循环调用学生类中自我展示的方法。
* @author Lenovo
*
*/
public class StudentBiz {
//定义数组
Student[] students = new Student[3];
//通过循环将对象保存到数组中 @param stu --参数就是学生对象
public void addStudent(Student stu){
for (int i = 0; i < students.length; i++) {
if(students[i] == null){
students[i] = stu;
break;
}
}
}
//通过循环的方式,调用自我展示的功能
public void show(){
for (int i = 0; i < students.length; i++) {
students[i].showInfo();
}
}
}

定义测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class Test {
public static void main(String[] args) {
//批量创建多个对象
Student stu1 = new Student();
stu1.name = "王有志";
stu1.sex = "男";
stu1.score = 60;
stu1.age = 18;

Student stu2 = new Student();
stu2.name = "曹佩鑫";
stu2.sex = "男";
stu2.score = 70;
stu2.age = 19;

Student stu3 = new Student();
stu3.name = "赵泽天";
stu3.sex = "男";
stu3.score = 80;
stu3.age = 20;
//创建学生管理类对象
StudentBiz biz = new StudentBiz();
biz.addStudent(stu1);
biz.addStudent(stu2);
biz.addStudent(stu3);
//展示信息
biz.show();
}
}

15. 字符串

15.1 概念

  • 使用 String 对象存储字符串
1
2
3
String s = "Hello World";
String s = new String();
String s = new String("Hello World");
  • 概念String 类位于 java.lang 包中,具有丰富的方法

15.2 String方法

  1. 字符串长度:length()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Test{
public static void main(String[] args){
String str = "教育改变生活";
String s = new String("你好");
System.out.println(s);

//查看String字符串中的一些方法
//1、字符串长度 length()
System.out.println("字符串的长度是:"+str.length());
Scanner input = new Scanner(System.in);
System.out.println("请输入密码");
String pwd = input.next();
if(pwd.length()<6){
System.out.println("密码长度不能小于6位");
}
}
}
1
2
3
4
源码
public int length(){
}
字符串标识符.length();
  1. 字符串比较 ==与equals
1
2
3
4
5
6
7
8
9
//2、判断两个字符串是否相等,使用equals(),返回的结果是boolean类型,true或者false== 用来比较两个整型类型的值是否相等
String num1 = "张三";
String num2 = "张三";
System.out.println(num1.equals(num2));
String a1 = "10";
String a2 = "20";
System.out.println("拼接字符串:"+(a1+a2));
//如果想要a1和a2的结果相加,则需要将字符串类型的值转换成int类型的值
System.out.println("结果是:"+(Integer.parseInt(a1)+Integer.parseInt(a2)));

注意:

**equals(): ** 检查组成字符串内容的字符是否完全一致

==: 判断两个字符串在内存中的首地址,即判断是否是同一个字符串对象

  1. 字符串转换大小写 toLowerCase()和toUpperCase()
1
2
3
4
5
//3、转大写和转小写
String name = "Hello World";
System.out.println(name);
System.out.println("转小写:"+name.toLowerCase());
System.out.println("转大写:"+name.toUpperCase());
  1. 忽略大小写 :equalsIgnoreCase
1
2
3
4
5
6
7
8
9
public class Test02 {
public static void main(String[] args) {
String pwd = "HelloWorld";
Scanner input = new Scanner(System.in);
System.out.println("请输入密码");
String password = input.next();
System.out.println("忽略大小写的方法:"+pwd.equalsIgnoreCase(password));
}
}
  1. 连接字符串,使用+或者concat方法
1
2
3
4
5
6
//拼接字符串的方法
String a = "教育";
String b = "改变生活";
System.out.println(a+b);//使用+号
String c = a.concat(b);//使用concat方法
System.out.println(c);
  1. 提取字符串的方法indexof()
1
2
3
4
5
6
7
String name = "阿里巴巴软件开发工程师巴";
String wei = "巴";
int num = name.indexOf(wei);
System.out.println("位置是:"+num);

int n = name.lastIndexOf(wei);
System.out.println("位置是:"+n);
方 法 说 明
public int indexOf ( int ch ) 搜索第一个出现的字符 ch (或字符串 value
public int indexOf (String value)
public int lastIndexOf ( int ch ) 搜索最后一个出现的字符 ch (或字符串 value
public int lastIndexOf (String value)

注: 返回出现第一个匹配的位置如果没有找到字符或字符串,则返回 -1

  1. 截取字符串的方法 substring(int beginindex,int endindex)
1
2
3
4
String result = name.substring(3, 7);
System.out.println("截取后:"+result);
//从3开始截取到最后一位
System.out.println(name.substring(3));
方 法 说 明
public String substring ( int index) 提取从位置索引开始的字符串部分
public String substring ( int beginindex , int endindex ) 提取 beginindex endindex 之间的字符串部分
public String trim () 返回一个前后不含任何空格的调用字符串的副本

注: beginindex : 字符串的位置从 0 开始算; endindex : 字符串的位置从 1 开始算

  1. 字符串拆分 split
1
2
3
4
5
6
//拆分字符串
String strs = "打游戏;逛街;看电影;下棋";
String[] array = strs.split(";");
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
  1. 去空格 trim()
1
2
3
4
5
//去空格
String it = "张小海 ";
//去掉空格后
String its = it.trim();
System.out.println("使用trim()后的结果是:"+"张小海".equals(its));

15.3 StringBuffer类

定义:StringBuffer是String的增强版

​ 对字符串频繁修改(如字符串连接)时,使用StringBuffer类可以大大提高程序执行效率。

创建对象

1
2
StringBuffer sb = new StringBuffer();
StringBuffer sb = new StringBuffer("aaa");
  1. 字符串拼接 append
1
2
3
4
5
6
7
8
//起到一个拼接的作用拼接效率比String使用+拼接效率高上百倍乃至上千倍
StringBuffer sb = new StringBuffer();
sb.append("今天周一");
sb.append("中午吃盖饭");
System.out.println(sb);
//将其他类型的值转换成字符串类型的值toString();
String str = sb.toString();
System.out.println(str);
  1. 字符串插入
1
2
3
4
5
6
7
8
9
10
11
12
public class Test05 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入一串数字: ");
String nums = input.next();
StringBuffer str=new StringBuffer(nums);
for(int i=str.length()-3;i>0;i=i-3){
str.insert(i,',');
}
System.out.print(str);
}
}

项目案例:吃货联盟订餐系统

1. 技能点

  • 顺序结构
  • 选择结构
  • 循环结构
  • 数组
  • 类和对象
  • 方法

2. 开发流程

  • 需求

  • 设计

  • 开发

  • 测试

  • 部署

  • 用户培训

3. 系统概述

只要动动手指,就能送餐上门”,网上定餐深受现代人青睐,现开发一个网上订餐系统,功能如下

  • 我要订餐
  • 查看餐袋
  • 签收订单
  • 删除订单
  • 我要点赞
  • 退出系统

4. 需求说明

初始化菜品信息

菜品名称 单价 点赞数
红烧带鱼 38.0 0
鱼香肉丝 20.0 0
时令鲜蔬 10.0 0

初始化订单信息

订餐人 所订餐及份数 日期 送餐地址 状态 价格
张晴 红烧带鱼 2****份 3 天成路207 1 76.0
张晴 鱼香肉丝 2****份 10 天成路207 0 45.0

5. 思路分析

  • **创建项目: ** OrderingMgr

  • 创建类: OrderingSet,添加订单的6个属性

  • 创建类: OrderingUtil,添加方法initial()

    • 初始化3个菜品信息
    • 初始化两条订单信息**

6. 代码分析

定义订单类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class OrderingSet {
//订单人姓名
public String name;
//所选信息
public String dishMegs;
//送餐时间
public int times;
//送餐地址
public String address;
//订单状态
public int states;
//订单总金额
public double sumPrices;
}

定义菜品信息类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
public class OrderingUtil {
//菜品名称
public String disName;
//菜品单价
public double prices;
//点赞数
public int praiseNums;

//创建订单类型的对象数组,用来保存所有的订单
OrderingSet[] sets = new OrderingSet[4];
//创建菜品类型的对象数组,用来保存所有的菜品
OrderingUtil[] utils = new OrderingUtil[4];
Scanner input = new Scanner(System.in);

//通过循环的方法添加订单和菜品,写两个方法
//添加订单的方法
public void addOrderSet(OrderingSet set){
for (int i = 0; i < sets.length; i++) {
if(sets[i] == null){
sets[i] = set;
break;
}
}
}
//向数组添加菜品信息的方法
public void addOrderUtil(OrderingUtil util){
for (int i = 0; i < utils.length; i++) {
if(utils[i] == null){
utils[i] = util;
break;
}
}
}
//开始执行业务流程菜单
public void start(){
do{
System.out.println("***********************************");
System.out.println("1.我要订餐");
System.out.println("2.查看餐带");
System.out.println("3.签收订单");
System.out.println("4.删除订单");
System.out.println("5.我要点赞");
System.out.println("6.退出");
System.out.println("***********************************");
System.out.println("请选择:");
int choose = input.nextInt();
switch(choose){
case 1:
addFood();
break;
case 2:
disPlay();
break;
case 3:
signOrder();
break;
case 4:
deleteOrder();
break;
case 5:
dianZan();
break;
case 6:
System.out.println("谢谢使用,再会");
return;
default:
System.out.println("输入错误,请重新输入");
break;
}
}while(true);
}
//1、我要订餐
public void addFood(){
System.out.println("*********我要订餐********");
boolean flag = false;
//判断订单类型的数组中属否有空位置
//如果有,则可以继续订餐,如果没有,则提示餐带已满。
for (int i = 0; i < sets.length; i++) {
if(sets[i] == null){
flag = true;
System.out.println("请输入订餐人姓名:");
String name = input.next();
//循环输出所有的菜品
System.out.println("序号\t菜名\t单价\t点赞数");
for (int j = 0; j < utils.length; j++) {
if(utils[j]!=null){
System.out.println((j+1)+"\t"+utils[j].disName+"\t"+utils[j].prices+"元\t"+utils[j].praiseNums+"赞");
}
}
System.out.println("请选择您要点的菜品编号");
int nums = input.nextInt();

System.out.println("请输入您要点的份数");
int fenShu = input.nextInt();

//通过编号减1可以得到数组中的具体的对象
//sumMoney是总价钱
double sumMoney = utils[nums-1].prices*fenShu;
/*double songMoney;
if(sumMoney>50){
songMoney = 0;
}else{
songMoney = 5;
}*/
//也可以通过三元运算符的方式。
double songMoney = sumMoney > 50 ? 0:5;
System.out.println("请输入送餐时间:");
int times = input.nextInt();
while(times>20||times<10){
System.out.println("您输入的时间不再配送范围时间内,请重新输入");
times = input.nextInt();
}
System.out.println("请输入送餐地址");
String address = input.next();
//创建一个订单对象
sets[i] = new OrderingSet();
sets[i].name = name;
sets[i].address = address;
sets[i].times = times;
sets[i].dishMegs = utils[nums-1].disName;//把菜品名称赋给所选信息
sets[i].sumPrices = sumMoney + songMoney;
sets[i].states = 0;//已预订
break;
}
}
if(!flag){
System.out.println("对不起,您的餐带已满,不能继续订餐");
}
}
//2、查看餐带
public void disPlay(){
System.out.println("*****查看餐带****");
System.out.println("序号\t订餐人\t餐品信息\t送餐日期\t送货地址\t\t总金额\t订单状态");
for (int i = 0; i < sets.length; i++) {
if(sets[i]!=null){
//String state = "";
/*if(sets[i].states == 1){
state = "已完成";
}else{
state = "已预订";
}*/
String state = sets[i].states == 1?"已完成":"已预订";
System.out.println((i+1)+"\t"+sets[i].name+"\t"+sets[i].dishMegs+"\t "+sets[i].times+"点\t"+sets[i].address+"\t"+sets[i].sumPrices+"\t "+state);
}
}
}
//3、签收订单
public void signOrder(){
System.out.println("请输入您要签收的订单编号");
int signId = input.nextInt();
boolean flag = false;

for (int i = 0; i < sets.length; i++) {
if(sets[i]!=null&&sets[i].states==0&&signId == (i+1)){
flag = true;
sets[i].states = 1;
System.out.println("您的订单已经签收成功");
}else if(sets[i]!=null&&sets[i].states==1&&signId == (i+1)){
flag = true;
System.out.println("对不起,您的订单已经签收,不能再次签收");
}
}

if(flag == false){
System.out.println("对不起,您输入的订单编号不存在");
}
}
//4、删除订单
public void deleteOrder(){
//删除前先查看一下所有的餐带
disPlay();
System.out.println("请输入要删除的订单编号");
int signId = input.nextInt();
boolean flag = false;
//___ ____ ____ ____
//通过循环删除订单,预定的订单不能删除,已完成的订单可以删除
for (int i = 0; i < sets.length; i++) {
if(sets[i]!=null&&sets[i].states == 1&&signId == (i+1)){
flag = true;
//将这个位置置空
sets[i]=null;
//将后面的值向前移动
sets[i] = sets[i+1];
//将移动后的下一个元素置空
sets[i+1] = null;
System.out.println("删除成功");
disPlay();
}else if(sets[i]!=null&&sets[i].states == 0&&signId == (i+1)){
System.out.println("对不起,预定状态下的订单不能删除");
flag = true;
}
}

if(flag == false){
System.out.println("对不起,您输入的订单编号不存在");
}

}
//5、我要点赞
public void dianZan(){
//循环输出所有的菜品
System.out.println("序号\t菜名\t单价\t点赞数");
for (int j = 0; j < utils.length; j++) {
if(utils[j]!=null){
System.out.println((j+1)+"\t"+utils[j].disName+"\t"+utils[j].prices+"元\t"+utils[j].praiseNums+"赞");
}
}

System.out.println("请输入要点赞的菜品编号");
int nums = input.nextInt();
//在原有基础上加1
//utils[nums-1].praiseNums = utils[nums-1].praiseNums + 1;
utils[nums-1].praiseNums++;

//循环输出所有的菜品
System.out.println("序号\t菜名\t单价\t点赞数");
for (int j = 0; j < utils.length; j++) {
if(utils[j]!=null){
System.out.println((j+1)+"\t"+utils[j].disName+"\t"+utils[j].prices+"元\t"+utils[j].praiseNums+"赞");
}
}
}
}

定义测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
public class OrderingMgr {
public static void main(String[] args) {
//1、准备订单信息测试数据,两条
OrderingSet set1 = new OrderingSet();
set1.name = "王有志";
set1.dishMegs = "鱼香肉丝";
set1.times = 12;
set1.address = "邯郸市鹏泰大厦";
set1.sumPrices = 76;
set1.states = 1;//1表示已完成 0表示已预订

OrderingSet set2 = new OrderingSet();
set2.name = "张晓海";
set2.dishMegs = "红烧带鱼";
set2.times = 1;
set2.address = "邯郸市鹏泰大厦";
set2.sumPrices = 60;
set2.states = 0;//1表示已完成 0表示已预订

//2、准备菜品信息测试数据,3条
OrderingUtil util1 = new OrderingUtil();
util1.disName = "鱼香肉丝";
util1.prices = 38;
util1.praiseNums = 1;

OrderingUtil util2 = new OrderingUtil();
util2.disName = "红烧带鱼";
util2.prices = 50;
util2.praiseNums = 2;

OrderingUtil util3 = new OrderingUtil();
util3.disName = "宫保鸡丁";
util3.prices = 29;
util3.praiseNums = 0;

//3、创建OrderingUtil对象,将数据保存到对象数组中
OrderingUtil u = new OrderingUtil();
//把订单存数组
u.addOrderSet(set1);
u.addOrderSet(set2);
//把菜品存数组
u.addOrderUtil(util1);
u.addOrderUtil(util2);
u.addOrderUtil(util3);
//调用开始的方法,执行业务
u.start();
}
}