使用java理解程序逻辑，知识总结

变量、数据类型和运算符

一、“词汇”：（变量、关键字、运算符等）。
二、变量
变量：变量是用来存储数值的区域
作用：变量用来记录数值，使用变量进行代数计算，则该变量中数值可以随着程序的逻辑计算而改变。当计算全部结束后，再将数值拿出展示给用户。
常用java数据类型

数据类型	说明
byte、short、int、long	整数、用于存储整数
double、float	双精度浮点型、用于存储带小数的数字，如商品的价格，员工工资
char	字符型、 用于存储单个字符，如"男"，“女”、成绩"优"，“良”
String	字符串 、用于存储一串字符，如：员工姓名、产品型号、产品的介绍信息
boolean	布尔类型、判断、true,真、false，假

变量声明及使用
（1）声明变量：语法
数据类型 变量名；
double score; //声明双精度浮点型变量score存储分数
String name; //存储姓名
char sex; //存储性别
（2）给变量赋值，即“将数据存储至对应的内存空间”。
语法：变量名 = 值；
score = 98.5; //存储98.5
name = “张三”; //存储"张三"
sex = ‘男’; //存储’男’
（3）调用变量。使用存储的变量，我们称之为“调用变量”。
语法：数据类型 变量名 = 值；
double score = 98.5;
String name = “张三”;
char sex = “男”;
System.out.println(score);//从控制台输出变量score存储的值
变量命名规则
1、变量必须以字母、下划线“”或“￥”符号开头
2、变量可以包括数字，但不能以数字开头
3、除了“”或“$”符号以外，变量名不能包含任何特殊字符
4、不能适用java语言的关键字，如int、class、public等
★合法变量名：_myCar、 score1、 $myCar、 graph1_1
常见错误
1、变量未赋值先使用 String title;
2、使用非法的变量名 int %hour = 18;
3、变量不能重名 String name = “张三”; String name = “李四”;
java提供各种类型的运算符
◆赋值运算符（=）切记，“=”的功能是将等号右边表达式的结果赋给等号左边的变量。
◆算数运算符

运算符	说明、 举列
+	加法运算符，求操作的和、 5+3等于8
—	减法运算符，求操作数的差、5-3等于2
*	乘法运算符，求操作数的乘积、 5*3等于15
/	除法运算符，求操作数的商、 5/3等于1
%	取余运算符，求操作数相除的余数 5%3等于2

◆关系运算符

关系运算符	说明、 举列
>	大于、 99>100，结果为false
<	小于、大象的寿命<乌龟的寿命，结果为true
>=	大于等于、 你的考试成绩>=200分，结果为false
<=	小于等于、每次的考试成绩<=60分，结果为false
==	等于、 地球的大小==篮球的大小，结果为false
!=	不等于、水的密度！=铁的密度，结果为true

java提供Scanner类，可以实现从控制台获取键盘上输入的信息。
Scanner input = new Scanner(System.in);
▲数据类型转换
(1)、自动类型转换：小的转大的 int —> double
●<1>、需要满足的是，两种数据类型要兼容 例如：double和int
int num1 = 10；
double num2 = 5.5；
double sum = num2 + num1;
(2)、强制类型转换：大的转小的 double—>int (int)
<1>、大转小
int num1 = 10;
double num2 = 5.5;
int sum = (int)num2 + num1;
规则：满足自动类型转换的条件
两种类型要兼容：数值类型（整数和浮点型）相互兼容。
目标类型大于源类型：double类型可以存放int类型数据，因为为double类型变量分配的空间宽度足够存储int类型变量。因此，我们也把int类型变量转换成double类型变量称为“放大转换”。
强制类型转换
语法：（数据类型）表达式

//在在变量前加上括号，括号中的类型就是要强制转换成的类型。列如
double d = 34.5634;
int b = (int)d;

选择结构（一）

if选择结构：
if语法：
if(条件) {
//代码块
}
if选择结构是根据条件判断之后再做处理的一种语法结构。
对条件进行判断
如果结果是真，则执行代码块；否则，执行代码块后面的部分。关键字if后小括号里的条件是一个表达式，而且表达式的值必须为true或false。
程序执行时，先判断条件。当结果为true时程序先执行大括号里的代码块，再执行if结构（即{}部分）后面的代码当结果为false时不执行大括号里的代码块，而直接执行if结构后面的代码。

public class Demo{
	public static void main(String[] args){
		//语句1;
		//语句2;
		if(条件){
		//语句3;
		}
		//语句4;
	}
}

一、使用基本的if选择结构

