一、初识Java

1.1 Java语言概述

Java语言发展史

詹姆斯•高斯林（James Gosling）1977年获得了加拿大卡尔加里大学计算机科学学士学位，1983年获得了美国卡内基梅隆大学计算机科学博士学位，毕业后到IBM工作，设计IBM第一代工作站NeWS系统，但不受重视。后来转至Sun公司，1990年，与Patrick，Naughton和Mike Sheridan等人合作“绿色计划”，后来发展一套语言叫做“Oak”，后改名为Java。
JDK的历史(Java Development Kit)

1.0 - 1.1 - 1.2 - 1.3 - 1.4 - 1.5
5.0 - 6.0 - 7.0 - 8.0……
Sun公司于1995年推出
1991年sun公司James Gosling等人开始开发Oak语言
1994年，将Oak语言更名为Java
1996年获得第一笔投资1亿元
1998年提出jdk1.2【GUI】
之后推出jdk1.3 jdk1.4【反射】
2005年重新更名为jdk5.0，进行了大幅的版本改进
2006年sun公司宣布将Java作为免费软件对外发布
2007年3月起，全世界所有的开发人员均可对Java源代码进行修改
2007年推出jdk6.0
2009年4月Oracle以74亿美元收购了sun公司
2011年7月由Oracle正式发布jdk7
2014年3月正式发布了java8
2017年9月正式发布了java9【短期支持】
2018年3月正式发布了java10【短期支持】
2018年9月正式发布了java11
1.8是企业主流使用的版本【LTS版本-longTimeService版本】

Java语言平台版本

J2SE/JAVASE — Standard Edition—标准版/基础版
开发普通桌面和商务应用程序提供的解决方案，该技术体系是其他两者的基础。
J2EE/JAVAEE — Enterprise Edition— 企业版/商务版
是为开发企业环境下的应用程序提供的一套解决方案，主要针对于企业级应用程序开发。
J2ME/JAVAME — Micro Edition — 微型版/移动版
是为开发移动设备和嵌入式设备(电器、机器人、机顶盒…)提供的解决方案。Java不是不侧重，而是分支出安卓。

Java语言特性

简单性安全性面向对象高性能编译性解释性分布式处理健壮性开源跨平台
什么是跨平台性？
通过Java语言编写的应用程序在不同的系统平台上都可以运行,那原理是什么？

我们所写的JAVA程序是".java"为后缀的源文件,但这些文件计算机无法直接执行，需要先进行编译环节,通过编译变为以".class"为后缀的字节码文件,这个字节码文件交由JVM(JAVA虚拟机)来运行.

那我们只要在需要运行java应用程序的OS(操作系统)上，安装一个JVM,由JVM来负责Java程序在该系统中的运行即可。不同的OS(操作系统)都有与之对应的JVM,所以只需要写一个Java程序,就可以在多个不同的操作系统上执行。这样就实现了Java程序的跨平台性。也称为Java具有良好的可移植性。

注意JVM是Java语言能够跨平台的前提,但是JVM本身不跨平台

1.2 HelloWorld 案例

记事本方式

1 新建一个java文件

文件后缀名为.java
HelloWorld.java

2 记事本打开文件，编写代码

 public class HelloWorld{public static void main(String[] args){System.out.print("HelloWorld");}}

3 编译javac java文件名，生产一个class文件

注意：文件路径与文件名
4 运行class文件，java class文件名

IDEA创建HelloWorld

1 创建项目

2 创建类

1.3 运行原理

我们编写的文件是以”.java”为后缀的源代码文件,Ctrl+S保存时会触发编译器idea对写好的代码进行编译,
编译后生成以”.class”为后缀的字节码文件,当Ctrl+F11运行代码时,JVM就会加载字节码文件, 并加载main方法执行程序, 进而在控制台显示代码效果

1.4 案例解析

/***public --公共的，作为类的修饰符*class --类，用于定义类的一个特殊的单词*HelloWorld --类名，驼峰命名法，每个单词的首字母大写*{ } -- 类的主体内容*注意:{} () "" 都是成对出现的,而且都是英文符号*/
public class HelloWorld {/*** public static void main(String[] args) {}--入口函数的标准写法* public --公共的，作为main()的修饰符* static --静态的* void --空，无，表示这个方法没有返回值* main --方法名* () --表示这是一个方法* String[] args--main()的固定写法* {} -- 方法的主体内容*/public static void main(String[] args) {/*** System --系统，表示要发出一个系统指令* out -- 向外输出* println() --如何输出/输出的方式：输出后换行* print() --如何输出/输出的方式：输出后不换行* "Hello world!"--向控制台输出的具体内容* ;表示结束符*/System.out.println("Hello World !");}
}

1.5 基础语法

标识符

标识符可以简单的理解成一个名字。
在Java中，我们需要给代码中的很多元素起名，包括类名、方法名、字段名、变量名等等。我们给对应元素起的名称就被称为标识符，一个正确的标识符需要遵循以下规则：

标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符
不能以数字开头。如：123name 就是不合法
标识符严格区分大小写。如: tmooc 和 tMooc 是两个不同的标识符
标识符的命名最好能反映出其作用，做到见名知意。
标识符不能是Java的关键字

关键字

在Java中,有一些单词被赋予了特定的意义,一共有50个关键字。
这50个单词都是全小写,其中有两个保留字:const和goto。
注意,关键字不能被用作标识符！

需要注意的是，除了上述的50个关键字以外，true,false,null也不可以被用作标识符~

注释

几乎所有编程语言都允许程序员在代码中输入注释
因为编译器会忽略注释,所以注释并不会影响程序的运行结果。
注释的真正作用是：它可以向任何阅读代码的人描述或者解释程序的实现思路,如何使用以及其它任何相关信息，提高代码的可读性,方便后期的维护与复用。
Java的注释有3种:

单行注释: 注释单行内容.
格式: 每行都以”//”开头.
快捷方式: Ctrl+/ 添加注释,同样的快捷键,再按一次取消注释
多行注释：注释多行内容,虽然叫多行注释,也可注释单行内容.
格式: 以” /* ”开头，以” * / ”结束.
快捷方式: 可以输入” /* ”之后按回车添加注释
文档注释: 一般用来注释类和方法,通过注释内容来记录类或者方法的信息.
格式: 以” /** ”开头。以” * / ”结尾
快捷方式: 输入 “ /** ” 之后按回车添加注释

二、变量、数据类型和运算符

2.1 变量

在JAVA中，我们需要记录一些数据
但这些数据的值是不固定的，总在变，我们可以把这些数据理解为变量。
我们通过三个元素来描述变量：变量类型变量名以及变量值。
定义变量的两种格式：
格式一：声明变量时并且赋值：int age = 18;
格式二：先声明变量：String tel ; 然后给变量赋值：tel = 119;

变量名必须是一个有效的标识符
变量名不可以使用java关键字
变量名不能重复

2.2 数据类型

基本类型介绍(八种)

变量要保存值，这个值是存在内存中的，所以就需要向内存申请存储空间
java是一个强类型的语言
为了方便内存管理系统根据变量类型更加合理的分配内存空间
会把我们常见的数据,分成不同类型
不同类型分配的内存大小是不同的，这个大小的单位就是字节Byte

拓展：常用的转换关系:
位 bit，来自英文bit，音译为“比特”，表示二进制位。
1 Byte = 8 Bits (1字节 = 8位)
1 KB = 1024 Bytes 1 MB = 1024 KB 1 GB = 1024 MB

练习：输出个人信息

需求: 在控制台打印: java讲师今年23岁，月薪3000，感慨java是世界上最好的语言

/**本类用于完成个人信息输出案例*/
public class Demo01 {//1.添加程序的入口函数main()public static void main(String[] args) {/**1.定义变量的规则：变量的类型  变量名  变量的值*//**2.String是字符串类型，用来保存多个字符*///2.定义变量String name = "哈哈"; //定义一个String变量用来保存姓名"哈哈"int age = 23; //定义一个age变量用来保存年龄23double salary = 3000.9;//定义一个变量salary用来保存工资//3.我们可以通过打印语句查看变量的值System.out.println(name);System.out.println("java讲师"+name+"，今年"+age+"岁，月薪"+salary+"，感慨Java是世界上最好的语言！");}
}

基本类型的类型转换

箭头开始的地方是小类型,箭头指向的地方是大类型
我们此处所指的"大"和"小",指的是对应类型的取值范围,不是字节数。

小到大(隐式转换)

byte m = 120;
int n = m;//小转大,右面的m是小类型,给左面的n大类型赋值,可以直接使用
float f = 3.2f; double d = f; -->可以执行

大到小(显式转换)

int x = 999;
byte y =(byte)x;//大转小,右面x给左面的y小类型赋值,不可以,需要强制类型转换

转换过程中可能导致溢出或损失精度例如：int i =128; byte b = (byte)i; //打印的结果是-128 因为
byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。
浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入
例如：float f = 32.7f; int a2 =(int) f; //打印的结果是32
不能对boolean类型进行类型转换。

口诀

2.3 运算符

概述

运算符用于连接表达式的操作数，并对操作数执行运算。
例如，表达式num1+num2，其操作数是num1和num2，运算符是”+”。
在java语言中，运算符可分为5种类型：
算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符。
根据操作数的不同，运算符又分为单目运算符、双目运算符和三目运算符。
单目运算符只有一个操作数，双目运算符有两个操作数，三目运算符则有三个操作数。
位运算符涉及到二进制位的运算，在java 程序中运用不是很多。

运算符速查表

练习：求圆形的面积

需求:求出指定半径圆的面积
公式:圆的面积：π * r * r

import java.util.Scanner;public class Demo02 {//1.创建程序的入口函数main()public static void main(String[] args) {/**等号右边的值赋值给等号左边的变量来保存*///1.提示用户输入圆的半径：System.out.println("请您输入要求的半径值：");/**变量的第二种定义方式：先定义，再赋值*///2.1定义一个变量用来保存圆的半径//double r = 5.5;double r ;//2.2接收用户在键盘上输入的数据，并把这个数据交给r保存//开启扫描(发出一个系统指令，准备接收控制台输入的数据)//nextDouble()控制用户只能输入double类型的数据，否则报错r = new Scanner(System.in).nextDouble();//根据半径值求出圆的面积double circleArea = 3.14 * r * r;//打印计算的结果System.out.println("圆的面积是："+circleArea);}
}

练习：测试自增自减

