008Java基础语法

合集 - Java学习(2)

1.009Java基础之流程控制2023-07-06

2.008Java基础语法2023-07-04

收起

Java基础语法

1、注释、标识符、关键字

注释

平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到注释了。

注释并不会被执行，是给我们写代码的人看的。

书写注释是一个非常好的习惯

Java中的注释有三种：

• 单行注释 //
• 多行注释 /* 文本 */
• 文档注释/** */

标识符

关键字

一些常见的关键字如下：

Java的所有组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

标识符注意点

• 所有的标识符都应该以字母（A-Z或者a-z）、美元符号（$）、或者下划线（_）开始。
• 首字符之后可以是字母（A-Z或者a-z）、美元符号（$）、下划线（_）或者数字的任何字符组合。
• 不能使用关键字作为类名或方法名或变量名。
• 标识符是大小写敏感的
• 合法标识符举例：age、$salary、_value
• 非法标识符举例：123abc、-salary、#abc
• 可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，很Low

2、数据类型

• 强类型语言
  • 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用。安全性高，速度慢。
• 弱类型语言

Java的数据类型分为两大类：

1. 基本类型（primitive type）
2. 引用类型（reference type）

上述数据类型展开为：

• 基本数据类型（Primitive Type）
  • 数值类型
    • 整数类型
      • byte占1个字节范围：-128~127
      • short占2个字节范围：-32768~32767
      • int占4个字节范围：-2147483648~2147483647
      • long占8个字节范围：-9223372036854775808~9223372036854775807
    • 浮点类型
      • float占4个字节
      • double占8个字节
    • 字符类型char占2个字节
  • boolean类型：占1位，其值只有true和false两个
• 引用数据类型
  • 类
  • 接口
  • 数组

8种基本数据类型里不包括String类型。

什么是字节？

• 位（bit）：是计算机内部数据储存的最小单位，如11001100是一个8位二进制数。
• 字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示，
• 1B（byte，字节） = 8bit（比特）
• 字符：是指计算机中使用的字母、数字、字和符号

存在以下一些换算关系：

• 1bit表示1位
• 1Byte表示一个字节，1B = 8bit
• 1024B = 1KB
• 1024KB = 1MB
• 1024MB = 1GB
• 1024GB = 1TB

关于数据类型扩展及面试题讲解

以代码为例：

//整数拓展：   进制   二进制0b   十进制   八进制0   十六进制0x
int i = 10;
int i2 = 010;   //八进制0      8
int i3 = 0x10;  //十六进制0x    16
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
//=====================================
//浮点数拓展？    银行业务怎么表示？钱
//BigDecimal 数学工具类
//=====================================
//用float和double计算是有问题的： 浮点数能表示的字长是有限的，表示的值是离散的
//一般都存在舍入误差，大约，接近但不等于，最好完全避免使用浮点数比较
float f = 0.1f;     //0.1
double d = 1.0/10;  //0.1
System.out.println(f == d);//false
 
float d1 = 219239874421431321f;
float d2 = d1 + 1;
System.out.println(d1 == d2);//true
 
//======================================
//字符拓展
//======================================
char c1 = 'a';
System.out.println((int)c1);    //强制转换
char c2 = '中';
System.out.println((int)c2);    //强制转换
//******所有的字符本质上还是数字******
int c3 = 'a';
System.out.println(c3);         //97
//Unicode编码 可以处理各种语言的文字，占2个字节，最多可以表示65536个字符
//最早的Excell表格 有 2^16行 即65536行
//范围：  U0000 - UFFFF
char c4 = '\u0061'; //反斜杠u表示转义，注意除转义用外，不要在任何地方包括注释这么写
System.out.println(c4);
//转义字符：
// \t   制表符
// \n   换行
System.out.println("Hello\tWorld!");
System.out.println("Hello\nWorld!");
 
//======================================
//引用类型的比较
//======================================
String sa = new String("Hello World");
String sb = new String("Hello World");
System.out.println(sa == sb);   //false，地址不同要用.equals()比较
 
String sc = "Hello World";
String sd = "Hello World";
System.out.println(sc == sd);//true，Java中存在常量池
//以上比较涉及对象知识，要从内存分析
 
//======================================
//布尔值扩展
//======================================
boolean flag = true;
if (flag == true){      //或者if(flag){},Less is More,代码要精简易读
    //执行代码
    System.out.println(flag);
}

3、类型转换

• 由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。

• 小数的优先级一定是大于整数的，所以即使long是8字节64位，float仅仅是4字节32位，float的优先级也高于long。

• 运算中，不同类型的数据先转化成同一类型，然后进行运算。

有两种类型转换方式：

1. 强制类型转换
2. 自动类型转换

强制类型转换用于从高优先级类型转为低优先级类型，如：

int i = 128;
byte b = (byte)i;//这里是让int类型的变量i的值强制转换为byte类型，并赋值给b，会造成内存溢出。

