JavaSE_基础语法

注释

注释 :用于解释说明程序的文字

注释分类 :

• 单行注释 :以//开始,一直到本行结束都是注释内容
• 多行注释 :以/*开始,一直到下一个*/结束都是注释内容
• 文档注释 :以/**开始,一直到下一个*/结束都是注释内容,被javadoc所识别,生成以网页形式的API,可以添加一些注解

关键字和保留字

关键字 :被Java赋予特殊含义的单词,不能随意使用

保留字 :当前版本还未被使用,但以后可能会被作为关键字使用.有goto和const

标识符

标识符 :在给变量,方法,类等起名字时使用的字符序列

硬性规定

• 由字母,数字,下划线,美元符号组成
• 数字不能开头
• 不能是Java中的关键字

约定俗成

• 给类,接口起名时,使用大驼峰 :所有单词的首字母都大写
• 给方法,变量起名时,使用小驼峰 :第一个首字母小写,后面所有单词首字母都大写
• 给常量起名时 :所有字母都大写,使用下划线分割
• 见名知意
• Java采用Unicode编码,支持中文作为标识符,但不推荐

变量

变量 :就是内存中的一小块存储区域,可以在同一类型范围内不断变化

变量的定义

变量定义格式 : 变量类型 变量名 = 变量值;

//变量的定义
int num;
//变量的赋值
num = 20;

//一步到位
int num2 = 20;

变量的注释事项

变量必须先声明赋值后,才能使用

//System.out.println(num);//变量未定义,不能使用
int num;
//System.out.println(num);//变量未赋值,不能使用
num = 30;
System.out.println(num);

变量都有作用域,在作用域内是有效的

{
    int num = 20;
    System.out.println(num);
}
//System.out.println(num);//出了他的作用域,已经被释放了

• {}被成为代码块,作用:限定局部变量的声明周期

同一个作用域内,不可以声明两个同名的变量名

int num = 30;
//double num =3.14;//编译报错,同一作用域中,不能出现相同变量名
System.out.println(num);

变量的分类

按照数据类型分类

按照声明的位置分类

基本数据类型

整数型 :byte,short,int,long

// byte 1个字节 -128~127
byte b = 124;
// short 2个字节
short s = 3333;
// int 4个字节 默认类型
int i = 123456789;
// long 8个字节 使用时需要添加L或l作为后缀
long l = 12345678987654321L;

整数类型可以使用进制进行赋值

// 二进制 使用0b或0B进行标识
int num1 = 0b10;
// 八进制 使用0进行标识
int num2 = 07;
// 十进制 默认
int num3 = 10;
// 十六进制 使用0x或0X标识
int num4 = 0xF;

浮点型: float,double

// float 4个字节 使用时需要添加f或F进行标识
float f = 3.2F;
// double 8个字节 默认类型
double d = 5.6;

浮点类型存储的是近似值,并非准确值

//举例1
double d = 321654985122134567532.0;
double d2 = d + 1;
System.out.println(d == d2);//true
//举例2
double d3 = 1 - 0.9;
double d4 = 0.1;
System.out.println(d3 == d4);//false

字符类型 :char

//字符类型 0-65535
char c = ‘a‘;
//单引号中必须存放一个字符,多了和少了都不行

字符类型支持数值型,Unicode类型,字符型,转义字符的赋值

        /*
            数值类型赋值
            0 48
            A 65
            a 97
         */
        char c1 = 97;
        /*
            Unicode赋值
         */
        char c2 = ‘\u0000‘;
        /*
            字符类型赋值
            单引号中存放字符只能有一个
         */
        char c3 = ‘a‘;
        /*
            转义字符赋值
            \n  换行
            \t  制表符
            \r  回车
         */
        char c4 = ‘\n‘;

布尔类型 :boolean

// boolean 只有两个值true和false
boolean b = true;
b = false;

基本数据类型转换

类型转换 :变量参与运算时,会现将类型转换为同一类型,再参与运算

//自动类型转换
long l = 10;//int -> long
//强制类型转换
int i = (int) l;// long -> int

• 基本数据类型从小到大 : byte,short,char -> int -> long -> float ->double

byte,short,char类型变量在参与运算时,会自动提升为int类型

