基础知识:
java编译运行过程:
java源文件(.java),经过编译,编译为java字节码文件(.class),然后通过JVM来加载.class并运行.class文件
不同系统有不同的JVM,但对.class是一样的
java可以实现跨平台
一次编程到处运行
JDK:java开发工具包
JRE:java运行环境
JVM:java虚拟机
JRE=JVM+java系统类库
JDK=JRE+编译、运行等开发环境
运行的最小环境为JRE
开发的最小环境为JDK
IDE:集成开发环境,eclipse是JAVA最主流的IDE
eclipse为IBM公司的,开源的
变量:
变量是一个代词,指代内存中的数据 变量是可以改变的量---指代不同的数据
变量必须先声明,再使用
语法: 数据类型 变量名;
int a;
可以一条语句声明多个同类型变量
eg: int a,b,c;
int a=1,b,c=2;
变量的命名:
规定:
1)只能包含字母、数字、_、$,并且不能以数字开头
2)严格区分大小写
3)不能使用关键字(java已经用了的字)
建议:
1)不建议中文命名变量
2)最好"见名知意"
3)驼峰命名法:第一个单词首字母小写,其余单词首字母大写
变量的初始化:
java语法规定:变量在使用前必须初始化
初始化两种方式:
1)声明同时初始化
int a=5;
2)先声明再初始化
int b;
b=8;
变量的使用:
1)必须与数据类型匹配
eg: int a=2.5; //错误,类型不匹配
数据类型:
int:
1)整型,占4个字节,范围-21个多亿到21个多亿
2)整数直接量(25,250,2500...),默认为int类型
3)两个整数相除,结果为整数(无条件舍去小数位)
int型变量只占4字节
long:
1)长整型,占8个字节,范围特别大(足够用)
2)long型直接量,在数字后面加l或L
eg: long a = 35L;
int a=10000000000; //错误
long a = 10000000000; //错误
long a = 10000000000L;//正确
float:
1)单精度浮点型,占用4字节。
2)float型直接量直接在浮点数后加f或者F
double:
1)双精度浮点型,占8个字节。
2)浮点型直接量(1.1,1.0,……)默认为double
char:
1)字符型。占用一个字节
2) 赋值是用单引号('')括起来
3) 字符型变量只接受一个字符。
eg: char c = 'a';
char c ='ab' //错误。
boolean:
1) 布尔型变量,属于int的子集。
2)只有两个值 true 和 false。
3)一切非0值代表true其余代表false。
各个类型之间的转换: 变量 = (需要转换的类型)变量
eg int a = 10;
long l = (long)a;
逻辑运算符:
&&:两边都为真,则为真
||:有一边为真,都为真
!:非真则假,非假则真
Java中的HelloWorld:
public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World"); } }
Java中main方法为程序的入口。
Java中输出语句为:System.out.println();
Java接收用户输入:
import java.util.Scanner; //1.导入Scanner包 public class HelloWorld { public static void main(String[] args) { Scanner scan = new Scanner(System.in); //2.创建Scanner对象 System.out.println("请输入你的年龄:"); int age=scan.nextInt(); //3.等待用户输入一个int型变量。 System.out.println("请输入你的身高:"); double height = scan.nextDouble();//等待用户输入一个double变量 boolean b1 = age>=18 && age<=50;//判断年龄是否在18-50之间。 System.out.println(b1); //true }
接受用户输入主要分为3步:
1)import java.util.Scanner; //导入Scanner包
2)Scanner scan = new Scanner(System.in); //创建一个scanner对象。
3)int age=scan.nextInt(); //3等待用户输入。
运算符:
表格中的实例假设整数变量A的值为10,变量B的值为20:
操作符 | 描述 | 例子 |
---|---|---|
+ | 加法 - 相加运算符两侧的值 | A + B 等于 30 |
- | 减法 - 左操作数减去右操作数 | A – B 等于 -10 |
* | 乘法 - 相乘操作符两侧的值 | A * B等于200 |
/ | 除法 - 左操作数除以右操作数 | B / A等于2 |
% | 取模 - 左操作数除以右操作数的余数 | B%A等于0 |
++ | 自增: 操作数的值增加1 | B++ 或 ++B 等于 21(区别详见下文) |
-- | 自减: 操作数的值减少1 | B-- 或 --B 等于 19(区别详见下文) |
public class Test { public static void main(String[] args) { int a = 10; int b = 20; int c = 25; int d = 25; System.out.println("a + b = " + (a + b) ); System.out.println("a - b = " + (a - b) ); System.out.println("a * b = " + (a * b) ); System.out.println("b / a = " + (b / a) ); System.out.println("b % a = " + (b % a) ); System.out.println("c % a = " + (c % a) ); System.out.println("a++ = " + (a++) ); System.out.println("a-- = " + (a--) ); // 查看 d++ 与 ++d 的不同 System.out.println("d++ = " + (d++) ); System.out.println("++d = " + (++d) ); } }
结果如下:
a + b = 30 a - b = -10 a * b = 200 b / a = 2 b % a = 0 c % a = 5 a++ = 10 a-- = 11 d++ = 25 ++d = 27
自增自减运算符
1、自增(++)自减(--)运算符是一种特殊的算术运算符,在算术运算符中需要两个操作数来进行运算,而自增自减运算符是一个操作数。
public class selfAddMinus{ public static void main(String[] args){ int a = 3;//定义一个变量; int b = ++a;//自增运算 int c = 3; int d = --c;//自减运算 System.out.println("进行自增运算后的值等于"+b); System.out.println("进行自减运算后的值等于"+d); } }
运行结果为:
进行自增运算后的值等于4 进行自减运算后的值等于2
解析:
-
int b = ++a; 拆分运算过程为: a=a+1=4; b=a=4, 最后结果为b=4,a=4
-
int d = --c; 拆分运算过程为: c=c-1=2; d=c=2, 最后结果为d=2,c=2
2、前缀自增自减法(++a,--a): 先进行自增或者自减运算,再进行表达式运算。
3、后缀自增自减法(a++,a--): 先进行表达式运算,再进行自增或者自减运算 实例:
实例
public class selfAddMinus{ public static void main(String[] args){ int a = 5;//定义一个变量; int b = 5; int x = 2*++a; int y = 2*b++; System.out.println("自增运算符前缀运算后a="+a+",x="+x); System.out.println("自增运算符后缀运算后b="+b+",y="+y); } }
运行结果为:
自增运算符前缀运算后a=6,x=12 自增运算符后缀运算后b=6,y=10
关系运算符
下表为Java支持的关系运算符
表格中的实例整数变量A的值为10,变量B的值为20:
运算符 | 描述 | 例子 |
---|---|---|
== | 检查如果两个操作数的值是否相等,如果相等则条件为真。 | (A == B)为假(非真)。 |
!= | 检查如果两个操作数的值是否相等,如果值不相等则条件为真。 | (A != B) 为真。 |
> | 检查左操作数的值是否大于右操作数的值,如果是那么条件为真。 | (A> B)非真。 |
< | 检查左操作数的值是否小于右操作数的值,如果是那么条件为真。 | (A <B)为真。 |
>= | 检查左操作数的值是否大于或等于右操作数的值,如果是那么条件为真。 | (A> = B)为假。 |
<= | 检查左操作数的值是否小于或等于右操作数的值,如果是那么条件为真。 | (A <= B)为真。 |
位运算符
Java定义了位运算符,应用于整数类型(int),长整型(long),短整型(short),字符型(char),和字节型(byte)等类型。
位运算符作用在所有的位上,并且按位运算。假设a = 60,b = 13;它们的二进制格式表示将如下:
A = 0011 1100 B = 0000 1101 ----------------- A&b = 0000 1100 A | B = 0011 1101 A ^ B = 0011 0001 ~A= 1100 0011
下表列出了位运算符的基本运算,假设整数变量A的值为60和变量B的值为13:
操作符 | 描述 | 例子 |
---|---|---|
& | 如果相对应位都是1,则结果为1,否则为0 | (A&B),得到12,即0000 1100 |
| | 如果相对应位都是0,则结果为0,否则为1 | (A | B)得到61,即 0011 1101 |
^ | 如果相对应位值相同,则结果为0,否则为1 | (A ^ B)得到49,即 0011 0001 |
〜 | 按位取反运算符翻转操作数的每一位,即0变成1,1变成0。 | (〜A)得到-61,即1100 0011 |
<< | 按位左移运算符。左操作数按位左移右操作数指定的位数。 | A << 2得到240,即 1111 0000 |
>> | 按位右移运算符。左操作数按位右移右操作数指定的位数。 | A >> 2得到15即 1111 |
>>> | 按位右移补零操作符。左操作数的值按右操作数指定的位数右移,移动得到的空位以零填充。 | A>>>2得到15即0000 1111 |
逻辑运算符
下表列出了逻辑运算符的基本运算,假设布尔变量A为真,变量B为假
操作符 | 描述 | 例子 |
---|---|---|
&& | 称为逻辑与运算符。当且仅当两个操作数都为真,条件才为真。 | (A && B)为假。 |
| | | 称为逻辑或操作符。如果任何两个操作数任何一个为真,条件为真。 | (A | | B)为真。 |
! | 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true,则逻辑非运算符将得到false。 | !(A && B)为真。 |
赋值运算符
下面是Java语言支持的赋值运算符:
操作符 | 描述 | 例子 |
---|---|---|
= | 简单的赋值运算符,将右操作数的值赋给左侧操作数 | C = A + B将把A + B得到的值赋给C |
+ = | 加和赋值操作符,它把左操作数和右操作数相加赋值给左操作数 | C + = A等价于C = C + A |
- = | 减和赋值操作符,它把左操作数和右操作数相减赋值给左操作数 | C - = A等价于C = C - A |
* = | 乘和赋值操作符,它把左操作数和右操作数相乘赋值给左操作数 | C * = A等价于C = C * A |
/ = | 除和赋值操作符,它把左操作数和右操作数相除赋值给左操作数 | C / = A等价于C = C / A |
(%)= | 取模和赋值操作符,它把左操作数和右操作数取模后赋值给左操作数 | C%= A等价于C = C%A |
<< = | 左移位赋值运算符 | C << = 2等价于C = C << 2 |
>> = | 右移位赋值运算符 | C >> = 2等价于C = C >> 2 |
&= | 按位与赋值运算符 | C&= 2等价于C = C&2 |
^ = | 按位异或赋值操作符 | C ^ = 2等价于C = C ^ 2 |
| = | 按位或赋值操作符 | C | = 2等价于C = C | 2 |
三目运算符(?:)
条件运算符也被称为三元运算符。该运算符有3个操作数,并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
variable x = (expression) ? value if true : value if false
public class Test { public static void main(String[] args){ int a , b; a = 10; // 如果 a 等于 1 成立,则设置 b 为 20,否则为 30 b = (a == 1) ? 20 : 30; System.out.println( "Value of b is : " + b ); // 如果 a 等于 10 成立,则设置 b 为 20,否则为 30 b = (a == 10) ? 20 : 30; System.out.println( "Value of b is : " + b ); } }
以上实例编译运行结果如下:
Value of b is : 30 Value of b is : 20
运算符优先级:
下表中具有最高优先级的运算符在的表的最上面,最低优先级的在表的底部。
类别 | 操作符 | 关联性 |
---|---|---|
后缀 | () [] . (点操作符) | 左到右 |
一元 | + + - !〜 | 从右到左 |
乘性 | * /% | 左到右 |
加性 | + - | 左到右 |
移位 | >> >>> << | 左到右 |
关系 | >> = << = | 左到右 |
相等 | == != | 左到右 |
按位与 | & | 左到右 |
按位异或 | ^ | 左到右 |
按位或 | | | 左到右 |
逻辑与 | && | 左到右 |
逻辑或 | | | | 左到右 |
条件 | ?: | 从右到左 |
赋值 | = + = - = * = / =%= >> = << =&= ^ = | = | 从右到左 |
逗号 | , | 左到右 |
分支结构:
if 语句的用语法如下:
if(布尔表达式) { //如果布尔表达式为true将执行的语句 }
如果布尔表达式的值为 true,则执行 if 语句中的代码块,否则执行 if 语句块后面的代码。
if...else语句
if 语句后面可以跟 else 语句,当 if 语句的布尔表达式值为 false 时,else 语句块会被执行。
if(布尔表达式){ //如果布尔表达式的值为true }else{ //如果布尔表达式的值为false }
if...else if...else 语句
if 语句后面可以跟 elseif…else 语句,这种语句可以检测到多种可能的情况。
使用 if,else if,else 语句的时候,需要注意下面几点:
- if 语句至多有 1 个 else 语句,else 语句在所有的 elseif 语句之后。
- if 语句可以有若干个 elseif 语句,它们必须在 else 语句之前。
- 一旦其中一个 else if 语句检测为 true,其他的 else if 以及 else 语句都将跳过执行。
if(布尔表达式 1){ //如果布尔表达式 1的值为true执行代码 }else if(布尔表达式 2){ //如果布尔表达式 2的值为true执行代码 }else if(布尔表达式 3){ //如果布尔表达式 3的值为true执行代码 }else { //如果以上布尔表达式都不为true执行代码 }
嵌套的 if…else 语句
嵌套的else只与最近的if相配对。
switch 语句
switch 语句判断一个变量与一系列值中某个值是否相等,每个值称为一个分支。
语法
switch 语法格式如下:
switch(expression){ case value : //语句 break; //可选 case value : //语句 break; //可选 //你可以有任意数量的case语句 default : //可选 //语句 }
switch 语句有如下规则:
-
switch 语句中的变量类型可以是: byte、short、int 或者 char。从 Java SE 7 开始,switch 支持字符串类型了,同时 case 标签必须为字符串常量或字面量。
-
switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
-
case 语句中的值的数据类型必须与变量的数据类型相同,而且只能是常量或者字面常量。
-
当变量的值与 case 语句的值相等时,那么 case 语句之后的语句开始执行,直到 break 语句出现才会跳出 switch 语句。
-
当遇到 break 语句时,switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现,程序会继续执行下一条 case 语句,直到出现 break 语句。
-
switch 语句可以包含一个 default 分支,该分支必须是 switch 语句的最后一个分支。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
循环语句:
循环三要素:
1.循环变量初始化
2.循环条件(以循环变量为条件)
3.循环变量的改变(向着循环结束变)
循环变量:在循环过程中改变的那个量
int count=1; //跑的圈数---计数
count<=3 //条件------------跑
count++; //改变计数
count=1 true 跑
count=2 true 跑
count=3 true 跑
count=4 false
while 循环
while是最基本的循环,它的结构为:
while( 布尔表达式 ) { //循环内容 }
do…while 循环
对于 while 语句而言,如果不满足条件,则不能进入循环。但有时候我们需要即使不满足条件,也至少执行一次。
do…while 循环和 while 循环相似,不同的是,do…while 循环至少会执行一次。
do { //代码语句 }while(布尔表达式);
注意:布尔表达式在循环体的后面,所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true,则语句块一直执行,直到布尔表达式的值为 false。
for循环
虽然所有循环结构都可以用 while 或者 do...while表示,但 Java 提供了另一种语句 —— for 循环,使一些循环结构变得更加简单。
for(初始化; 布尔表达式; 更新) { //代码语句 }
关于 for 循环有以下几点说明:
- 最先执行初始化步骤。可以声明一种类型,但可初始化一个或多个循环控制变量,也可以是空语句。
- 然后,检测布尔表达式的值。如果为 true,循环体被执行。如果为false,循环终止,开始执行循环体后面的语句。
- 执行一次循环后,更新循环控制变量。
- 再次检测布尔表达式。循环执行上面的过程。
Java 增强 for 循环
Java5 引入了一种主要用于数组的增强型 for 循环。
Java 增强 for 循环语法格式如下:
for(声明语句 : 表达式) { //代码句子 }
声明语句:声明新的局部变量,该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块,其值与此时数组元素的值相等。
表达式:表达式是要访问的数组名,或者是返回值为数组的方法。
public class Test { public static void main(String args[]){ int [] numbers = {10, 20, 30, 40, 50}; for(int x : numbers ){ System.out.print( x ); System.out.print(","); } System.out.print("\n"); String [] names ={"James", "Larry", "Tom", "Lacy"}; for( String name : names ) { System.out.print( name ); System.out.print(","); } } }
以上实例编译运行结果如下:
10,20,30,40,50, James,Larry,Tom,Lacy,
break 关键字
break 主要用在循环语句或者 switch 语句中,用来跳出整个语句块。
break 跳出最里层的循环,并且继续执行该循环下面的语句。
continue 关键字
continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在 for 循环中,continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中,程序立即跳转到布尔表达式的判断语句。
嵌套循环执行过程:
外层循环走一次,内层循环走所有次
建议:
循环层数越少越好
break:
只能跳出一层循环
数组:
1.数组可以装一组数,必须类型相同
2.数组按线性顺序,一个跟一个
3.数组也是一种数据类型
4.数组new之后,数组中的每个元素都有一个默认值
整数:0 浮点数:0.0 boolean:false
1)数组的定义:
int[] arr = new int[4]; //每个数都是0
2)数组的初始化
int[] arr; //声明数组 arr = new int[4]; //初始化 int[] arr = {1,5,8,3}; //只能声明同时初始化 int[] arr = new int[]{1,5,8,3}; int[] arr; arr = {1,5,8,3}; //错误
3)数组的访问:通过下标
下标从0开始
int[] arr = new int[4]; System.out.println(arr.length);//数组的长度4 arr[0] = 55;//给arr中的第1个数赋值为55 arr[4] = 99; //错误,数组越界,最大到3 System.out.println(arr[2]);//输出第3个数
遍历数组:
//遍历数组 int[] arr = {1,8,5,3}; for(int i=0;i<arr.length;i++){ //正序 System.out.println(arr[i]); } for(int i=arr.length-1;i>=0;i--){ //倒序 System.out.println(arr[i]); }
int[] arr = {2,9,6,1,56,67,234,45,7657,234}; for(int i=0;i<arr.length;i++){ System.out.println(arr[i]); } System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); System.out.println(arr[3]);
声明一个整型数组名为a,可以存储4个整数
int[] a = new int[4];
double[] s = new double[4];
String[] ns = new String[10];
数组的.length:
int[] arr = new int[5];
int i = arr.length; //5
数组
1)定义
数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[5];
2)初始化
int[] arr = new int[3]; //默认值为0
int[] arr = {2,4,7};
int[] arr = new int[]{2,4,7};
3)访问:通过下标/索引
int len = arr.length; //长度
int num = arr[0]; //取第1个元素
int num = arr[arr.length-1];//取最后1个元素
arr[0] = 88; //赋值
System.out.println(arr[0]); //取值
4)复制
//从a的第1个元素开始
//复制到a1中,从第3个元素开始
//一共复制4个元素
System.arraycopy(a,0,a1,2,4);
//将a数组复制到b数组,b有6个元素
int[] b = Arrays.copyOf(a,6);
//给a数组扩容
a = Arrays.copyOf(a,a.length+1);
5)排序
Arrays.sort(arr); //升序
dataType[] arrayRefVar; // 首选的方法 或 dataType arrayRefVar[]; // 效果相同,但不是首选方法
注意: 建议使用 dataType[] arrayRefVar 的声明风格声明数组变量。 dataType arrayRefVar[] 风格是来自 C/C++ 语言 ,在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。
方法(函数,过程):
方法:也叫函数、过程。
1)用于封装一段特定的逻辑功能。
2)尽可能独立。 (一个方法只干一件事)
3)可以在程序中反复调用。
4)避免了代码的冗余。便于的代码的维护,有利于团队协作开发。
方法的定义:五要素
1)修饰词
2)返回值类型:
-可以有返回值也可以没有返回值。没有返回值写void,有返回值写特定的返回值类型。
-方法执行完后需要用到方法中的某个数据 ----需要返回值。
-通过return语句返回,return语句的作用在于结束方法并将数据返回。
3)方法名:见名知意。
4)参数列表:在调用时传递给方法 ,需要被方法处理的数据
-可以有参数,也可以无参数。 ----有参更灵活。
-在调用时,会将实际的参数值传递给方法的参数 变量,必须保证传递参数的类型和个数符合方法的声明
5)方法体:放在一对大括号内。
修饰词 返回值类型 方法名(参数列表){
方法体
}
当方法需要返回结果时,设计特定返回值类型
不需要结果时,返回值类型为void
返回结果通过return关键字