自动类型转换不需要任何操作，自动从低优先级类型转为高优先级类型，如：

int i = 9999;
double b = i;//输出b，显示9999.0，这是因为double优先级高于int，向下兼容的缘故。

注意点：

1. 不能对布尔值进行转换，因为布尔值只有1位。
2. 不能把对象类型转换为不相干的类型。
3. 在把高容量转换到低容量的时候，需要强制转换。
4. 在转换的时候，可能存在内存溢出或者精度问题。

JDK7新特性，数字之间可以用下划线分割，下划线并不会被输出，如：

int money = 10_0000_0000;
System.out.println(money);//输出1000000000

操作比较大的数的时候，要注意溢出问题，如：

int money = 10_0000_0000;
int year = 20;
int total = money * year;//-1474836480，计算的时候溢出了。
long total2 = money * year;//不能这样操作，因为会先计算右边表达式，默认是int，转换之前已经存在问题了
//那要怎么解决溢出问题呢？
long total3 = (long)money * year;
//long转换放在前后后可以，但是不要(long)(money*year)，因为已经计算完，已经溢出，再转换也没有用
System.out.println(total3);

4、变量、常量

变量

• 变量是什么：就是可以变化的量！
• Java是一种强类型语言，每个变量都必须声明其类型。
• Java变量是程序中最基本的存储单元，其要素包括变量名、变量类型、作用域。

type varName [=value][{,varName[=value]}];
//数据类型 变量名 = 值;可以使用逗号隔开来声明多个同类型变量。

• 注意事项：
  • 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
  • 变量名必须是合法的标识符。
  • 变量声明是一条完整的语句，因此每一个声明都必须以分号结束。

变量的作用域

• 类变量（需要加关键词static）
• 实例变量
• 局部变量

如：

public class Variable{
    static int allClick = 0;//类变量
    String str = "Hello World!";//实例变量
    
    public void method(){
        int i = 0;//局部变量
    }
}

实操代码：

public class Demo07 {
    
    //类变量 static
    static double salary = 2500;
    /*如果把static去掉，那么下面的main函数就不能直接引用
    * 因为静态方法只能引用静态变量
    *
    * */
 
    //属性：变量
 
    //实例变量：从属于对象；如果不进行初始化，会给这个类型的默认值
    //使用的时候要:
    //Demo demo = new Demo();
    //System.out.println(demo.实例变量);
    //布尔值默认是false
    //除了基本类型，其余的默认值都是null
    String name;
    int age;
    boolean flag;
 
    //静态代码块
    /*
    * 在Java中，静态代码块是一个特殊的代码块，它在类加载时被执行，而不是在创建对象时执行
    *静态代码块的作用主要是在类加载时初始化类的静态成员变量，
    * 或执行其他需要在类加载时完成的初始化操作。
    * 在静态代码块中可以包含任何Java语句，例如赋值语句、循环语句、条件语句等
    * 当类被加载时，静态代码块中的代码会被自动执行一次，且只执行一次，
    * 无论创建多少个该类的对象。
    *
    * */
    static {
        //静态代码块中的代码
    }
 
    //main方法
    public static void main(String[] args) {
 
        //局部变量：在方法或代码块内，使用之前必须声明和初始化值，只在方法内可以使用
        int i;
        //System.out.println(i);因为没有初始化，所以输出不了
 
        //变量类型 变量名字 = new Demo07();
        Demo07 demo07 = new Demo07();
        demo07.name = "ZCQ";
        //demo07.age = 10;
        System.out.println(demo07.name);
        System.out.println(demo07.age);//age没有赋初始值，但是也输出了一个0
        System.out.println(demo07.flag);//float
 
        //类变量 static
        System.out.println(salary);
    }
 
    //其他方法
    public void add(){
 
    }
 
}
 

常量

• 常量（Constant）：初始化（initialize）后不能再改变值，使用关键字final修饰。
• 所谓常量可以理解成一种特殊的变量，只不过它的值被设定后，在程序运行过程中不允许被改变。

如：

//final 常量类型 常量名 = 值;
final double PI = 3.14;
 
static final double E = 2.7;
final static double E1 = 2.7;

修饰符不存在先后顺序

常量名一般使用大写字符。

变量的命名规范

• 所有变量、方法、类名：见名知意
• 类成员变量：首字母小写和驼峰原则：monthSalary
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首字母大写和驼峰原则：Man，GoodMan
• 方法名：首字母小写和驼峰原则：run()，runRun()

5、运算符

Java支持如下运算符：

1. 算数运算符：+，-，*，/，%（模运算），++，--
2. 赋值运算符：=
3. 关系运算符：>，<，>=，<=，==，!=，instanceof【用法为引用类型变量(object) instanceof 类(class)，判断前面的对象是否属于后面的类或子类，是true否false】
4. 逻辑运算符：&&，||，!
5. 位运算符：&，|，^，~，>>，<<，>>>（了解）
6. 条件运算符：? :
7. 扩展赋值运算符：+=，-=，*=，/=