//代码如示例
import java.util.Scanner;
public class GetPrize{
	public static void main(String[] args){
		Scanner input = new Scanner(System.in);
		System.out.print("输入张三的java成绩：");//提示输入java成绩
		int score = input.nextInt();//从控制台获取张三的java成绩
		if(score > 98 ){
		System.out.println("老师说：不错，奖励一个日记本！");
		}
	}
}

常用逻辑运算符

运算符	汉语名称、表达式
&&	与、并且、 条件1&&条件2
II	或、或者、 条件1 II 条件2
！	非、 ！条件
说明	&&、两个条件同时为真，则结果为真；两个条件有一个为假，则结果为假
说明	II、两个条件有一个为真，则结果为真；两个条件同时为假，则结果为假
说明	！、条件为真时，结果为假；条件为假时，结果为真

二、使用复杂条件下的if选择结构
★写法：
（score1 > 98 && score2 > 80）|| （score1 == 100 && score2 >70）

//if判断小示例
public class GetPrize{
	public static void main(String[] args){
		int score = 91;//张三的java成绩
		if(score > 98){
		System.out.println("老师说：不错，奖励一个日记本！");
		}
		if(score <= 98){
		System.out.println("老师说：惩罚进行编程！");
		}
	}
}

三、使用if—slse选择结构
if—else选择结构的语法：
if(条件){
//代码块1
}else{
//代码块2
}

//if—else选择结构小示例
public class GetPrize{
	public static void main(String[] args){
		int score = 91;//张三的java成绩
		if(score > 98){
		System.out.println("老师说：不错，奖励一个日记本！");
		}else{
		System.out.println("老师说：惩罚进行编程！");
		}
	}
}

多重if选择结构
语法：
if(条件1){
//代码块1
}else if(条件2){
//代码块2
}else{
//代码块3
}
注意：else块最多有一个或没有，else块必须要放在else if 块之后。

//小实列
public class ScoreAssess{
	public static void main(String[] args){
		int score = 70;//考试成绩
		if(score >= 80){//考试成绩>=80
			System.out.println("良好");
		}else if(score >= 60){//>考试成绩>=60
			System.out.println("中等");
		}else{//考试成绩<60
			System.out.println("差");
		}
	}
}

else if 块的执行顺序可以看出，else if块的顺序是连续的，而不是跳跃的。
else if 块的顺序不是随意排列的，要么从大到小，要么从小到大，总之要有顺序地排列。
嵌套if选择结构
语法：

if(条件1){
	if(条件2){
		//代码块1
	}else{
		//代码块2
	}
}else{
	//代码块3
}

嵌套if选择结构小示例：

import java.util.*;
public class RunningMatch{
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.err.println("请输入比赛成绩（s）：");
		double score = input.nextDouble();
		System.out.println("请输入性别：");
		String gender = input.next();
		if(score<=10){
			if(gender.equals("男")){
				System.out.println("进入男子组决赛！");
			}else if(gender.equals("女")){
				System.out.println("进入女子组决赛！");
			}
		}else{
			System.out.println("淘汰！");
		}
	}
}

注意：只有当满足外层if选择结构的条件时，才会判断内层if的条件。
else总是与它前面最近的那个缺少else的if配对。

选择结构（一）小总结
常见的逻辑运算符有&&、||、！。
java中的if选择结构，包含以下形式。
◆基本的if选择结构：可以处理单一或组合条件的情况。
◆if—else选择结构：可以处理简单的条件分支情况。
◆多重if选择结构：可以处理连续区间的条件分支情况。
◆嵌套if选择结构：可以处理复杂的条件分支情况。

选择结构（二）

什么是switch选择结构
switch选择结构可以更好地解决等值判断问题。
语法：

switch(表达式){
	case 常量 1:
		//代码块 1；
		break;
	case 常量 2:
		//代码块 2；
		break;
	default :
		//代码块 n;
		break;
}

解释：这里switch、case、default、break都是java的关键字。
◆switch:表示“开关”，这个开关就是switch关键字后面小括号里表达式的值。switch语句小括号里可以是int、short、byte、char、枚举类型、String类型表达式。
◆case：表示“情况，情形”，case后可以是int、short、byte、char、枚举类型、String类型，通常是一个固定的值。case块可以有多个，顺序可以改变，但是每个case后常量的值必须各不相同。
◆default：表示“默认”，即其他情况都不满足。default后要紧跟冒号。default块和case块的先后顺序可以变动，不会影响程序执行的结果。通常，default块放在末尾，也可以省略。
◆ break ：表示“停止”，即跳出当前结构。

[使用switch选择结构]