/**本类用于测试取余运算符*/
public class Demo03 {//0.创建程序的入口函数mainpublic static void main(String[] args) {//1.测试除法与取余数System.out.println(25 / 10);//2System.out.println(25 % 10);//5//2.练习1：获取一个两位数59的十位与个位int x = 59;System.out.println(x/10);//打印十位,5System.out.println(x%10);//打印个位,9//3.练习2：获取一个三位数159的百位、十位与个位int y = 159;System.out.println(y / 100);//打印百位System.out.println(y / 10 % 10);//打印十位System.out.println(y % 10);//打印个位//4.测试自增自减运算符/** 前缀式：符号在前：++a --a ,先改变变量本身的值，再使用，比如打印* 后缀式：符号在后:   a++ a--，先使用，再改变变量本身的值* ++:相当于给变量本身的值+1* --: 相当于给变量本身的值-1*/System.out.println("我是一个无情的分界线");/**普通的四则运算并不会改变变量本身的值*    自增自减运算符才会改变变量本身的值*/int z = 1;System.out.println(z+4);//5System.out.println(z);//1int a = 1;System.out.println(++a);//2System.out.println(a);//2int b = 1;System.out.println(b++);//1System.out.println(b);//2int c = 1;System.out.println(--c);//0,符号在前，先自减，再打印System.out.println(c);//0，上面已经自减过了int d = 1;System.out.println(d--);//1，符号在后，先打印，再自减System.out.println(d);//0,打印过后，自减成0//之前的代码会对后面的代码产生影响，c的值是0System.out.println(c);//0System.out.println(--c-c-c--);//1,-1-(-1)-(-1)=1System.out.println(c);//-2,经历了两次自减，所以0-2=-2}
}

练习：测试逻辑运算符

/**本类用于测试逻辑运算符*/
public class Demo04 {public static void main(String[] args) {/**与：全真才真*/System.out.println("测试单与：");System.out.println(true & true);System.out.println(true & false);System.out.println(false & true);System.out.println(false & false);System.out.println("测试双与：");System.out.println(true && true);System.out.println(true && false);System.out.println(false && true);System.out.println(false && false);/**或：全假才假*/System.out.println("测试单或：");System.out.println(true | true);System.out.println(true | false);System.out.println(false | true);System.out.println(false | false);System.out.println("测试双或：");System.out.println(true || true);System.out.println(true || false);System.out.println(false || true);System.out.println(false || false);}
}

练习：求两数的最大值

需求:接收用户输入的两个整数,并比较输出这两个数的最大值

