Day02 03 Java语言基础组成
2.1 关键字
对某些单词赋予特殊含义
2.2 标识符
在程序中自定义的一些名称
由26个英文字母大小写，数字：0-9 符号：_$组成
定义合法标识符规则：1. 数字不可以开头 2. 不可以使用关键字
Java中严格区分大小写
注：在起名字时，为了提高阅读性，要尽量有意义。
Java中的名称规范：
包名：多单词组成时所有字母都小写。xxxyyyzzz
类名接口名：多单词组成时，所有单词的首字母大写。XxxYyyZzz
变量名和函数名：多单词组成时，第一个单词首字母大写，第二个单词首字母开始每个单词首字母大写。xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接。XXX_YYY_ZZZ
2.3 注释
单行 ：//注释文字
多行 ：/* 注释文字 */
文档（Java特有注释）：/**注释文字 */
对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行。
对于文档注释，是java特有注释，体重注释内容可以被JDK提供的工具javadoc所解析，生成一套网页文件形式体现的该程序的说明文档。
2.4 常量和变量
常量表示不能改变的值。
Java中常量的分类：
- 整数常量：所有整数
- 小数常量：所有小数
- 布尔型常量：只有两个数值，true false
- 字符型常量：将一个数字字母或者符号用单引号（‘’）标识
- 字符串常量：将一个或者多个字符用双引号标识
- null常量，只有一个数值 null
对于整数：java有三种表现形式。
十进制：0-9，满10进1
八进制：0-7，满8进1，用0开头表示
十六进制：0-9，A-F，满16进1，用0x开头表示
8个二进制表示1个字节，n多字节表示计算机中的数据。计算机硬盘里存放的是二进制数据
进制越大，表现形式越短
变量的概念：内存中的一个存储区域（将不确定的数据进行存储，需要在内存中开辟一个空间）
该区域有自己的名称（变量名）和类型（数据类型）
该区域的数据可以在同一类型范围内不断变化
byte：8个2进制位表示数据，1个8位
short：16个2进制位表示数据，2个8位
long：long l = 4l;
int：4个8位，32个2进制表示数据（写整数默认int ） int x = 4;
float：单精度，小数点后面有限，4个8位 float f = 2.3f;(f表示单精度，要写，不写会报错)
double：双精度 u，精确程度更高，8个8位（写小数默认double）
char ch = ‘4’; char ch1 = ‘a’; char ch2 = ‘+’; char ch3 = ’ ';注：1个中文2字节。
boolean bo = true; boolean bo1 = false;
为什么要定义变量：用来不断的存放同一类型的常量，并可以重复是使用
使用变量注意：变量的作用范围（一对{}之间有效），初始化值
定义变量的格式：数据类型 变量名 = 初始化值；
理解：变量就如同数学中的未知数
**什么时候定义变量：**当数据不确定的时候，需要对数据进行存储时，就定义一个变量来完成存储动作。
类型的转换
自动类型转换（也叫隐士类型转换，默认小的向大的数据类型提升，自动类型提升）
强制类型转换（也叫显示类型转换）
表达式的数据类型自动提升
所有的byte型、short型和char的值将被提升到int型
如果一个操作数是long型，计算结果就是long型
如果一个操作数是float型，计算结果就是float型
如果一个操作数是double型，计算结果就是double型
分析：System.out.println(‘a’)与System.out.println(‘a’+1)的区别
’a‘ char类型，1个8位；1 int类型，4个8位；数据类型自动提升，’a‘ ASCII码表中对应97 + 1 -->98
字符在ASCII码表中都有对应的数字 a–>97 b–>98
2.5 运算符
算术运算符
1%-5 = 1; -1%5 = -1 取模符号只看被除数
字符串数据和任何数据使用+，都是相连接，最终都会变成字符串。
System.out.println(“ab”+5+5);//“ab5”+5–>“ab55”
System.out.println(“5+5=”+5+5);//“5+5=55”
System.out.println(“5+5=”+(5+5));//“5+5=10”
int a = 3,b;
b = ++a;
System.out.println(“a=”+a+",b="+b);
println:ln是在括号中数据打印后结尾处数据换行
转义字符：通过\来转变后面字母或者符号的含义。
\n：换行(相当于backspace)、\b:推格、\t:制表符(相当于table)
\r：按下回车键（window系统，回车符由两个字符来表示\r\n；Linux系统，回车符由一个字符表示\n；DOS里直接识别\n）
打印"“hello”:System.out.println("“hello”");System.out.println("\hello\");
赋值运算符
int x = 3;
x+=4;//x = x+4;
short s = 4;
s = s+5;–>编译失败，因为s被提升为int类型，运算后的结果还是int类型。无法赋值给short类型。
s+=5;–>编译通过，因为+=运算符在给赋值时，自动完成了强制转换。
比较运算符
比较运算符的结果都是boolean型，也就是要么是true，要么是false。
比较运算符“==”不能误写为“=”
逻辑运算符
逻辑运算符连接boolean类型的表达式
& 与：两边全是1时才为1
|或：全0时才为0
^异或：相异为1，相同为0
&和&&的特点：
&：无论左边是true是flase，右边都运算。|:两边都运算。
&&：当左边为flase时，右边不运算。 ||：当左边为true，右边不运算。
位运算符
位运算符是直接对二进制进行运算。
<<:相当于乘以2的倍数
>> :相当于除以2的倍数
移n位u，是对乘以或者除以2的n次幂。
3*2^2=12
>>：最高位补什么由原有数据的最高位值而定。
如果最高位0，右移后，用0补空位。如果最高位1，右移后，用1补空位。
>>>：无论最高位是什么，右移后，都用0补。
练习
- 最有效率的方式算出2乘8等于几？2*8
位运算效率最高 2<<3 - 对两个整数变量的值进行互换（不需要第三放变量）
int n = 3,m = 8;
System.out.println("n="+n+",m="+m);
//1, 通过第三方变量
int temp;
temp = n;
n = m;
m = temp;
//2, 不通过第三方变量
11 = 3 + 8;
3 = 11 - 8;
8 = 11 - 3;
n = n + m;//如果n和m的值非常大，容易超出int范围
m = n - m;
n = n - m;
//3
n = n^m;
m = n^m;//(n^m)^m,n异或1个数两次还是n
n = n^m;//n^(n^m)
练习：知道一个数的二进制形式，想知道它的十六进制（32位中获取每4位，右移）
int num = 60;
//获取60的最低4位，通过&15
int n1 = num & 15;-->12
System.out.print(n1>9?(char)(n1-10+'A'):n1);
//要获取下一组4位，将60右移4位
int temp = 60>>>4; //>>>:把原有数据移光，左边补0
//对temp的值进行最低四位的获取
int n2 = temp & 15;-->3
System.out.print(n2>9?(char)(n1-10+'A'):n2);-->会被提升
/*
0-9 'A' 'B' 'C' 'D' 'E' 'F'
65 66 67
10 11 12 13 14 15
12 - 10 = 2+'A' = (char)67;
*/
三元运算符
（条件表达式）？表达式1：表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；
例：获取2个事中大数。
int x = 3,y = 4,z;
z = (x>y)?x:y;//z变量存储的就是两个数的大数
2.6 语句 程序流程控制
顺序结构
判断结构
1. if(条件表达式)
{
执行语句;//如果控制的语句只有一条，则{}可以不写，if只控制离得最近的一条语句
}
2. if(条件表达式)
{
执行语句;
}
else
{
执行语句;
}
/*
if else 结构简写格式： 变量 = （条件表达式）？表达式1：表达式2；
三元运算符：好处：可以简化if else代码。弊端：因为是一个运算符，所以运算完必须要有一个结果。
*/
3. if(条件表达式)
{
执行语句;
}
else if(条件表达式)
{
执行语句;
}
......
else
{
执行语句;
}
例：
//需求1：根据用户定义的数值不同，打印对应的星期英文
int num = 2:
if (num == 1)
System.out.println(''monday");
else if(num == 2)
Systrem.out.print("Tuesday");
else
System.out.prinln("none");
//需求2：根据用户指定的月份，打印该月份所属的季节。3，4，5春；6，7，8夏；9，10，11秋；12，1，2冬
F1; int x = 4;
if (x== 3 || x ==4 || x ==5)
System.out.println(x+"春季")；
else if (x== 6 || x ==7 || x ==8)
System.out.println(x+"夏季")；
else if (x== 9 || x ==10 || x ==11)
System.out.println(x+"秋季")；
else if (x== 12 || x ==1 || x ==2)
System.out.println(x+"冬季")；
else
System.out.println(x+"月份不存在")；
F2:
if(x>12||x<1)
System.out.println(x+"月份不存在")；
else if(x>=3 &&x<=5)
System.out.println(x+"春季")；
else if(x>=6 &&x<=8)
System.out.println(x+"夏季")；
else if(x>=9 &&x<=11)
System.out.println(x+"秋季")；
选择结构
switch语句
switch(表达式)
{
case 取值1：
执行语句；
break;
case 取值2：
执行语句；
break;
…
default：
执行语句；
break;–>最后一个break可以不写
}
switch语句特点：
switch 语句选择的类型只有4中：byte,short,int,char
case之间与default没有顺序，先执行第一个case，没有匹配的case执行default.
结束switch语句的两种情况：遇到break，执行到switch 语句结束。
如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。
//需求2：根据用户指定的月份，打印该月份所属的季节。3，4，5春；6，7，8夏；9，10，11秋；12，1，2冬
int x = 4;
{
case 3:
case 4:
case 5:
System.out.println(x+"春")；
break;
case 6:
case 7:
case 8:
System.out.println(x+"夏")；
break;
case 9:
case 10:
case 11:
System.out.println(x+"秋")；
break;
case 12:
case 1:
case 2:
System.out.println(x+"冬")；
break;
default:
System.out.println(“none”)；
}
if和switch语句使用选择：
如果判断的具体数值不多，而是符合byte,short,int,char这四种类型。虽然两个语句都可以使用，建议使用switch，效率更高。
其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。
循环结构
while,do while,for
-
while(条件表达式)
{
执行语句；
} -
do
{
执行语句；
}while（条件表达式）；
do while特点是条件无论是否满足，循环至少被执行一次。
while:先判断条件，只有条件满足才执行循环体。
do whille:先执行循环体，再判断条件，条件满足，再继续执行循环体。
3.for(初始化表达式：循环表达式：循环后的表达式)
{
执行语句；
}
注：for里面的连个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复这个过程，直到条件不满足为止。
while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放，而while循环使用的变量在循环结束后还可以继续使用。
最简单无限循环格式：while(true){},for( ; ; ) {},无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。
for(int x = 0:x<3;x++)
{
System.outt.println("x="+x);
}
// System.outt.println("x===="+x);
int = y=0;
while(y<3)
{
System.outt.println("y="+y);
y++;
}
// System.outt.println("y===="+y);
1.变量有自己的作用域，对于for来讲：如果将用于控制循环的增量定义在for语句中，那么该变量值在for语句内有效。for语句执行完毕，该变量在内存中被释放。
2.for和while可以进行互换，如果需要定义循环增量，用for更为合适。
总结：什么时候使用循环结构
当要对某些语句执行很多次时，就使用循环结构。
使用一个变量，该变量的数值变化是有规律的，这个规律可以通过循环来完成，用循环操作这个变量后在下面的代码使用这个循环变量的结果，使用while。
练习
for(System.out.println("a");System.out.println("b");System.out.println("c"))
{
System.out.println("d");
}
//“b”看不出真假
for(System.out.println("a"); x<3 ;System.out.println("c")，x++)
{
System.out.println("d");
// x++；
}
//adcdc
for(int y=0; y<3; y++)
{
}与下面相同
int y=0;
for( ; y<3; )
{
y++;
}
练习
- 获取1~10的和，并打印
//1.定义一个变量用于存储不断变化的和
int sum = 0;
/2./定义变量，记录不断变化的被加的数
int x = 1;
//定义循环，重复加法的过程
while(x<=10)
{
sum = sum + x;
x++;
}
System.out.println("sum="+sum);
//循环注意：一定要明确哪些语句需要参加循环，哪些不需要。
//用for
int sum = 0;
for (int x= 0;x<=10;x++)
{
sum = +=x;
}
System.out.println("for sum="+sum);
累加思想：
原理：通过变量记录住每次变化的结果，通过循环的形式，进行累加动作。
例：一个数不断变大/变小，字符串的不断延长。
2. 1~100之间7的倍数的个数，并打印。
思路：
1.先对1~100进行循环（遍历）通过循环的形式。
2.在遍历的过程中，定义条件，只对7的倍数进行操作。
3.因为7的倍数不确定，只要符合条件，就通过一个变量来记录注这个变化的次数。
步骤：
1.定义循环语句，选择for语句
2.在循环中定义判断，只要是7的倍数即可，使用if 语句，条件：7的倍数 x%7 == 0;
3.定义变量，该变量随着7的倍数的出现而自增
int count = 0;
for (int x = 1;x<=100;x++)
{
if (x%7 == 0);
//System.out.println("x="+x);//(ln-->(L)换行)
count++;
}
System.out.printIn("count="+count);
计数器思想：
原理：通过一个变量记录住数据的状态变化，也通过循环完成。
例：想获取某一个里面条件内容有多少个，计数器思想，计数器条件根据需求而定。
语句嵌套形式：语句中还有语句。
循环嵌套
for (int x = 0; x< 3; x++)
{
for (int y = 0; y<4 ;y++)
{
System.out.ptint(" $ ");
}
System.out.ptintln(); //只有一个功能，换行
// System.out.ptint();一句废话
}
$$
$$
对于打印的长方形：外循环控制的行数，内循环控制的是每一行的列数，也就是一行中元素的个数。
练习
1.
%%%%%
%%%%
%%%
%%
%
分析：发现一个图形有很多行，每一行有很多列。要使用嵌套循环，原理：大圈套小圈
int z = 5;//定义一个变量记录列数的变化
for (int x = 0 ; x<5 ; x++)//x<5：因为外循环控制行数，一共5行
{
for (int y = 0 ; y<z ; y++)
{
System.out.print("%");//如果这里打印的结果全是竖着排列，多打印一个ln
}
System.out.println();
z--;
}
int z = 0;//定义一个变量记录列数的变化
for (int x = 0 ; x<5 ; x++)//x<5：因为外循环控制行数，一共5行
{
for (int y = z ; y<5 ; y++)
{
System.out.print("%");//如果这里打印的结果全是竖着排列，多打印一个ln
}
System.out.println();
z++;
}
修改y=0，z的值，同x的值，令y = x;
for (int x = 0 ; x<5 ; x++)//x<5：因为外循环控制行数，一共5行
{
for (int y = x ; y<5 ; y++)
{
System.out.print("%");//如果这里打印的结果全是竖着排列，多打印一个ln
}
System.out.println();
}
for (int x = 5 ; x>0 ; x--)//x<5：因为外循环控制行数，一共5行
{
for (int y = 0 ; y<x ; y++)
{
System.out.print("%");//如果这里打印的结果全是竖着排列，多打印一个ln
}
System.out.println();
}
%
%%
%%%
%%%%
%%%%%
for (int x = 0; x<5 ; x++)
{
for (int y = (5-x); y <= 5 ; y++)
//for (int y = 0; y <= x ; y++)
{
System.out.print("*");
}
System.out.println();
}
不是规律的规律：
尖朝上，可以改变条件，让条件随着外循环变化。
尖朝下，可以改变初始化，让初始化随着外循环变化。
3.
1
12
123
1234
12345
for (int x = 1; x<=5 ; x++)
{
for (int y = 1; y<=x ; y++ )
{
System.out.print(y);
}
System.out.println();
}
4.九九乘法表
11=1
12=2 22=4
13=3 23=6 33=9
…
for (int x = 1; x<=9 ; x++)
{
for (int y = 1; y<=x ; y++ )
{
System.out.print(y+"*"+x+"="+y*x+"\t");// \t制表符
}
System.out.println();
}
其他流程控制语句
break（跳出），continue（继续）
break语句：应用范围：选择结构和循环结构。
continue语句：应用于循环结构。
注：
1.这两个语句离开应用范围存在是没有意义的。
2.这两个语句单独存在下面都不可以有语句，因为执行不到。
3.continue语句是结束本次循环继续下次循环。
4.标号的出现，让这两个语句作用于指定的范围。
练习：
----%
—% %
–% % %
-% % % %
% % % % %
–>去掉空格，是两个三角形。
----%
—%%
–%%%
-%%%%
for (int x = 0; x<5 ; x++)
{
for (int y = x+1; y<5 ; y++)
{
System.out.print("-");
}
for (int z = 0; z<=x ; z++)
{
System.out.print("* ");
}
System.out.println();
}
2.7 函数
函数的定义
什么是函数：函数就是定义在类中的具有特定功能的一段独立小程序。函数也成为方法。
函数的格式：
修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2，…）
{
执行语句；
return 返回值；
}
返回值类型：函数运行后的结果的数据类型。
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
return：用于结束函数。
返回值：该值会返回给调用者。
函数的特点
定义函数可以将功能代码进行封装。
便于对该函数进行复用。
函数只有被调用才会被执行。
函数的出现提高了代码的复用性。
对于函数没有返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句在最后一行可以省略不写。
注：函数中只能调用函数，不可以在函数内部定义函数。
定义函数时，函数的结果应该返回给调用者，交由调用者处理。
函数的应用
如何定义一个函数：
1.既然函数一个独立的功能，那么该功能的运算结果是什么先明确。–>明确函数的返回值类型。
2.在明确在定义该功能的过程中是否需要未知的内容参与运算。–>明确函数的参数列表（参数类型和个数）。
需求：定义一个功能，完成3+4的运算，并将结果返回给调用者。
1.明确功能的结果：是一个整数的和。
2.在实现该功能的过程中是否有位置内容参与运算，没有。
public static void main(String[] args)
{
int sun = getSum();
System.out.println("sum="+sum);
}
public static int getSum()；
{
return 3+4;
}
以上函数的功能，结果是固定的，毫无扩展性而言。为了方便用户需求，由用户来指定加数和被加数，这样功能才有意义。
思路：1.功能的结果是一个整数的和，返回值类型是int。
2.有未知内容参与运算，有两个，这两个未知内容的类型都是int。
public static void main(String[] args)
{
int sum = getSum(4,6);
System.out.println("sum="+sum);
}
public static int getSum(int x,int y)；
{
return x+y;
}
public static void main(String[] args)
{
//System.out.println(get(4,6));-->返回值是void，不能在输出语句输出，该功能在运算完后没有具体的值，无法打印。
get(4.5);-->直接调用，函数内部已经有打印语句了。
}
public static void get(int x,int y)
{
System.out.println(a+b);
return;
}
定义功能时不要这样定义，做了 求和 和 打印和 两件事，定义功能只为完成加法运算功能的函数，和 怎样操作次数不考虑，是调用者该做的。
练习
1.定义一个功能，用于打印一个矩形。
思路：1.确定结果：没有，直接打印。所以返回值类型是void。
2.有未知内容，两个，因为矩形的行和列不确定。
public static void main(String[] args)
{
draw(5,6);
printHr();
draw(6,7);
printHr();
}
public static void draw(int row,int col)
{
for (int x = 0; x<row ; x++)
{
for (int y = 0; y<col; y++)
{
System.out.print("*");
}
System.out.println();
}
}
public static void printHr()
{
System.out.println("---------------------");
}
2.定义一个打印99乘法表功能的函数。
public static void main(String[] args)
{
print99();
}
public static void print99()
{
for (int x = 1; x<=9 ; x++)
{
for (int y = 1; y<=x ; y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
函数的重载(overload)
重载的概念：在同一个类中，允许讯在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可。
重载只和参数列表有关（参数类型和参数个数）
重载的特点：与返回值类型无关，只看参数列表。
重载的好处：方便于阅读，优化了程序设计。
//返回两个整数的和
int add(int x,int y)(return x+y;)
//返回三个整数的和
int add(int x,int y，int z)(return x+y+z;)-->return add(x+y)+z;
//返回两个小数的和
double add(double x,double y)(return x+y;)
什么时候使用重载：
当定义的功能相同时，但西安与运算的未知内容不同。那么，这时就定义一个函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分多个同名函数。
练习
void show(int a,char b,double c){} 哪个答案和给定函数重载
a.void show(int x,char y,double z){}//没有，因为和原函数一样
b.int show(int a,double c,char b){}//重载，参数类型不同。注意：重载和返回值类型无关。
c.void show(int a,double c,char b){}//重载，参数类型不同。注意：重载和返回值类型无关。
d.boolean show(int c,char b){}//重载，参数个数不同。
e.void show(double c){}//重载，参数个数不同。
f.double show(int x,char y,double z){}//没有，这个函数不可以和给定函数同时存在于一个类中。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
