Loading

Java学习笔记01-基本语法

强烈安利韩顺平老师的b站Java教程!


1. Java执行流程

.java文件(源文件) javac编译 .class文件(字节码文件) java运行 结果

//Hello.java
//Hello是一个公有类
public class Hello {
    //主方法,程序的入口
	public static void main(String[] args) {
		System.out.println("hello world!");
	}
}

注意
一个源文件最多一个public类,其他类 不限;
如果源文件包含一个public类,则文件名以该类命名;
可将main方法写在非public类中,然后指定运行非public类,这样入口方法就是非public类的main方法。

2. Java转义符

  1. \t 一个制表位,实现对齐功能
  2. \n 换行符
  3. \r 一个回车
  4. " ' \ 输出双引号、单引号、反斜杠

3. 文档注释

可被javadoc所解析,生成一套以网页形式体现的说明文档。

/**
 * @author Tom
 * @version 0.1
*/

javadoc -d /doc -author -version Hello.java

4. Java代码规范

  1. 类、方法的注释,要以javadoc的方式写
  2. 运算符和等号两边有空格
  3. 源文件使用utf-8保存
  4. 行宽度不要超过80字符

5. 变量

5.1 变量概念

变量必须先声明再使用;
变量在同一个作用域内不能重名;
变量可以在同一类型下更改其他值。
int a = 10
Java变量首字母不能大写。
+号使用:

  • 左右两边都是数值型,做加法运算
  • 左右两边一方为字符串,做字符串拼接
  • 运算顺序从左到右

5.2 数据类型

Java数据类型分两大类,基本数据类型和引用类型。
基本数据类型:

  • 数值型
    • 整数类型 byte short int long 占字节数:1、2、4、8
    • 浮点型 float double 占字节数:4、8
  • 字符型 char 占字节数:2
  • 布尔型 boolean 占字节数:1

引用类型:

  • 类(class)
  • 接口(interface)
  • 数组

整型

各整型类型有固定的范围和字段长度,不受OS影响。
整型常量(具体值)默认为int,声明long型需在后面加‘l’或‘L’。
long num = 1L
变量一般声明为int,除非长度不足才用long。

浮点型

单精度float 占4字节
双精度double 占8字节
浮点数在机器中存放形式:浮点数=符号位+指数位+尾数位,尾数部分可能丢失,造成精度损失。
浮点型常量(具体值)默认为double,声明float时需在后面加‘f’或‘F’。
float num = 1.1f
浮点型常量两种表示形式:

  • 十进制数:9.11 911.0f .0911 (必须有小数点)
  • 科学计数法:5.12e2(5.12102) 5.12E-2(5.1210-2)

通常情况应使用double型。
浮点数使用陷阱:2.7与8.1/3,要小心对小数运算结果的相等判断,正确的判断应是对两个数差值的绝对值控制在非常小的精度。

double num1 = 2.7;
double num2 = 8.1 / 3; //计算结果小于但接近2.7
//错误的判断相等
if (num1 == num2) {
    System.out.println("equal");
}
//正确的判断相等
if (Math.abs(num1 - num2) < 0.1e-6) {
    System.out.println("equal");
}

字符类型

用单引号括起来,存放单个字符,两字节,可存放一个汉字,还允许使用转义字符。
Java中char的本质是一个整数,输出是Unicode码对应的字符。
char型可以进行运算,相当于对应Unicode码整数的运算。

char c1 = 'a';
char c2 = 97;
char c3 = '\t';
char c4 = '啊';
System.out.println('a'+10); //输出107

ASCII一个字节表示字符,
Unicode两个字节表示字符,
UTF-8字母一个字节,汉字三个字节。

布尔型

boolean型占1字节,true和false。Java中不可用0或非零代替false或true。

自动类型转换

当Java程序在赋值或运算时,精度小的类型自动转换为精度大的。
数据类型按精度(容量)大小排序:
char<int<long<float<double
byte<short<int<long<float<double
double a = 80;int b = 'a';

注意
有多种类型的数据混合运算时,系统自动将所有类型转换成精度最大的那种类型。
把精度大的数据类型赋值给精度小的会报错,反之不会。
(byte,short)和char之间不会相互自动转换。
byte,short,char之间可以计算,计算时首先转换成int,即便byte与byte运算也会自动转换为int。
boolean型不参与类型自动转换。
表达式结果的类型自动提升为操作数中最大的类型。

强制类型转换

自动类型转换的逆过程,将容量大的类型转换为容量小的,使用强制转换符,可能造成精度损失或数据溢出。

int i = (int)1.9; //1
int j = 2000;
byte b = (byte)j; //-48

强转符号只针对最近的操作符,对全部操作数需小括号。
char类型可以保存int常量值,不可保存int变量值,需要强转。

基本数据类型与String的转换

基本数据类型转String:后+""

int i = 100;
String s1 = i + "";
boolean b = true;
String s2 = b + "";

String转基本数据类型:使用数据类型对应的parse方法

String s1 = "123";
int i1 = Integer.parseInt(s1);
double d1 = Double.parseDouble(s1);

字符串转char:获取字符串的第一个字符

String s = "123";
System.out.println(s.charAt(0));

注意
将String转成基本数据类型时,确保String数据的有效性,如果格式不正确会抛出异常。

6. 运算符

6.1 算术运算符

+加,-减,*乘,/除,%取模,++自增,--自减

System.out.println(10 / 4); //输出2,整数除以整数
System.out.println(10.0 / 4); //输出2.5
double d = 10 / 4; //结果2.0
//%本质:a % b = a - a / b * b
System.out.println(-10 % 3); //结果-1
System.out.println(10 % -3); //结果1
System.out.println(-10 % -3); //结果-1
int i = 1;
i = i++; //temp = i; i = i+1; i = temp;
System.out.println(i); //1

