Day2-JAVA-基础.md

发表于 更新于 阅读次数： 本文字数： 6.5k 阅读时长 ≈ 6 分钟

JAVA-基础

Day2-JAVA-基础

关键字

abstract assert boolean break byte
case catch char class const
continue default do double else
enum extends final finally float
for goto if implements import
instanceof int interface long native
new package private protected public
return strictfp short static super
switch synchronized this throw throws
transient try void volatile while

标识符

Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符

标识符都应该以字母，美元符、下划线开始，不能以==数字==开头

首字母后的字母，美元符，下划线或数字任意组合

不能使用关键字作为变量名或方法名

标识符大小写敏感

数据类型

强类型语言

​ 必须先定义再使用

JAVA数据类型：

  • 基本数据类型
  • 引用数据类型
类型名称 关键字 占用内存 取值范围
字节型 byte 1 字节 -128~127
短整型 short 2 字节 -32768~32767
整型 int 4 字节 -2147483648~2147483647
长整型 long 8 字节 -9223372036854775808L~9223372036854775807L
单精度浮点型 float 4 字节 +/-3.4E+38F（6~7 个有效位）
双精度浮点型 double 8 字节 +/-1.8E+308 (15 个有效位）
字符型 char 2 字节 ISO 单一字符集
布尔型 boolean 1 字节 true 或 false

Java数据类型结构图

==注意：==

用long类型时，要在后面加上L，建议用大写，用小写的话会看成1

用float类型时，要带后面加上F

char类型，表示一个字符

string是个类，不是关键词

例子：

1
2
3
4
5
6
7
8
9
10
// byte
byte num = 10;
// short
 short num2 = 20;
// int
int num3 = 30;
// long
long num4 = 40L;
// boolean
boolean num5 = true;
1
2
3
4
5
6
7
8
9
10
11
12
13
// 八大数据类型使用
public class Dome2 {
    public static void main(String[] args) {
        byte num = 10;
        short num2 = 20;
        int num3 = 30;
        long num4 = 40L;
        System.out.println(num);
        System.out.println(num2);
        System.out.println(num3);
        System.out.println(num4);
    }
}

扩展

整数扩展

二进制0b 十进制 八进制0 十六进制0x

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class dome3 {
    public static void main(String[] args) {
        // 0b二进制表示
        int num = 0b10;
        // 0八进制表示
        int num2 = 010;
        // 十进制正常表示
        int num3 = 10;
        // 0x十六进制表示
        int num4 = 0x10;
        System.out.println(num);
        System.out.println(num2);
        System.out.println(num3);
        System.out.println(num4);

    }
}

浮点数扩展

银行业务一般不用float类型计算

float与double

1
2
3
4
5
6
7
8
9
10
11
12
13
public class dome4 {
    public static void main(String[] args) {
        float f1 = 0.1f;
        double d1 = 0.1;
        System.out.println(f1==d1);
        System.out.println(f1);
        System.out.println(d1);
    }
}
// 结果
// false
// 0.1
// 0.1

float与float

1
2
3
4
5
6
7
8
9
public class dome4 {
    public static void main(String[] args) {
        float f1 = 22222222222222f;
        float f2 = f1 + 1;
        System.out.println(f1==f2);
    }
}
// 结果
// true

==奇怪的原因：==

案一，按照正常思路，f1与d1的输出结果相同，应该f1与d1相等，那为什么程序给的结果是false呢？

案二，按照正常思路f1+1后，结果肯定与f1不相同了，那为什么程序给的结果是true呢？

原因都是float是一个离散、有限、舍入误差、大约、接近但不等于的数据库

白话就是是一个近似值

==最好完全避免使用浮点数进行比较，可以使用BigDecimal类==

字符扩展

字符可以强制转换，==所有字符的本质都是数字==

1
2
3
char c1 = '中';
System.out.println((int)c1);
//20013

字符对应着一个编码表，所以可以强制转化为数字；反之一些对应的数字也可以转换为字符

转义字符

\t 制表符，空格
\n 换行
\r 回车
\b 退格

布尔扩展

1
2
3
4
5
boolean flag = true;
// 方式一：
if (flag==true){}
// 方式二：
if (flag){}

类型转换

分为强制类型转换和自动性转换

强制类型转换是由内存大的转换为内存小的类型

自动性转换是由内存小的转换为内存打的

1
2
3
4
5
6
// 强制类型转换
int i = 123;
byte b = (byte)i;
// 自动性转换
byte b = 111;
int i = b;

格式：

强制类型转换 (需转换类型)变量名

自动性转换 直接写变量名

==注意点：==

  1. 不能对布尔值进行转换
  2. 不能将对象类型转换为不相干的类型(变量就是对象，万物皆对象)
  3. 高容量转换为低容量的时候需要强制转换
  4. 强制转换的时候可能会出现内存溢出，或者精度问题
  5. 转换不会四舍五入，直接抹去小数位
  6. byte/short/int/long在和int 一起计算的时候都会转为int

JDK7新特性，数字间可以用下划线分割，但结果不会变

关于内存溢出必懂案例分析：

1
2
3
4
5
int money = 10_0000_0000;
int years = 20;
long total = money * years;
System.out.println(total);
//-1474836480

关于上面的例子，结果应该为 200 0000 0000才对，为什么是一个复数呢，原来int类型与int类型运算时，结果也为int类型，但int最大容量为21 4748 3647，显然已经超了容量了，这是就会发生内存溢出，然后我们想到的解决办法是将他转换为大容量类型，如long，没错我在第3行显然，有转换为long类型，但负数的结果从int转换为long后任然没变，因为long是大容量类型

解决办法：

1
2
3
4
5
int money = 10_0000_0000;
int years = 20;
long total = money * (long)years;
System.out.println(total);
// 20000000000

思路就是，int与long计算时，最终结果会自动转换为long，所以long就有足够大的容量来接收结果，就不会发生内存溢出的问题

==案例总结：==

int与int计算，结果自动转换为int

int与long计算，结果自动转换为long

变量

变量就是一个可以变换的储存空间量

Java变量是程序中最基本的储存单元，其要素包括变量名，变量类型和作用域

==每一个声明都必须以分号结束==

格式：数据类型 变量名 = 值;

变量的作用域

类变量

static关键词，写在main函数外面，相当于全局变量

1
2
3
4
5
6
7
public class dome06 {
    static int salary = 2500;
    public static void main(String[] args) {
        System.out.println(salary);
    }
}
// 2500

实例变量

写在main函数外面，从属于对象，不需要必须初始化，数值类型默认值一般为0或0.0；布尔值默认为false；除了基本类型其余默认值都是null

1
2
3
4
5
6
7
8
9
10
11
12
13
// 使用方法
public class dome05 {
    String name;
    int age;

    public static void main(String[] args) {
        dome05 dome05 = new dome05();
    	dome05.name = "aaa";		// 赋值
        dome05.age = 14;			// 赋值

    }
}

局部变量

生命周期只在方法以内，也就是方法大括号之间，必须声明和初始化

常量

不会改变的值，是一个特殊的变量，值被设定后，程序不允许改变，用final定义

final 常量名 = 值

修饰符不存在先后顺序

1
2
3
4
5
6
7
8
9
public class dome07 {
	//static final double PI = 3.14;
    static final double PI = 3.14;		//两种写法都没错
		
    public static void main(String[] args) {
        System.out.println(PI);
    }
}
// 3.14

==命名规范==

所有变量、方法、类名：==见名知意==

类成员变量、局部变量、方法名：遵循小驼峰原则

常量：大写字母和下划线

类名：大驼峰原则

运算符

算数运算符：

运算符 描述 示例
+ 加法运算符,第一个操作数加上第二个数操作数 A + B结果为：30
- 减法运算符,从第一个操作数减去第二个操作数 A - B结果为：-10
* 两个操作数相乘 A * B结果为：200
/ 左操作数除以右操作数返回模值 B / A结果为：2
% 左操作数除以右操作数返回余数 B / A结果为：0
++ 将操作数的值增加1 A++，则A的值为：11
-- 将操作数的值减1 A--，则A的值为：9

算数运算时，整数结果一般都是int类型，

如果与其他类型计算，结果按最高位类型

==a++与++a的区别==

1
2
3
4
5
6
7
8
// a++
int num = 3;
int b = num++;
System.out.println(num);
System.out.println(b);
// 结果
// 4
// 3
1
2
3
4
5
6
7
8
// ++a
int a = 1;
int b = ++a;
System.out.println(b);
System.out.println(a);
// 结果
// 2
// 2

通过案例说区别总结：

 int b = ++a是两个语句： int b = a; a = a +1;所以打印b就等于3

==a++是赋值，然后再自增。==所以a=3先赋给b，这是b=3，然后再自增，a+1，a于是就等于4

==++a是先自增，再赋值。==所以a=1先加1，等于2，然后再将2赋值给b

==幂运算：==

需要借助Math类的pow

1
2
3
double pow = Math.pow(3, 2);
System.out.println(pow);
// 9.0

(3, 2)表示3的2次方

关系运算符：

运算符 描述 示例
== 等于运算符，检查两个操作数的值是否相等，如果相等，则条件变为真。 A==B结果为假。
!= 不等于运算符，检查两个操作数的值是否不相等，如果不相等，则条件变为真。 A!=B结果为真。
> 大于运算符，检查左操作数的值是否大于右操作数的值，如果大于，则条件变为真。 A>B结果为假。
< 小于运算符，检查左操作数的值是否小于右操作数的值，如果小于，则条件变为真。 A<B结果为真。
>= 大于或等于运算符，检查左操作数的值是否大于等于右操作数的值，如果大于或等于，则条件变为真。 A>=B结果为假。
<= 小于或等于运算符，检查左操作数的值是否小于或等于右操作数的值，如果小于或等于，则条件变为真。 A<=B结果为真。

逻辑运算符：

假设布尔变量A的值为：true，变量B 的值为：false，则 -

运算符 描述 示例
&& 逻辑AND运算符。 如果两个操作数都不为零，则条件成立。 (A && B)结果为：false
ΙΙ 逻辑OR运算符。 如果两个操作数中的任何一个非零，则条件变为真。 (A ΙΙ B)结果为：true
! 逻辑非运算符。用于反转其操作数的逻辑状态。 如果条件为真，则口逻辑NOT运算符将为false。 !(A && B)结果为：true

位运算

效率极高！！！

是用于二进制的，有& | ^ ~ << >>，通过上下对应位

通过例子理解 0相当于false，1相当于true

1
2
3
4
5
6
7
A = 0011 1100
B = 0000 1101
-------------
A&B = 0000 1100		
A|B = 0011 1101
A^B = 0011 0001    // 相同为0，否则为1
~B = 1111 0010	   // 0为true，1为false

<< 左移，相当于将数*2 >>右移，相当于将数/2

左移右移是指二进制中1移动的位置

条件运算符

a+=b 就是a = a+b a -= b 就是 a = a-b

==字符串连接符==用+拼接，只要String类型在前面就会拼接

数字想拼接时，如果String在数字后是不能拼接的，例子：

1
2
3
4
int a = 2;
int b = 3;
System.out.println(""+a+b);			// 23
System.out.println(a+b+"");			// 5

x ? y : z

意思：如果x为true，则结果为y，否则为z

1
2
3
int grade = 40;
String result  = grade<60?"不及格":"及格";
System.out.println(result);

关于优先级，是先运算带有括号里边的

包机制

包的本质就是文件夹

一般利用公司域名倒置作为包名

尽量不要让包的名字重复

定义包package 导入包import

*表示通配符，加上会导入这个包下所有的类

JavaDoc

javadoc命令是用来生成自己API文档的

参数信息：

1
2
3
4
5
6
@author 	作者名
@version	版本号
@since		指明需要最早使用jdk版本
@param		参数名
@return		返回值结果
@throw		异常抛出结果

使用命令生成：

1
javadoc -encoding UTF-8 -charset UTF-8 文件名

-encoding UTF-8 -charset UTF-8是用来避免中文乱码

形成后，在当前路径运行index.html就可以看到