JavaSE基础

转义字符

        //转义字符  \
        //1.输出“你好世界”
        System.out.println("\"你好世界\"");
        //2.输出\你好世界\
        System.out.println("\\你好世界\\");
        //3.换行符
        System.out.println("你好\n世界");
        //4.制表符
        System.out.println("你好\t世界\t你好\tJava");
 

运行结果：

"你好世界"
\你好世界\
你好
世界
你好	世界	你好	Java 

计算机中的存储单元

• 最小的信息单位bit（比特）
• 最小的存储单位Byte（字节）
• 两者之间的关系1Byte = 8bit
• 汉字占用字节数2个字节

8bit = 1B
1024B = 1KB
1024KB = 1MB
1024MB = 1TB
1024TB = 1PB
1024PB = 1EB
1024EB = 1ZB

数据类型

基本数据类型

• 四类八种基本数据类型

数据类型	关键字	内存大小	取值范围
字节型	byte	1个字节1B	-128~127 2^7-1
短整型	short	2个字节2B	-32768~32767 2^15-1
整形	Int	4个字节4B	21开头的十位数 2^31-1
长整型	long	8个字节8B	92开头的19位数 2^63-1
单精度浮点数	float	4个字节	-1.4013E-45~3.4028E+38
双精度浮点数	double	8个字节8B	4.9E-324~1.7977E+308
字符型	char	2个字节2B	0~65535
布尔类型	boolean	1个字节1B	true、false

备注：java中的默认的基本数据类型：整数类型为int，浮点型为double

package com.ligong.basic;

public class BasicDataType {
    public static void main(String[] args){
        //整形
        System.out.println(getType(123));
        //长整型
        System.out.println(getType(123456789L));
        //双精度浮点数
        System.out.println(getType(3.5));
        //单精度浮点数
        System.out.println(getType(3.5f));
    }
    //获取对应数据的类型
    public static String getType(Object o){
        String type = o.getClass().toString();
        return type;
    }
}

运行结果：

class java.lang.Integer
class java.lang.Long
class java.lang.Double
class java.lang.Float

引用数据类型

• 类
• 数组
• 接口
• 字符串

变量

• 定义变量
• 给变量赋值
• 定义并赋值
• 一般建议定义时赋值
• 注意
  *变量没有赋值是不能使用的
  *变量的作用域问题
  *变量的重复定义

运算符

算术运算符

运算符	运算规则	范例	结果
+	正号	+3	3
+	加法	1+3	4
+	字符串连接	“中”+“国”	“中国”
-	负号	int a=3；-a	-3
-	减	3-1	2
*	乘	2*8	16
/	除	5/2	2
%	取模	5/2	1
++	自增	int a=1；a++/++a	2
（两个减号）	自减	int b=3；a-/-a	2

• 加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串
• 除法“/”当两边为整数时

package com.ligong.basic;

public class CountOperator {
    public static void main(String[] args){
        //正号
        System.out.println(+3);
        //加法
        System.out.println(1+3);
        //字符串连接
        String a = "今天周五";
        String b = "放假了";
        System.out.println(a+b);
        //减法
        System.out.println(3-1);

        String c = "阿斯蒂芬";
        int d = 438;
        System.out.println(c+d);
        //除法
        int m = 5;
        int n = 2;
        double x=m/n;
        System.out.println(x);
        System.out.println(m/n);
        //乘法
        System.out.println(m*n);
    }
}

运行结果：

3
4
今天周五放假了
2
阿斯蒂芬438
2.0
2
10

赋值运算符

运算符	运算规则	范例	结果
=	赋值	int a=2	2
+=	加后赋值	int a=2，a+=2	4
-=	减后赋值	int a=2，a-=2	0
*=	乘后赋值	int a=2，a*=2	4
/=	整除后赋值	int a=2，a/=2	1
%=	取模后赋值	int a=2，a%=2	0

比较运算符

运算符	运算规则	范例	结果
==	相等于	4==3	false
！=	不等于	4！=3	true
<	小于	4<3	false
>	大于	4>3	true
<=	小于等于	4<=3	false
>=	大约等于	4>=3	true

逻辑运算符

运算符	运算规则	范例	结果
！	非	！true	flase
&&	短路与	false&&true	false
II	短路或	false II true	true

• 语法格式：
  *boolean r = 布尔表达式1 逻辑运算符（&；|；！…) 布尔表达式2
  1）逻辑运算符运算结果是布尔类型
  2）布尔表达式：是指运算结果是布尔值的式子
• &与/和（and）
  只有&两边的表达式的值都是true 整体结果才是true，其他都是false
  全真都真，一假就假
• | 或
  只有| 两边的表达式的值都是false 整体结果才是false，其他都是true
  全假才假，一真就真
• ！ 非/取反
  非错即对
• && 短路与
  因为&是一错就错，所以当&&前已经是false时，那么就可以确定整体表达式的结果false
  后续的表达式就不再执行了
• || 短路或
  与上类似
• ===>
  只要第一个表达式的结果能确定整体表达式的结果，后面表达式就短路不执行

 boolean r1 = 1>0 && 2<0;//短路与 假
        boolean r2 = 2<0 || 1>0;//短路或 真
        boolean r3 = 1>0 & 2<0;
        boolean r4 = 2<0 | 1>0;
        System.out.println(r1);
        System.out.println(r2);
        System.out.println(r3);
        System.out.println(r4);
        System.out.println((1 < 0 || 1/1==1)&&(1>0||1/0==1));
        //1.先判断两个小括号里true/false 
        //2.第一个小括号：1<0为假 1 / 1 == 1为真 ==> 第一个小括号结果为true
        //3.第二个括号：1>0为true 因为短路或一真为真 后面的不做判断被短路 ==> true
        //4.小括号1：true 小括号2：true ==> true