6.2 关系运算符

instanceof 检查是否是类的对象,"abc" instanceof String结果为true。

6.3 逻辑运算符

  • 短路与 &&,短路或 ||,取反 !
  • 逻辑与 &,逻辑或 |,逻辑异或 ^

6.4 赋值运算符

  • 基本赋值运算符 =
  • 复合赋值运算符 +=,-=,*=,/=,%=

复合赋值运算会进行类型强制转换:

byte b = 3;
b += 2; //等价于b=(byte)(b+2),但b=b+2则不行
b++; //等价于b=(byte)(b+1)

6.5 三元运算符

条件表达式?表达式1:表达式2;
若条件表达式为true,则运算结果为表达式1;
若条件表达式为false,则运算结果为表达式2。
表达式1和表达式2要为可以赋给接受变量的类型(或可以自动转换)。
三元运算符可以转换为if-else语句。

6.6 标识符命名规则与规范

Java对各种变量、方法和类等命名使用的字符序列叫做标识符。

命名规则

  1. 由26各英文字母大小写,0-9,_或$组成;
  2. 数字不可开头;
  3. 不可使用关键字和保留字,但能包含关键字和保留字;
  4. 严格区分大小写,长度无限制;
  5. 标识符中不能包含空格。

命名规范

  1. 包名:多单词组成时所有字母小写 aaa.bbb.ccc;
  2. 类名、接口名:多单词组成时所有单词首字母大写;
  3. 变量名、方法名:多单词组成时,第一个单词首字母小写,后面单词首字母大写;
  4. 常量名:所有字母大写,多单词时每个单词间下划线连接。

6.7 进制与位运算

进制

二进制:以0b或0B开头,int n1 = 0b1010
八进制:以0开头,int n2 = 01010
十六进制:以0x或0X开头,A-F不区分大小写,int n3 = 0x1a

位运算

按位与&,按位或|,按位异或^,按位取反~
算术右移>>:低位溢出,符号位不变,并用符号位补溢出的高位。
算术左移<<:符号位不变,低位补0。
逻辑右移>>>:无符号右移,低位溢出,高位补0。(没有<<<)

int a = 15 >> 2; //相当于15/2/2=3
int b = 4 << 3; //相当于4*2*2*2=32

7. 控制结构

7.1 顺序控制

7.2 分支控制

单分支

import java.util.Scanner;
public class If01 {
	public static void main(String[] args) {
        Scanner myScanner = new Scanner(System.in);
        System.out.println("input age:");
        int age = myScanner.nextInt();
        if (age > 18) {
        	System.out.println(age + "is adult");   
        }
    }
}

双分支
多分支
嵌套分支
switch分支:
switch内的表达式结果数据类型需和case的常量类型一致;
switch表达式中的返回值必须是(byte、short、int、char、enum、String);
case子句中的值必须是常量;
若没有break跳出switch,则顺序执行下一个子句。

7.3 循环控制

for循环

while循环

do_while循环

多重循环

7.4 跳转控制

break

用于终止某个语句块的执行,在switch或循环中。
当某个条件满足时,终止循环。
break出现在多层嵌套的语句中,可通过标签指明要终止到哪里,若没有指定标签,默认退出最近的语句块。

abc1:
for (int j = 0; j < 4; j++) {
 	abc2:
    for (int i = 0; i < 10; i++) {
        if (i == 2) {
            //break; //输出4次01
            break abc1; //输出一次01
        }
        System.out.println("i=" + i);
}

continue

结束本次循环,继续执行下一次循环。
也可以使用标签。

return

如果return写在main方法,退出程序。

8. 数组

8.1 数组

数组是引用类型,存放多个同类型数据。
动态初始化1:
数组定义:数据类型 数组名[] = new 数据类型[大小];
数组的引用:数组名[下标]
动态初始化2:
先声明:数据类型 数组名[];
创建数组:数组名 = new 数据类型[大小];
静态初始化:
数据类型 数组名[] = {元素值1,元素值2};

注意:
数组中的元素可以是任意类型;
数组创建后,如果没有赋值,有默认值;
使用数组的步骤:1声明数组并开辟空间,2给数组各个元素赋值,3使用数组;
数组属引用类型,数组型数据是对象,赋的值为地址。

数组拷贝

int arr1[] = new int[]{10, 20,30};
int arr2[] = new int[arr1.length];
for (int i=0; i<arr1.length; i++) {
	arr2[i] = arr1[i];
}

数组反转

int arr[] = {11,22,33,44,55,66}
int temp = 0;
for (int i=0; i < arr.length/2; i++) {
	temp = arr[arr.length-1-i];
	arr[arr.length-1-i] = arr[i];
	arr[i] = temp;
}

8.2 二维数组

动态初始化1:类型 数组名[][] = new 类型[大小][大小]
动态初始化2:类型 数组名[][];数组名 = new 类型[大小][大小];
静态初始化:类型 数组名[][] = {{值1, 值2}, {...}};

int ar[][] = {{...}, {...}};
for (int i = 0; i < arr.length; i++) {
 	for (int j = 0; j < arr[i].length; j++) {
     	System.out.print(arr[i][j] +" ");   
    }
    System.out.println();
}

可以允许二维数组中的一维数组元素个数不同。

int arr[][] = new int[3][]; //创建三个一维数组的二维数组
for (int i = 0; i < arr.length; i++) {
    //给一维数组开辟空间
    arr[i] = new int[i+1];
    //遍历一维数组并给一维数组元素赋值
    for (int j = 0; j < arr[i].length; j++) {
        arr[i][j] = i + 1;
    }
}
posted @ 2022-03-20 17:26  KRDecad3  阅读(25)  评论(0编辑  收藏  举报