public class TestDeom {
	public static void main(String[] args) {
		int mingci = 1;//名词
		switch (mingci) {
		case 1:
			System.out.println("参加麻省理工大学组织的1个月夏令营");
			break;
		case 2:
			System.out.println("奖励惠普笔记本电脑一部");
			break;
		case 3:
			System.out.println("奖励移动硬盘一个");
			break;
		default:
			System.out.println("没有任何奖励");
			break;
		}
	}
}

//控制台出入选择
public class Test {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int num = input.nextInt();
		switch (num) {
		case 1:
			System.out.println("参加麻省理工大学组织的1个月夏令营");
			break;
		case 2:
			System.out.println("奖励惠普笔记本电脑一部");
			break;
		case 3:
			System.out.println("奖励移动硬盘一个");
			break;
		default:
			System.out.println("没有任何奖励");
			break;
		}
	}
}

选择结构总结

语法：if
if(条件){
	//代码块
}
语法：else—if
if(条件){
	//代码块1
}else{
	//代码块2
}
语法：多重if
if(条件1){
	//代码块1
}else if(条件2){
	//代码块2
}else{
	//代码块3
}
语法：嵌套if选择结构
if(条件1){
	if(条件2){
		//代码块1
	}else{
		//代码块2
	}
}else{
	if(条件3){
		//代码块3
	}else{
		//代码块4
	}
}

循环结构（一）

什么是循环结构
循环就是重复地做事情。称为循环操作
▲所有的循环结构都有这样的特点，首先，循环不是无休止进行的，满足一定条件的时候循环才会继续，称为“循环条件”，循环条件不满足的时候，循环退出，其次循环结构是反复进行相同的或类似的一系列操作，称为“循环操作”。
循环结构：
循环条件
循环操作

while循环结构语法：
while(循环条件){
	//循环操作
}
举例
		int i = 1;
		while(i <= 100){
			System.out.println("第"+i+"编写：好好学习，天天向上！");
			i = i + 1;//这里必须加上i++；否则就会死循环
		}
	}
循环实列
public class TestDeom {
	public static void main(String[] args) {
		int i = 1;
		while(i <= 100){
			System.out.println("第"+i+"编写：好好学习，天天向上！");
			i++;//这里必须加上i++；否则就会死循环
		}
	}
}
while循环结构的执行顺序一般如下：
（1）声明并初始化循环变量。
（2）判断循环条件是否满足，如果满足则执行循环操作，否则退出循环。
（3）执行完循环操作后，再次判断循环条件，决定继续执行循环或退出循环。
注意：while循环结构如果第一次判断循环条件就不满足，则会直接跳出循环，循环操作一遍都不会执行，这是while循环结构的一个特点，先判断，后执行。

public class TestDeom {
	public static void main(String[] args) {
		String answer;//标识是否合格
		Scanner input = new Scanner(System.in);
		System.out.println("合格了吗?(y/n):");
		answer = input.next();
		while(!"y".equals(answer)){
			System.out.println("上午阅课读教材！");
			System.out.println("下午上机编程！\n");
			System.out.println("合格了吗(y/n):");
			answer = input.next();
		}
		System.out.println("完成学习任务！");
	}
}

程序调试

什么是程序调式：为了找出程序中的问题所在。
使用MyEclipse开发工具，提供的调试功能解决这个问题，由以下两个步骤组成。
（1）分析错误，设置断点。
（2）启动调试，单步执行。
注意：在调试视图中，按F5键或F6键都是单步执行，他们的区别如下：
按F5键“单步跳入”，会进入本行代码内部执行，如进入方法内部。
按F6键“单步跳过”，仅执行本行代码，执行完则跳到下一行代码。

do—while循环

什么是do—while循环
语法：结构
do{
//循环操作
}while(循环条件);
举例
int i =1;
do{
System.out.println(“好好学习！”);
i++;
}while(i <= 100);

do—while循环的执行顺序一般如下：
（1）声明并初始化循环变量。
（2）执行一遍循环操作。
（3）判断循环条件，如果循环条件满足，则循环继续执行，否则退出循环。do—while循环的执行过程可以看出，循环操作至少执行一遍。

小列子
import java.util.Scanner;
public class TestDeom {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		String answer = "y";//标识是否合格
		do{
			System.out.println("上机编程写程序！");
			System.out.println("合格了吗(y/n):");
			answer = input.next();
			System.out.println("");
		}while(!"y".equals(answer));
		System.out.println("恭喜你通过了测试！");
	}
}

