第一篇java基础知识复习
目录
一、基本格式
二、Java代码的注释（方便阅读，方便记忆，阅读性强）
三、标识符
四、关键字
五、常量
整型常量:
浮点数常量:
float型:2e3f 0.6f
double型:41d 1.23d
布尔常量:
字符常量:
字符串常量:
六、变量
变量的定义
变量的数据类型
1、整型类型变量
2、浮点数类型变量：
3.字符类型变量：
变量的类型转换
七、变量的作用域
八、运算符
算术运算符
赋值运算符
比较运算符
逻辑运算
运算符的优先级
九、选择结构语句
if语句：
if...else语句：
三元运算通常用于对某个变量进行赋值，当判断条件成立时，运算结果为表达式一的值，否则结果为表达2的值if...else if...else语句
while循环语句
do…while循环语句
for循环语句
嵌套循环:
跳转语句（break、continue）
break语句：
continue语句：
猜数字游戏
十一、方法
什么是方法
方法的重载
十二、数组
数组的定义：
数组的常见操作
1、数组遍历
2.数组排序
多维数组
随机点名器
一、基本格式
java中的程序代码必须都放在一个类中，类需要使用class关键词定义
修饰符class 类名{
程序代码
}
注意：
1、Java是严格区分大小写的
2、功能执行语句以；结束，这个分号必须是英文输入法中的(;)
3、连续的字符串不能换行，可使用(+)连接。
二、Java代码的注释（方便阅读，方便记忆，阅读性强）
1、单行注释//:通常用于对程序中的某一行代码进行解释
2、多行注释/**/：注释中的内容可以为多行
3、文档注释/**.......*/
三、标识符
标识符可以由任意顺序的大小写字母、数字、下划线（-）、美元$符号组成，但不能以数组开头，
也不能是java中的关键字
需遵循以下规则:
1、包名所有字母一律小写。例如:cnitcasttest。
2、类名和接口名每个单词的首字母都要大写。如:Arravlist、Iterator。
3、常量名所有字母都大写，单词之间用下划线连接。例如:DAY OF MONTH。
4、变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写。例如: lineNumber、getLineNumber。
5、在程序中，应该尽量使用有意义的英文单词来定义标识符，使得程序便于阅读。例如使用userName表示用户名，password表示密码。
四、关键字
关键字不能作为普通的标识符使用，并且都是小写的
五、常量
final 类型常量名[，常量名]=值;
Java 中的常量包括整型常量、浮点型常量、布尔常量、字符常量等。
整型常量:
十进制:不能以0开头，多个0~9之间的数字
十六进制:以0x或0X开头 0x8a0X56d
八进制:必须以0开头0340376
长整型:必须以L结尾87L 345L
浮点数常量:
浮点数常量就是在数学中用到的小数，生活中带有小数点的小数。
float型:2e3f 0.6f
double型:41d 1.23d
布尔常量:
true 和 false，它是一种真假的状态。一般条件成立或执行成功就用true表示;条件不成立或执行失败就用false表示。
字符常量:
常量用于表示一个字符，特殊字符 “a’652
字符串常量:
用于表示一串连续的字符，“hello”“123”长度为0
null 常量:只有一个值null，表示对象的引用为空
六、变量
变量的定义
在java语言中储一个数据信息，必将它保存到一个变量中。变量在使用前必须有定义，即有确定的类型和名称
变量的数据类型
Java是一门强类型的编程语言，它对变量的数据类型有严格的限定。在定义变量时必须声明变量的类型，在为变量赋值时必须赋予和变量同一种类型的值，否则程序会报错。
1、整型类型变量
用来存储整数数值，即没有小数部分的值。
整数类型分为四种：字节型（byte）、短整型（short）、整型（int）和长整型（long）。
取值范围是变量存储的值不能超出类型的范围，如果超出取值范围将会报错。
long类型：当定义整数常量的时候，一般用long类型在数值后面用加字母“L”（或小写“l”）。
2、浮点数类型变量：
浮点数类型变量用来存储小数数值。
浮点数类型分为两种：单精度浮点数（float)，双精度浮点数（double)，double型所表示的浮点数比float型更精确。
float在为一个float类型的变量赋值时需要注意一点。所复制的后面一定要加上字母“F”（或“f”），为double类型的变量赋值时，可以在所复制的后面加上字母“D”（或“d”）， 也可不加。
在程序中也可以为一个浮点类型变量赋予一个整数数值；但是一个整数不可以赋予一个浮点类型。
3.字符类型变量：
a、用于存储一个单一字符，在Java中用char表示。
b、每个char类型的字符变量都会占用两个字节。
c、赋值时要用英文半角格式的单引号（' '）把字符括起来，如'a'。
d、也可以赋值为0~65535范围内的整数。计算机会自动将这些整数转化为所对应的字符，如数值97对应的字符为'a'。
4.布尔类型变量：
布尔类型变量用来存储布尔值，在Java中用boolean表示，该类型的变量只有两个值，即true和false。
变量，数据类型以及赋值，就构成了变量定义的三要素。
变量的类型转换
1、自动类型转换(隐式类型转换）
需要同时满足两个条件:
a、两种类型彼此兼容
b、目标类型取值的范围要大于源类型的取值范围
2、强类型转换(显示类型转换)：容易丢失数据
当两种类型不兼容，或目标取值类型范围小于源类型时，自动类型转换无法进行，需要进行强制类型转换。
布尔类型不参与转换
七、变量的作用域
变量的作用域指一个变量起作用的范围，它决定了一个变量何时可以访问、何时不可以访问。Java
中任何变量的作用域都从该变量声明之后开始，并且只在该声明的语块中使用，也就是该变量只能
在声明它的那个花括号{}中使用
八、运算符
算术运算符
就是用来处理四则运算的符号，这就是最简单、最常用的运算符号。
算术运算符需要注意的问题：
a、在进行自增（++）和自减（--）的运算时，如果运算符放在操作数的前面则是先进行自增或自减运算，再进行其他运算。反之，如果运算符放在操作数的后面。则是先进行其他运算再进行自增或自减运算。
b、在进行除法运算时，当除数和被除数都为整数时，得到的结果也是一个整数。如果除法运算有小数参与，得到的结果也是一个小数。
c、在进行取模（%）运算时，运算结果的正负取决于被模数（%左边的数）的符号，与模数（%右边的数）的符号无关。
赋值运算符
赋值运算符的作用就是将常量、变量或表达式的赋值给某一个变量，表中列出了Java中的赋值运算符及用法。
在赋值运算符的使用中，需要注意以下几个问题：
在Java中可以通过一条赋值语句对多个变量进行赋值
除了“=”，其他的都是特殊的赋值运算符，以“+=”为例，X+=3就相当X=x+3，首先会进行加法运算x+3，再将运算结果赋值给变量x。-=、*=、/=、%=赋值运算符都可依此类推。
1、在为变量赋值时，当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，需要进行强制类型转换。
2、然而在使用+=, -=, *=, /=, %=运算符进行赋值时，强制类型转换会自动完成，程序不需要做任何显式的声明
比较运算符
两个数值或变量进行比较，比较运算结果是一个布尔值，即true或false。 在比较运算中，不能将比较运算符“==”误写成赋值运算符“=”。 要注意两个符号之间不能隔开
逻辑运算
符用于对布尔型的数据进行操作，其结果仍是一个布尔值。
逻辑与，两者都为真，结果才是真，逻辑或，只要有一者为真，结果就是真，逻辑非，非真即假，非假即真
1 、逻辑运算符可以针对结果为布尔值的表达式进行运算
2、“&” “&&”的区别
在使用“&”进行运算时，不论左边为 true 或者false，右边的表达式都会进行运算。
在使用“&&”进行运算，当左边为 false 时右边的表达式就不再进行运算,因此“&&”被称作短路与
运算符的优先级
在对一些比较复杂的表达式进行运算时，要明确表达式中所有运算符参与运算的先后顺序，把这种顺序称作运算符的优先级。
案例：
public class Hello {
public static void main(String[] args) {
// TODO Auto-generated method stub
//苹果笔记本电脑
String macBrand = "MacBookAIR";
double macSize = 13.3;
double macPrice = 5998.99;
String macConfig = "i5处理器4GB内存128GB固体硬盘";
int macCount = 5;
//联想Thinkpad笔记本电脑
String thinkpadBrabd = "ThinkpadT450";
double thinkpadSizs = 14.0;
double thinkpadPrice = 5999.99;
String thinkpadConfig = "i5处理器4GB内存500G硬盘";
int thinkpadCount = 10;
//华硕笔记本电脑
String ASUSBrand = "ASUS-FL5800";
double ASUSSize = 15.6;
double ASUSPrice = 4999.50;
String ASUSConfig = "i7处理器4G内存128G固态硬盘";
int ASUSCount = 18;
//列表的顶部
System.out.println("------------------------------商城库存清单------------------------------");
System.out.println(" 品牌型号 尺寸 价格 配置 库存数");
//列表的中部
System.out.println(macBrand + " "+macSize + " "+macPrice + " "+macConfig+" "+macCount);
System.out.println(thinkpadBrabd + " "+thinkpadSizs + " "+thinkpadPrice + " "+thinkpadConfig+" "+thinkpadCount);
System.out.println(ASUSBrand + " "+ASUSSize + " "+ASUSPrice + " "+ASUSConfig+" "+ASUSCount );
//统计总库存数 总库存金额
int totalCount = macCount + thinkpadCount + ASUSCount;
double totalMoney = (macPrice*macCount)+(thinkpadPrice*thinkpadCount)+(ASUSPrice*ASUSCount);
//列表底部
System.out.println("---------------------------------------------------------------------");
System.out.println("总库存是:"+totalCount);
System.out.println("库存商品总金额:"+totalMoney);
}
}
九、选择结构语句
if语句：
if语句是指如果满足某种条件就进行某种处理。
语法：
if（条件语句）｛
代码块
｝
流程图：
if...else语句：
是指如果没有满足某种条件就进行某种处理，否则就进行另一种处理。
语法：if（判断条件）｛
执行语句1
……
｝
else｛
执行语句
…..
｝
在java中有一种特殊的运算叫做三元运算，它和if…else语句类似
语法：判断条件 ？ 表达式1 ：表达式2
三元运算通常用于对某个变量进行赋值，当判断条件成立时，运算结果为表达式一的值，否则结果为表达2的值
if...else if...else语句
用于对多个条件进行判断，进行多种不同的处理
语法：
if（判断条件1）｛
执行语句1
｝else if（判断条件）｛
执行语句2
｝
…
else if（判断条件n）｛
执行语句n
｝else｛
执行语句n+1
｝
swich语句
语句：switch （表达式）{
case 目标值1：
执行语句1
break；
case 目标值2；
执行语句2
break；
........
case 目标值n；
执行语句n
break；
befault ：
执行语句n+1
break；
}
public class Hello {
public static void main(String[] args) {
// TODO Auto-generated method stub
int week = 8;
switch(week) {
case 1:
System.out.println("星期一");
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;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("输入的数字不正确...");
break;
}
}
}
注意:
1、条件表达式的返回值类型必须是以下类型之一:int 、byte、 char、short 、string
2、case子句中的值常量N必须是常量，而且所有case子句中的值应是不同的。
3、break语句用来在执行完一个case分支后，是程序跳出switch语句，即终止 switch语句的执行。
4、在一些特殊情况下，多个不同的case值执行一组相同的操作，这时可以不用break
十、循环结构语句
while循环语句
while语句和if条件语句有点类似，都是根据条件判断来决定是否执行后面的代码，区别在于，while循环语句会反复的进行条件判断，只要条件成立，｛｝内的执行语句就会执行，直到条件不成立，while循环结束。
语法:while(循环条件）{
执行语句
.......
}
流程图：
do…while循环语句
do…while循环语句和while循环语句功能类似。其语法结构如下：
语句：do{
执行语句
......
}while(循环语句)
流程图：
for循环语句
For循环语句是最常用的循环语句，一般用在循环次数已知的情况下，其语法格式如下：
语句：
for（初始化表达式；循环条件；操作表达式）{
执行语句
.......
}
流程图：
在上述语法格式中， For后面的（）中包括三部分内容，初始化表达式、循环条件和操作表达式，他们之间用“；”分隔，｛｝中的执行语句为循环体。
如果用1表示初始化表达式（从 For循环开始到结束只执行一次）、2表达循环条件、3表示操作表达式、4表示循环体
嵌套循环:
是指在一个循环语句的循环体中，再定义一个循环语句的语法结构
for（初始化表达式；循环条件；操作表达式；）｛
….
for（初始化表达式；循环条件；操作表达式；）｛
执行语句
…….
｝
……
｝
外循环循环一次，内循环循环多次，所以他的总都循环次数，就是内外的乘积
public class Hello {
public static void main(String[] args) {
// TODO Auto-generated method stub
int i,j;//定义两个循环变量
for(i = 1;i<=9;i++) {//外层循环
for(j = 1;j<=i;j++) {//内层循环
System.out.print("*");//输出
}
System.out.print("\n");//换行
}
}
}
跳转语句（break、continue）
跳转语句用于实现循环执行过程中程序流程的跳转，在Java中的跳转语句有break语句和continue语句
break语句：
用在switch条件语句和循环语句中，它的作用是终止某个case并跳出switch结构。break语句出现在嵌套循环的内层时，他只能跳出内层循环，如果想跳出外层循环，则需要对外层循环添加标记
break语句
public class Hello{
public static void main(String[] args) {
int x=1;//定义变量x，初始化值为1
while(x<=4) {//循环条件
System.out.println("x="+x);//条件成立，打印x的值
if(x==3) {
break;
}
x++;//x进行自增
}
}
}
break语句（跳出外层循环）
public class Hello{
public static void main(String[] args) {
int i,j;//定义两个循环变量
incast:for(i=1;i<=9;i++) {//外层循环
for(j=i;j<=i;j++) {//内层循环
if(i>4) {
break incast;
}
System.out.print("*");//打印
}
System.out.println("\n");//换行
}
}
}
continue语句：
用在循环语句中，它的作用是终止本次循环，执行下一次循环。continue语句可以立刻重新开始下一轮循环，而不在循环循环后面的语句。
public class Hello{
public static void main(String[] args) {
// TODO Auto-generated method stub
int sum = 0;//定义变量sum，用于记住和
for(int i=1;i<=100;i++) {
if(i%2==0) {//i是一个偶数，不累加
continue;//结束本次循环
}
sum += i;//实现sum和i的累加
}
System.out.println(sum);
}
} 
猜数字游戏
import java.util.Random;
import java.util.Scanner;
public class Hello {
public static void main(String[] args) {
//1、通过RANDOM类中的nextInt（n）方法，生成一个0-9之间的随机数
int randomNumber =new SecureRandom().nextInt(10);
System.out.println("随机数已生成！");
//2、输入猜的数字
System.out.println("----请输入您猜的数字:-----");
Scanner sc=new Scanner(System.in);
int enterNumber=sc.nextInt();
//3、通过while循环，进行猜数字对错判断
while(enterNumber!=randomNumber) {
//猜错了，根据结果，给出提示，接着猜数字，游戏继续
if(enterNumber>randomNumber) {
//如果猜大了，打印sorry,您猜大了！继续下一次循环
System.out.println("sorry,您猜大了！");
}
else {
//如果猜小了，打印sorry,您猜小了！继续下一次循环
System.out.println("打印sorry,您猜小了！");
}
//输入猜的数字
System.out.println("-----请输入您的数字：-------");
enterNumber=sc.nextInt();
}
System.out.print("恭喜您，答对了！");
}
}
十一、方法
什么是方法
假设一个游戏程序，程序在运行过程中，要不断的发射炮弹。发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方，都需要重复的编写这100行代码，这样程序会变得很臃肿，可读性也非常差。
为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个｛｝中，并为这段代码起个名字，然后每次发射炮弹的地方通过这个名字来调用代码就可以了。
上述过程中所提取出来的代码可以被看作是程序中的一个方法，程序在需要发射炮弹时调用该方法即可。
方法可以看成完成一个功能的，具有独立性的代码的一个小的片段。
public class Hello {
public static void main(String[] args) {
// TODO Auto-generated method stub
//下面的循环是使用*打印宽为5，高为3的矩形
for(int i = 0; i<3 ; i++) {
for(int j = 0;j < 5; j++) {
System.out.print("*");
}
System.out.print("\n");
}
//下面的循环是使用*打印宽为4，高为2的矩形
for(int i = 0; i < 2; i++){
for(int j = 0; j < 4; j++) {
System.out.print("*");
}
System.out.print("\n");
}
//下面的循环是使用*打印宽为10，高为6的矩形
for(int i = 0;i < 6; i++){
for(int j = 0;j < 10; j++) {
System.out.print("*");
}
System.out.print("\n");
}
}
}
在Java中，声明一个方法的具体语法格式如下：
修饰符 返回值 方法名（[参数类型 参数1，参数类型 参数2，......]){
执行语句
.......
return 返回值
}
修饰符：是对访问权限的限定，例如：public、static都是修饰符
返回值类型：用于限定方法返回值的数据类型。
参数类型：用于限定调用方法时传入参数的数据类型
参数名：是一个变量，用于接收调用方法时传入的数据
return关键字：用于结束方法以及返回方法指定类型的值
返回值：被return语句返回的值，该值会返回调用者
方法名首字母需要大写
public class Hello{
public static void main(String[] args) {
// TODO Auto-generated method stub
int area = getArea(3,5);//调用getArea方法
System.out.println("The area i7" + area);//输出
}
//下面定义了一个求矩形面积的方法，姐收两个参数，其中x为高，y为宽
private static int getArea(int i, int j) {
// TODO Auto-generated method stub
return i * j;
}
}
方法的重载
public class Hello {
public static void main(String[] args) {
// TODO Auto-generated method stub
//下面针对求和的方法调用
int sum1 = add01(1,2);
int sum2 = add02(1,2,3);
double sum3 = add03(1,2);
//下面的代码是打印求和的结果
System.out.println("sum1="+sum1);
System.out.println("sum2="+sum2);
System.out.println("sum3="+sum3);
}
//下面的方法实现两个小数相加
private static double add03(double i, double j) {
// TODO Auto-generated method stub
return i+j;
}
//下面方法实现了三个整数相加
private static int add02(int i, int j, int k) {
// TODO Auto-generated method stub
return i+j+k;
}
//下面的方法实现两个数整数相加
private static int add01(int i, int j) {
// TODO Auto-generated method stub
return i+j;
}
}
重载的特点： Java允许在一个程序中定义多个名称相同的方法，但是参数的类型或个数必须不同（个数不一样，类型不一样，顺序不一样也是重载），这就是方法的重载。（方法名相同，但是这个参数列表不一样）
重载和前面的内容没有关系，返回值没关系修饰符也没关系。只和方法名和参数列表有关系。
十二、数组
数组的定义：
是用来存储一组或多组相同类型数据的数据类型
在程序中，可以通过“数组名.length”的方式来获取数组的长度，也就是元素的个数
正在初始化数组时还有一种方式叫做静态初始化，就是在定义数组的同时就为数组的每个元素赋值。数组的静态初始化有两种方式。
1、类型【】数组名=new类型【】｛元素，元素，……｝；
2、类型【】数组名=｛元素，元素，….｝；
public class Hello {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr;//声明变量
arr = new int[100];//创建数组的容器
System.out.println("arr[0]="+arr[0]);//访问数组中的第一个元素
System.out.println("arr[1]="+arr[1]);//访问数组中的第二个元素
System.out.println("arr[2]="+arr[2]);//访问数组中的第三个元素
System.out.println("数组的长度是："+arr.length);//输出数组的长度
}
}
1、每个数组的索引都有一个范围，从0～length-1，在访问数组的元素时，索引不能超过这个范围，否则程序会报错
2、在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现空指针异常
数组的常见操作
1、数组遍历
在操作数组时，经常需要依次访问数组中的每个元素，这种操作叫做数字的遍历。
索引思想，操作数组中的元素，赋值还是获取值，都是依赖索引 arr［0］
索引思想：操作数组。arr［0］赋值，获取
循环：循环的变量，从0开始，每次递增。
public class Hello{
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = {1,2,3,4,5};//定义数组
//使用for循环遍历数组的元素
for(int i = 0;i
2.数组排序
在操作数组时，经常需要对数组中的元素进行排序，其中冒泡排序是比较常见的一种算法。冒泡过程中，不断比较数组中相邻的两个元素，较小者向上浮，较大者往下沉，整个过程中水中气泡上升的原理相似。
数组排序的过程如下：
a、从第1个元素开始，将相邻的两个元素依次比较，直到最后两个元素完成比较，如果第1个元素比后一个大，则交换位置。整个过程完成后，触组中最后一个元素就是最大值。（相邻的两个元素进行比较换位 ）（数组元素换位：临时变量）
public class Hello {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = {9,4,5,3,7};//定义数组，赋值无序
System.out.println("冒泡排序前：");
pintArray(arr);//输出数组元素
bubbleSort(arr);//调用排序的方法
System.out.println("冒泡排序后：");
pintArray(arr);//输出数组元素
}
//定义打印数组的元素的方法
public static void pintArray(int[] arr) {
//循环遍历数组的元素
for(int i=0;iarr[j+1]) {//比较相邻的元素
//
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1]=temp;
}
}
}
}
} 
b、除最后一个元素，将剩下的元素继续进行两两比较，过程与第1步类似，这样数组中第二大的元素放在了倒数第2个位置。
c.以此类推，持续对越来越少的元素重复上面的步骤，直到没有任何一个元素需要比较为止。
public class Hello {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = {4,1,16,3,9,8};//定义一个数组
int max = getMax(arr);//调用获取最大值的方法
System.out.println("max="+max);//输出最大值
}
private static int getMax(int[] arr) {
// TODO Auto-generated method stub
int max = arr[0];//定义变量max用于记住最大值。首先保存数组中的第0个索引上的元素
//下面通过一个for循环遍历数组中的元素
for(int x=1;xmax) {//比较arr[x]的值是否大于max
max=arr[x];//条件成立，将arr[x]的值赋值给max
}
}
return max;//返回最大值
}
} 
多维数组
可以简单地理解为在数组中的嵌套数组
二维数组的定义方式
方式一：
int【】【】arr=new int【n】【m】
特点：元素固定
方式二：
int【】【】arr=new int【n】【】
特点：可以让一维数组储存的元素是可变的
方式三：int【】【】arr=｛｛1，2｝，｛3，4，5，6｝，｛7，8，9｝｝；
特点：直接把里面的所有元素的都附上
二维数组的访问同样也是通过索引去访问的
public class Hello{
public static void main(String[] args) {
// TODO Auto-generated method stub
int [] [] arr = new int[3] [];//定义一个长度为3的二维数组
arr[0] = new int[] {11,12};//为数组的元素赋值
arr[1] = new int[] {21,22,23};
arr[2] = new int[] {31,32,33,34};
int sum = 0;//定义变量记录总销售额
for(int i =0;i
随机点名器
/*
* 随机点名器
* */
import java.security.SecureRandom;
import java.util.Scanner;
public class Hello {
// 1、存储全班同学的姓名 创建一个存储多个同学的姓名的容器（数组）
// 键盘录入每个同学的姓名，存储到数组容器中
public static void addStudentName(String[]students) {
//键盘录入多个同学姓名存储到容器中
Scanner sc =new Scanner (System.in);
for(int i=0;i