运行结果：

false
true
false
true
true

进程已结束，退出代码 0

位运算符

运算符	运算规则	范例	结果
&	与	1&0，0&0，1&1	0，0，1
I	或	1I0,0I0,1I1	1，0，1
^	异或	1^ 0,0^ 0,1^1	1,0,0

• ^运算规律
  *1^0=1,00=0,任何数和0相异或得到的是这个数本身
  *0^ 1=1, 1^1=0,任何数和1相异或得到的是这个数的相反
  *一个数自己和自己异或得到的是0

三目/三元运算：

• 数据类型 变量 = 布尔表达式 ？当前面结果是true时执行此处；当前面结果是false时执行此处；
• 数据类型 变量 = A ? B : C;
  1）先执行A处的布尔运算，得到一个布尔值
  2）当布尔值是true时，执行B处的代码
  3）当布尔值是false时，执行C处的代码
  4）整体结果的数据类型根据执行B处或者·C处的代码的结果而定
  5）B处和C处的结果数据类型一致

语句：

分支语句 - if语句

• 语法：
  if（布尔表达式）{
  语句1；
  语句2；
  …
  }
• 执行流程：
  1.先判断布尔表达式
  2.如果结果是true，就执行if后的{}内的语句，然后继续执行后续的
  3.如果结果是false，就跳过if后的{}而是执行后续的代码

双分支- if…else…

• 布尔结果是true执行if语句跳过else
• 布尔结果是false时，不执行if，执行else后的语句

选择语句 - switch case语句

• 语法：
  switch(值){
  case 值1:
  语句1;
  break;
  case 值2;
  语句2;
  break;
  …
  case 值n:
  语句n;
  break；
  default：
  语句n+1；
  }
• 执行流程:
  1）switch后的值,与case后的值比较
  2)如果相等,就执行改case下的语句
  3)如果遇到break,跳出switch结构,执行后续
  4)如果没有break,会造成case击穿
  5)如果不相等,比对下一个case
  6)…
  7)如果没有一个case比对成，那么会执行default中的语句
  8)switch后支持byte short int char String enum（枚举）
  9)case后的值的数据类型要与switch的值数据类型一致

循环语句

• 循环四要素：
  1）循环初始值
  2）循环控制条件
  3）循环体
  4）循环迭代

int i =1;	//1
while (i < 6){	//2
	System.out.println("你好");	//3
	i++;	//4
}

while循环

• 语法：
  while （布尔表达式）{
  循环体；
  循环迭代；（++ / --）–>控制循环次数
  }
• 执行流程：
  1）先判断while后的表达式
  2）如果是true，就行{}内的语句
  3）执行完{}内语句，再次判断while后的表达式
  4）当while后的结果是false就不再执行{}内的内容
  5）继续执行后续

public static void main(String[] args){
        //输出五句你好
        int a= 1;
        while(a<6){
            System.out.println("你好");
            a++;
        }
        System.out.println("a = "+a);
        //输出1-10
        int b =1;
        while(b<=10){
            System.out.println(b);
            b++;
        }
        //输出10-1
        int c = 10;
        while(c>=1){
            System.out.println(c);
            c--;
        }
        //分别输出1-100中的奇数/偶数
        int i = 1;
        while (i<=100){
            if(i%2==0){
                System.out.println("偶数"+i);
            }else{
                System.out.println("奇数"+i);
            }
            i++;
        }
        
    }

while：先判断，后执行

do while循环–>直到型

• 语法：先执行后判断
  do{
  循环体；
  迭代
  }while（布尔表达式）；
  1）先执行do中的循环内容
  2）判断while后的表达式
  3）表达式为true，再执行do中内容
  4）在判断。。
  5）直到判断为false时，跳过循环，执行后续
  6）do-while至少执行一次

public static void main(String[] args){
        //求1-100的和
        int a = 0;
        int b = 1;
        do {
            a += b;
            b++;
        }while(b<101);
        System.out.println(a);
    }

for循环

for（初始值；控制条件；迭代）{
循环体；
}

• 变量名：在同一作用域内不能重复
• 变量在这一范围内有效
• 同一作用域：在同一个最近的{}内
  1）限制性初始值1处，且只执行一次
  2）开始2处判断，如果为true，就向下执行循环体
  3）执行完后，执行迭代
  4）继续判断，如果判断为false，就跳出for结构，执行后续

public static void main(String[] args) {
        for (int i = 10;i >= 1;i--){
            System.out.println(i+"");
        }
    }

——————————————————————————

eclipse快捷键

ctrl + d:删除整行
alt + 方向上（下）键：整行向上（下）移动
ctrl + alt + L 自动对齐代码
ctrl + alt + 方向下键：向下复制一行代码

基本数据类型转换

• 自动转换范围小的可以向范围大的进行转换：byte < short < int < long < floa < double
• 强制转换范围大的向范围小的进行转换，需要强制类型转换：小范围数据类型 标识符 = （小范围数据类型）变量名称；

 //强制转换
        double a = 1.23;
        int c = (int) a;
        System.out.println(c);

运行结果：

1

进程已结束，退出代码 0

int和char类型数据转换

• char转换成int,字符型和数值型进行转换的时候都会直 询编码表,由于int4个字节,char2个字节,所以属于自动的 类型转换
• int转换成char,需要强制类型转换
• 如果char是汉字,转换成整数查询的就是Unicode编码表
• char类型的最大整数是65535,因为char没有负数
• char可以直接赋值为Unicode编码,格式为luxox,十六 进制

ASCII表

• 字符0~9：对应（48-57），A-Z对应（65-90），a-z对应（97-122）