重拾Java-2-Java基础
重拾Java-2-Java基础
-
打开IDEA，建立一个空项目Empty Project，命名为JavaSE
(暂时不设置项目结构Project Structure)
-
在JavaSE项目中新建一个Module，命名“基础语法”
-
打开项目结构，对运行环境进行配置（若不配置，项目可能无法编译）
![]()
注释
-
注释并不会被执行，是给开发人员所用
-
书写注释是一个非常好的习惯
-
平时写代码一定要注意规范
-
Java中的注释有三种：
- 单行注释 只能注释一行文字
//表示单行注释 //可以在Settings-Editor-Color Scheme-Java-Comments（注释）-Line Comment/Block Comment/JavaDoc中设置对应的颜色及样式- 多行注释 可以注释一段文字
/* 我 是 多行注释------------------------ */- 文档注释 可以加参数
/** * @author yxyang * @create 2025/3/17-23:46 */注释在IDEA中的快捷键可以选择该行或多行，再用Ctrl + Shift + /
标识符和关键字
关键字
| abstract | assert | boolean | break | byte |
|---|---|---|---|---|
| case | catch | char | class | const |
| continue | default | do | double | else |
| enum | extends | final | finally | float |
| for | goto | if | implements | improt |
| instanceof | int | interface | long | native |
| new | package | private | protected | public |
| return | stricitfp | short | static | super |
| switch | synchronized | this | throw | throws |
| transient | try | void | volatile | while |
标识符
Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
关键字是固定的，不能以关键字定义标识符。
标识符注意点：
- 所有的标识符都应该以字母(A-Z或者a-z)，美元符($)、或者下划线(_)开始
- 首字符之后可以是字母(A-Z或者a-z)，美元符($)、下划线(_)或者数字的任何字符组合
- 不能使用关键字作为变量名或方法名
- 标识符是大小写敏感的
- 可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，养成良好的规范
String Atest = "yuu";
String test = "yuu";
String $test = "yuu";
String _test = "yuu";
//String #test = "yuu"; 报错-注意点1
//String 1test = "yuu"; 报错-注意点1
String t1est = "yuu";
//String t%est = "yuu"; 报错-注意点2
//String class = "yuu"; 报错-注意点3
String Man = "男";
String men = "男";
//Man与men不同，大小写敏感 -注意点4
数据类型
Java是一种强类型语言 （要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用）
- 强类型语言 eg: Java, C, C++
- 弱类型语言 eg: Javascript
Java的数据类型
-
基本类型(primitive type)
-
数值类型
-
整数类型
- byte占1个字节范围：-128~127
- short占2个字节范围：-32768-32767
- int占4个字节范围：-2147483648-21477/697
- long占8个字节范围：-9223372036854775808-9223372036854775807
-
浮点类型
- float占4个字节
- double占8个字节
-
字符类型char 占2个字节
字符代表一个字，使用''表示；多个字用字符串，使用""表示
注意：String不是关键字
在底层，
char实际上是一个整数类型，它存储的是字符对应的 ASCII 码（或系统使用的字符集编码，如 Unicode 的子集）。例如，字符'A'的 ASCII 值是 65。
-
-
boolean类型 占1位其值true和false两个
//八大基本数据类型 //整数 byte num1 = 10; int num2 = 20; //最常用的整数类型 short num3 = 30; long num4 = 40L; //Long类型要在数字后面加个L //小数：浮点数 float num5 = 50.1F; //float类型后面要在数字后面加个f double num6 = 3.1415926589793238462643; //字符 char name = '嗨'; //字符串String不是关键字，String是个类 //String string = "哈喽"; //布尔值：是非 boolean flag = true; //boolean flag = false;-
long和float类型都需要在数字后面加个L或F，否则浮点数会默认认为double类型，报错;
-
char为字符类型，为一个字，可以存储-128~127之间的整数或对应的ASCII码；
多个字用String类，但String不是基本数据类型；
字符使用
''表示，而字符串使用''表示。 -
整数与浮点数类型均有包装类，其数值大小已在包装类（类名为其首字母大写）中定义；
-
-
引用类型(reference type) （除上述八种基本类型之外的均为引用类型）
- 类
- 接口
- 数组
拓展：什么是字节？
-
位(bit)：是计算机内部数据储存的最小单位。
eg: 11001100是一个八位二进制数
-
字节(byte)：是计算机中的数据处理的基本单位，习惯上用B来表示。
-
1B = 8bit 因此byte的字节范围为-27~27-1
1024B= 1KB 1024KB = 1M 1024M = 1G 1024G= 1TB
思考：电脑32位和64位的区别
答：在CPU中的寻址能力与其挂钩。32位最多支持4GB内存（内存条无法扩充），64位支持128GB内存
32位指的就是内存寻址空间，也就是说总共有2的32次方个内在地址，一个地址存储一个字节，所以换成GB有232B=2(32-30)GB=22GB=4GB
那么64位即为264B=2(64-30)GB=234GB ????
解答：32位即2^32=4GB
64位即264，但实际因为其它因素，最大容量不可能到达264B，因此最多支持128GB
- 字符：是指计算机中使用的字母、数字、字和符号
拓展：数据类型面试题
//整数拓展：进制前缀表示 二进制0b 八进制0 十进制 十六进制0x
int i1 = 10;
int i2 = 010; //八进制0
int i3 = 0x11; //十六进制0x 0~9 A~F
System.out.println(i1); //10
System.out.println(i2); //8
System.out.println(i3); //17
//浮点数拓展：银行业务怎么表示？
//float能表示的字长是有限的，但也是离散的，存在舍入误差，无法精确表示结果，即接近但不等于
float f = 0.1f; //0.1
double d = 1.0/10; //01
System.out.println(f==d); //false
float f1 = 23131f;
float f2 = f1 + 1;
float f3 = 23131312312312313f; //f3=2.3131313E16
float f4 = f3 + 1; //f4=2.3131313E16
System.out.println(f1 == f2); //false
System.out.println(f3 == f4); //true
//最好完全避免使用浮点数进行比较
//银行业务用类表示，BigDecimal 数学工具类
//字符拓展
char c1 = 'a';
char c2 = '中';
System.out.println(c1);
System.out.println((int)c1); //强制转换
System.out.println(c2);
System.out.println((int)c2); //强制转换
//所有的字符本质还是数字
//char涉及编码问题 Unicode编码对应一张编码表，一般通过转义表示 U0000-UFFFF
// 0-可以处理任何语言的文字，占2个字节 可以表示0-65536（2^16）个字符
//Unicode的编码表使数字对应一个字符 eg: 97 = a, 65 = A
char c3 = '\u0061';
System.out.println(c3); //a \\u转义 0061为十六进制对应97，即a
//转义字符
//\t 制表符 \n 换行 及等等
System.out.println("Hello\tWorld"); //Hello World
System.out.println("Hello\nWorld"); //Hello(换行)World
//从内存分析对象，后期讲解
String str_a = new String("hello world");
String str_b = new String("hello world");
System.out.println(str_a == str_b); //false
String str_c = "hello world";
String str_d = "hello world";
System.out.println(str_c == str_d); //true
//布尔值拓展
boolean flag1 = true;
//if(flag == true){} 新手程序员写法
if(flag1){
//Less is More！ 代码要精简易读
}
int类型中，不同进制其前缀表示不同；
尽量完全避免用浮点数进行计算和比较，会存在精度缺失，若有需要，可用数学工具类
BigDecimal（要小心float由于字长不足存在的比较陷阱）；
每个字符对应一个Unicode编码数字，因此char可用int进行转换(char要输出Unicode编码时需要转换成int型)；
转义字符可以char或String中使用，转义成相应的格式或Unicode字符（注意：在字符中，
包括注释使用转义符号会报错！）括号中内容错误，下述已修改例如：
char c = '\u0061'; //\u为转义字符 （！！！无法编译）错误！！！
:为了输出\字符，因为常见的转义字符都以''开头，所以当你输入\时，Java会自动认为你要输入转义字符，因此想要单独的输出\字符需要用\字符进行转义
上述代码修改：
char c = '\u0061'; //\\u为转义字符 即不会报错
Java书写讲究Less is More!
类型转换
由于Java是强类型语言，所以要进行有些运算的时候 ，需要用到类型转换。
低----------------------------------------------------->高(容量)
byte, short, char -> int -> long -> float -> double
-
运算中，不同类型的数据先转化为同一类型，然后进行去运算。
-
转换时，由低到高自动转换（小数的优先级一定大于整数）
public static void main(String[] args) {
int i = 128;
byte b = (byte)i; //要进行强制类型转换，但byte范围为-128~127，会导致内存溢出
double d = i; //低->高，自动转换
//强制转换格式： （类型）变量名 高->低
//自动转换： 低->高
System.out.println(i); //128
System.out.println(b); //-128，内存溢出
System.out.println(d); //128.0，自动转换
System.out.println((int)23.7); //23，精度缺失
System.out.println((int)-45.89f); //-45，精度缺失
char c1 = 'a';
int c2 = c1+1;
System.out.println(c2); //98
System.out.println((char)c2); //b
}
注意点：
- 不能对布尔值进行转换；
- 不能把对象类型转换为不相干的类型；
- 在把高容量转换到低容量的时候，强制转换；反之，自动转换；
- 转换的时候可能存在溢出，或者精度问题；
- 操作比较大的数时，注意溢出问题 ——运算前先转换其中一个数的类型
public static void main(String[] args) {
//JDK7新特性：数字之间可以用下划线分割
int money = 10_0000_0000; //用下划线分割，money值仍为1000000000
int years = 20;
int total1 = money*years; //-1474836480，计算时溢出了
long total2 = money*years; //-1474836480，先相乘，再进行转换，即转换前已经存在溢出问题
long total3 = money*((long)years); //20000000000，先把一个数转换为Long，使表达式全部用Long运算
System.out.println(total1);
System.out.println(total2);
System.out.println(total3);
}
变量和常量
变量
- 变量：可以变化的量。（可以通过变量操作一些内存中的数据-变量被指定一个内存的空间，空间固定，但其中的数据可变）
- Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
type varName [=value] [{,varName[=value]}];
//数据类型 变量名 = 值
//可以使用逗号隔开来声明多个同类型变量，但不建议！！
//int a=1, b=2, c=3 不建议，不便于程序的可读性
int a=1;
int b=2;
int c=3;
注意事项
- 每个变量都有类型，类型可以是基本类型，也可以是引用类型；
- 变量名必须是合法的标识符；
- 变量声明是一条完整的语句，因此每一个声明进行必须以分号结束。
public class Demo04 {
//类中，可以定义属性和方法
//类变量：从属于类；用static修饰
static double salary = 12000;
//实例变量：从属于对象；如果不自行初始化，则默认为这个类型的默认值
//所有数值类型为0 0.0（字符串为u0000，默认也为0）布尔值默认为false
//除了基本类型，其余的默认值都为null
String name;
int age;
//主程序方法，即main方法
public static void main(String[] args) {
//局部变量：定义在方法中，必须声明和初始化值
int i = 10;
System.out.println(i); //10
//实例变量 需new 类名()
Demo04 demo04 = new Demo04();
System.out.println(demo04.name); //null
System.out.println(demo04.age); //0
//类变量 static，可直接使用
System.out.println(salary); //12000.0
}
}
变量分为：
-
类变量：从属于类，需要用
static修饰，在方法中可以直接使用 -
实例变量：从属于对象，在方法中使用时，需要通过对象调用，即new 类名()
-
局部变量：只在定义的方法中起作用，必须声明和初始化值
注：类变量和实例变量若没有初始化，则其值为该数据类型的默认值（所有数值类型均为0或0.0，布尔值默认为false，除基本类型外，其余均为null)
常量
- 常量：初始化(initialize)后不能再改变值，即不会变动的值。
- 常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
- 常量用关键字final修饰
public class Demo05 {
//修饰符先后顺序不影响
static final double PI = 3.14;
final static double PI1 = 3.14;
public static void main(String[] args) {
System.out.println(PI); //3.14
System.out.println(PI1); //3.14
}
}
注意
- 常量通过final定义，一般使用大写字母定义常量
- 修饰符不存在先后顺序
- 使用常量可以增强代码的可读性，如可以把一些固定值定义为静态的常量，可以直接调用
变量的命名规范
-
所有变量、方法、类名要见名知意
-
类名：首字母大写和驼峰原则
eg: Demo, Evaluate
-
方法名：首字母小写和驼峰原则
eg: add(), mainRun()
-
类成员变量：首字母小写和驼峰原则
eg: monthSalary 即除了第一个单词以外，后面的单词首字母大写
-
局部变量：首字母小写和驼峰原则
-
常量：大写字母和下划线
eg: MAX_VALUE
运算符
-
Java语言支持如下运算符：
- 算术运算符：+， -， *， /， %（模运算，即取余）， ++， --
- 赋值运算符：=
- 关系运算符：>, <, >=, <=, ==, !=, instance of
- 逻辑运算符：&&(与), ||(或), !(非)
（除上述四种掌握，下列了解即可）
- 位运算符：&, |, ^, ~, >>, <<, >>> （用于二进制）
- 条件运算符：？ ：
- 扩展赋值运算符：+=, -=, *=, /=
二元运算符
public static void main(String[] args) {
//二元运算符
int a = 10;
int b = 20;
int c = 21;
System.out.println(a+b); //30
System.out.println(a-b); //-10
System.out.println(a*b); //200
System.out.println(a/b); //0，int型的0.5即为0
System.out.println(a/(double)b); //0.5，将其中一个数转为double型
//模运算（取余）
System.out.println(c%a); //1
}
加法运算
/*
整数运算：
如果两个操作数有一个为long，则结果也为long；
没有long时，结果为int. 即使操作数全为short, byte，结果也是int
浮点数运算：
如果两个操作数有一个为double，则结果为double；
只有两个操作数都是float，则结果才为float。
注意：int与float运算，结果为float。
*/
public static void main(String[] args) {
long a = 123123123123123L;
int b = 123;
short c = 10;
byte d = 8;
System.out.println(a+b+c+d); //123123123123264, long
System.out.println(b+c+d); //141, int
System.out.println(c+d); //18, int
}
除法运算
要注意数据类型是否合适，避免造成精度缺失（如int类型相除，需要先将一个数的数据类型转换为double型）
一元运算符
public static void main(String[] args) {
//++自增 --自减 一元运算符
int a = 3;
int b = a++; //执行完这行代码后，先给b赋值，再自增
//即b=a; a=a+1;
int c = ++a; //执行完这行代码后，先自增，再给c赋值
//即a=a+1; c=a;
System.out.println(a); //5
System.out.println(b); //3
System.out.println(c); //5
//很多运算，我们会使用一些工具类来操作
//如：幂运算 Math.pow(a,b)
//IDEA快捷键：使用方法时，Alt Enter可以跳出定义提示，再Enter即可
double pow = Math.pow(3, 2);
System.out.println(pow); //9.0
}
- b = a++; //等价于b=a; a=a+1;
- b = ++a; //等价于a=a+1; b=a;
因此，自增自减符号的位置与赋值有前后关系，要注意自增或自减的时机
逻辑运算符
public static void main(String[] args) {
//与(and) 或(or) 非（取反）
boolean a = true;
boolean b = false;
System.out.println("a && b: "+(a&&b)); //false
System.out.println("a || b: "+(a||b)); //true
System.out.println("!(a && b): "+!(a&&b)); //true
//短路运算
int c = 5;
boolean d = (c<4)&&(c++<4); //逻辑与运算中，c<4-false，则短路，后而不再处理
System.out.println(d); //false
System.out.println(c); //c仍为5
}
- 逻辑与运算
&&：两个变量都为真 （注意短路运算！！） - 逻辑或运算
||：两个变量有一个为真，则结果才为真 - 逻辑非运算
!：如果是真，则为假；如果是假，则为真
&&中存在短路运算，因为只有两真才为真，若第一个表达式为假，后面的表达式将不再处理
位运算
位运算效率高，因为其与底层（二进制）打交道
面试题：2*8=16 怎么运算最快
位运算中有<<（左移，即*2）、>>（右移，即/2）
2*8即左移3位
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
0000 1000 8
0001 0000 16
扩展赋值运算符
public static void main(String[] args) {
int a = 10;
int b = 20;
//扩展赋值运算符 （偷懒运算符，不建议）
a+=b; //建议书写为 a = a+b
System.out.println(a); //30
//字符串连接符 +
System.out.println(a+b); //50
System.out.println(""+a+b); //3020
System.out.println(a+b+""); //50 字符串在后面，a+b仍进行运算
System.out.println(a+b+""+a+b); //503020
}
注意：字符串连接符的位置若位于数值类型运算之前，则将数值类型转换为字符串进行拼接；
若位于数值类型运算之后，则先运算，再转换为字符串
三元运算符
三元运算符便于精简代码，并利于理解
表达式：x ? y : z 如果x==true，则结果为y，否则结果为z
public static void main(String[] args) {
int score = 80;
String grade = score < 60 ? "不及格" : "及格";
System.out.println(grade);
}
运算符优先级
口诀：单算移关与，异或逻条赋
-
括号级别最高，逗号级别最低
-
单目 > 算术 > 位移 > 关系 > 逻辑 > 三目 > 赋值
包机制
为了更好的组织类，Java提供了包机制，用于区别类名的命名空间。（防止命名空间重复）
包的语句语法格式为：package pkg1[.pkg2[.pkg3...]];
- 一般利用公司域名倒置作为包名 package
如：百度www.baidu.com
包名为com.baidu.www (再例如baidu下面有baike、wenku等等)
-
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。
import package1 [.package2...].(classname|*);
【IDEA中导入包，可以在成员处使用快捷键Alt Enter】
注意：
- import要在package后使用
- *为通配符，表示导入该包下所有类
JavaDoc
百度： Jdk帮助文档 - JavaSE帮助文档-Jdk8 https://docs.oracle.com/javase/8/docs/api/
JavaDoc命令是用来生成自己的API文档
-
加在类上，为类的注释
-
加在方法上，即为方法的注释。（写完方法后，在方法上方使用/*回车，即可自动生成）
参数信息
- @author 作者名
- @version 版本号
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
用命令行操作JavaDoc：
javadoc [参数，例如：-encoding UTF-8 -charset UTF-8] 文件.java
- 在IDEA中选择.java文件，右键-show in Explorer-在文件夹中cmd进入命令行
- 生成很多html，打开index.html(首页)
- 即可看见生成的文档
思考：学会查找使用IDEA生成JavaDoc文档
浙公网安备 33010602011771号