byte b = 10;
//b = b + 1;//不兼容的类型: 从int转换到byte可能会有损失
int i = b + 1;

基本类型转换可能会丢失精度或数据溢出

//自动类型转换出现精度丢失
long l = 12345678987654321L;
float f = l;
System.out.println(f);//1.23456795E16
//强制类型转换出现精度丢失
double d = 3.8;
int i = (int) d;
System.out.println(i);//3
//强制类型转换出现溢出
byte b = (byte) 500;
System.out.println(b);//-12

运算符

算数运算符

算数运算符 : + - * / % ++ --

+作为字符串的连接符

// + 作为字符串的连接符
System.out.println(‘a‘ + ‘b‘ + 123);//318
System.out.println("a" + ‘b‘ + 123);//ab123
System.out.println(‘a‘ + ‘b‘ + "123");//195123

%的结果与被模数一致

System.out.println(10 % 3);//1
System.out.println(-10 % 3);//-1
System.out.println(10 % -3);//1
System.out.println(-10 % -3);//-1

++单独使用时,在前在后没有区别

复杂使用时,在前,先自增,再参与运算.在后,先参与运算,再自增

//单独使用
int a = 10;
int b = 10;
++a;
b++;
System.out.println(a);//11
System.out.println(b);//11

//复杂使用
a = 10;
b = 10;
System.out.println(++a);//11
System.out.println(b++);//10
System.out.println(a);//11
System.out.println(b);//11

• --同理

++ --不会改变变量的类型

byte b = 10;
//b = b + 1;//编译报错
b++;

赋值运算符

赋值运算符 :=

复合赋值运算符 : += -= *= /= %=

赋值运算符 :就是将右边的值赋值给左边的变量

//赋值
int num = 10;
String str = "hello";

复合赋值运算符不会改变变量的类型

byte b = 10;
//b = b - 1;//编译报错
b -= 1;//等效于 b = b - 1,但不会改变数据的类型

比较运算符

比较运算符 : == != > >= < <=

比较运算符的结果都是布尔类型

System.out.println(3 != 4);//true
System.out.println(3 == 4);//false

逻辑运算符

逻辑运算符: && || ! ^

逻辑运算符连接两个布尔值,结果还是布尔值

// && 有false则false,同为true则true
System.out.println(true && true);//true
System.out.println(false && true);//false
System.out.println(true && false);//false
System.out.println(false && false);//false

// || 有true则true,同为false则false
System.out.println(true || true);//true
System.out.println(false || true);//true
System.out.println(true || false);//true
System.out.println(false || false);//false

// ^ 相同为false,不同为true
System.out.println(true ^ true);//false
System.out.println(false ^ true);//true
System.out.println(true ^ false);//true
System.out.println(false ^ false);//false

// ! 取反
System.out.println(!true);//false

&& 与 &的区别

1. &&只是逻辑运算符,&不仅是逻辑运算符,还是位运算符
2. &&具有短路效果,&没有

//短路效果
int a = 10;
int b = 10;
System.out.println(false && ++a > 0);
System.out.println(false & ++b > 0);
System.out.println(a);//10
System.out.println(b);//11

• -- 同理

三元运算符

三元运算符 布尔表达式?表达式一 :表达式二

三元运算符必须使用,要么打印输出,要么赋值给变量

int a = 10;
int b = 20;
int max = a > b ? a : b;
System.out.println("max:" + (a > b? a : b));

表达式一和表达式二类型不一致

//符合自动类型提升,会先提升,在运算
System.out.println(true ? 3 : 4.0);//3.0
//不合符自动类型提升,只能打印
System.out.println(true ? 123 : "hello");

流程控制

顺序结构

顺序结构 :从上往下执行,中间没有跳转和循环

分支结构

分支结构 :包含if语句和switch语句

if语句

int age = 19;
// 单if语句
if (age > 18){
    System.out.println("你成年了");
}
//标准if语句
if (age < 18){
    System.out.println("你还未成年");
}else{
    System.out.println("你成年了");
}
//多重if语句
if (age >= 0 && age < 18){
    System.out.println("你还未成年");
}else if (age >= 18 && age <150){
    System.out.println("你成年了");
}else{
    System.out.println("age不合规则");
}