小总结
▲循环结构由循环条件和循环操作构成。只要满足条件，循环操作就会反复执行。
▲使用循环解决问题的步骤：分析循环条件和循环操作，套用循环的语法写出代码，检查循环能否退出
▲编写循环结构代码时需要注意：循环变量的初值，循环操作中对循环变量值的改变和循环条件三者间的关系：确保循环次数正确，不要出现，“死循环”。
▲while循环结构的特点是先判断，后执行；do—while循环结构的特点是先执行，再判断。
▲程序调试是满足暂停程序，观察变量和逐条执行语句等功能的工具和方法的总称。其主要方法包括设置断点，单步运行和观察变量。

循环结构（二）

一、是什么是for循环结构：
循环语句的主要作用是反复执行一段代码，直到满足一定的条件为止。总结一下，可以把循环结构分成四个部分。
★初识部分：设置循环的初始状态，如设置记录循环次数的变量i为0。
★循环体：重复执行的代码，即输出“好好学习，天天向上！”。
★迭代部分：下一次循环开始前要执行的部分，在while循环结构中它作为循环体的一部分，如使用“i++”；进行循环次数的累加。
★循环条件：判断是否继续循环的条件，如使用“i<100”判断循环次数是否已经达到100。
在for循环结构中，这几个部分同样必不可少，不然循环就会出现错误。for循环的一般格式如下：
语法：
for(表达式1;表达式2;表达式3){
//循环体
}
for循环结构中三个表达式的含义

表达式				形象									功能													举例
表达式1		赋值语句					循环结构的初始部分，为循环变量赋初值									int i = 0；
表达式2		条件语句					循环结构的循环条件																i<100
表达式3		赋值语句，通常使用++或--运算符				循环结构的迭代部分，通常用来修改循环变量的值				i++；

使用for循环结构：

import java.util.Scanner;
public class Deom1 {
	public static void main(String[]args){
		Scanner input = new Scanner(System.in);
		int score;//每门课程的成绩
		int sum = 0;//成绩之和
		double avg = 0.0;//平均分
		System.out.println("请输入学生姓名：");
		String name = input.next();
		for (int i=0; i<5; i++){
		System.out.println("请输入5门功课中第"+(i+1)+"门课的成绩：");
		score = input.nextInt();//录入成绩
		sum = sum + score;//计算成绩和
		}
		avg = (double) sum /5;//计算平均分
		System.out.println(name+"的平均分是："+avg);
	}
}

import java.util.Scanner;
public class Deom1 {
	public static void main(String[]args){
		Scanner input = new Scanner(System.in);
		int i, j;
		System.out.println("请输入一个值：");
		int val = input.nextInt();
		System.out.println("根据这个值可以输出一下加法表：");
		for (i = 0, j = val; i <= val; i++, j--){
			System.out.println(i +"+"+ j + "+" +(i+j));
		}
	}
}

跳转语句： break语句的使用

import java.util.Scanner;
public class Deom1 {
	public static void main(String[]args){
		Scanner input = new Scanner(System.in);
		System.out.println("出席日程表，请输入日期(1-5):");
		int day = input.nextInt();
		switch(day){
		case 1:
			System.out.println("出席IT科技展剪彩依式：");
			break;
		case 2:
			System.out.println("飞抵香港参加亚太区会议：");
			break;
		case 3:
			System.out.println("会议结束游香港海洋公园");
			break;
		case 4:
			System.out.println("抵京召开公司月度股东大会");
			break;
		case 5:
			System.out.println("自由时间");
			break;
		}
	}
}

import java.util.Scanner;
public class Deom1 {
	public static void main(String[]args){
		Scanner input = new Scanner(System.in);
		int score;//每门课程的成绩
		int sum = 0;//成绩之和
		double avg = 0.0;//平均分
		boolean isNegative = false;//是否为负数
		System.out.println("请输入学生姓名：");
		String name = input.next();//输入姓名
		for(int i = 0; i < 5; i++){//循环五次，录入五门课程成绩
			System.out.println("请输入第"+ (i+1) + "门课的成绩：");
			score = input.nextInt();
			if(score < 0){//输入负数
				isNegative = true;
				break;
			}
			sum = sum +score;//累加求和
		}
		if(isNegative){
			System.out.println("抱歉，分数录入错误，请重新进行录入！");
		}
		else{
			avg = (double)sum /5;//计算平均风
			System.out.println(name+"的平均分是："+ avg);
		}
	}
}
/*
小结：break语句用于终止某个循环，使程序跳转到循环体外的下一条语句。在循环中位于break后的语句将不再执行，循环也停止执行。
经验：break语句不仅可以用在for循环结构中，也可以用在while和do—while循环结构中。break语句通常与if条件语句一起使用。
*/

