java学习笔记_入门基础
1. 符号及类型
1.1 添加注释comment
- 注释:就是对代码的解释和说明。其目的是让人们能够更加轻松地了解代码。为代码添加注释,是十分必须要的,它不影响程序的编译和运行。
- Java中有单行注释和多行注释
- 单行注释以
//开头 换行结束
- 多行注释以
/*开头 以*/结束
- 单行注释以
1.2 关键字keywords
- 关键字 : 是指在程序中,Java已经定义好的单词,具有特殊含义。
- 出现的关键字有
public
、class
、static
、void
等,这些单词已经被Java
定义好,全部都是小写字母,notepad++
中颜色特殊。 - 关键字比较多,不能死记硬背,学到哪里记到哪里即可。
1.3 标识符
标识符:是指在程序中,我们自己定义内容。比如类的名字、方法的名字和变量的名字等等,都是标识符。
-
命名规则:
硬性要求
- 标识符可以包含 英文
字母26个(区分大小写)
、0-9数字
、$(美元符号)
和_(下划线)
。 - 标识符不能以数字开头。
- 标识符不能是关键字。
- 标识符可以包含 英文
命名规范: (建议)
类名规范:首字母大写,后面每个单词首字母大写(大驼峰式)。
HelleWorld
方法名规范: 首字母小写,后面每个单词首字母大写(小驼峰式)
helleWorld
变量名规范:全部小写。
1.4 常量
- 分类
类型 | 含义 | 数据举例 |
---|---|---|
整数常量 | 所有的整数 | 0,1, 567, -9 |
小数常量 | 所有的小数 | 0.0, -0.1, 2.55 |
字符常量 | 单引号引起来,只能写一个字符,必须有内容 | 'a' , ' ', '好' |
字符串常量 | 双引号引起来,可以写多个字符,也可以不写 | "A" ,"Hello" ,"你好" ,“ ” |
布尔常量 | 只有两个值(流程控制中讲解) | true , false |
空常量 | 只有一个值(引用数据类型中讲解) | null |
public class DemoConst{
public static void main(String[] args){
//输出整数常量
System.out.println(123);
//输出小数常量
System.out.println(0.125);
//输出字符常量
System.out.println('A'); // 单引号里面有且只有一个字符
//输出布尔常量
System.out.println(true);
//输出字符串常量
System.out.println("你好Java");
//空常量不能直接输出
}
}
1.5 变量和数据类型
-
变量:常量是固定不变的数据,那么在程序中可以变化的量称为变量。
Java中要求一个变量每次只能保存一个数据,必须要明确保存的数据类型。
-
数据类型:
- Java的数据类型分为两大类:
- 基本数据类型:包括 整数 、 浮点数 、 字符 、 布尔 。
- 引用数据类型:包括 类 、 数组 、 接口 。
基本数据类型
四类八种基本数据类型:
数据类型 | 关键字 | 内存占用 | 取值范围 |
---|---|---|---|
字节型 | byte | 1个字节 | -128~127 |
短整型 | short | 2个字节 | -32768~32767 |
整型 | int(默认) | 4个字节 | -231~2的31-1 |
长整型 | long | 8个字节 | -263~2的63-1 |
单精度浮点数 | float | 4个字节 | 1.4013E-45~3.4028E+38 |
双精度浮点数 | double(默认) | 8个字节 | 4.9E-324~1.7977E+308 |
字符型 | char | 2个字节 | 0-65535 |
布尔类型 | boolean | 1个字节 | true,false |
字符串 | String | -- | -- |
格式
数据类型 变量名 = 数据值;
实列代码:
public class Variable {
public static void main(String[] args){
//定义字节型变量
byte b = 100;
System.out.println(b);
//定义短整型变量
short s = 1000;
System.out.println(s);
//定义整型变量
int i = 123456;
System.out.println(i);
//定义长整型变量
long l = 12345678900L;
System.out.println(l);
//定义单精度浮点型变量
float f = 5.5F;
System.out.println(f);
//定义双精度浮点型变量
double d = 8.5;
System.out.println(d);
//定义布尔型变量
boolean bool = false;
System.out.println(bool);
//定义字符型变量
char c = 'A';
System.out.println(c);
}
}
long类型:建议数据后加L表示。
float类型:建议数据后加F表示 。
1.6 数据类型的转换
-
自动转换
实列:
一个 int 类型变量和一个 byte 类型变量进行加法运算, 结果会是什么数据类型?
public static void main(String[] args) { int i = 1; byte b = 2; // byte x = b + i; // 报错 //int类型和byte类型运算,结果是int类型 int j = b + i; System.out.println(j); }
运算结果,变量的类型将是 int 类型,这就是出现了数据类型的自动类型转换现象。
自动转换:将类型自动提升为 取值范围大的类型 。byte、short、char ‐‐> int ‐‐> long ‐‐> float ‐‐> double
-
强制转换
数据类型 变量名 = (数据类型)被转数据值;
实列:
public static void main(String[] args) { //short类型变量,内存中2个字节 short s = 1; /* 出现编译失败 s和1做运算的时候,1是int类型,s会被提升为int类型 s+1后的结果是int类型,将结果在赋值会short类型时发生错误 short内存2个字节,int类型4个字节 必须将int强制转成short才能完成赋值 */ s = s + 1;//编译失败 s = (short)(s+1);//编译成功 }
1.7 ASCII编码表
在计算机的内部都是二进制的0、1数据,如何让计算机可以直接识别人类文字的问题呢?就产生出了编码表的概念。
- 编码表:就是将人类的文字和一个十进制数进行对应起来组成一张表格。
2. 运算符
2.1 算数运算符
算数运算符 | |
---|---|
+ | 加法运算,字符串连接运算 |
- | 减法运算 |
* | 乘法运算 |
/ | 除法运算(对于整数的除法,这里是整除) |
% | 取模运算,两个数字相除取余数(只对整数有用) |
++ 、 -- | 自增自减运算 |
-
++
运算,变量自己增长1。反之,--
运算,变量自己减少1,用法与++
一致。-
独立运算:
- 变量在独立运算时, 前++ 和 后++ 没有区别 。
- 变量 前
++
:例如++i
。 - 变量 后
++
:例如i++
。
混合运算:
和其他变量放在一起,
前++
和后++
就产生了不同。-
变量
前++
:变量a自己加1,将加1后的结果赋值 给b,也就是说a先计算。a和b的结果都是2public static void main(String[] args) { int a = 1; int b = ++a; System.out.println(a);//计算结果是2 System.out.println(b);//计算结果是2 }
变量
后++
:变量a先把自己的值1,赋值给变量b,此时变量b的值就是1,变量a自己再加1。a的结果是2,b的结果是1。
```java public static void main(String[] args) { int a = 1; int b = a++; System.out.println(a);//计算结果是2 System.out.println(b);//计算结果是1 } ```
-
+
符号在字符串中的操作:
+
符号在遇到字符串的时候,表示连接、拼接的含义。
"a"+"b"
的结果是“ab”
,连接含义
public static void main(String[] args){
System.out.println("5+5="+5+5);//输出5+5=55
}
2.2 赋值运算符
赋值运算符包括: | |
---|---|
= |
等于号 |
+= |
加等于 |
-= |
减等于 |
*= |
乘等于 |
/= |
除等于 |
%= |
取模等 |
public static void main(String[] args){
short s;
s = s + 1 ; // 错误,因为 s+1 会转化为int类型,再赋值给short类型的s,则会出错。
short s = 1;
s+=1; // 正确,等同于s = short(s+1);
System.out.println(s);
}
分析:
s += 1
逻辑上看作是s = s + 1
计算结果被提升为int类型,再向short类型赋值时发生错误,因为不能将取值范围
大的类型赋值到取值范围小的类型。但是, s=s+1进行两次运算 , += 是一个运算符,只运算一次,并带有强制转换的特点,
也就是说s += 1
就是s = (short)(s+1)
,因此程序没有问题编译通过,运行结果是2.
2.3 比较运算符
比较运算符包括: | |
---|---|
== |
比较符号两边数据是否相等,相等结果是true。 |
< |
比较符号左边的数据是否小于右边的数据,如果小于结果是true。 |
> |
比较符号左边的数据是否大于右边的数据,如果大于结果是true。 |
<= |
比较符号左边的数据是否小于或者等于右边的数据,如果小于结果是true。 |
>= |
比较符号左边的数据是否大于或者等于右边的数据,如果小于结果是true。 |
!= |
不等于符号 ,如果符号两边的数据不相等,结果是true。 |
2.4 逻辑运算符
逻辑运算符包括 | |
---|---|
&& 且 | 1. 两边都是true,结果是true 2. 一边是false,结果是false 短路特点:符号左边是false,右边不再运算 |
|| 或 | 1. 两边都是false,结果是false 2. 一边是true,结果是true 短路特点: 符号左边是true,右边不再运算 |
! 非 | 1. ! true 结果是false 2. ! false结果是true |
注 : 逻辑运算符,是用来连接两个布尔类型结果的运算符,运算结果都是布尔值 true 或者 false
2.5 三元运算符
-
三元运算符格式:
数据类型 变量名 = 布尔类型表达式?结果1:结果2
- 布尔类型表达式结果是true,三元运算符整体结果为结果1,赋值给变量。
- 布尔类型表达式结果是false,三元运算符整体结果为结果2,赋值给变量。
实列 :
public static void main(String[] args) {
// 比较运算符
System.out.println(1==1);//true
System.out.println(1<2);//true
System.out.println(3>4);//false
System.out.println(3<=4);//true
System.out.println(3>=4);//false
System.out.println(3!=4);//true
// 逻辑运算符
System.out.println(true && true);//true
System.out.println(true && false);//false
System.out.println(false && true);//false
System.out.println(false || false);//falase
System.out.println(false || true);//true
System.out.println(true || false);//true
System.out.println(!false); //true
int i = (1==2 ? 100 : 200);
System.out.println(i);//200
int j = (3<=4 ? 500 : 600);
System.out.println(j);//500
}
2.6 常量和变量的运算
public static void main(String[] args){
byte b1=1;
byte b2=2;
byte b3=1 + 2; //正确
byte b4=b1 + b2; //错误
System.out.println(b3);
System.out.println(b4);
}
分析:
b3 = 1 + 2
, 1 和 2 是常量,为固定不变的数据,在编译的时候, 已经确定了 1+2 的结果并没有超过byte类型的取值范围,可以赋值给变量b3
,因此b3=1 + 2
是正确的。
反之,b4 = b2 + b3
,b2
和b3
是变量,变量的值是可能变化的,在编译的时候,编译器javac
不确定b2+b3
的结果是什么,因此会将结果以int类型
进行处理,所以int类型不能赋值给byte类型
,因此编译失败。
3. 方法的入门学习
方法:就是将一个功能抽取出来,把代码单独定义在一个大括号内,形成一个单独的功能。当我们需要这个功能的时候,就可以去调用。这样即实现了代码的复用性,也解决了代码冗余的现象。
3.1 方法的定义
- 定义格式:
修饰符 返回值类型 方法名 (参数列表){
代码...
return ;
}
- 修饰符:
public
,default
,private
,protected
...
- 返回值类型:
void
,int
,double.
... - 方法名:为我们定义的方法起名,满足标识符的规范,用来调用方法。
- 参数列表: 目前无参数, 带有参数的方法在后面的课程讲解。
-
return
:方法返回值类型。返回值类型是void
,return
可以不写。
public static void methodName() {
System.out.println("这是一个方法");
}
3.2 方法的调用
方法在定义完毕后,方法不会自己运行,必须被调用才能执行, 我们可以在主方法main中来调用我们自己定义好的方法。在主方 法(main)中,直接写要调用的方法名字就可以调用了。
public static void main(String[] args) {
//调用定义的方法method
method();
}
//定义方法,被main方法调用
public static void method() {
System.out.println("自己定义的方法,需要被main调用运行");
}
3.3 注意事项
- 方法必须定义在一个类中的方法外
- 方法不能定义在另一个方法的里面
public class Demo {
public static void main(String[] args){} //正确写法,类中,main方法外面可以定义方法
public static void method(){}
}
public class Demo {
public static void main(String[] args){
//错误写法,一个方法不能定义在另一方法内部
public static void method(){}
}
}
4. java中的流程控制语句
在一个程序执行的过程中,各条语句的执行顺序对程序的结果是有直接影响的。也就是说,程序的流程对运行结果有直接的影响。所以,我们必须清楚每条语句的执行流程。而且,很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能
4.1 顺序结构
public static void main(String[] args){
//顺序执行,根据编写的顺序,从上到下运行
System.out.println("frist");
System.out.println("second");
System.out.println("third");
}
4.2 判断语句
- 单
if
语句
public static void main(String[] args){
System.out.println("判读开始");
// 定义两个变量
int a = 10;
int b = 20;
//变量使用if判断
if (a == b){
System.out.println("a==b");
}
int c = 10;
if(a == c){
System.out.println("a==c");
}
System.out.println("判断结束");
}
-
if - else
语句
public static void main(String[] args){
// 判断给定的数据是奇数还是偶数
// 定义变量
int a = 1;
if(a % 2 == 0) {
System.out.println("a是偶数");
} else{
System.out.println("a是奇数");
}
System.out.println("结束");
}
if - else if - else
public static void main2(String[] args) {
int score = 100;
if (score < 0 || score > 100) {
System.out.println("成绩给定出错");
} else if (score >= 90 && score <= 100) {
System.out.println("成绩属于优秀");
} else if (score >= 80 && score < 90) {
System.out.println("成绩属于好");
} else if (score >= 70 && score < 80) {
System.out.println("成绩属于良");
} else if (score >= 60 && score < 70) {
System.out.println("成绩属于及格");
} else {
System.out.println("成绩属于不及格");
}
}
- 三元运算符和
if
语句
public static void main2(String[] args) {
int a = 10;
int b = 20;
//定义变量,保存a和b的较大值
int c;
if (a > b) {
c = a;
} else {
c = b;
}
//可以上述功能改写为三元运算符形式
c = a > b ? a : b;
}
4.3 判断语句 switch
-
switch语句格式:
switch(表达式) { case 常量值1: 语句体1; break; case 常量值2: 语句体2; break; ... default: 语句体n+1; break; }
-
标准的
switch
语句:public static void main(String[] args) { //剪刀石头布游戏 String chose = "剪刀"; //switch语句实现选择 switch(chose) { case "剪刀": System.out.println("石头"); break; case "石头": System.out.println("布"); break; case "布": System.out.println("剪刀"); } }
-
switch
语句中的无break;
,将不会理会case
public static void main(String[] args) { // write your code here System.out.println("Hello, Word !!!"); int i = 5; switch (i) { case 0: System.out.println("执行case0"); break; case 5: System.out.println("执行case5"); case 10: System.out.println("执行case10"); default: System.out.println("执行default"); } } 输出: 执行case5 执行case10 执行default
4.4 循环语句
4.4.1
for
循环-
使用
for
循环 输出9 * 9 乘法表:public static void main(String[] args) { // write your code here System.out.println("9 * 9 乘法表"); for (int i = 1; i <= 9; i++) { for (int b = 1; b <= i; b++) { System.out.print(b + "X" + i + "=" + b * i + "\t"); } System.out.print("\n"); } }
-
4.4.2 while
循环:
- 使用 while计算1 - 100 的求和:
public static void main(String[] args) {
// write your code here
System.out.println("Hello, Word !!!");
int i = 1, sum =0;
while (i<100){
sum += i;
i++;
}
System.out.println(sum);
}
4.4.3 do - while
循环:
- 输出十次 JAVA:
public static void main(String[] args) {
int x=1;
do {
System.out.println("JAVA");
x++;
}while(x<=10);
}
4.4.4 几种循环语句的区别:
-
for
和while
的区别:
1. `for` 循环中控制变量在每次循环结束后,就在内存中消失,说以在一般情况下更加的推荐使用`for`循环,提高内存的使用效率。
2. 在已知循环次数的时候使用推荐使用`for`,循环次数未知的时推荐使用`while`。
5. Java 中的四种权限修饰符
<center>public > protected > (default) > private</center>
访问控制 :
修饰符 | 当前类 | 同一包内 | 子孙类(同一包) | 子孙类(不同包) | 其他包 |
---|---|---|---|---|---|
public |
Y | Y | Y | Y | Y |
protected |
Y | Y | Y | Y/N* | N |
default |
Y | Y | Y | N | N |
private |
Y | N | N | N | N |
N*: 接口及接口的成员变量和成员方法不能声明为 protected
6. 关键字final
关键字
final
代表最终、不可改变的。在继承中,子类可以重写父类的方法,为了避免这种随意改写的情况,Java提供了 final
关键字,用于修饰不可改变内容。常见四种用法:
- 可以用来修饰一个类
- 可以用来修饰一个方法
- 还可以用来修饰一个局部变量
- 还可以用来修饰一个成员变量
6.1 final 修饰类
格式:
public final class 类名称 { // ... }
含义:当前这个类不能有任何的子类。
注意:一个类如果是final的,那么其中所有的成员方法都无法进行覆盖重写。
6.2 final 修饰方法
当
final
关键字用来修饰一个方法的时候,这个方法就是最终方法,也就是不能被覆盖重写。
格式:修饰符 final 返回值类型 方法名称(参数列表) { // 方法体 }
注意事项:
对于类、方法来说,abstract关键字和final关键字不能同时使用,因为矛盾。
6.3 final 修饰局部变量
一旦使用final用来修饰局部变量,那么这个变量就不能进行更改。
“一次赋值,终生不变”
- 对于基本类型来说,不可变说的是变量当中的数据不可改变
- 对于引用类型来说,不可变说的是变量当中的地址值不可改变
6.4 final 修饰成员变量
对于成员变量来说,如果使用
final
关键字修饰,那么这个变量也照样是不可变。
- 因为
final
修饰的成员变量,赋值后不可修改,所有不允许无参构造方法默认赋值null
。- 对于
final
的成员变量,要么使用直接赋值,要么通过构造方法赋值。二者选其一。- 必须保证类当中所有重载的构造方法,都最终会对
final
的成员变量进行赋值。例如:
public class Person { // 直接赋值,一旦使用final修饰的成员变量进行了直接赋值,构造方法就不能再对其赋值。 // private final String name = "AAA"; // 不使用直接赋值,构造方法必须进行赋值。 private final String name; public Person() { name = "AAA"; } public Person(String name) { this.name = name; } }