基础常识
1.JVM,JRE,JDK
JRE = JVM + 相关类库
JDK = JRE + 工具
2.下载安装jdk,设置path环境变量
3.第一个java程序HelloWorld
1)创建.java源文件,使用记事本进行编辑
public class HelloWorld {
//main方法,程序的入口方法
public static void main (String[] args) {
System.out.println("hi,boy");
}
}
2)进入命令行,使用javac进行编译(javac HelloWorld.java)
3)使用java执行程序(java HelloWorld)
javac java
.java源文件 -------->字节码文件-------> 结果
注意:
Java源文件以“java”为扩展名。源文件的基本组成部分是类(class),如本类中的HelloWorld类。
一个源文件中最多只能有一个public类。其它类的个数不限,如果源文件包含一个public类,则文件名必须按该类名命名。
Java应用程序的执行入口是main()方法。它有固定的书写格式:public static void main(String[] args) {...}
Java语言严格区分大小写。
Java方法由一条条语句构成,每个语句以“;”结束。
大括号都是成对出现的,缺一不可。
含有主方法的public类叫公共主类,公共主类的类名必须和源文件名字一致,含有主方法的类叫做主类
4.Java语言的特性:
1)安全 每个Java程序的执行都需要通过类加载器的安全检查
2)面向对象 面向对象关注的是完成事务的角色,将具有相同特性或者相同功能的东西进行抽象,然后统一调用,而不是一步一步的执行。
程序的设计也是以对象为个体。
3)跨平台 Java中利用虚拟机实现跨平台,我们编写程序是面向的是虚拟机(JVM),程序执行时,JVM面对不同的操作系统做出不同的处理。
4)健壮 Java中对指针有了很好的解决
5)分布式 统一网络上的多台电脑解决同一问题
6)性能好
7)简单
8)多线程 多并发
5.注释的使用:
// 行注释
/*
*/段注释(多行注释) 不可以嵌套使用
/**
*/文档注释
基础语法
标识符&关键字
关键字:Java语言中赋予了特殊含义,用作专门用途的字符串
保留字
标识符:凡是自己可以起名字的地方都叫标识符
命名规则:(必须准守,否则报编译错误)
1.由26个英文字母大小写,0~9,_,$组成
2.数字不可以开头
3.不可以直接使用关键字和保留字,但是可以包含关键字和保留字
4.Java严格区分大小写,长度无限制
5.标识符不能包含空格
Java中的命名规范:(建议遵守,不遵守不会报编译错误)
包名:多单词组成时所有字母都小写:xxxyyyzzz
类名、接口名:多单词组成时,所有单词的首字母大写:XxxYyyZzz
变量名、方法名:多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写:xxxYyyZzz
常量名:所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_ZZZ
变量
变量:解决单个数据的存储问题
在内存中的一块被命名的,有特定的数据类型的存储区域,其中的值可以在类型范围内无限次改变
变量的声明
类型 变量名;
初始化赋值,变量刚声明完后的第一次赋值
变量名 = 值;
普通赋值
变量名 = 值;
变量的使用:
只需要通过变量名就可以了。
变量的使用注意事项:
1) 有其作用范围 声明语句所属的一对{}
2) 必须先声明, 后使用
3) 局部变量必须进行初始化赋值
4) 变量必须有名字, 和类型
5) 变量在其范围内不允许重复定义
6) 变量保存的值有其范围和类型
int a = 10; //在内存中开辟一块名字为a,类型为int型的区域,并将10写入这个区域
int b = a; //在内存中开辟一块名字为b,类型为int型的区域,找到名字为a的内存区域,将其中的值复制到一块临时空间,然后写入b
变量的分类:
1.按照数据类型进行分类:
1)基本数据类型:区域中保存的是数据本身
1) 数值型
1) 整数
byte 1 -128~127 1000 0000 -> 0x80 ~ 0111 1111 -> 0x7f
short 2 -32768~32767 1000 0000 0000 0000 -> 0x8000 ~ 0111 1111 1111 1111 -> 0x7fff
int 4 -20多亿~20多亿 0x80000000 ~ 0x7FFFFFFF
long 8 0x80000000000000000 ~ 0x7FFFFFFFFFFFFFFF
char 2 0-65535 0x0 ~ 0xFFFF
2) 浮点数
float 4 10的38次方
double 8 10的308次方
数据的自动转型(小--大) byte -> short -> int -> long -> float -> double
char ->int (char byte short 这三个类型互不兼容) 浮点数默认类型double 整型默认类型int
数据的强转转型(大--小) 若是字面值可以直接在值后面加字母: float f =3.14f long l =1000000000000000000000000l
非字面值必须使用强转符 ( ) 括号中写目标类型
任何数据在计算机底层都是以二进制补码的形式存储。
2) 布尔型
boolean 1 true(1),false(0)
2)引用数据类型:区域中保存的是其他数据的内存地址,是一个无符号整数,大小取决于JDK的版本null地址就是0地址
2.按照变量的范围进行分类
1)局部变量:在方法中声明的变量 范围小,寿命短
2)成员变量:在类中方法外声明的变量 范围大,寿命长
class A {
int i = 1; // 成员变量
void m() {
int i = 0; // 局部变量
}
}
运算符
运算符是一种特殊的符号,用以表示数据的运算,赋值,比较等。
算术运算符:
+ - + - * / % ++ -- +
注意: 1) /: int i = 12; i = i / 5;
2) %:最后的符号只跟被模数相同
3) 前++:先+1,后运算
后++:先运算,后+1
4)+:String字符串与其他数据类型只能做连接运算,且结果为String类型。sysout('*' + '\t' + '*'); vs sysout("*" + '\t' + '*');
System.out.println('a' +'b' + "hello"); //两个字符 + 返回int型(将它们的Unicode码值进行求和),再和字符串连接
System.out.println("hello" +'a' + 'b');//字符串跟任意字符 + 都是连接运算
赋值运算符:
= += -= *= /= %=
= 基本类型的赋值运算,将值copy写入
+= 累加(既可以实现运算,又不改变运算对象的数据类型) 注:没有涉及强转
-= 累减
*= 累乘
/= 累除
%= 累余
【特别地】
short s = 10;
s = s + 5;//报编译的异常
s = (short)(s + 5);
s += 5;//s = s + 5,但是结果不会改变s的数据类型。(注只是和强转效果一致,但是没有涉及强转)
比较运算符(关系运算符)
== > < >= <= instanceof (用于后边的实例的判断)
【注意】区分== 与 = 区别。 == 比较运算符 = 赋值运算符
进行比较运算操作以后,返回一个boolean类型的值
4>=3 表达的是4 > 3或者 4 = 3.结果是true。
if(i > 1 && i < 10){ }
不能写为:if(1 < i < 10){}
逻辑运算符(运算符的两端是boolean值)
& && | || ^ !
【注意】 & 与 && 的区别, &无论左端真假都要执行右端
&&若左端为假不执行右端
| 与 || 的区别 |无论左端真假都要执行右端
||左端为真不执行右端、
^ 逻辑异或 不同为真
相同为假
我们使用的时候,选择&& , ||
位运算符(两端是数值类型的数据)
两端的数值类型的数据按位进行运算(这里的位指其二进制位)
<< >> >>> & | ^ ~
<< 左移 (左移一位相当于*2)高效的完成*2操作
>>右移(右移一位相当于/2)高效的完成/2操作 符号位为0补0 为1补1
>>>无符号右移 不管正负都用0补
【例子】1.如何交换m = 12和n = 5的值(利用^高效的交换)
2.将60转换为十六进制输出。
三元运算符
(条件表达式)? 表达式1 : 表达式2;
1)既然是运算符,一定会返回一个结果,并且结果的数据类型与表达式1,2的类型一致
2)表达式1与表达式2 的数据类型一致。
3)使用三元运算符的,一定可以转换为if-else。反之不一定成立。
例子:获取两个数的较大值;获取三个数的最大值。
流程控制
分支
1.条件判断: if - else
①if(条件表达式){ }
②if(条件表达式){
//执行的语句1;
}else{
//执行的语句2;
}
③if(条件表达式1){
//执行的语句1;
}else if(条件表达式2){
//执行的语句2;
}else if( 条件表达式3){
//执行的语句3;
}...
}else{
//执行的语句;
}
【注意】
1)一旦满足某个条件表达式,则进入其执行语句块执行,执行完毕,跳出当前的条件判断结构,不会执行其以下的条件结构语句。
2)如果诸多个条件表达式之间为“互斥”关系,多个结构可以上下调换顺序
如果诸多个条件表达式之间为“包含”关系,要求条件表达式范围小的写在范围大的上面。
3)严格的分支语句
2.选择结构 switch - case
switch(变量){
case 值1:
语句1;
//break;
case 值2:
语句2;
//break;
...
default:
语句N;
break;
}
【注意】
1)变量可以为如下的数据类型:byte short int char 枚举 String
2)switch - case 中的break省略掉就不是严格的分支语句
3)可以利用break的特性快速的实现好几个值实现同一个功能
4)case后只能填写变量的值,不能写范围。
5)default是可以省略的。并且其位置也是灵活的,但是通常将其放在case语句之后。
6)一旦满足某个case语句,则进入执行其操作。直至遇到break或者程序终止。
7)若要判断的语句的条件满足switch变量的数据类型,且值不多的情况下,建议选择switch-case .
除此之外,选择if-else.
循环
1.循环的格式:
①初始化条件
②循环条件
③迭代部分
④循环体
while循环
①
while(②){
④
③
}
执行0~N次
do-while循环
①
do{
④
③
}while(②);
执行1~N次
for循环
for(①;②;③){
④
}
执行顺序:① ② ④ ③ ② ④ ③ ② ④ …… ② 迭代语句是每一循环的开始语句(除第一次)
例子:
for (int i = 0; i < 20; i++) {
System.out.println(i);
}
2.嵌套循环:循环结构还可以声明循环。让内层循环结构整体充当外层循环的循环体。
若外层循环执行m次,内层循环执行n次,整个程序执行m*n次。
【题目】
******
******
******
for(int i = 0;i < 3;i++){
for(int j = 0;j < 6;j++){
System.out.print("*");
}
System.out.println();
}
说明:外层循环控制行数,内层循环控制列数
【例题】1.九九乘法表
2.输出100内的质数。(两种)(参照for循环经典程序分析博客)
3.无限循环结构
while(true){
} //死循环
do {
} while (true); 死循环
do {
语句1;
语句2;
条件
break;
语句3
语句4
} while (false); 利用do-while的特性完成特殊功能
for
死循环的多种写法:
for (;;) {}
for (初始化;;迭代语句) {}
for (初始化;true;迭代语句) {}
for (初始化; 条件语句;) {}
for(;;){
...
if( ){
break;
}
...
}
或者
while(true){
...
if( ){
break;
}
...
}
往往我们在无限循环结构内部提供循环的终止条件,使用break关键字。否则,此循环将无限制的执行下去,形成死循环!
死循环是我们要避免的。
break&continue
break:
使用在switch-case结构或者循环结构中
中断它所隶属的某个语句块的执行(在循环结构中,一旦执行到break,就跳出当前循环)
break 标签; 中断标签指定的循环体
continue:
使用在循环结构中
中断当次循环, 直接进入下一次循环
while (条件) {
continue;
}
continue 标签 中断标签指定的循环的当次循环, 直接进入标签指定的循环的下一次循环.
小例子:
for(int i = 1;i <= 10;i++){
if(i % 4 == 0){
//break; //123
continue; //123567910
}
System.out.print(i);
}
在嵌套循环中,使用带标签的break和continue。
label:for(int i = 1;i < 5;i++){
for(int j = 1;j <= 10;j++){
if(j % 4 == 0){
//break;
//continue;
//break label;
continue label;
}
System.out.print(j);
}
System.out.println();
}
利用break和continue打印质数
方法(method)
1.方法 : 功能封装(类或对象行为特征的抽象) 方法=函数
方法不能独立存在必须定义在类里,方法不能嵌套
声明方法 :
修饰符 返回值类型 方法名(形参类型1 形参1, 形参类型2 形参2, ....) {
方法体;
return 返回值类型的值;
}
API
public static Type methodName(Type1 parmeter1, Type2 parameter2, ....) {
code;
return value;
}
方法调用:
方法名(实参1,实参2,....);
public static void anotherMethod() {
// 调用方法, 方法名(实参1, 实参2, ....);
Type var = methodName(argument1, argument2, ....);
}
【注意】:
方法 = 方法签名 + 方法体
方法调用依据只能是方法签名(方法的使用说明书)
实参:调用方法是实际传递给形参的值
方法的返回值就是方法调用本身
方法无返回只是,不可以打印输出方法调用
无返回值是,不写return,编译器自动加
方法调用,实参和形参是赋值关系,赋值时并不严格按照形参类型,只要能赋值就行
声明在方法中的局部变量保存在栈中
方法调用: 1.其他方法调用
2.自己调自己,就是递归
方法调用时,流程发生改变。方法调用的执行过程:
方法的重载(overload)
要求:1.同一个类中 2.方法名必须相同 3.方法的参数列表不同(①参数的个数不同②参数类型不同)
补充:方法的重载与方法的返回值类型没有关系!
//如下的四个方法构成重载
//定义两个int型变量的和
public int getSum(int i,int j){
return i + j;
}
//定义三个int型变量的和
public int getSum(int i,int j,int k){
return i + j + k;
}
//定义两个double型数据的和
public double getSum(double d1,double d2){
return d1 + d2;
}
//定义三个double型数组的和
public void getSum(double d1,double d2,double d3){
System.out.println(d1 + d2 + d3);
}
//不能与如上的几个方法构成重载
// public int getSum1(int i,int j,int k){
// return i + j + k;
// }
// public void getSum(int i,int j,int k){
// System.out.println(i + j + k);
// }
//以下的两个方法构成重载。
public void method1(int i,String str){
}
public void method1(String str1,int j){
}