Java基础语法
关键字和标识符
-
关键字：java赋予了特殊含义的单词。
例如:
class类public公开的void无返回值
-
关键字特点：
一般都是小写。
-
保留字:java暂时没用，但是不保证后面不用
goto const
-
标识符:程序员为类、方法、变量等成员起的字符序列,用于区分不同的成员的,起标识作用的符号
-
标识符起名规则:
-
字母 数字 _ $ 组成，并且数字不能开头
-
支持中文，区分大小写。但是不建议用中文，也不建议通过大小写区分。
-
见名之意
-
驼峰原则
大驼峰:从每个单词首字母大写.给类起名.例如:AxxBxx
小驼峰:从第二个单词开始首字母大写.给变量、方法.例如:axxBxx
-
不能用关键字。
-
不能用java提供的类名。
-
String
-
注释
-
注释作用：解释说明代码的.
-
分类:
- 单行注释：对一行有效 //
- 多行注释:对多行有效但是不能嵌套使用/* */由于不能嵌套这个地方中间用了一个空格。
- 文档注释:/** */由于不能嵌套，这个地方中间用了一个空格。
-
注释好处：
- 解释说明
- 排错
- 梳理思路
-
代码:
/** 1.注释作用：解释说明代码的. 2.分类: 1>单行注释：对一行有效// 2>多行注释:对多行有效但是不能嵌套使用/* */由于不能嵌套，这个地方中间用了一个空格。 3>文档注释:/** */由于不能嵌套，这个地方中间用了一个空格。 3.注释好处： ①解释说明 ②排错 ③梳理思路 */
注释快捷键
快捷键:
注释：
- 单行注释 // ctrl+ /
- 多行注释 ctrl+shift +/
- 文档注释
权限修饰符
权限修饰符：
- 四种权限：
- public：公开的，在整个项目中都可以访问。
- protected：受保护的，当前包和其它包的子类。
- default/friendly 这种就是省略不 写，表示该种，没有权限修饰符的 专门词。 默认的 本包可以访问
- private 私有的 本类可以访问。
变量 、常量和数据类型
常量：
-
概念：内存中开辟的一块存储区域，该区域存储的值不能发生改变的，称为常量.
例如：1 12.5 长虹 true
-
常量的分类：
字面值常量:例如：1 12.5 长虹 true
-
整数常量 浮点数常量 字符常量 布尔常量
- 符号常量: 例如： a b
变量：
- 概念：内存中开辟的一块存储区域，该区域存储的值可以改变，称为变量。
Java 基本数据类型：
变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。
内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。
因此，通过定义不同类型的变量，可以在内存中储存整数、小数或者字符。
Java 的两大数据类型:
- 内置数据类型
- 引用数据类型
基本数据类型(简单数据类型):
Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
整数类型：
byte：
byte 字节型 1个字节
byte 数据类型是8位、有符号的，以二进制补码表示的整数；
最小值是 -128（-2^7）；
最大值是 127（2^7-1）；
默认值是 0；
byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
例子：byte a = 100，byte b = -50。
short：
short 短整型 2个字节
short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768（-2^15）；
最大值是 32767（2^15 - 1）；
Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
默认值是 0；
例子：short s = 1000，short r = -20000。
int：
int 整型 4个字节
int 数据类型是32位、有符号的以二进制补码表示的整数；
最小值是 -2,147,483,648（-2^31）；
最大值是 2,147,483,647（2^31 - 1）；
一般地整型变量默认为 int 类型；
默认值是 0 ；
例子：int a = 100000, int b = -200000。
long：
long 长整型 8个字节
long 数据类型是 64 位、有符号的以二进制补码表示的整数；
最小值是 -9,223,372,036,854,775,808（-2^63）；
最大值是 9,223,372,036,854,775,807（2^63 -1）；
这种类型主要使用在需要比较大整数的系统上；
默认值是 0L；
例子： long a = 100000L，Long b = -200000L。 “L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。
代码
class 整数类型 {
public static void main(String[] args) {
//声明一个byte类型的变量，存储数据100
/*byte b = 100;
System.out.println(b);*/
//声明一个long类型的变量,存储数据1234567890123456
//注意: 默认没有指定数据类型时，为int类型，那么会存在溢出问题，需要加l或L表示是 long类型。
long l = 1234567890123456l;
System.out.println(l);
}
}
浮点数类型 ：
float：
float 单精度浮点型 4个字节
float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
float 在储存大型浮点数组的时候可节省内存空间；
默认值是 0.0f；
浮点数不能用来表示精确的值，如货币；
例子：float f1 = 234.5f。
double：
double 双精度浮点型 8 个字节
double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数；
浮点数的默认类型为 double 类型；
double类型同样不能表示精确的值，如货币；
默认值是 0.0d；
默认没有指定数据类型时，double为默认类型。
浮点型在使用的时候，都会有精度损失问题。是一个近似值。在银行等要求精度高的项目中， 使用BigDecimal类来计算。
代码
import java.math.BigDecimal;
class 浮点数类型 {
public static void main(String[] args) {
//声明一个double类型的变量，并且赋值为12.5
double d = 12.51;
System.out.println(d);
BigDecimal bg = new BigDecimal(d);
System.out.println(bg);
//声明一个float类型的变量,并且赋值为12.51
//注意:为float类型数据赋值时，必须指定为float类型，可以通过加f或F表示
float f = 12.51f;
BigDecimal bg1 = new BigDecimal(f);
System.out.println(bg1);
}
}
字符类型：
-
字符类型:char 2个字节 0-65535
-
① 常见写法:
-
格式：
‘‘引起来的单个字符
例如：‘a’
-
-
② 数字
-
③ unicode码的形式:
- 格式:’\u0000’
-
④ (***)转义字符：
-
格式：
‘\t’制表符 表示8个位置的空格
‘\r’回车
‘\n’换行
在window系统下 \r\n连用
-
-
-
代码
class 字符 { public static void main(String[] args) { // ① 常见写法: //声明一个变量 赋值为'a' /*char m = '我'; System.out.println(m);*/ // ② 数字 //声明一个变量，赋值为97 /*char m1 = 97; // m1 = m1 + 3; System.out.println(m1);*/ //③ unicode码的形式: /*char m2 = '\u4e50'; System.out.println(m2);*/ /*④ 转义字符： 格式： '\t'制表符 表示8个位置的空格 '\r'回车 '\n'换行 */ /*System.out.print("aaa"); System.out.print('\t'); System.out.println("bbb");*/ System.out.println("\""); } }
布尔类型：
boolean：
-
boolean数据类型表示一位的信息；
-
只有两个取值：true 和 false；
-
这种类型只作为一种标志来记录 true/false 情况；
-
默认值是 false；
-
例子：boolean one = true。
-
boolean 表示 值只有true或false 没有其他的值。
-
代码
class 布尔类型 {
public static void main(String[] args) {
//声明一个布尔类型的变量
boolean flag = true ;
boolean flag1 = false;
}
}
引用数据类型(复杂数据类型)：
数组
类： String (不是基本数据类型)
接口:
字节:
bit ：比特。计算机中存储的都是0或者1 ，一个0或者1表示一位，称为比特。
byte：8个0或者1表示一个字节。用B表示。
1KB = 1024 B
K M G T
变量和常量的声明
变量格式：
数据类型 变量的名称(标识符)
注意：
不能多次声明，但是可以多次赋值，对于变量来说。
常量格式:
final 数据类型 常量的名称
注意:
常量的名称 往往都大写
变量和常量的赋值
变量的名称 = 数据值
注意:
= 在java上有个专业术语 称为赋值符号，该符号将右侧的数据值赋值给左侧。
声明与赋值的简写形式
数据类型 变量的名称 = 数据值
final 数据类型 常量的名称 = 数据值
代码
/**
1.变量的声明和赋值：
① 声明: 数据类型 变量名称
② 赋值: 变量名称 = 数据值
*/
class 变量 {
public static void main(String[] args) {
//声明一个int类型的变量，并且存储数据为15
//常量声明需要加final，变量不需要
/*final*/ int a ;
//赋值 a = 15 ;
System.out.println(a);
a = 20; System.out.println(a);
//声明一个常量
final int B ;
}
}
变量的作用域
变量的作用域
1.变量的作用域：
- 变量的使用范围.
2.常见作用域:(位置)
-
1> 全局变量: 类中方法外
- 作用域：整个类中，类中所有的方法都可以使用该变量
-
2> 局部变量: 方法中
- 作用域: 方法中，出了该方法，就不能被使用。
3.全局变量与局部变量区别：
-
1> 局部变量要先声明赋值然后再使用。
- 全局变量一旦声明后，就有默认值。
-
2> 当全局变量与局部变量重名时，就近原则，局部优先。
4.全局变量的默认值.
-
1> (***)基本数据类型：
- 整数类型： byte short int long 默认值 0
- 浮点数类型: float double 默认值0.0
- 布尔类型: boolean 默认值false
- 字符类型： char 默认值 ‘\u0000’
-
2> (***)引用数据类型:
- String 默认值:null
代码
class 变量的作用域 {
static int b = 20;//全局变量
static int c ;
static byte b1;
static short b2;
static double d;
static char c1;
static boolean b3;
static String s;
public static void main(String[] args) {
//声明一个int类型的变量
int a = 10; //局部变量
// 1> 局部变量要先声明赋值然后再使用。
int m = 5;
//System.out.println(m);
/*System.out.println("c="+c);
System.out.println("b1="+b1);
System.out.println("b2="+b2);
System.out.println("d="+d);
System.out.println("c1="+c1);
System.out.println("b3="+b3);
System.out.println("s="+s);*/
//重名问题
int b = 30;
System.out.println(b);
}
public static void add() {
System.out.println(c);
}
}
数据类型转换
数据类型转换
1.数据的运算 25 + 13
2.操作数据，数据的运算原则:
同种数据类型进行运算,如果数据类型不同，要转换成相同数据类型才能运算。
并且运算结果也是同种数据类型。
3.数据类型转换分类：
1》自动类型提升：从小的空间转换成大的空间。
byte short char -> int-> long -> float -> double
注意：
byte short char但凡运算，都会转成int类型。
2》强制类型转换: 从大的空间转换成小的空间。
格式：
(要转换成的数据类型) 要转换的变量/数据
注意：
强制类型转换可能会发生精度损失问题
代码
class 数据类型转换 {
public static void main(String[] args) {
//1》自动类型提升
/*System.out.println( 25 + 13 ); //25 int 13 int ==> int
System.out.println( 25 + 13.0 );//25 int 13 double ==> 25 double 13 double ==》double
System.out.println( 25 / 13 );// 25 int 13 int ==> int
System.out.println( 25/13.0 );*///25 int 13 double ==> 25 double 13 double ==》double
//2》自动类型提升需要注意的事项,byte short char 都会自动转int类型，才运算。
byte a = 127;
byte b = 1;
/*byte c = a + b ;*/
//3》 强制类型转换
//将上述的数据 存储到byte类型的c中
byte c = (byte)(a + b);
//System.out.println(c);
char c1 = 97 ;
c1 = (char)(c1 + 3);
System.out.println(c1);
}
}
算术运算符
算术运算符
1.算术运算符:
+ - * / ``%
加 减 乘 除 取余/模
2.++ /--
自增 / 自减
在变量原有基础上加1 然后赋值给变量.
格式:
a++:变量在前 ,先取变量的值，然后自身加1
++a:变量在后,先自身加1，然后再去变量的值
3.加号的用法：
① 加法：
② 正号（正数）:+5 -5
③ 表示字符串的拼接：
但凡有一侧有字符串，表示字符串的拼接，如果两侧都是数字，表示加法运算
代码：
class 算术运算符 {
public static void main(String[] args) {
/*System.out.println( 5 % 2 );
System.out.println( 5 / 2 );*/
//自增
int a = 5;
//a++ ;
//++a;
//int b = a++;
//int b = ++a;
//int b = (++a)+(a++)+(++a);
int b = (a--) + (++a) + (--a)+ (a++);
/*System.out.println(a);
System.out.println(b);*/
//③ 表示字符串的拼接：
String s = "abc";
System.out.println( 123 + 45 + s);
}
}
赋值运算符
赋值运算符
用来给变量赋值
1.赋值运算符 :
基本赋值运算符: =
扩展赋值运算符: += 、 -= 、 *= 、 /= 、 %=
2.作用：
① 简化书写。
② 自动类型转换。
注意：
可能会有精度损失问题。
代码
class 赋值运算符 {
public static void main(String[] args) {
int a = 5;
int b = 7 ;
b = b + a;
//简写
b += a;// b = b+a
byte m = 10;
byte k = 15;
//笔试简单题:以下两种方式，哪种可以编译成功。第一种可以编译成功，第二种不行，
//不行的原因在于，对于数据类型运算来说，byte类型的数据需要转换成int才能运算，
//不能放置在byte类型的空间里，如果要放,必须要强制类型转换，而第一种，可以自动类 型转换。
//k -= m;
k = k-m ;
}
}
比较运算符
比较运算符
1.比较运算符:
> < >= <=
== 等于
!=不等于
运算结果：都是布尔类型的值 true/false
注意:
a < b < c
在java中不允许，java中比较运算只有一个运算符。
如果非要用这种形式，可以通过逻辑运算符进行连接。
代码
class 比较运算符 {
public static void main(String[] args) {
System.out.println( 2 > 3);
System.out.println(2 == 5 );
System.out.println(3 != 5);
}
}
逻辑运算符
逻辑运算符
\1. 逻辑运算符
& && | || ^ !
与 逻辑与 或 逻辑或 异或 非
\2. & 与：集合中的交集
true & true –》 true
true & false –》 false
false & true –》 false
false & false –》 false
3.&&与&的区别：
&& 称为短路与，一般用于逻辑运算。当第一个表达式结果为false的情况下，第二个表达式不再执行。
& 一般用于位运算，不参与逻辑运算。
4.| 或： 集合中的并集
true | true –》 true
true | false –》 true
false | true –》 true
false | false –》 false
\5. (***)||与|的区别
|| 称为短路或，一般用于逻辑运算。当第一个表达式结果为true的情况下，第二个表达式不再执行。
| 一般用于位运算，不参与逻辑运算。
6.^ 异或 :相同为false 相异为true
7.! 非 ，取反
代码
class 逻辑运算符 {
public static void main(String[] args) {
//a<b<c b大于2 小于10
int b = 5;
/*System.out.println(2 < b || (++b) < 10);
System.out.println(b);*/
//^ 异或 :相同为false 相异为true
//System.out.println(true ^ false );
// 7.! 非
System.out.println(!false);
}
}
三元运算符
三元运算符
1.三元运算符 ： 三目运算符
格式：
结果为true或false
表达式 ? 表达式1(true) : 表达式2 (false)
注意：
其中 表达式1 和2 ，数据类型其实可以不一致，但是建议一致。
代码
class 三元运算符 {
public static void main(String[] args) {
int a = 5;
System.out.println(a>7 ? 1 : 2);
//String b = a>7 ? "1" :2;
System.out.println(a>7 ? "1" :2);
}
}
进制
进制
-
常见进制
① 二进制：组成0 1 ，前缀0b
② 八进制：组成0-7， 前缀0
③ 十进制：组成 0-9
④ 十六进制：组成0-9 abcdef 10-15用字符来表示,前缀0x
-
计算机的进制：二进制
① 数的进制：逢?进一
二进制: 0 1
八进制: 0-7
十进制: 0-9
十六进制: 0-9 a-f a 10 b 11 c 12 d 13 e 14 f 15
② 写法：
15 默认为十进制。
二进制前缀 0b
八进制 0
十六进制 0x
③ 进制的转换:
-
十进制与二进制之间的转换:
将十进制转换成二进制: 除商取余倒序输出
转换成二进制：除以2，直到商为0，将余数倒序输出。
例如：
13
转成二进制：
1101
-
十进制转其它进制
除商取余倒序输出，转几进制就除以几，直到商为0，倒序输出余数
-
将二进制转换成十进制: 位权法
位权:每一位上代表的基数值
位权指数制中每一固定位置对应的单位值
例如 ：十进制 1025 –》 1 表示千位 位权 10^3 2 表示十位 位权 10^1
二进制 1101 –》
-
任意进制转换成十进制
位权法： 系数乘以该进制的位权之和。
-
二进制与八 、十六进制转换
三个二进制位表示一个八进制位，四个二进制位表示一个十六进制位。
例如：
015
转二进制
00001101
代码：
/**1.常见进制:
① 二进制：组成0 1 ，前缀0b
② 八进制：组成0-7， 前缀0
③ 十进制：组成 0-9
④ 十六进制：组成0-9 abcdef 10-15用字符来表示,前缀0x
2.进制转换：
① 十进制与二进制转换。
*/
class 进制 {
public static void main(String[] args) {
System.out.println(0b11);
System.out.println(23);
System.out.println(023);
System.out.println(0x23);
}
}
计算机中数据的存储
概述
1.计算机中数据存储都是以二进制的形式进行存储。
(***)2.数据存放以二进制补码的形式进行存放。
3.一个字节为例：
+0 0000 0000
-0 1000 0000
4.计算机中正数 表示时，最高位，表示符号位，如果为0 表示正数。如果为1，表示负数。
5.补码形式：
1》 原码： 符号位 + 该数的绝对值的表示形式
2》 反码： 除了符号位之外，按位取反。
3》 补码： 反码 + 1
6.其中，正数的补码与原码相同，负数的补码等于 反码+1
例如：
一个字节为例：
13
原码： 0000 1101
补码： 0000 1101
-13
原码： 1000 1101
反码： 1111 0010 反码+1
补码： 1111 0011
两个字节：
-13
原码: 1000 0000 0000 1101
反码： 1111 1111 1111 0010
补码： 1111 1111 1111 0011
例如：
一个字节：
25
原码： 0001 1001
补码： 0001 1001
- 25
原码： 1001 1001
反码： 1110 0110
补码： 1110 0111
从计算机中取出二进制的数据
byte a= 127 :0000 0000 0000 0000 0000 0000 0111 1111
byte b =1 :0000 0000 0000 0000 0000 0000 0000 0001
+ ======> 0000 0000 0000 0000 0000 0000 1000 0000
+= ======> 1000 0000 计算机 该数由于最高位为1 表示就是负数
补码：1000 0000
反码：1111 1111 补码-1
原码：1000 0000
例如：
一个字节：
10010011
该数 在计算机中表示补码。
该数由于是一个字节，最高位1，该数表示的负数。反码 –》 原码
反码： 1001 0010
原码： 1110 1101
- 109
二个字节：
该数在计算机中表示正数，补码与原码相同。
总结
计算机数据的存储：
① 将数据存储到计算机：其它进制转二进制。数据存储 以补码形式存放。正数原码与补码相同，负
数以补码形式存储。
正数最高位为0 ，负数最高位为1.
② 从计算机中取出：
根据字节数判断最高位是多少，最高位为0 表示该数是正数，最高位为1 表示该数是负数。
位运算
概述
« » »> ^ & |
«
1.« 左移：按位向左侧移动，左移后，空位全补0
格式：
操作数 « 左移的位数
规律(一般规律，会有特殊情况)：
左移多少位，就相当于操作数乘以2的多少次幂
例如：
5 « 1
以一个字节为例：
5的二进制： 0000 0101
0000 1010
**
»
\2. » 右移：又称有符号右移，按位向右侧移动，右移后，空位按最高位补，最高位为1补1 最高位
为0 补0
格式：
操作数 » 右移的位数
规律(正数一般规律,会有特殊情况:)
右移多少位，相当于操作数除以2的多少次幂
例如：
5 » 1
»>
3.»> 右移 ：又称无符号右移，按位向右侧移动。 右移后，空位全部补0.
格式：
操作数 »> 右移的位数
4.& | ^
& 按位于
| 按位或
^ 按位异或 ： 相同为0 不同为1
~ 取反
代码
/**
1.<< 左移：按位向左侧移动，左移后，空位全补0
格式：
操作数 << 左移的位数
规律(一般规律，会有特殊情况)：
左移多少位，就相当于操作数乘以2的多少次幂
2. >> 右移：又称有符号右移，按位向右侧移动，右移后，空位按最高位补，最高位为1补1 最高位 为0 补0
格式：操作数 >> 右移的位数
规律(正数一般规律,会有特殊情况:)
右移多少位，相当于操作数除以2的多少次幂。
3.>>> 右移 ：又称无符号右移，按位向右侧移动。 右移后，空位全部补0.
格式：操作数 >>> 右移的位数
4.& | ^
& 按位于
| 按位或
^ 按位异或 ： 相同为0 不同为1
~ 取反
*/
class 位运算 {
public static void main(String[] args) {
// 1.<< 左移
/*System.out.println(5 << 1);
System.out.println(5 << 2);
System.out.println(5 << 3);
System.out.println(5 << 4);*/
// 2.>> 右移
/*System.out.println(5 >> 1);
System.out.println(5 >> 2);
System.out.println(5 >> 3);
System.out.println( -5 >> 1);
System.out.println( -5 >> 2);
System.out.println( -5 >> 3);*/
//3.>>> 无符号右移
/*System.out.println(-5 >>> 1);
System.out.println(-5 >>> 2);
System.out.println(-5 >>> 3);
System.out.println(-5 >> 1);
System.out.println(-5 >> 2);
System.out.println(-5 >> 3);*/
// 4.& | ^
/*System.out.println(2 & 3);
System.out.println(2 | 3);
System.out.println(2 ^ 3);*/
//异或 既可以做位运算也可以做逻辑运算
//System.out.println(true ^ false);
System.out.println(~2);
}
}