long a = 12213133323123123L;
int b = 123;
short c = 14;
byte d = 8;
 
System.out.println(a+b+c+d);//输出为long类型，如果运算中有long类型，则结果为long类型
System.out.prinln(b+c+d);//int
System.out.println(c+d);//int，如果整数运算中没有long，则运算结果为int类型，即使运算的两个整数并非int型
//以上运算中，如果有一个数为double，则最后结果一定为double型，这涉及到数据类型的优先级问题

自增自减运算符

以代码为例：

int a = 3;
int b = a++;
int c = ++a;
 
System.out.println(a);//5
System.out.println(b);//3
System.out.println(c);//5

之所以会出现以上结果是因为：a++是先执行赋值运算，后执行自增运算；++a是先执行自增运算，后执行赋值运算。

幂运算

很多运算，我们会借助一些工具类来实现，如：

double a = Math.pow(2,3);//计算2的3次方

逻辑运算符

//与（and） 或（or） 非（no）
boolean a = true;
boolean b = false;
 
//逻辑与
System.out.println("a && b:"+(a&&b));//要记得给a&&b加上括号，因为逻辑运算符优先级小于字符串拼接运算符+，而圆括号的优先级是最高的，会先执行圆括号内的内容，再进行字符串拼接
//逻辑或
System.out.println("a || b:"+(a||b));
//逻辑非
System.out.println("!(a && b):"+!(a&&b));
 
//短路运算:逻辑与只要前面的数为假则直接为假，逻辑或只要前面的数为真则直接为真，不计算后面的表达式
int c = 5;
boolean d = (c<4)&&(++c<10);
System.out.println(c);//c=5,说明++c<10这条语句根本没有被执行
System.out.println(d);

位运算符

/*
A =     0011 1100
B =     0000 1101
 
A&B     0000 1100
A|B     0011 1101
A^B     0011 0001
~B      1111 0010
*/
//面试题：2*8怎么计算最快？
//<<左移，相当于*2
//>>右移，相当于/2
//问题可以认为是2*2^3，可以将2的二进制数（0000 0010）向左边移3位，变成0001 0000，也就是十进制的16
System.out.println(2<<3);//16
/*>>和>>>的区别
>>是算术右移，是有符号的，左边空出的符号位采取正数补0，负数补1的方式
而>>>是逻辑右移，也叫无符号右移，左边空出的地方直接补0
因此>>>对正数没有影响，而对于负数则会出错
*/

位运算直接与底层打交道，效率极高！

字符串运算符

int a = 10;
int b = 20;
 
a+=b;//a = a + b;
System.out.println(a);//30
 
//字符串连接符 +
System.out.println(a+b);
System.out.println(""+a+b);//3020
System.out.println(a+b+"");//50

字符串在字符串连接符前面，则后面的内容进行拼接；

如果字符串在字符串连接符后面，则前面的内容依然会进行运算。

条件运算符（三元运算符）

//x ? y : z
//如果x为true，则结果为y，否则结果为z
 
int score = 60;
String type = score >= 60 ? "及格" : "不及格";
System.out.println(type);

运算符的优先级（必须掌握）

6、包机制、JavaDoc

包机制

包的本质其实就是文件夹。

• 为了更好的组织类，Java提供了包机制，用于区别类名的命名空间
• 包语句的语法格式为：

package pkg1[.pkg2[.pkg3...]];

一般利用公司域名倒置作为包名

• 为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用import语句可以完成此功能。

import package1[.package2...].(classname|*);//*是通配符的意思，可以导入这个包下所有的类

注意：尽量不要让包里面的类名重复，如pkg1和pkg2中同样有一个名为A的类，则在pkg2的A中引用pkg1中的A时，会提示A已经被定义过。

代码的书写规范非常重要，推荐去看《阿里巴巴Java开发手册》，养成良好的编程习惯！

JavaDoc

• JavaDoc命令是用来生成自己API文档的

• 参数信息：

  • @author 作者名
  • @version 版本号
  • @since 指明需要最早使用的jdk版本
  • @param 参数名
  • @return 返回值情况
  • @throws 异常抛出情况

package com.rootgence.base;
 
/**
 * Created by Enzo Cotter on 2023/7/3.
 * @author ZCQ
 * @version 1.0
 * @since 1.8
 */
public class Doc {
    String name;
 
    /**
     *
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
}

通过命令行生成JavaDoc：javadoc 参数 Java文件

使用IDEA生成JavaDoc：

1. 点击Tools->Generate JavaDoc

2. 进行配置，选择生成文档的范围，设置输出目录，设置文档语言为zh_CN（简体中文），设置参数，使显示中文不乱码

3. 点击生成即可，可在设置过的输出目录中找到JavaDoc文档。