switch语句

int month = 10;
switch (month){
    case 3:
    case 4:
    case 5:
        System.out.println("春天");
        break;
    case 6:
    case 7:
    case 8:
        System.out.println("夏天");
        break;
    case 9:
    case 10:
    case 11:
        System.out.println("秋天");
        break;
    case 12:
    case 1:
    case 2:
        System.out.println("冬天");
        break;
    default:
        System.out.println("month数据异常");
}

• case穿透 :当匹配某个case值时,进入对应的case语句中,如果这个case语句中没有break语句,那么不在进行下一个case判断,直接进入下一个case语句中,直到遇到break语句或switch语句结束
• switch支持 :byte,short,char,int,枚举,字符串

循环结构

循环结构 :包含for循环,while循环和do...while循环

for循环

int sum = 0;
for (int i = 1;i <= 100;i++){
    sum += i;
}
System.out.println(sum);

while循环

int sum = 0;
int i = 1;
while (i <= 100){
    sum += i;
    i++;
}
System.out.println(sum);

do...while循环

int sum = 0;
int i = 1;
do {
    sum += i;
    i++;
}while (i <= 100);
System.out.println(sum);

• 至少循环一次

循环说明

1. 在不确定循环条件次数时使用结构 :for(;;)或while(true)
2. 结束循环方式
   1. 条件不满足,结束循环
   2. break,强制跳出循环
   3. return,结束方法,循环也结束了

嵌套循环 :循环内嵌套一个循环

for (int i = 1;i <= 9;i++){
    for (int j = 1;j <= i;j++){
        System.out.print(j + " * " + i + " = " + (j * i) + "\t");
    }
    System.out.println();
}

特殊关键字的使用

break :跳出循环

continue :跳出本次循环,进入下次循环

for (int i = 0; i < 100; i++) {
    if (i % 2 == 0 ){
        continue;
    }
    System.out.println(i);
}

• break和continue后面不能有语句

带标签的循环 ,用于使用break和continue时跳出指定的循环

lab:for (int i = 0; i < 100; i++) {
    for (int j = 0; j < 100; j++) {
        System.out.println("i=" + i + ",j=" + j);
        if (i == j && i == 50){
            break lab;
        }
    }
}

数组

数组 :是多个相同类型数据按一定顺序排列的集合,并使用一个名字命名,并通过编号的方式对这些数据进行同一的管理

数组特点

• 数组是有序排列的
• 数组属于引用数据类型,数组中的元素可以是基本数据类型,也可以时引用数据类型
• 数组在内存中是一整块内存空间
• 数组的长度一旦初始化,就不能修改

一维数组

一维数组的声明初始化

int[] arr = new int[5];
int[] arr2 = new int[]{1,2,3,4,5};
int[] arr3 = {1,2,3,4,5};

一维数组的遍历

int[] arr = {10,20,30,60,50,80,90,70,40};
//普通循环遍历
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}
//增强for循环遍历
for (int i : arr) {
    System.out.println(i);
}

• 数组名.length :代表数组的长度
• 数组名[索引] :代表获取数组中某个元素,索引从0开始,到length-1

数组的默认初始化值

• 整数类型 0
• 浮点数类型 0.0
• 字符类型 ‘\u0000‘
• 布尔类型 false
• 引用类型 null

数组内存分析

二维数组

二维数组初始化

int[][] arr = new int[5][5];
int[][] arr2 = new int[5][];
int[][] arr3 = new int[][]{{10},{20,30},{40,50,60}};
int[][] arr4 = {{10},{20,30},{40,50,60}};

二维数组遍历

int[][] arr = {{10},{20,30},{40,50,60}};
for (int i = 0; i < arr.length; i++) {
    for (int j = 0;j < arr[i].length;j++){
        System.out.println(arr[i][j]);
    }
}

二维数组的初始化

int[][] arr = new int[5][5];

• arr[0] 的值为地址值
• arr[0][0] 的值为0

int[][] arr = new int[5][];

• arr[0] 的值为null
• arr[0][0] 报错,空指针

二维数组内存解析

JavaSE_基础语法

原文：https://www.cnblogs.com/qablogs/p/14546904.html