continue语句的使用

import java.util.Scanner;
public class TestDeom {
	public static void main(String[] args) {
		int score;//成绩
		int total;//班级总人数
		int num = 0;//成绩大于或等于80分的人数
		Scanner input = new Scanner(System.in);
		System.out.println("输入班级总人数：");
		total = input.nextInt();//输入班级总人数
		for (int i = 0; i < total; i++) {
			System.out.println("请输入第"+(i + 1)+"位学生的成绩：");
			score = input.nextInt();
			if(score < 80){
				continue;
			}
			num++;
		}
		System.out.println("80分以上的学生人数是："+num);
		double rate = (double)num / total * 100;
		System.out.println("80分以上的学生所占的比例为："+rate+"%");
	}
}
小结：continue语句可以用于for循环结构，也可以用于while和do—while循环结构。在for循环结构中，continue语句使程序先跳转到迭代部分，
然后判断循环条件。如果为true，则继续下一次循环；否则终止循环。在while循环结构中，continue语句执行完毕后，程序将直接判断循环条件。
continue语句只能用在循环结构中。
注意：break与continue的区别：
▲break语句用于终止某个循环，程序跳转到循环体外的下一条语句。
▲continue语句用于跳出本次循环，进入下一次循环的语句。

循环结构总结
对比：→语法不同：
while循环语句如下。
while（<条件>）{
//循环体
}
do—while循环语句如下。
do{
//循环体
}while（<条件>）；
for循环语句如下。
for（初始化；条件；迭代）{
//循环体
}
循环执行顺序是不同的，一定要记住哦！
◆while循环结构：先执行条件判断，再执行循环体如果条件不成立，退出循环。
◆do—while循环结构：先执行循环体，再执行条件判断，循环体至少执行一次。
◆for循环结构：先执行初始化部分，再执行条件判断，然后执行循环体，最后进行迭代部分的计算。如果条件不成立，跳出循环。

循环结构综合练习

public class SelectGame{
	public static void main(String[] args) {
		System.out.println("欢迎进入小鸟游迷你戏平台\n");
		System.out.println("请选择您喜爱的游戏：\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();
			switch (choice) {
			case 1:
				System.out.println("您已进入斗地主房间！");
				break;
			case 2:
				System.out.println("您已进入斗牛房间！");
				break;
			case 3:
				System.out.println("您已进入泡泡龙房间！");
				break;
			case 4:
				System.out.println("您已进入连连看房间！");
				break;
			default:
				System.out.print("输入错误，请重新输入数字：");
				isRight = false;
				break;
			}
		}while(!isRight);
	}
}

public class SelectGame2 {
	public static void main(String[] args) {
		System.out.println("欢迎进入小鸟游迷你戏平台\n");
		System.out.println("请选择您喜爱的游戏\n");
		System.out.println("*******************************");
		System.out.println("1.斗地主");
		System.out.println("2.斗牛");
		System.out.println("3.泡泡龙");
		System.out.println("4.连连看");
		System.out.println("*******************************\n");
		System.out.print("请选择，输入数字：");
		Scanner input = new Scanner(System.in);
		int selectInt = input.nextInt();
		while (selectInt>=5||selectInt<=0) {
			System.out.print("选择错误,请重新选择");
			selectInt = input.nextInt();
		}
		switch (selectInt) {
		case 1:
			System.out.println("你已进入斗地主房间！");
			break;
		case 2:
			System.out.println("你已进入斗牛房间！");
			break;
		case 3:
			System.out.println("你已进入泡泡龙房间！");
			break;
		case 4:
			System.out.println("你已进入连连看房间！");
			break;
		}
	}
}


public class RiseGame {
	public static void main(String[] args) {
		System.out.println("青鸟迷你游戏平台>游戏晋级\n");
		Scanner input = new Scanner(System.in);
		int n = 1;
		int count=0;
		while (n<=5) {
			System.out.print("您正在玩第"+n+"局，成绩为：");
			int scroe = input.nextInt();
			if(scroe>80){
				count++;
			}
			if(n!=5){
				System.out.println("继续玩下一局吗？（yes/no)");
				String answer = input.next();
				if(answer.equals("no")){
					System.out.println("你已经退出游戏");
					break;
				}
				System.out.println("你进入一下局");
			}
			n++;
		}
		System.out.println("n的值："+n);
		if(n>5){
			if(n>=4){
				System.out.println("\n恭喜，通过一级！");
			}else if(n>=3&&n<4){
				System.out.println("\n恭喜，通过二级！");
			}else {
				System.out.println("\n对不起，你未能晋级！");
			}
		}
	}
}