import java.util.Scanner;public class Demo05 {public static void main(String[] args) {//1.提示用户输入System.out.println("请输入您要比较的第一个整数:");//2.接收用户输入的整数,并把这个值交给变量a来保存int a = new Scanner(System.in).nextInt();System.out.println("请输入您要比较的第二个整数:");int b = new Scanner(System.in).nextInt();//3.比较接收两个数,使用三元运算符/**1 ? 2 : 3* 1是表达式,若1的结果为true,结果取2位置,若1的结果为false,结果取3位置* *///4.定义变量max来保存比较的最大值int max = a > b ? a : b;//5.打印最大值System.out.println("两个数的最大值是:"+max);/**思考题:如何判断3个数的最大值? int max = a>b?(a>c?a:c):(b>c?b:c);*/}
}

总结1: 算术运算符之自增自减运算符

a是操作数，++是自增运算符，- -是自减运算符，自增和自减运算符即可以放在变量的前面，也可以放在变量的后面，例如：a++、++a、a- -、- -a等。
自增（++）：将变量的值加1
分前缀式（如++a）和后缀式（如a++）。前缀式是先加1再使用；后缀式是先使用再加1。
自减（- -）：将变量的值减1
分前缀式（如- -a）和后缀式（如a- -）。前缀式是先减1再使用；后缀式是先使用再减1。

总结2: 逻辑运算符

逻辑运算符连接两个关系表达式或布尔变量，用于解决多个关系表达式的组合判断问题
注意逻辑运算符返回的运算结果为布尔类型
通常，我们用0表示false，用1表示true
与：表示并且的关系
&单与： 1 & 2 ，结果想要是true，要求1和2都必须是true
&&双与(短路与)：1 && 2 ，当1是false时，2会被短路，提高程序的效率
或：表示或者的关系
|单或： 1 | 2，结果想要是true，要求1和2只要有一个为true就可以
||双或(短路或)：1 || 2，当1是true时，2会被短路，提高程序效率

总结3: 优先级控制

当一个表达式包含多个运算符时，就需要考虑运算符的优先级，优先级高的运算符先参与运算，优先级低的运算符后参与运算。在实际的开发中，不需要特别去记忆运算符的优先级别，也不要刻意的使用运算符的优先级别，对于不清楚优先级的地方使用小括号辅助进行优先级管理。

三、选择结构（if else）

练习：求平年闰年

需求:接收用户输入的年份,判断是平年还是闰年
如果年份是闰年,需要满足下面两个条件之一:
条件1:能被4整除,并且不能被100整除
条件2:能被400整除

import java.util.Scanner;public class demo06 {public static void main(String[] args) {//1.提示并接收用户输入的年份System.out.println("请输入您要判断的年份:");int year = new Scanner(System.in).nextInt();//2.定义一个变量用来保存结果String result = "平年";//默认值是平年,假设每年都是平年//3.判断用户输入的年份是否满足闰年的条件/**解决方案1*//**条件1:能被4整除,并且不能被100整除*/
//      if(year % 4 == 0) {//能被4整除
//          if(year %100 != 0) {//不能被100整除
//              result = "闰年";//符合闰年的条件1,修改结果为闰年
//          }
//      }
//      /**条件2:能被400整除*/
//      if(year % 400 == 0) {//能被400整除
//          result = "闰年";//符合闰年的条件2,修改结果为闰年
//      }/**解决方案2*//**判断结构 if(判断条件){满足判断条件以后执行的代码} *///if(条件1  || 条件2){是闰年 }//if((小条件1  && 小条件2) || 条件2){ 是闰年 }//if((能被4整除  && 不能被100整除) || 能被400整除){ 是闰年 }if((year % 4 == 0 && year %100 != 0) || year % 400 == 0){result = "闰年";//符合闰年的条件,修改结果为闰年}System.out.println(year+"年是"+result);}
}

练习：商品打折案例

需求: 接收用户输入的原价。满1000打9折;满2000打8折;满5000打5折

import java.util.Scanner;public class Demo07 {public static void main(String[] args) {//1.提示用户输入原价System.out.println("请输入商品原价:");//2.接收用户输入的原价double price = new Scanner(System.in).nextDouble();//3.计算打折后的价格//3.1定义变量用来保存打折后的价格double count = price;//初始值是商品的原价//3.2判断用户的打折段位并打折if(price >= 5000) {//满5000count = price *0.5;//打5折}else if(price >= 2000) {//满2000count = price * 0.8;//打折8折}else if(price >= 1000) {//满1000count = price *0.9;//打9折}
//      if(1000 <= price && price< 2000) {//          count = price *0.9;
//      }else if(2000 <= price && price < 5000) {//          count = price * 0.8;
//      }else if(price >= 5000) {//          count = price *0.5;
//      }//3.3输出用户实际支付的价格System.out.println("您实际应该支付:"+count);}
}

练习: 统计学员得分段位案例

需求：接收用户输入的成绩。成绩 90分及以上优秀；80-89 良好； 70-79 中等； 60-69 及格；60分及以下不及格

import java.util.Scanner;public class Demo08 {public static void main(String[] args) {//1.提示并接收学员的分数System.out.println("请输入你的分数：");int score = new Scanner(System.in).nextInt();/**为了增强程序的健壮性，如果用户输入的数据不符合规则，就结束*/if(score <0 || score >100 ) {System.out.println("输入数据不合法，请重新输入！！！");}else {//2.判断分数的段位，并输出结果if(score >= 90) {//大于90System.out.println("优秀！");//}else if(score>=80 && score <=89) {}else if(score>=80) {//[80,90)System.out.println("良好！");}else if(score>=70) {//[70,80)System.out.println("中等！");}else if(score>=60) {//[60,70)System.out.println("及格！");}else {//小于60System.out.println("不及格！");}}}
}

四、选择结构（switch case）

switch case 语句用来判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
当一个case成立，从这个case向后穿透所有case，包括default，直到程序结束或者遇到break程序才结束

练习：数字匹配

/*本类用于练习switch结构*/
/**总结：* 1.变量a的类型byte short char int String* 2.会拿着变量a的值依次与case后的值做比较，如果不加break,*        会向后穿透所有case,包括default* 3.如果设置了default“保底选项”，并且没有任何case匹配到的话，就执行default* 4.break与default是可选项，根据具体业务来决定加不加* */
public class Demo09 {//1.创建程序的入口函数mainpublic static void main(String[] args) {//2.定义一个变量int a = 19;//3.完成switch结构的测试switch(a) {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(0);}}
}

练习: Switch中的String类型

public class Demo10 {public static void main(String[] args) {String day = "星期五";switch(day) {case "星期一" : System.out.println("星期一吃四川火锅");break;case "星期二" : System.out.println("星期二吃齐齐哈尔烤肉");break;case "星期三" : System.out.println("星期三吃新疆羊肉串");break;case "星期四" : System.out.println("星期四吃阳澄湖大闸蟹");break;case "星期五" : System.out.println("星期五吃兰州拉面");break;case "星期六" : System.out.println("星期六吃南昌拌粉");break;case "星期日" : System.out.println("星期日吃武汉藕汤");break;default : System.out.println("想吃点啥吃点啥吧~");}}
}

switch结构的注意事项

switch 语句中的变量类型可以是： byte、short、int 、char、String(jdk1.7以后支持)
switch 语句可以拥有多个 case 语句
每个 case 后面跟一个要比较的值和冒号,且此值的数据类型必须与变量的数据类型一致
当变量值与 case 语句值相等时，开始执行此case
语句的内容,执行完会判断此行代码是否有break,如果有,结束执行,如果没有,会继续向后执行穿透所有case,包括default
switch 语句可以包含一个 default 分支，该分支一般是写在switch 语句的最后
如果在default之前的case有break,则default不会执行

五、循环结构（一）

循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构。
它由循环体中的条件，判断继续执行某个功能还是退出循环。
根据判断条件,循环结构又可细分为先判断后执行的循环结构和先执行后判断的循环结构。

5.1 循环结构while

形式(先判断,再执行)

练习：猜数字之while练习

package cn.huo.xh;import java.util.Random;
import java.util.Scanner;public class Demo01_WhileTest {public static void main(String[] args) {//让程序产生一个随机数//java.util.Random,注意导包,快捷键:Ctrl+Shift+Oint r = new Random().nextInt(100);//参数100是自定义的,此时生成的随机数范围是[0,100)的整数System.out.println("打个小抄:"+r);//1.写一个死循环while(true) {//死循环--需要设置程序的出口//2.接收用户输入的值System.out.println("猜猜看~");int input = new Scanner(System.in).nextInt();//3.判断是否猜对(拿用户猜的数字与生成的随机数做比较)if(input > r) {System.out.println("猜大了,继续猜猜看");}else if(input < r) {System.out.println("猜小了,继续努力");}else if(input == r) {System.out.println("猜对了!");//一定注意:要设置程序出口!!!break;}}}
}

5.2 循环结构 do-while

形式(先执行,再判断,循环体代码保证最少执行一次)

do-while练习

需求：在0-300的范围中生成一个随机数，打印每次生成的随机数，直到生成的随机数小于50，程序结束

import java.util.Random;public class Demo01_DoWhileTest {public static void main(String[] args) {int n;do {System.out.println("我是循环体");n = new Random().nextInt(300);//生成随机数的范围[0,300)System.out.println(n);}while(n>50);//循环条件  随机数n大于50 则继续生成随机数；直到随机数小于50结束循环}
}

需求：如果用户输入错误，可以重复输入直到输入正确，执行相应的操作后退出循环

import java.util.Scanner;public class Demo03_DoWhileTest2 {public static void main(String[] args) {System.out.println("欢迎使用MyShopping管理系统\n");System.out.println("*******************************");System.out.println("\t1.客 户 信 息 管 理");System.out.println("\t2.购 物 结 算");System.out.println("\t3.真 情 回 馈");System.out.println("\t4.注 销");System.out.println("*******************************\n");int choice;        //用户选择boolean isRight;  //输入是否正确System.out.print("请选择，输入数字：");Scanner input = new Scanner(System.in);do{isRight = true;choice = input.nextInt();if(choice == 1){System.out.println("执行客户信息管理");}else if(choice == 2){System.out.println("执行购物结算");}else if(choice == 3){System.out.println("执行真情回馈");}else if(choice == 4){System.out.println("执行注销");}else{System.out.print("输入错误，请重新输入数字：");isRight = false;}}while(!isRight);System.out.println("\n程序结束");}
}

六、循环结构（二）

6.1 for循环

练习：打印100次slogon/打印0到10/打印10到0/打印8,88,888,8888

public class Demo04_ForTest1 {public static void main(String[] args) {//需求:打印100次自己的宣言//for(开始条件;循环条件;更改条件){循环体;}for(int i = 1;i<=100;i++) {System.out.println("又不是没那条件，干就完啦！");}//需求:打印0到10//for(开始条件;循环条件;更改条件){循环体;}//0 1 2 3 4 5 6 7 8 9 10//从哪开始：0//到哪结束：10//怎么变化：+1 ++for(int i = 0;i<=10;i++) {System.out.println(i);}System.out.println("**********************");//需求:打印10到0//10 9 8 7 6 5 4 3 2 1 0//从哪开始：10//到哪结束：0//怎么变化：-1  --//for(开始条件;循环条件;更改条件){循环体}for(int i = 10 ;i >= 0;i--) {System.out.println(i);}//需求：打印8，88，888，8888,//8 88 888 8888//从何开始：8//到哪结束：8888//如何变化：*10+8for(int i =8 ; i <= 8888 ; i=i*10+8) {System.out.print(i+",");//使用的是print(),打印后不换行}}
}

练习:求[1,100]以内元素之和,偶数之和。

public class Demo05_ForTest2 {public static void main(String[] args) {/*需求：求出1-100以内所有偶数的和*///1.定义变量用来保存最终求和的结果int sum = 0;//2.创建循环，依次循环1-100范围内的数for(int i = 1;i <101;i++) {//3.过滤出来需要累加的偶数if(i%2 == 0) {//if(i%2 == 1) {//过滤奇数//4.能进来，说明是偶数，累加sum = sum +i;}}//5.在for循环结束以后，打印所有偶数累加的和System.out.println(sum);/*需求：求出1-100以内所有数的和*//*//1.定义一个变量用来保存求和的结果int sum = 0;//2.创建循环，依次循环1-100范围内的数for(int i = 1;i<=100;i++) {//3.将本轮循环到的数字累加到最终的结果中sum = sum + i;}//4.打印最终累加的结果System.out.println(sum);*/}
}

6.2 break与continue

break: 直接结束当前循环,跳出循环体,简单粗暴

break以后的循环体中的语句不会继续执行,循环体外的会执行
注意如果是嵌套for循环,在内层循环遇到了break,只会跳出当前这一层内循环

continue: 跳出本轮循环,继续下一轮循环

continue后本轮循环体中的语句不会继续执行,但是会继续执行下轮循环,循环体外的也会执行

练习：测试Break与Continue

需求：找数字88
提示并接受用户输入100次数字，如果不是88，则继续输入，找到88就结束

import java.util.Scanner;public class Demo06_BreakTest {public static void main(String[] args) {//循环体可以帮助我们执行重复的事情,控制for循环执行100次for(int i = 1;i <= 100; i++) {//在每一次循环中都要提示并接收用户输入的数字System.out.println("请输入数字:");int input = new Scanner(System.in).nextInt();if(input != 88) {//用户输入的不是88continue;//直接继续输入/**注意,不管是不是加continue,都可以在猜不对的情况下继续输入* 只不过加了continue后效率更高,只要数据不等于88,就无需执行后面的代码* 直接进行下一轮的猜数字即可* *//**break或者continue之后都不允许写代码,都是不可到达的代码*///System.out.println(0);//Unreachable code}System.out.println("用来测试continue有没有跳过循环后半部分代码");if(input == 88) {//找到88了System.out.println("恭喜您,猜对了!");break;//结束程序}}}
}

6.3 三种循环的区别

for：知道循环次数
while/do while：当循环次数不确定时
while：先判断，不符合规则，不执行代码
do while：代码最少被执行一次，再去判断，符合规则，再次执行代码
循环之间都可以互相替代,但是一般最好选择合适的循环结构来完成代码

七、指导学习:循环使用

–练习1–

需求：用户进入游戏平台后，可以选择喜爱的游戏
使用switch选择结构

–练习2–

–练习3–

–练习4–

–练习5–

需求：为了维护用户信息，需要将其信息录入系统中

用户的信息包括：用户编号、年龄、积分
要求年龄10岁以上

八、数组（重点）

8.1 概念

数组Array，标志是[ ] ,用于储存多个相同类型数据的集合
想要获取数组中的元素值，可以通过脚标（下标）来获取
数组下标是从0开始的,下标的最大值是数组的长度减1

8.2 创建数组

动态初始化
int[] a = new int[5];
静态初始化
int[] b = new int[]{1,2,3,4,5};
int[] c = {1,2,3,4,5};

8.3 创建数组过程分析

程序创建数组 int[] a = new int[5]; 时发生了什么?
在内存中开辟连续的空间,用来存放数据,长度是5
给数组完成初始化过程,给每个元素赋予默认值,int类型默认值是0
数组完成初始化会分配一个唯一的地址值
把唯一的地址值交给引用类型的变量a去保存

数组名是个引用类型的变量,它保存着的是数组的地址,不是数组中的数据

8.4 数组的长度

数组的长度用 length属性来表示,数组一旦创建，长度不可改变
数组的长度允许为0

8.5 练习：向数组中存入数据hello

import java.util.Arrays;public class Demo01 {public static void main(String[] args) {//1.创建数组//1.1静态创建--创建的时候已经知道了每一个元素的值char[] c1 = {'h','e','l','l','o'};char[] c2 = new char[] {'h','e','l','l','o'};//1.2动态创建--知道了数组的长度，后面再具体赋值char[] c3 = new char[5];//在内存中开辟一块连续的内存空间，用来存放5个字符//1.2.2给c3数组动态的赋值/**我们通过数组的下标来操作数组中的每一个元素，注意数组下标从0开始*/c3[0] = 'h';//给数组中的第1个元素赋值c3[1] = 'e';//给数组中的第2个元素赋值c3[2] = 'l';//给数组中的第3个元素赋值c3[3] = 'l';//给数组中的第4个元素赋值c3[4] = 'o';//给数组中的第5个元素赋值//2.打印查看刚刚创建好的数组System.out.println(c1);System.out.println(c2);System.out.println(c3);//3.创建String类型的数组，存放数据"a","b","c"String[] s1 = {"a","b","c"};String[] s2 = new String[] {"a","b","c"};String[] s3 = new String[3];s3[0] = "a";//给s3数组的第1个元素赋值为"a"s3[1] = "b";//给s3数组的第2个元素赋值为"b"s3[2] = "c";//给s3数组的第3个元素赋值为"c"/**char类型的数组底层中做了处理，可以直接打印数组中的具体元素* 除了char类型以外的数组想要查看数组中的具体元素，需要使用数组的工具类Arrays* 具体方式：Arrays.toString(数组名);* 注意Arrays使用时需要导包*///4.打印创建好的数组System.out.println(s1);//打印出来的是数组的地址值System.out.println(Arrays.toString(s2));//5.查看数组的长度--数组中存放的元素的个数/**数组一旦创建，长度不可改变，如果想要增加/删除数组中的元素* 只能先创建一个新长度的数组，再将原来的数据复制过去*/System.out.println(c1.length);System.out.println(s1.length);}
}

8.6 数组的遍历

遍历:从头到尾,依次访问数组每一个位置,获取每一个位置的元素.形式如下:
我们通过数组的下标操作数组,所以for循环变量操作的也是数组下标

开始:开始下标0 结束:结束下标length-1 如何变化:++
for(从下标为0的位置开始 ; 下标的取值 <= 数组的长度-1 ; 下标++){
循环体;
}

8.7 练习(月天数；存1-10；随机数组)

练习1：输出每个月的天数

package cn.huo.test08;public class Demo02 {public static void main(String[] args) {//1.创建数组用来存12个月的天数int[] a = {31,28,31,30,31,30,30,31,30,31,30,31};//2.输出每个月的天数打印到控制台//数组的遍历--通过循环的方式--操作的是数组的下标//循环开始:a[0]--数组中的第一个元素//循环结束:a[a.length-1]--数组中的最后一个元素//如何变化:++//for(int i = 0 ; i <=a.length-1 ; i++) {for(int i = 0 ; i <a.length ; i++) {//a[i]--根据下标i来获取数组a中对应位置上元素的值System.out.println((i+1)+"月有:"+a[i]+"天");}}
}

练习2：遍历数组，存入1到10

import java.util.Arrays;public class Demo03 {public static void main(String[] args) {//1.创建数组--动态创建int[] a = new int[10];//2.遍历数组,依次给每个位置赋值//循环开始:a[0]--数组中的第一个元素//循环结束:a[a.length-1]--数组中的最后一个元素//如何变化:++for(int i = 0 ; i <= a.length-1 ; i++) {//a[i]--根据下标i来获取数组a中对应位置上元素的值a[i] = i+1;}//for循环结束//3.在存入10个数据之后,打印a数组System.out.println(a);//[I@15db9742//除了char类型的数组,其他类型的数组想要查看具体内容需要借助工具类Arrays//Arrays.toString(要打印的数组的名字)来查看数组中的具体内容System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]}
}

练习3：创建随机数组

import java.util.Arrays;
import java.util.Random;public class Demo04 {public static void main(String[] args) {//1.创建数组--动态int[] a = new int[10];//2.遍历数组,给数组中的每个元素赋值for(int i = 0 ; i <a.length ; i++) {//100是自定义的数据,表示生成的随机整数的范围是[0,100)a[i] = new Random().nextInt(100);//a[i] = new Random().nextInt(100)+1;//取值范围前后都+1-->[1,101)}//3.使用数组的工具类查看数组中的元素System.out.println(Arrays.toString(a));}
}

8.8 数组工具类Arrays

Arrays.toString(数组)

把数组里的数据,用逗号连接成一个字符串[值1,值2]

Arrays.sort(数组)

对数组进行排序,对于基本类型的数组使用的是优化后的快速排序算法,效率高
对引用类型数组,使用的是优化后的合并排序算法

package cn.huo.test08;import java.util.Arrays;public class Demo05 {public static void main(String[] args) {//1.创建无序数组int[] a = {21,96,75,23,25};//底层使用的排序算法是进行优化后的快速排序算法Arrays.sort(a);//对无序数组进行直接排序System.out.println(Arrays.toString(a));}
}

Arrays.copyOf(数组，新的长度)

把数组赋值成一个指定长度的新数组
新数组的长度大于原数组, 相当于复制,并增加位置
新数组的长度小于原数组, 相当于截取一部分数据

import java.util.Arrays;public class Demo06 {public static void main(String[] args) {//1.创建数组int[] from = {1,2,3,4,5};//数组一旦创建，长度不可改变//2.1 数组的普通复制/**copyOf()用于完成数组的复制，两个参数：* 参数1：要复制哪个数组* 参数2：新数组的长度*/int[] to = Arrays.copyOf(from, 5);System.out.println(Arrays.toString(to));//2.2数组的扩容/**扩容：给数组扩大容量，新数组的长度>原数组的长度* 扩容思路：先创建对应长度的新数组，每个位置上都是默认值0* 然后从原数组中将元素复制到新数组，没有被覆盖的元素还是默认值0*/int[] to2 = Arrays.copyOf(from, 10);System.out.println(Arrays.toString(to2));//2.3数组的缩容/**缩容：缩小数组的容量，新数组的长度<原数组的长度* 缩容思路：先创建对应长度的新数组，每个位置上都是默认值0* 然后从原数组中复制指定个数的元素到新数组中，类似于截取*/int[] to3 = Arrays.copyOf(from, 3);System.out.println(Arrays.toString(to3));//2.4指定首尾截取原数组中的元素/**copyOfRange()用于完成数组的截取，3个参数：* 参数1：要截取哪个数组【原数组】* 参数2：从原数组的哪个下标开始* 参数3：到原数组的哪个下标结束* 注意：截取的元素包含开始下标处的元素，不包含结束下标处的元素*/int[] to4 = Arrays.copyOfRange(from, 2, 4);System.out.println(Arrays.toString(to4));}
}

8.9 数组插入数据

有一组学员的成绩{99，85，82，63， 60}，将它们按升序排列。要增加一个学员的成绩，将它插入成绩序列，并保持升序

将成绩序列保存在长度为6的数组中
将该位置后的元素后移一个位置
将增加的学员成绩插入到该位置

import java.util.Arrays;
import java.util.Scanner;public class Demo07 {public static void main(String[] args) {//1.创建数组int[] from = {99,85,82,63,60};//数组一旦创建，长度不可改变//2 数组的扩容int[] to = Arrays.copyOf(from, from.length + 1);//3 输入新增成绩System.out.println("请输入新增成绩：");int cj=new Scanner(System.in).nextInt();//4 比较成绩找到要插入的位置int index=0; //存放要插入的下标for(int i=0;i<from.length;i++){if(from[i]<cj){index=i;break;}}System.out.println("插入成绩的下标是："+index);//5 依次移动插入位置后面的元素for(int i=to.length-1;i>index;i--){to[i]=to[i-1];}//6 插入数据to[index]=cj;System.out.println(Arrays.toString(to));}
}

–练习–

练习1：字符逆序输出

练习2：求最低价格
需求：定义数组存储价格，并利用循环输入。求出最低价格

练习3：向有序序列中插入字符
需求：一组有序的字符序列a、b、c、e、f、p、u、z，向次字符序列中插入一个新的字符，要求插入之后字符序列仍保持有序

九、循环结构进阶

9.1 二重循环（嵌套for循环）

存在至少2层for循环,根据外层的条件，判断里层能否执行
如果能执行，就把里层代码都循环完毕后，再继续判断是否执行外层循环的下一次循环

9.2 嵌套for循环案例一

public class Demo01 {public static void main(String[] args) {//执行顺序//执行外层循环第一轮，i=1,打印1，遇到内层循环，打印12345,i自增成2//执行外层循环第二轮，i=2,打印2，遇到内层循环，打印12345,i自增成3//执行外层循环第三轮，i=3,打印3，遇到内层循环，打印12345,i自增成4//i为4，不满足循环条件，循环结束/**总结：外层循环执行一次(控制轮数)* 内层循环执行多次(在每一轮中执行的次数)*/for(int i = 1; i<=3;i++) {//外层循环System.out.println("外层循环的第："+i+"轮");for(int j = 1; j <=5 ; j++) {//内层循环System.out.println("内层循环的第"+j+"次");}}System.out.println("**************打印矩形******************");//执行顺序分析：//外层第一轮i=1,遇到内层循环,打印*****,内层循环结束，换行，i自增成2//外层第二轮i=2,遇到内层循环,打印*****,内层循环结束，换行，i自增成3//外层第三轮i=3,遇到内层循环,打印*****,内层循环结束，换行，i自增成4//此时i的值为4，不符合循环条件，循环结束/**总结：外层循环控制的是行数* 内层循环控制的是每行打印的列数*/for(int i = 1;i<=3;i++) {for(int j = 1;j<=5;j++) {System.out.print("*");}System.out.println();//用空白行来换行}}
}

9.3嵌套for循环案例二

import java.util.Scanner;public class Demo02 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);for(int i=1;i<=3;i++){int score=0;System.out.println("请输入第"+i+"个班级的成绩");for (int j=1;j<=4;j++){System.out.print("第"+j+"个学员的成绩:");score += sc.nextInt();}double avg=score/4.0;System.out.println("第"+i+"个班级参赛学员的平均分是:"+avg+"\n");}}
}

–练习–

练习一

练习二

练习三

练习四

9.4 二重循环使用continue

需求：在嵌套for循环案例二的基础上，统计成绩大于等于85分学员数；使用continue；

public class Demo02 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int num=0;for(int i=1;i<=3;i++){int score=0;int sum=0;System.out.println("请输入第"+i+"个班级的成绩");for (int j=1;j<=4;j++){System.out.print("第"+j+"个学员的成绩:");score = sc.nextInt();sum+=score;if(score<85){continue;}num++;}double avg=sum/4.0;System.out.println("第"+i+"个班级参赛学员的平均分是:"+avg+"\n");}System.out.println("成绩85分以上的学员人数有"+num+"个");}
}

9.4 二重循环使用break

需求：使用break控制内层循环

public class Demo05 {public static void main(String[] args) {for (int i=1; i<=5;i++){for (int j=1;j<=5;j++){if(j>i){break;}System.out.print("*");}System.out.println();}}
}

十、复习、幸运抽奖

阶段1：实现菜单的输出显示

需求：

输出菜单
选择菜单编号，输出菜单信息
如果编号选择错误，输出“您的输入有误！”

阶段2：实现循环执行功能

需求：

系统询问用户是否继续
如果用户选择继续，则可以继续选择菜单，否则程序结束，退出系统

阶段3：实现注册

需求：

输入用户名和密码，系统产生4位随机数作为卡号。
注册成功，显示注册信息并修改注册标识为true
提示：
int vip=new Random().nextInt(9999-1000)+1000; //会员卡号

阶段4：实现登录功能

输入注册时的用户名和密码，登录成功，提示欢迎信息
如果用户名和密码输入错误，提示用户继续输入，最多有3次输入机会

阶段5：实现幸运抽奖

登录成功后，用户选择幸运抽奖菜单，进入幸运抽奖功能
输入会员卡号，系统生成5个4位随机数作为幸运数字
如果会员卡号是其中之一，则成为本日幸运会员；否则不是幸运会员

补充、局部变量，成员变量，方法

1 变量

1.1 概念

可以改变的数，称为变量。在Java语言中，所有的变量在使用前必须声明。
一般通过“变量类型变量名 = 变量值 ;”这三部分来描述一个变量。如:int a = 3 ;
变量的使用原则：就近原则,即尽量控制变量的使用范围到最小

1.2 局部变量

位置:定义在方法里或者方法的声明上
注意:必须手动初始化来分配内存.如:int i = 5;或者int i; i = 5;
生命周期:随着方法的调用而存在,方法运行完毕就释放了

1.3 成员变量

位置:定义在类里方法外
注意:不用初始化,也会自动被初始化成默认值
生命周期:整个类中,类消失了,成员变量才会释放

变量的默认值测试

package cn.oop.test;public class TestVariable {static String name;static byte b;//整数类型默认值都是0static short c;static int d;static long e;static float f;//小数类型的默认值是0.0static double g;static char j;//char类型的默认值是\u0000static boolean h;//boolean类型的默认值是falsepublic static void main(String[] args) {System.out.println(name);//null,引用类型的默认值System.out.println(b);System.out.println(c);System.out.println(d);System.out.println(e);System.out.println(f);System.out.println(g);System.out.println(h);System.out.println(j);System.out.println(h);}
}

局部变量与成员变量测试

package cn.oop.test;public class TestVariable2 {//2.定义成员变量://1)位置:类里方法外//2)无需手动初始化,会自动赋予对应类型的默认值//3)作用域:在整个类中生效,类消失,变量才会消失static int count;//3.变量有一个使用的原则:就近原则static int sum = 200;public static void main(String[] args) {//1.定义局部变量://1)位置:在方法里/局部代码块里//2)必须手动初始化//3)作用域:在方法/局部代码块中,对应的代码执行完局部变量就被释放int sum = 100;//定义在方法中的局部变量sumSystem.out.println(sum);//变量的就近原则:使用的都是自己附近的变量,100System.out.println(count);for (int i = 0; i < 10; i++) {//局部变量i只能在循环中使用System.out.println(i);}//System.out.println(i);//报错:无法引用变量i:i cannot be resolved to a variable}
}

1.4 成员变量与局部变量的区别

2 方法

2.1 概述

被命名的代码块,方法可以含参数可以不含参数,可以提高代码的复用性。

2.2 方法定义的格式

2.3 测试方法的调用顺序/参数/返回值

package cn.oop.test;public class TestMethod {public static void main(String[] args) {System.out.println(1);/**2.通过方法名+参数列表的方式来调用方法的功能*/method1();//调用method1()System.out.println(2);method2(3);//调用method2()int add = method3(1,2);//调用method3()System.out.println(add);}/**3.如果方法想要返回值,必须修改返回值类型* 并且return对应类型的结果* 如果方法的返回值类型是void,不允许有返回值* */public static int method3(int i, int j) {/**4.通过return关键字将方法结果返回到调用位置*/return i+j;}public static void method2(int a) {System.out.println("我是method2："+a);}/**1.方法的修饰符 方法的返回值类型 方法名(方法参数){方法体}*/public static void method1() {System.out.println("我是method1");}
}

2.4 方法的重载

方法的重载是指在一个类中定义多个同名的方法,但是每个方法的参数列表不同(也就是指参数的个数和类型不同),程序在调用方法时,可以通过传递给他们的不同个数和类型的参数来决定具体调用哪个方法.

2.5 测试方法的重载

package cn.oop.test;public class TestMethodOverload {public static void main(String[] args) {/**1.我们根据方法名+参数列表确定具体调用哪个方法*//**2.方法的重载:* 在同一个类中,存在方法名相同,但参数列表不同的方法* 如果在同类中,同名方法的参数个数不同,一定构成重载* 如果在同类中,同名方法的参数个数相同,* 需要查看对应位置上参数的类型,而不是参数名,与参数名无关* (int a,String b)与(int b,String a)--不构成重载* (int a,String b)与(String a,int b)--构成重载* *///2.调用method()method();//4.调用method(int)method(666);//6.调用method(int,String)method(888,"哈哈");}//1.创建一个无参的method()public static void method() {System.out.println("哈哈哈哈我没参数");}//3.创建一个method(int n)public static void method(int n) {System.out.println("哈哈哈哈我的参数是:"+n);}//5.创建一个method(int n,String s)public static void method(int a,String b) {System.out.println(b+"今晚要干他"+a+"碗大米饭");}public static void method(String a,int b) {System.out.println(b+"今晚要干他"+a+"碗大米饭");}
}

十一、面向对象、类和对象

11.1 面向对象

概念

面向过程是一种编程思想，它强调的是过程，意思是我们做任何事，都需要亲力亲为。
面向对象也是一种编程思想，相对于面向过程，我们的身份可以由原来问题的执行者变为指挥者，进而把生活中很多复杂的问题变得简单化。

面向对象的三大特征

封装: 把相关的数据封装成一个“类”组件
继承: 是子类自动共享父类属性和方法，这是类之间的一种关系
多态: 增强软件的灵活性和重用性

11.2 类和对象

类

Java语言最基本单位就是类，相当于类型。
类是一类事物抽取共同属性与功能形成的。
可以理解为模板或者设计图纸。
注意:类在现实世界并不存在,它只是一种对象的数据类型

对象

每个对象具有三个特点：对象的属性，对象的功能和对象的标识。

对象的属性用来描述对象的基本特征。
对象的功能用来描述对象的可以完成的操作。
对象的标识是指每个对象在内存中都有一个唯一的地址值用于与其他对象进行区分，类似于我们的身份证号。

类和对象的关系

我们先创建类，再通过类创建出对象
我们可以通过一个类创建出多个对象
类是抽象的，对象是具体的

11.3 案例1：类的创建使用

通过class关键字创建类，通过new关键字创建对象。

package cn.huo.test11;/**在一个java文件中可以写多个class`,但是,被public修饰的class只能有一个* 而且要求这个公共类的名字必须与文件的名字保持一致*/
public class TestCreateClass {public static void main(String[] args) {//4.创建汽车类的对象c1Car c1 = new Car();//5.通过汽车类对象调用汽车类的功能c1.start();c1.brake();//6.通过汽车类对象打印查看属性值System.out.println(c1.brand); //nullSystem.out.println(c1.price); //0.0System.out.println(c1.color); //null}
}//1.通过class关键字创建汽车类--用来描述汽车这一类事物--属性+功能
class Car{//2.定义汽车类的属性--用成员变量来描述--位置:类里方法外String brand; //品牌double price; //价格String color; //颜色//3.定义汽车类的功能--用方法来描述--格式:修饰符 返回值类型 方法名(参数列表){方法体}public void start(){System.out.println("汽车点火，启动");}public void brake(){System.out.println("汽车刹车");}}

11.4 案例1.2：创建多个对象

package cn.huo.test11;/**在一个java文件中可以写多个class`,但是,被public修饰的class只能有一个* 而且要求这个公共类的名字必须与文件的名字保持一致*/
public class TestCreateClass {public static void main(String[] args) {//4.创建汽车类的对象c1Car c1 = new Car();//5.通过汽车类对象调用汽车类的功能c1.start();c1.brake();//6.通过汽车类对象打印查看属性值System.out.println(c1.brand); //nullSystem.out.println(c1.price); //0.0System.out.println(c1.color); //nullSystem.out.println("================================");//7.创建汽车类的第2个对象c2Car c2=new Car();//8.通过c2对象,调用Car类的2个方法c2.start();c2.brake();//9.给c2对象的3个属性赋值c2.brand="奥迪A6L";c2.price=40.5;c2.color="黑色";//10.打印查看c2对象的3个属性值System.out.println("品牌："+c2.brand);System.out.println("价格(W)："+c2.price);System.out.println("颜色："+c2.color);//11.查看两个对象的地址值System.out.println(c1);System.out.println(c2);}
}//1.通过class关键字创建汽车类--用来描述汽车这一类事物--属性+功能
class Car{//2.定义汽车类的属性--用成员变量来描述--位置:类里方法外String brand; //品牌double price; //价格String color; //颜色//3.定义汽车类的功能--用方法来描述--格式:修饰符 返回值类型 方法名(参数列表){方法体}public void start(){System.out.println("汽车点火，启动");}public void brake(){System.out.println("汽车刹车");}}

11.5 案例2

创建School类

package cn.huo.test11;public class School {String schoolName; //中心名称int classNumber; //教室数目int labNumber;  //机房数目public void showCenter(){System.out.println(schoolName + "培训学员\n" + "配备："+ classNumber + "教" + labNumber + "机");}
}

创建对象

package cn.huo.test11;public class TestSchool {public static void main(String[] args) {//创建对象 类名 对象名=new 类名();School center = new School();System.out.println("初始化成员变量前");//引用类的方法：对象名.方法名()center.showCenter();//引用类的属性：对象名.属性center.schoolName="北京中心";center.classNumber=10;center.labNumber=10;System.out.println("\n初始化成员变量后");center.showCenter();}
}

11.6 案例3

创建学员类

package cn.huo.test11;public class Student {String name; //姓名int age;        //年龄String classNo; //班级String hobby;   //爱好public void show(){System.out.println(name + "\n年龄：" + age + "\n就读于：" +classNo + "\n爱好：" + hobby);}
}

创建教员类

package cn.huo.test11;public class Teacher {String name; //姓名String major;   //专业方向String courses;   //教授课程int schoolAge;    //教龄//输出信息方法public void show(){System.out.println(name + "\n专业方向：" + major +"\n教授课程：" + courses + "\n教龄：" + schoolAge);}
}

测试学员于教员类

package cn.huo.test11;public class TestStudentTeacher {public static void main(String[] args) {//创建学员对象Student student = new Student();student.name = "张浩";              //给各个属性赋值student.age = 10;student.classNo = "S1班";student.hobby = "篮球";student.show();                       //调用方法System.out.println("========分割线=========");//创建教员对象Teacher teacher = new Teacher();teacher.name = "王老师";               //给各个属性赋值teacher.major = "计算机";teacher.courses = "使用Java语言理解程序逻辑";teacher.schoolAge = 5;teacher.show();                      //调用方法}
}

十二、类的无参方法

12.1 编写电池类

创建电池类 Cell

package cn.oop.test12;public class Cell {String callType; //品牌//续电方法public void continued(){System.out.println(callType+"电池续电超级好");}
}

测试电池类 TestCell

package cn.oop.test12;public class TestCell {public static void main(String[] args) {Cell cell = new Cell(); //创建电池对象cell.callType="南孚"; //给品牌属性赋值cell.continued(); //调用续电方法}
}

12.2 计算平均分和总成绩

创建成绩类 Score

package cn.oop.test12;public class Score {double javaScore; //java成绩 double cScore; //c成绩double dBScore; //数据库成绩/* 计算成绩总分 */public double sum(){double sumScore=javaScore+cScore+dBScore;return sumScore;}/* 计算成绩平均分 */public double avg(){double sumScore=sum();return sumScore/3;}
}

测试计算成绩类 TestScore

package cn.oop.test12;import java.util.Scanner;public class TestScore {public static void main(String[] args) {Scanner input = new Scanner(System.in);Score s1 = new Score(); //创建对象System.out.print("请输入java成绩：");s1.javaScore=input.nextDouble(); //为java成绩属性赋值System.out.print("请输入C#成绩：");s1.cScore=input.nextDouble();  //为c成绩属性赋值System.out.print("请输入DB成绩：");s1.dBScore=input.nextDouble();  //为数据库成绩属性赋值System.out.println("总成绩是："+s1.sum()); //调用计算成绩总分方法System.out.println("平均成绩是："+s1.avg()); //调用计算成绩平均分方法}
}

12.3 编写手机类

创建手机类 Phone

package cn.oop.test12;public class Phone {/* 下载音乐方法 */public void download(){System.out.println("下载音乐中.....");}/* 播放音乐方法 */public void play(){System.out.println("播放刚刚好--薛之谦");}/* 电池续电方法 */public void reusingCell(){Cell cell = new Cell(); //创建电池类对象cell.continued();  //调用续电方法}
}

测试手机类 TestPhone

package cn.oop.test12;public class TestPhone {public static void main(String[] args) {Phone phone = new Phone(); //创建手机对象phone.download();  //调用下载方法phone.play();  //调用播放方法phone.reusingCell();  //调用续电方法}
}

12.4 定义管理员类

创建管理员类 Manager

package cn.oop.test12.homeWork;public class Manager {String name="admin";  //管理员用户名String password="123456";  //密码/* 打印管理员信息方法 */public String show(){return "管理员信息用户名为："+name+"  密码为："+password;}
}

测试管理员类 TestManager

package cn.oop.test12.homeWork;public class TestManager {public static void main(String[] args) {Manager m1 = new Manager();System.out.println(m1.show());}
}

12.5 实现菜单的级联效果

创建类 Menu

package cn.oop.test12.homeWork;import java.util.Scanner;public class Menu {/*** 显示登录菜单*/public void showLoginMenu(){System.out.println("\n\t欢迎使用我行我素购物管理系统\n");System.out.println("\t\t 1. 登 录 系 统\n");System.out.println("\t\t 2. 退 出\n");System.out.println ("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");System.out.print("请选择,输入数字:");}/*** 显示主菜单*/public void showMainMenu(){System.out.println("\n\t我行我素购物管理系统主菜单\n");System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n");System.out.println("\t\t 1. 客 户 信 息 管 理\n");System.out.println("\t\t 2. 真 情 回 馈\n");System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");System.out.print("请选择,输入数字或按0返回上一级菜单:");boolean con;do{con = false;/*输入数字，选择菜单*/Scanner input = new Scanner(System.in);int no = input.nextInt();if (no == 1){showCustMMenu();}else if (no == 2){showSendGMenu();}else if (no == 0){showLoginMenu();}else{System.out.print("输入错误, 请重新输入数字：");con = true;}}while(con);}/*** 显示客户管理菜单*/public void showCustMMenu(){System.out.println("\n\t我行我素购物管理系统 > 客户信息管理");System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n");System.out.println("\t\t  1. 显 示 所 有 客 户 信 息\n");System.out.println("\t\t  2. 添 加 客 户 信 息\n");System.out.println("\t\t  3. 修 改 客 户 信 息\n");System.out.println("\t\t  4. 查 询 客 户 信 息\n");System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");System.out.print("请选择,输入数字或按0返回上一级菜单:");/*输入数字，选择菜单*/boolean con;do{con = false;Scanner input = new Scanner(System.in);int no = input.nextInt();if(no == 1){System.out.println("执行显示所有客户信息");}else if(no == 2){System.out.println("执行添加客户信息");}else if(no == 3){System.out.println("执行修改客户信息");}else if(no == 4){System.out.println("执行查询客户信息");}else if(no == 0){showMainMenu();// 返回主菜单}else{System.out.print("输入错误, 请重新输入数字：");con = true;}}while(con);}/*** 显示真情回馈菜单*/public void showSendGMenu(){System.out.println("\n\t我行我素购物管理系统 > 真情回馈");System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n");System.out.println("\t\t 1. 幸 运 大 放 送\n");System.out.println("\t\t 2. 幸 运 抽 奖\n");System.out.println("\t\t 3. 生 日 问 候\n");System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");System.out.print("请选择,输入数字或按0返回上一级菜单：");boolean con;do{con = false;/*输入数字，选择菜单*/Scanner input = new Scanner(System.in);int no = input.nextInt();if(no == 1){System.out.println("执行幸运大放送");}else if(no == 2){System.out.println("执行幸运抽奖");}else if(no == 3){System.out.println("执行生日问候");}else if(no == 0){showMainMenu();  // 返回主菜单}else{System.out.print("输入错误,请重新输入数字：");con = true;}}while(con);}
}

测试Menu类 StartSMS

package cn.oop.test12.homeWork;import java.util.Scanner;public class StartSMS {public static void main(String[] args) {/*初始化系统管理员*/Manager manager = new Manager();boolean con=true;do{/*显示登录菜单*/Menu menu = new Menu();menu.showLoginMenu();/*实现菜单*/Scanner input = new Scanner(System.in);int choice = input.nextInt();switch(choice){case 1:/*密码验证*/System.out.print("请输入用户名：");String name = input.next();System.out.print("请输入密码：");String psw = input.next();if(name.equals(manager.name)&& psw.equals(manager.password)){System.out.println("@@登录成功："+manager.name+"@@");menu.showMainMenu();}else{System.out.println("@@您没有权限进入系统，请重新登录。@@");}break;case 2:System.out.println("谢谢您的使用！");con=false;break;}}while(con);}
}

十三、人机猜拳

13.1 创建用户类 Person

package cn.oop.test13;
import java.util.Scanner;public class Person {String name = "匿名";  // 名字int score = 0;         // 积分/*出拳方法*/public int showFist(){// 接收用户的选择Scanner input = new Scanner(System.in);System.out.print("\n请出拳:1.剪刀 2.石头 3.布 (输入相应数字) :");int show = input.nextInt();// 输出出拳结果，并返回switch(show){case 1:System.out.println("你出拳: 剪刀");break;case 2:System.out.println("你出拳: 石头");break;case 3:System.out.println("你出拳: 布");break;}return show;}
}

测试用户类 TestPerson

package cn.oop.test13;public class TestPerson {public static void main(String[] args) {Person p1 = new Person();int num = p1.showFist();System.out.println(num);}
}

13.2 创建计算机类 Computer

package cn.oop.test13;import java.util.Random;public class Computer {String name = "电脑"; // 名字int score = 0;;       // 积分/*出拳方法*/public int showFist(){// 产生随机数int show = new Random().nextInt(3)+1;  //产生随机数，表示电脑出拳// 输出出拳结果并返回switch(show){case 1:System.out.println(name+"出拳: 剪刀");break;case 2:System.out.println(name+"出拳: 石头");break;case 3:System.out.println(name+"出拳: 布");break;}return show;}
}

测试计算机类 TestComputer

package cn.oop.test13;public class TestComputer {public static void main(String[] args) {Computer c1 = new Computer();System.out.println(c1.showFist());}
}

13.3 创建游戏类 Game

package cn.oop.test13;
import java.util.Scanner;public class Game {Person person;       //玩家方Computer computer;   //机器方int count;           //对战次数/* 初始化 */public void initial(){person = new Person();computer = new Computer();count = 0;}/*开始游戏*/public void startGame() {initial();System.out.println("----------------欢 迎 进 入 游 戏 世 界----------------\n");System.out.println("\n\t\t******************");System.out.println  ("\t\t**  猜拳, 开始    **");System.out.println  ("\t\t******************");System.out.println("\n\n出拳规则：1.剪刀 2.石头 3.布");/*选择对方角色*/System.out.print("请选择对方角色（1：刘备 2：孙权 3：曹操）： ");Scanner input = new Scanner(System.in);int role = input.nextInt();if(role == 1){computer.name = "刘备";}else if(role == 2){computer.name = "孙权";}else if(role == 3){computer.name = "曹操";}System.out.print("你选择了"+computer.name+"对战");}
}

测试游戏类 TestGame

package cn.oop.test13;public class TestGame {public static void main(String[] args) {Game game = new Game();game.initial();game.startGame();}
}

13.4 实现一局对战

修改Game类

package cn.oop.test13;
import java.util.Scanner;public class Game {Person person;       //甲方Computer computer;   //乙方int count;           //对战次数/* 初始化 */public void initial(){person = new Person();computer = new Computer();count = 0;}/*开始游戏*/public void startGame() {initial();  // 初始化System.out.println("----------------欢 迎 进 入 游 戏 世 界----------------\n");System.out.println("\n\t\t******************");System.out.println  ("\t\t**  猜拳, 开始    **");System.out.println  ("\t\t******************");System.out.println("\n\n出拳规则：1.剪刀 2.石头 3.布");/*选择对方角色*/System.out.print("请选择对方角色（1：刘备 2：孙权 3：曹操）： ");Scanner input = new Scanner(System.in);int role = input.nextInt();if(role == 1){computer.name = "刘备";}else if(role == 2){computer.name = "孙权";}else if(role == 3){computer.name = "曹操";}System.out.println("你选择了 "+computer.name+"对战");/*开始游戏*/System.out.print("\n要开始吗？（y/n） ");String con = input.next();int perFist;   //用户出的拳int compFist;  //计算机出的拳if(con.equals("y")){/*出拳*/perFist = person.showFist();compFist = computer.showFist();/*裁决*/if(perFist == compFist){System.out.println("结果说:和局,真衰！\n");  //平局}else if((perFist == 1 && compFist == 3) || (perFist == 2  && compFist == 1) || (perFist == 3 && compFist == 2)){System.out.println("结果说： 恭喜， 你赢了！");  //用户赢}else{System.out.println("结果说:^_^,你输了，真笨!\n");  //计算机赢}}}
}

继续用TestGame类进行测试

13.5 实现循环对战，并累计得分

修改Game类

package cn.oop.test13;
import java.util.Scanner;public class Game {Person person;       //甲方Computer computer;   //乙方int count;           //对战次数/* 初始化 */public void initial(){person = new Person();computer = new Computer();count = 0;}/*开始游戏*/public void startGame() {initial();  // 初始化System.out.println("----------------欢 迎 进 入 游 戏 世 界----------------\n");System.out.println("\n\t\t******************");System.out.println  ("\t\t**  猜拳, 开始    **");System.out.println  ("\t\t******************");System.out.println("\n\n出拳规则：1.剪刀 2.石头 3.布");/*选择对方角色*/System.out.print("请选择对方角色（1：刘备 2：孙权 3：曹操）： ");Scanner input = new Scanner(System.in);int role = input.nextInt();if(role == 1){computer.name = "刘备";}else if(role == 2){computer.name = "孙权";}else if(role == 3){computer.name = "曹操";}System.out.println("你选择了 "+computer.name+"对战");/*开始游戏*/System.out.print("\n要开始吗？（y/n） ");String con = input.next();int perFist;   //用户出的拳int compFist;  //计算机出的拳while(con.equals("y")){/*出拳*/perFist = person.showFist();compFist = computer.showFist();/*裁决*/if(perFist == compFist){System.out.println("结果:和局,真衰！嘿嘿,等着瞧吧 !\n");  //平局}else if((perFist == 1 && compFist == 3) || (perFist == 2  && compFist == 1) || (perFist == 3 && compFist == 2)){System.out.println("结果： 恭喜， 你赢了！");  //用户赢person.score++;}else{System.out.println("结果说:^_^,你输了，真笨!\n");  //计算机赢computer.score++;}count++;System.out.print("\n是否开始下一轮（y/n）:  ");con = input.next();}}
}

继续用TestGame类进行测试

13.6 显示对战结果

修改Game类
在 startGame() 中 while循环外添加 showResult() 方法调用

在Game类中添加方法

/* 显示比赛结果 */public void showResult(){/*显示最后结果*/System.out.println("---------------------------------------------------");System.out.println(computer.name + "  VS  " + person.name);System.out.println("对战次数："+ count);/*显示对战结果*/int result = calcResult();if(result == 1){System.out.println("结果：打成平手，下次再和你一分高下！");}else if(result == 2){System.out.println("结果：恭喜恭喜！");   //用户获胜}else{System.out.println("结果：呵呵，笨笨，下次加油啊！");   //计算机获胜}System.out.println("---------------------------------------------------");}/* 计算比赛结果 */public int calcResult(){if(person.score == computer.score){return 1; // 战平}else if(person.score > computer.score){return 2; // 用户赢}else{return 3; // 电脑赢}}

继续用TestGame类进行测试

13.7 显示用户与机器得分

修改 Game 类中 showResult() 方法

public void showResult(){/*显示最后结果*/System.out.println("---------------------------------------------------");System.out.println(computer.name + "  VS  " + person.name);System.out.println("对战次数："+ count);//显示最终的得分System.out.println("\n姓名\t得分");System.out.println(person.name+"\t"+person.score);System.out.println(computer.name+"\t"+computer.score+"\n");//显示对战结果int result = calcResult();if(result == 1){System.out.println("结果：打成平手，下次再和你一分高下！");}else if(result == 2){System.out.println("结果：恭喜恭喜！");   //用户获胜}else{System.out.println("结果：呵呵，笨笨，下次加油啊！");   //计算机获胜}System.out.println("---------------------------------------------------");}

用TestGame类进行测试

十四带参数的方法

14.1 榨汁机

创建榨汁机类 ZhaZhiJi

package cn.oop.test14;public class ZhaZhiJi {/* 榨汁方法 */public String zhaZhi(String fruit){String juice=fruit+"汁";return juice;}
}

测试榨汁机类 TestZhaZhiJi

package cn.oop.test14;public class TestZhaZhiJi {public static void main(String[] args) {ZhaZhiJi z1 = new ZhaZhiJi();String pg = z1.zhaZhi("苹果");System.out.println(pg);String bl = z1.zhaZhi("菠萝");System.out.println(bl);}
}

14.2 带一个参数的方法

创建班级类 StudentsBiz

package cn.oop.test14;public class StudentsBiz {String[] stuName=new String[30];//存放学生姓名//添加学生姓名方法public void addName(String name){/*将班级学生姓名存放到数组中*/for(int i=0;i< stuName.length; i++){/* 没有存放姓名的位置才能存放 */if(stuName[i]==null){stuName[i]=name;break;}}}//打印班级学生姓名public void showName(){for (int i=0; i<stuName.length; i++){System.out.print(stuName[i]+" ");}}
}

测试班级类 TestStudentsBiz

package cn.oop.test14;public class TestStudentsBiz {public static void main(String[] args) {StudentsBiz rj1 = new StudentsBiz();rj1.addName("张三"); //添加学生姓名rj1.addName("李四");rj1.addName("王五");rj1.showName();  //查看班级学生姓名}
}

14.3 带多个参数的方法

在 StudentsBiz 类中添加方法

//在一个范围内查找学生是否存在public boolean searchName(int start,int end,String name){boolean find = false;  // 是否找到标识// 指定区间数组中，查找姓名for(int i=start-1;i<end;i++){if(name.equals(stuName[i])){find=true; //找到后将标识设置为truebreak;}}return find;}

测试班级类 TestStudentsBiz

package cn.oop.test14;public class TestStudentsBiz {public static void main(String[] args) {StudentsBiz rj1 = new StudentsBiz();rj1.addName("张三"); //添加学生姓名rj1.addName("李四");rj1.addName("王五");rj1.showName();  //查看班级学生姓名//测试多个参数方法boolean tf = rj1.searchName(2, 10, "张三");if(tf){System.out.println("\n存在");}else {System.out.println("\n没有找到");}}
}

14.4 客户姓名添加和显示

创建客户类 CustomerBiz

package cn.oop.test14.homeWork;public class CustomerBiz {String[] names = new String[30];  // 姓名数组/* 添加姓名 */public void addName(String name){for(int i =0;i<names.length;i++){if(names[i]==null){names[i]=name;break;}}}/* 打印所有客户姓名 */public void showNames(){System.out.println("**************************");System.out.println("\t客户姓名列表：");System.out.println("**************************");for(int i =0;i<names.length;i++){if(names[i]!=null){System.out.print(names[i]+"\t");}}System.out.println();}
}

测试客户类 TestCustomerBiz

package cn.oop.test14.homeWork;import java.util.Scanner;public class TestCustomerBiz {public static void main(String[] args) {CustomerBiz cb=new CustomerBiz();boolean con=true; //判断是否继续Scanner input = new Scanner(System.in);while(con){System.out .print("请输入客户的姓名：");String newName = input.next();cb.addName(newName);System.out .print("继续输入吗？（y/n）：");String choice=input.next();if(choice.equals("n")){con=false;}}cb.showNames();}
}

14.5 修改客户姓名

在 CustomerBiz 类中添加方法

/* 修改客户姓名 */public boolean editName(String oldName,String newName){boolean find = false;  // 是否找到并修改成功标识// 循环数组，找到姓名为oldName的元素，修改为newNamefor(int i=0;i<names.length;i++){if(oldName.equals(names[i])){names[i] = newName;find=true;break;}}return find;}

测试修改客户姓名方法 TestCustomerBiz2

package cn.oop.test14.homeWork;import java.util.Scanner;public class TestCustomerBiz2 {public static void main(String[] args) {CustomerBiz cb=new CustomerBiz();Scanner input = new Scanner(System.in);for (int i=1; i<=5; i++){System.out .print("请输入客户的姓名：");String newName = input.next();cb.addName(newName);}cb.showNames();System.out .print("\n请输入要修改的客户姓名：");String oldName = input.next();System.out .print("请输入新的客户姓名：");String newName = input.next();boolean edit = cb.editName(oldName, newName);System.out.println("\n\n*****修改结果*****");if(edit){System.out.println("找到并修改成功");}else {System.out.println("修改失败");}cb.showNames();}
}

14.6 数组作为参数的方法

创建成绩类 Score

package cn.oop.test14;public class Score {//计算平均分public  double avgScore(int[] score){int sum=0;for (int i=0; i<score.length; i++){sum+=score[i];}double avg=sum/score.length;return avg;}//计算最高分public  int maxScore(int[] score){int max=score[0];for(int i=0; i<score.length; i++){if(max<score[i]){max=score[i];}}return max;}
}

测试成绩类 TestScore

package cn.oop.test14;import java.util.Scanner;public class TestScore {public static void main(String[] args) {Scanner input = new Scanner(System.in);Score s1 = new Score();int[] score=new int[5];System.out.println("请输入五名参赛者的成绩：");for(int i=0; i<5; i++){score[i]=input.nextInt();}double avg = s1.avgScore(score);System.out.println("平均成绩： "+avg);int max = s1.maxScore(score);System.out.println("最高成绩： "+max);}
}

14.7 对象作为参数的方法

创建学生类 Student

package cn.oop.test14.stu;public class Student {int id; //编号String name; //姓名int age; //年龄int score; //成绩//打印学生信息public void show(){System.out.println(id+"\t"+name+"\t"+age+"\t"+score);}
}

创建班级类

package cn.oop.test14.stu;public class StuClass {//创建学生数组Student[] students=new Student[30];/* 增加学生 */public void addStudent(Student stu){for(int i =0;i<students.length;i++){if(students[i]==null){students[i]=stu;break;}}}/* 显示本班的学生信息 */public void showStudents(){System.out.println("本班学生列表：");for(int i =0;i<students.length;i++){if(students[i]!=null){students[i].show();}}System.out.println();}
}

测试学生类以及班级类

package cn.oop.test14.stu;import cn.oop.test14.StudentsBiz;public class TestStu {public static void main(String[] args) {//实例化学生对象Student s1=new Student();s1.id=10;s1.name="哈哈";s1.age=18;s1.score=99;Student s2=new Student();s2.id=11;s2.name="呵呵";s2.age=19;s2.score=60;//新增学生对象StuClass studentsBiz=new StuClass();studentsBiz.addStudent(s1);studentsBiz.addStudent(s2);studentsBiz.showStudents();//显示学生信息}
}

14.8 对客户姓名排序

创建客户类 Customer

package cn.oop.test14.homeWork;import java.util.Arrays;public class Customer {//排序方法public String[] sortNames(String[] names) {Arrays.sort(names);return names;}
}

测试客户类 TestCustomer

package cn.oop.test14.homeWork;public class TestCustomer {public static void main(String[] args) {Customer st = new Customer();String[] str = new String[] { "Tom", "Jack", "Merry", "Smith","Sunny" };System.out.println("****排序前****");for (int i = 0; i < str.length; i++) {System.out.print(str[i] + "\t");}//调用排序方法st.sortNames(str);System.out.println("\n****排序后****");for (int i = 0; i < str.length; i++) {System.out.print(str[i] + "\t");}}
}

14.9 改进客户信息的添加和显示

修改客户类添加属性和方法 Customer

package cn.oop.test14.homeWork;import java.util.Arrays;public class Customer {public String name; //姓名public int age; //年龄public boolean isMember; //是否有会员卡//打印客户信息public void show() {System.out.println(name + "\t" + age + "\t" + isMember);}//排序方法public String[] sortNames(String[] names) {Arrays.sort(names);return names;}
}

创建Customers类声明客户对象数组

package cn.oop.test14.homeWork;public class Customers {Customer[] customers = new Customer[30]; // 客户数组/* 增加客户 */public void addCustomer(Customer cust) {for (int i = 0; i < customers.length; i++) {if (customers[i] == null) {customers[i] = cust;break;}}}/* 显示客户信息 */public void showCustomers() {System.out.println("客户信息：");for (int i = 0; i < customers.length; i++) {if (customers[i] != null) {customers[i].show();}}System.out.println();}
}

创建测试类 TestCust

package cn.oop.test14.homeWork;public class TestCust {public static void main(String[] args) {// 实例化客户对象Customer c1 = new Customer();c1.name = "哈哈";c1.age = 30;c1.isMember = false;Customer c2 = new Customer();c2.name = "呵呵";c2.age = 19;c2.isMember = true;// 新增客户对象Customers customers = new Customers();customers.addCustomer(c1);customers.addCustomer(c2);customers.showCustomers();// 显示客户信息}
}

十五字符串

15.1 字符串长度

package cn.oop.test15;import java.util.Scanner;public class StringDemo01 {public static void main(String[] args) {Scanner input = new Scanner(System.in);String uname,pwd;System.out.print("请输入用户名： ");uname=input.next();System.out.print("请输入密码： ");pwd=input.next();if(pwd.length()>=6){System.out.print("注册成功！ ");}else{System.out.print("密码长度不能小于6位！");}}
}

15.2 字符串比较(一）

package cn.oop.test15;import java.util.Scanner;public class StringDemo02 {public static void main(String[] args) {Scanner input = new Scanner(System.in);String uname,pwd;System.out.print("请输入用户名： ");uname=input.next();System.out.print("请输入密码： ");pwd=input.next();if(uname.equals("Huo")&&pwd.equals("123456")){System.out.print("登录成功！ ");}else{System.out.print("用户名或密码不匹配，登录失败！");}}
}

15.3 字符串比较(二）

package cn.oop.test15;public class StringDemo03 {public static void main(String[] args) {String s1="Huo";String s2="HUO";System.out.println(s1==s2); //falseSystem.out.println(s1.equalsIgnoreCase(s2)); //trueSystem.out.println(s1.toLowerCase()); //huoSystem.out.println(s2.toUpperCase()); //HUO}
}

15.4 实现会员注册（一）

package cn.oop.test15.homeWork;import java.util.Scanner;public class Demo1 {public static void main(String[] args) {Scanner input = new Scanner(System.in);String uname,p1,p2;boolean resp=false;System.out.println("***欢迎进入注册系统*** \n");do{System.out.print("请输入用户名： ");uname=input.next();System.out.print("请输入密码： ");p1=input.next();System.out.print("请再次输入密码： ");p2=input.next();resp=verify(uname, p1, p2);}while(!resp);}public static boolean verify(String name,String pwd1,String pwd2){boolean flag=false;if(name.length()<3 || pwd1.length()<6){System.out.println("用户名长度不能小于3，密码长度不能小于6！");}else if(!pwd1.equals(pwd2)){System.out.println("两次输入的密码不相同！");}else{System.out.println("注册成功！请牢记用户名和密码。");flag=true;}return flag;}
}

15.5 字符串连接

package cn.oop.test15;public class StringDemo04 {public static void main(String[] args) {int sqlScore = 80;         //SQL成绩int javaScore = 90;         //Java成绩double htmlScore = 86.7;   //HTML成绩/* 方法一 */String scoreSheet = "SQL:" + sqlScore + "  Java:" + javaScore  + "  HTML:" + htmlScore; //成绩单//打印成绩单System.out.println("*****成绩单*****");System.out.println(scoreSheet);/* 方法二 */String name="Java; ";String name2="sqL; ";System.out.println(name.concat(name2));/* 错误写法* System.out.println(name.concat(javaScore));* */}
}

15.6 字符串常用提取方法

package cn.oop.test15;public class StringDemo05 {public static void main(String[] args) {String s1 = "abcbdbba";System.out.println(s1.indexOf("b"));//1,返回本字符串中指定元素第一次出现的下标System.out.println(s1.indexOf("cb"));//2,返回本字符串中指定元素第一次出现的下标System.out.println(s1.lastIndexOf("b"));//6,返回本字符串中指定元素最后一次出现的下标System.out.println(s1.lastIndexOf("bb"));//6,返回本字符串中指定元素最后一次出现的下标String s2 = "abcdefgh";System.out.println(s2.substring(3));//defgh,从指定下标处截取子字符串[3,结束]System.out.println(s2.substring(3,6));//def,从指定下标处截取子字符串[3,6)含头不含尾String s3="  h  u  o  ";System.out.println(s3.trim());//去除字符开头与末尾的空格String s4="啊哈哈哈";System.out.println(s4.charAt(1)); //b; 根据下标获取字符，取到的值为char类型m();}private static void m() {String word = "Hello,      ";word = word.trim(); //Hello,String s = word.concat("小鱼儿!"); //Hello,小鱼儿!int index1 = s.indexOf(','); //5int index2 = s.indexOf('!'); //9System.out.println(s.substring(index1+1,index2 ));}
}

15.7 字符串拆分

package cn.oop.test15;public class StringDemo06 {public static void main(String[] args) {String words="长亭外 古道边 芳草碧连天 晚风扶 柳笛声残 夕阳山外山";System.out.println("***原歌词格式***\n"+words);System.out.println("\n***拆分后歌词格式***");String[] printWord=words.split(" ");//按照空格进行拆分for(int i=0;i<printWord.length;i++){System.out.println(printWord[i]);//打印输出}}
}

15.8 验证身份证号，电话号

package cn.oop.test15.homeWork;public class Demo02 {public static void main(String[] args) {String sfz="140430199803125600";String phone="18734510830";String zj="0350-7187064";System.out.println(sfz.matches("^[1-9]\\d{5}(18|19|([23]\\d))\\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\\d{3}[0-9Xx]$"));System.out.println(phone.matches("^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\\d{8}$"));System.out.println(zj.matches("\\d{3}-\\d{8}|\\d{4}-\\d{7}"));}
}

15.9 判断字符出现次数

package cn.oop.test15.homeWork;public class Demo03 {public static void main(String[] args) {String s="我爱你中国，我爱你故乡";String ch="爱";//调用方法，输出结果int num=counter(s,ch);System.out.print("\""+s+"\"中包含"+num+"个\""+ch+"\"。");}public static int counter(String s,String ch){int num=0;//计数器，初始化0String[] temps=new String[s.length()];//字符串转换成数组for(int i=0;i<temps.length;i++){temps[i]=s.substring(i,i+1);}//比较字母，计数for(int j=0;j<temps.length;j++){if(temps[j].equals(ch)){num++;}}return num;}
}

15.10 StringBuffer

package cn.oop.test15;public class StringDemo07 {public static void main(String[] args) {StringBuffer sb = new StringBuffer("青春无悔");int num=110;StringBuffer sb1 = sb.append("我心永恒");System.out.println(sb1);StringBuffer sb2 = sb1.append('啊');System.out.println(sb2);StringBuffer sb3 = sb2.append(num);System.out.println(sb3);System.out.println("=========================");StringBuffer s=new StringBuffer("12345678");for(int i=s.length()-3; i>0; i=i-3){s.insert(i,",");}System.out.println(s);}
}

15.11 StringBuilder和StringBuffer的区别

在线程安全上 :
–StringBuffer是旧版本就提供的，线程安全的。@since JDK1.0
–StringBuilder是jdk1.5后产生，线程不安全的。@since 1.5
在执行效率上，StringBuilder > StringBuffer > String
源码体现：本质上都是在调用父类抽象类AbstractStringBuilder来干活，只不过Buffer把代码加了同步关键字，使得程序可以保证线程安全问题。

JavaSE 知识学习相关推荐

简单超市管理系统的设计（运用Javase知识）
**简单超市管理系统的设计 ** 运用简单的javase知识去总结所学习的内容,这里包括定义简单的变量,数组,对象等知识,运用for和do while循环 shopping类: package com ...
虚幻引擎的数学知识学习教程 Math for Unreal Engine (Early Preview)
通过做真实世界的 Unreal Engine项目来学习数学你会学到什么理解游戏开发对数学的基本需求将数学直接应用到用例中,而不是钻研理论(用我们的示例项目进行实践) 正确编辑短视频,节省您的时间 ...
三代测序知识学习----Sequel
三代测序知识学习----Sequel (2017-03-26 22:38:34) 转载▼ 分类: 三代知识链接:http://www.pacb.com/blog/new-chemistry-so ...
计算机二级二叉树基础知识,2017年计算机二级公共基础知识学习教程：树与二叉树...
(六)树与二叉树 1．树的基本概念树是一种简单的非线性结构.在树结构中,数据元素之间有着明显的层次结构.在树的图形表示中,用直线连接两端的结点,上端点为前件,下端点为后件. 在树结构中,每一个结点只 ...
c语言运算符ppt,C语言知识学习运算符.ppt
C语言知识学习运算符.ppt 第三章,C语言运算符,回顾,变量和常量的含义熟悉基本数据类型 - int.char.float 和 double 使用算术运算符理解类型转换熟练使用 scanf 和 ...
JavaSE进阶学习笔记-目录汇总（待完成）
声明:此博客来自于黑马程序员学习笔记,并非商用,仅仅是为了博主个人日后学习复习用,如有冒犯,请联系qq208820388立即删除博文,最后,来跟我一起喊黑马牛逼黑马牛逼黑马牛逼 JavaSE进阶学习笔 ...
安全测试3_Web后端知识学习
其实中间还应该学习下web服务和数据库的基础,对于web服务大家可以回家玩下tomcat或者wamp等东西,数据库的话大家掌握基本的增删该查就好了,另外最好掌握下数据库的内置函数,如:concat() ...
Python 基础知识学习笔记——NumPy
Python基础知识学习笔记--NumPy 与 matlab 优秀的矩阵运算类似,python 提供了 numpy 库,这对熟悉 matlab 的用户来说非常友好.向量.矩阵和多维数组是数值计算中必不 ...
Python 基础知识学习笔记——OpenCV（1）
Python 基础知识学习笔记--OpenCV(1) OpenCV是一个开源的跨平台计算机视觉和机器学习软件库,它轻量而且高效,被广泛的使用. 整理一下OpenCV学习笔记,以防忘记. 文章目录 Py ...