数组

为什么需要数组
用数组集中操作数据比使用多个变量操作数据便捷得多。
1.数组是可以在内存中连续存储多个元素的结构，数组中的所有元素必须属于相同的数据类型。
2.数组中的元素通过数组的下标进行访问，数组的下标从0开始。
3.一维数组可用一个循环动态初始化，或者用一个循环动态输出数组中的元素信息。
4.利用Arrays类提供的sort()方法可以方便地对数组中的元素进行排序。
5.int、double、char、boolean类型是基本数据类型。
6.String和数组是引用数据类型。

数组定义：
数组是一个变量，存储相同数据类型的一组数据。通过下标进行区别。
同一个数组变量，存储的数据类型都是相同的，它们都有同一个变量名，
只通过下标来进行区别。
★小结：
提问：数据有什么好处？
答案：将数据集中，便于操作，提高效率。
如何使用数组：
四个步骤：
1、声明数组
语法：
数据类型 [] 数组名；
或者
数据类型 数组名[]；
两种方法都可以声明一个数组，数组名可以是任意合法的变量名。
int [] score;//类型为int
double height [];//类型为double
String [] names；类型为String
2、分配空间
在java中可以使用new关键字来给数组分配空间。
语法：
数组名 = new 数据类型[数组长度];
score = new int[30];//长度为30的int类型数组
height = new double[30];//长度为30的double类型数组
names = new String[30]//长度为30的String类型数组
语法：
数组类型 [] 数组名 = new 数据类型[数组长度];
int score [] = new int[30];//存储30个学员成绩
3、赋值
语法：
数组名[下标值]；
例如：向score数组中存放数据
score [0] = 89;
score [1] = 60;
score [2] = 70;
语法：
数据类型[] 数组名 = {值1，值2，值3，…，值n}；
int [] score = new int[]{60,70,98,90,76};
▲声明数组的方式
//第一种：数据类型[] 数组名 = new 数据类型[长度]
int[] score = new int[5];
//第二种：数据类型[] 数组名 = new 数据类型[]{值1，值2，值3};
int[] number = new int[]{12,13,14};//写几个值，就代表数组的长度是多少
//第三种：数据类型[] 数组名 = {值1，值2，值3};
int[] num = {13,15,14};
4、对数组进行处理

public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int[] number = new int[7];
		System.out.println("数组的长度是"+number.length);
		for(int i=0;i<number.length;i++){
			System.out.println("请输入第"+(i+1)+"个数");
			//一次向数组中输入数据
			number[i] = input.nextInt();
		}
		//把数组中的数据一次循环输出
		for(int i=0;i<5;i++){
			System.out.println(number[i]+"\t");
		}
	}
}


import java.util.Scanner;
public class Test03 {
	public static void main(String[] args) {
		//求全班同学的平均分
		Scanner input = new Scanner(System.in);
		int sum = 0;
		double avg;
		int[] score = new int[5];
		for(int i=0;i<score.length;i++){
			System.out.println("请输入成绩");
			score[i] = input.nextInt();
			sum = sum + score[i];
		}
		avg = sum*1.0/score.length*1.0;
		System.out.println("平均分是"+avg);
	}
}

数组的总结
▲数组是可以在内存中连续存储多个元素的结构，数组中的所有元素必须属于相同的数据类型。
▲数组中的元素通过数组的下标进行访问，数组的下标从0开始。
▲数组可用一个循环为元素赋值，或者用一个循环输出数组中的元素信息。
▲通过数组，length可以获得数组长度。
▲利用Arrays类提供的sort（）方法可以方便地对数组中的元素进行排序。

循环结构进阶

什么是循环二重循环
▲简单地说，二重循环就是一个循环体内又包含另一个完整的循环结构。
while循环、do—while循环和for循环。这三种循环之间是可以相互嵌套的，一个循环要完整地包含在另一个循环中，
如下四种形式都是合法的。
语法：

//while与while循环嵌套
while(循环条件1){
	//循环操作1
	while(循环条件2){
		//循环操作2
	}
}

//do—while与do—while循环嵌套
do{
	//循环操作1
	do{
		//循环操作2
	}while(循环条件2);
}while(循环条件1);

//for循环与for循环嵌套
for(循环条件1){
	//循环操作1
	for(循环条件2){
		//循环操作2
	}
}

//while与for循环嵌套
while(循环条件1){
	//循环操作1
	for(循环条件2){
		//循环操作2
	}
}
//在二重循环中，外层循环变量变化一次，内层循环变量要从初始值到结束值变化一遍。

public class AvgScore {
	public static void main(String args[]){
		int[] score = new int[4];				//成绩数组
		int classNum = 3;						//班级数目
		double sum = 0.0;						//成绩总和
		double average = 0.0;					//平均成绩

		//循环输入学员成绩
		Scanner input = new Scanner(System.in);
		for(int i = 0; i < classNum; i++){
			sum = 0.0f;							//成绩总和归0
			System.out.println("请输入第" + (i+1) + "个班级的成绩");
			for(int j = 0; j < score.length; j++){
				System.out.print("第" + (j+1) + "个学员的成绩：");
				score[j] = input.nextInt();
				sum = sum + score[j];			//成绩累加
			}
			average = sum / score.length;	//计算平均分
			System.out.println("第" + (i+1) + "个班级参赛学员的平均分是：" + average + "\n");
		}
	}
}

/**
 * 打印九九乘法表
 */
public class MulTable {
	public static void main(String[] args) {
		int rows = 9;						//乘法表的行数
		for(int i = 1; i<=rows; i++){		//一共9行
			for(int j = 1; j <= i; j++){	//第i行有i个式子
				System.out.print(j+"*"+i+"="+j*i+"	");
			}
			System.out.print("\n");			//打印完一行后换行
		}
	}
}

import java.util.Scanner;
public class Demo02 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int sum = 0;
		//定义班级的数组
		int[] className = new int[3];
		//定义分数的数组
		int[] score = new int[4];
		double avg = 0;
		//进行双重for循环
		for(int i=0;i<className.length;i++){
			sum = 0;
			System.out.println("请输入第"+(i+1)+"个班级的成绩");
			for(int j=0;j<score.length;j++){
				System.out.println("------请输入第"+(j+1)+"个学员的分数-----");
				score[i] = input.nextInt();
				sum = sum + score[i];
			}
			avg = sum*1.0/score.length*1.0;
			System.out.println("第"+(1+i)+"个班级的平均分是"+avg);
		}
	}
}

指导学习：信用抽奖案例

import java.util.Scanner;
public class Deom1 {
	public static void main(String[]args){
		String answer = "y"; // 标识是否继续
		String userName = ""; // 用户名
		String password = ""; // 密码
		int cardNumber = 0; // 卡号
		boolean isRegister = false; // 标识是否注册
		int max = 9999;
		int min = 1000;
		Scanner input = new Scanner(System.in);
		do {
		System.out.println("*****欢迎进入奖客富翁系统*****");
		System.out.println("\t1.注册");
		System.out.println("\t2.登录");
		System.out.println("\t3.抽奖");
		System.out.println("***************************");
		System.out.print("请选择菜单：");
		int choice = input.nextInt();
		switch (choice) {
		case 1:
			System.out.println("[奖客富翁系统 > 注册]");
			System.out.println("请填写个人注册信息：");
			System.out.print("用户名：");
			userName = input.next();
			System.out.print("密码：");
			password = input.next();
			// 获取4位随机数作为卡号
			cardNumber = (int)(Math.random()*(max-min))+min;
			System.out.println("\n注册成功，请记好您的会员卡号");
			System.out.println("用户名\t密码\t会员卡号");
			System.out.println(userName + "\t" + password + "\t" + cardNumber);
			isRegister = true; // 注册成功，标志位设置为true
			break;
		case 2:
			System.out.println("[奖客富翁系统 > 登录]");
			if (isRegister) { // 判断是否注册
				// 3次输入机会
				for (int i = 1; i <= 3; i++) {
					System.out.print("请输入用户名：");
					String inputName = input.next();
					System.out.print("请输入密码：");
					String inputPassword = input.next();
					if (userName.equals(inputName) && password.equals(inputPassword)) {
						System.out.println("\n欢迎您：" + userName);
						isRegister = true; // 登录成功，标志位设置为true
			break;
					} else if (i < 3) {
						System.out.println("用户名或密码错误，还有" + (3 - i) + "次机会！");
					} else {
						System.out.println("您3次均输入错误！");
					}
				}
			} else {
				System.out.println("请先注册，再登录！");
			}
			break;
		case 3:
			System.out.println("[奖客富翁系统 > 抽奖]");
			if (!isRegister) { // 判断是否登录
				System.out.println("请先登录，再抽奖！");
				System.out.println("继续吗？（y/n）");
				answer = input.next();
			} else {
				//生成5个4位随机数字，并保存在数组中
				int[] luckynums = new int[5];
			    for(int i = 0; i < luckynums.length; i++){
			    	luckynums[i] = (int)(Math.random()*(max-min))+min;
			    }
				System.out.print("请输入您的卡号：");
				int yourcard = input.nextInt();
				int i;
				System.out.print("\n本日的幸运数字为：");
				for (i = 0; i < luckynums.length; i++) {
					System.out.print(luckynums[i] + "  ");
				}
				for (i = 0; i < luckynums.length; i++) {
					if (luckynums[i] == yourcard) {
						System.out.println("\n恭喜！您是本日的幸运会员！");
						break;
					}
				}
				if (i == luckynums.length) {
					System.out.println("\n抱歉！您不是本日的幸运会员！");
				}
			}
			break;
		default:
			System.out.println("[您的输入有误！]");
			break;
		}
		System.out.print("继续吗？（y/n）:");
		answer = input.next();
        System.out.println("");
	} while ("y".equals(answer));
	if ("n".equals(answer)) {
		System.out.println("系统退出，谢谢使用！");
	}
	}
}

类和对象

1 对象
什么是对象，对角是用来描述客户事物的一个实体
Java是一种面向对象的编程语言
2 身边的对象
用向对象方法来解决问题是，首先要对现实世界中的对象进行分析与归纳，找出哪些对象与要解决的问题是相关的
对象都有一些特征，这些特征是有别于其他对象
所以对象由特征和操作组成

3 对象的属性和方法
在面向对象的编程思想中，把对象的静态特征和动态特征分别称为对象属性和方法
在编程中，对象的属性被存储在一些变量中，对象的行为则通过定义方法来实现
对象：用来描述客观事物的一个实体，由一组属性和方法构成

4 封装
对象同时具有属性和方法两项特性
封装：就是把一个事物包装起来，并尽可能隐藏内部细节

一辆汽车，有完好的零件和特定的颜色，还应具备开动、刹车等方法行为
二、类
类定义了对象将会拥有的特征（属性）和行为（方法）

类是对象的类型
三、 类和对象的关系
类是抽象的概念，仅仅是模板
对象是一个你能够看得到、摸得着的具体实体
小结
对象是用来描述客观事物的一个实体
类定义了对象将会拥有的特征（属性）和行为（方法）
类是对象的类型，对象是类的实例
使用类的步骤

public class AdministratorTest {
	String name;//给name属性赋值
	String password;//给password属性赋值
	public void show(){
		System.out.println("用户名:"+ name+"\t"+"密码:"+ password);
	}
}
import java.util.Scanner;
public class tor {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		AdministratorTest dydxm = new AdministratorTest();//创建管理员对象
		dydxm.name = "admin1";//用户名  给name属性赋值
		dydxm.password = "111111";//密码// 给password属性赋值
		//输入旧的用户名和密码是否正确
		System.out.print("请输入用户名:");
		String nameyhm = input.next();
		System.out.print("请输入密码：");
		String mimajx = input.next();//密码
		//判断用户输入的用户名和密码是否正确
		if(dydxm.name.equals(nameyhm)&& dydxm.password.equals(mimajx)) {
			System.out.println("\n请输入新密码：");
			dydxm.password = input.next();
			System.out.println("修改密码成功，您的新密码为："+dydxm.password);
		}else{
			System.out.println("用户名和密码不匹配！您没有权限更新管理员信息。");
		}
	}
}

Java的类模板
语法
public class 类名 {
//定义属性部分
属性1的类型 属性1;
属性2的类型 属性2;
…
属性n的类型 属性n;
//定义方法部分
方法1;
方法2;
…
方法m;
}
如何定义类
定类的步骤:
•定义类名
•编写类的属性
•编写类的方法
实现
public class School {
String schoolName; //中心名称
int classNumber; //教室数目
int labNumber; //机房数目
//定义北大青鸟中心的方法
public void showCenter() {//School类的showCenter（）方法
System.out.println(schoolName + “培训学员\n” + “配备：”
+ classNumber + “教” + labNumber + “机”);
}
}

类和对象总结
≥对象是用来描述客观事物的一个实体，由一组属性和方法构成。
≥类定义了对象将会拥有的特征（属性）和行为（方法）。
≥类和对象的关系是抽象和具体的关系。类是对象的类型，对象是类的实例。
≥对象的属性和方法被共同封装在类中，相辅相成，不可分割。
≥面向对象程序设计的优点如下：
◆与人类的思维习惯一致。
◆影藏信息，提高了程序的可维护性和安全性。
◆提高了程序的可重用性。
≥使用类的步骤如下：
◆定义类：使用关键字class。
◆创建类的对象：使用关键字new。
◆使用类的属性和方法：使用“.”操作符。