Java基础03：变/常量、运算符、包机制、JavaDoc

Bruce6379

已于 2024-01-05 23:57:24 修改

阅读量419

点赞数

分类专栏： Java 文章标签： java 开发语言

于 2023-03-06 19:41:08 首次发布

本文链接：https://blog.csdn.net/weixin_45754498/article/details/129365456

版权

Java 专栏收录该内容

32 篇文章 1 订阅

订阅专栏

本文详细介绍了Java编程中的变量类型，包括静态变量、实例变量和局部变量，以及它们的作用域和默认值。同时，讲解了算术、关系、逻辑和位运算符的用法，还有条件运算符和扩展赋值运算符。此外，还探讨了包机制的概念和JavaDoc的使用，以及如何生成帮助文档。

摘要由CSDN通过智能技术生成

4、变量、常量、作用域

4.1 变量命名规范：驼峰原则

驼峰原则：除了第一个单词以外，后面的单词首字母大写。如：monthSalary、lastName、userId 点击查看标识符命名原则

所有变量名、方法名、类名：见名知意；
类名：首字母大写和驼峰原则；
常量：大写字母和下划线，如：MAX_VALUE；
类成员变量：首字母小写和驼峰原则;
方法名：首字母小写和驼峰原则；
局部变量：首字母小写和驼峰原则。

定义同名问题：

同一个域中局部变量不能定义为相同的名字，无法编译；
同一个域中成员变量也不能定义为相同的名字，无法编译；
局部变量和成员变量定义的名字可以相同，但是使用过程中遵循就近原则，不建议；

4.2 变量

变量就是可以变化的量，根据变量声明的位置不同可以分为：局部变量和成员变量，成员变量又可以分为静态变量（类变量）和实例变量。

Java是一种强类型语言，每个变量都必须声明其类型；
Java变量是程序中最基本的存储单元，其要素包括变量类型、变量名和作用域。

声明变量的格式：
type varName [= value] [{,varName [=value]}];
数据类型变量名 = 值；// 可以使用逗号个开来声明多个同类型的变量，但是不建议使用。

变量注意事项：
(1) 变量名必须是合法的标识符；
(2) 每个变量都有类型，可以是基本类型，也可以是引用类型（如：String类）；
(3) 变量声明是一条完整的语句，因此每一个声明必须以分号; 束。
1.静态变量/类变量 ：由static 关键字限定；
2.实例变量 ：从属于对象，如果不初始化，就输出这个类型的默认值；

3.局部变量：位于方法内部，只能在当前方法内使用。

4.2.1 静态变量/类变量

静态变量 / 类变量从该类的准备阶段起开始存在，直到系统完全销毁这个类。类变量的作用域与这个类的生存范围相同。

public class China{
	static String nationality = "China";// 类变量：国籍
	
	public static void main(String[] args) {
		Chinese tom = new Chinese();
        String nat1 = tom.nationality;// 不推荐
		String nat2 = China.nationality;
        
        System.out.println(nat2); // 输出：China
	}
}

4.2.2 实例变量

实例变量是指在类中声明的变量，每个类的实例都会拥有自己的一组实例变量。
实例变量在类的任何方法、构造函数或块中都可以被访问和使用。
它们的值是与类的每个实例相关联的，因此每个实例都可以具有不同的实例变量值。

public class Demo422{
    // 实例变量
    int i = 5;
    
    public static void main(String[] args) {
        Demo422 obj1 = new Demo422(); // 创建对象1
        Demo422 obj2 = new Demo422(); // 创建对象2
        
        // 实例变量只能通过对象名调用
        System.out.println(obj1.i); // 输出：5
        System.out.println(obj2.i); // 输出：5
        
        obj1.i = 10; // 修改对象1的实例变量值
        
        System.out.println(obj1.i); // 输出：10
        System.out.println(obj2.i); // 输出：5
    }
}

public class Chinese{
	static String nationality = "China";// 国籍
	String name;
	int age;	
	Chinese(String name,int age){
		this.name = name;
		this.age = age;
	}
}

public class Test{
	Chinese tom= new Chinese("Tom",18);
	String name = tom.name;
	String age= tom.age;
	String nationality = tom.nationality;// 不推荐
	String nationality = China.nationality;
}

4.2.3 局部变量

局部变量

1.局部变量必须先赋值才能使用

2.局部变量在重合的作用范围内不能重名

3.作用范围，在离当前变量最近的大括号以内
4.生命周期：局部变量是随着方法的入栈(压栈)而生效，随着方法的出栈(弹栈)而死亡

5.存储位置：基本数据类型存储在栈(stack)中，引用数据类型存储在堆(heap)中

public class Test323 {
	public static void main(String[] args) {
		int a = 10;
		System.out.println(a);
		if(a > 5) {
			// double a = 20;
			System.out.println(a);
			int b = 20;
		}else {
			int b = 20;
		}
		// String a ; 之前定义了a  不能定义重名的
	}
}

4.2.4 默认值

byte、short、int、long 默认值是 0;
float、double 默认值是 0.0
boolean 默认是 false；
char默认是 ’ ’
引用类型 默认都是null

注意：空 != null : "null"是字符串的内容；’ '就是什么也没有,空格都没有。

public class Demo042 {

    /** 属性：就是变量*/
    // 1. 类变量：由`static` 关键字限定
    static double salary = 1_2000;

    // 2. 实例变量：从属于对象；如果不初始化，就输出这个类型的默认值
    String str = "China";
    String name;
    int age;
    char ch;
    
    // main方法
    public static void main(String[] args) {
        /* 3. 局部变量
         int a,b,c;
         */
        int a=1,b=2,c=3;

        // 引用实例变量
        Demo04 demo04 = new Demo04();
        System.out.println(demo04.age);// 输出：0
        System.out.println(demo04.str);// 输出：China
        System.out.println(demo04.name);// 输出：null
        System.out.println(demo04.ch);//
        //动态变量中的类变量，输出：12000.0
        System.out.println(salary);
    }
}

4.3 常量（Constant）

常量：初始化(initalize) 后不能再改变其值，是固定值！
常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

常量声明格式：
final 常量名 = 值;
final double PI = 3.14;

注意：常量名一般使用大写字符，单词中间用下划线隔开。

public class Demo043 {
    /**
    常量：由`static final` 关键字限定，可以没有static，但一定要有final。
    注意：修饰符static 和final不区分先后
     */
    static final double PI = 3.1415926;
    final static String CHINA_CHINESE_NAME= "中华人民共和国";
    
    public static void main(String[] args) {
		// 常量PI = 3.1415926
        System.out.println(PI);
        // 常量ChinaChineseName = 中国
        System.out.println(CHINA_CHINESE_NAME);
	}
}

4.4 作用域

1.变量的有效范围以大括号为标准，在定义的大括号范围内有效，出了大括号就不是同一个变量了；
2.对于同一个作用域的变量名，即便是变量的类型不同，变量名也不能相同；
3.不同作用域的变量名可以相同（不建议），运行时采用就近原则。

5 运算符

5.1 算术运算符、赋值运算符

算术运算符：+、-、*、/、%、++、–；
赋值运算符：=;

5.1.1 算术运算符1：+、-、*、/、%(取余)

package com.b.operator;

public class demo01 {
    public static void main(String[] args) {
        byte a = 45;
        short b = 23;

        System.out.println(a-b);//Int，输出：22
        System.out.println(a*b);//int，输出：1035
        //强制转换成Double 1.9565217391304348
        System.out.println(a/(double)b);
        //取余int 45/23 = 1....22
        System.out.println(a%b);// 输出：22
    }
}

5.1.2 算术运算符2：++、–

++、-- 在前：先运算再赋值
++、--在后：先赋值再运算

public class demo01 {
    public static void main(String[] args) {
        byte a = 45;
        int e = a;
        System.out.println("e = "+e);//e = 45
        int f = e++;
        // 由结果可知：先赋值再加减
        System.out.println("e++之后,f= e++ = "+f);// 输出：45
        System.out.println("e++之后，++e之前 e = "+e);// 输出：46

        int g = ++e;
        // 由结果可知：先加减后赋值
        System.out.println("++e之后,g= ++e = "+g);// 输出：47
        System.out.println("++e之后,e = "+e);// 输出：47
        System.out.println("-------======");
    }
}

5.1.3 算术运算符3：数据类型不同的数运算

类型不同的数运算时，自动向上转型

public class demo01 {
    public static void main(String[] args) {
        byte a = 45;
        short b = 23;
        int c = 451;
        long d = 154153153L;
        System.out.println(a+b+c+d);// Long,输出：154153672
        System.out.println(a+b+c);// Int,输出：519
        System.out.println(a+b);// Int,输出：68
    }
}

5.2 关系运算符：>、<、、!=、instanceof

关系运算符：>、<、>=、<=、==、!=、instanceof
instanceof：判断是否有父子关系

package com.b.operator;

public class demo01 {
    public static void main(String[] args) {
        byte a = 45;
        short b = 23;

        /**
         * @description 3.关系运算符返回的结果：true、false，
         * 一般和if语句一起使用。
         */
        System.out.println(a>b);// 输出：true
        System.out.println(a<b);// 输出：false
        System.out.println(a>=b);// 输出：true
        System.out.println(a<=b);// 输出：false
        System.out.println(a==b);// 输出：false
        System.out.println(a!=b);// 输出：true
    }
}

Java08面向对象02—— 4.3.3 instanceof判断对象类型

5.3 逻辑运算符：&&`与、`||`或、`!`非

逻辑运算符：&&与、||或、!非；
短路运算：前面一个不满足条件直接跳出，不再判断后面的条件是否满足

package com.b.operator;

/**
 * @description 逻辑运算符——做判断
 * &&与（and）、||或（or）、！非（取反）
 */
public class demo02Logic {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        //逻辑与运算，两个变量都是真，结果为真；
        System.out.println("b && a："+ (b&&a));
        //逻辑或运算，两个变量有一个是真，结果为真；
        System.out.println("b || a："+ (b||a));
        //逻辑非运算，如果为真，结果为假；如果为假，结果为真。
        System.out.println("! (b&&a)："+ !(b&&a));
        System.out.println("========--------");

        /**
         * @description 短路运算：如果运算符前面的条件都不满足，就不会计算运算符后面的运算
         */
        int num = 6;
        boolean c = (num<5)&&(num++<5);
        System.out.println(c);// 输出：false
        // 6:num没有变，说明没有运行(num++<5)
        System.out.println(num);// 输出：6

        boolean d = (num<9)&&(num++<5);
        System.out.println(c);// 输出：false
        // 7:num自增了，说明已经运行(num++<5)
        System.out.println(num);// 输出：7
    }
}

5.4 位运算符：&、<<、>>>

位运算符：&(与运算符)、|(或运算符)、~(非运算符)、^(异或运算符)、<<(左移运算符)、>>(右移运算符) 和 >>>(无符号右移运算符)。

位运算符:与二进制有关
异或：相同为0，不同为1。

5.4.1 位运算符：`&`、`|`、`~`、`^`(异或)

package com.b.operator;
public class Demo03BitArithmetic {
    public static void main(String[] args) {
        int a = 108;
        int b = 86;
        /*   A = 0110 1100 =108
             B = 0101 0110 =86
        --- --- --- --- --- ---
        与 :A&B = 0100 0100 =68
        或 :A|B = 0111 1110 =126
        异或:A^B = 0011 1010 =58
        取反: ~B = 1010 1001 =-41 */
        System.out.println("a&b = "+(a&b));// 输出：a&b = 68
        System.out.println("a|b = "+(a|b));// 输出：a|b = 126
        System.out.println("a^b = "+(a^b));// 输出：a^b = 58
        System.out.println("~b = "+(~b));// 输出：~b = -87
    }
}

5.4.2 位运算符2：`<<`、`>>`和 `>>>`

int c = 5; // 二进制表示为 0101
int result1 = c << 2; // 二进制结果为 010100，即20
System.out.println(result1); // 输出：20

int d = -10; // 二进制表示为 11111111111111111111111111110110
int result2 = a >> 2; // 二进制结果为 11111111111111111111111111111101，即-3
System.out.println(result2); // 输出：-3

// 二进制表示为 11111111111111111111111111110110
int e = -10; 
// 二进制结果为 00111111111111111111111111111101，即1073741821
int result = a >>> 2; 
System.out.println(result); // 输出：1073741821

5.4.3 位运算符3：工具类

/** 补充：
* @description 幂运算、取绝对值等 运算，可以使用一些工具类
* 如：2^3 = 2*2*2 = 8;3^2 = 3*3 = 9 */
double pow1 = Math.pow(2,3);
double pow2 = Math.pow(3,2);
System.out.println(pow1);// 输出：8.0
System.out.println(pow2);// 输出：9.0
System.out.println(Math.pow(2, 3));// 输出：8.0

5.5 条件(三元)运算符

示例：a > b ? a : b ;//取a和b的最大值
条件成立输出为 a,否则为 b

package com.b.operator;
/**
 * @description 三元（条件）运算符
 */
public class Demo04Ternary {
    public static void main(String[] args) {
        /* x ? a : b ;
        若 x==true,则结果为a，否则为b。 */
        int score = 50;
        String type = score < 60 ? "不及格" : "及格";
        System.out.println(type);
    }
}

5.6 扩展赋值运算符

扩展赋值运算符：+=、-=、*=、/=

package com.b.operator;

/** Assignment 赋值
 * @description  7. 扩展赋值运算符：+=、-=、*=、/=；
 */
public class Demo05Assignment {
    public static void main(String[] args) {
        int a = 2;
        int b = 6;
        a+=b;//a=a+b;
        System.out.println("a="+a+";b="+b);// 输出：a=8;b=6
        b-=a;//b=b-a;
        System.out.println("a="+a+";b="+b);// 输出：a=8;b=-2

        /** 补充
         * @description 字符串连接符，位置问题
         */
         
        /*字符串在最前面时,后面默认是字符串的拼接，
        不再进行运算。输出结果：A+B ? 8-2 */
        System.out.println("A+B ? "+a+b);
        
        /*字符串在最后面时：默认是前面先运算，后面再拼接。
        输出结果：6 = A+B*/
        System.out.println(a+b+" = A+B");
    }
}

6 包机制、JavaDoc

6.1 包机制

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

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

一般采用公司域名倒置的方法作为包名，如：com.baidu.www；
**导包：**为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用import完成此功能

impoort package1[.package2[.package3...]].(classname|*);

6.2 JavaDoc

JavaDoc命令是用来生成自己API帮助文档的。
参数信息

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

6.3 生成帮助文档步骤

6.3.1 方法一：代码生成

步骤一：写代码，如下

package com.b.operator;
/**
 * @author bruce
 * @version 1.0
 * @since jdk 1.6
 * @description 包机制、JavaDoc
 */
public class Demo06PackageDoc {
    //属性
    String name ;

    /**
     * @description 测试方法
     * @param name
     * @return name
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }

    /**
     * @description main 方法
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        Demo06PackageDoc doc = new Demo06PackageDoc();
        System.out.println(doc.test("Tom"));
    }
}

步骤二：打开Demo06PackageDoc.java文件所在位置，导航栏输入cmd，

步骤三：输入下面代码，然后回车

javadoc -encoding UTF-8 -charset UTF-8 Demo06PackageDoc.java

步骤四：返回文件所在目录，双击index.html文件，就可查看文档。

6.3.2 使用 IDEA生成JavaDoc

步骤一：Toos–>Generate JavaDoc
生成JavaDoc
步骤二：Generate JavaDoc页面设置

Generate JavaDoc界面翻译：

Generate JavaDoc Scope生成文档范围：
1）Whole project:整个项目都生成文档
2）Custom scope 自定义范围。如下：
（1）project files 项目文件，
（2）project production files 项目产品文件，
（3）project test files 项目的测试文件，
（4）Scratches and Console 临时文件和控制台
（5）Open files打开的文件
（6）Moudule ‘’ 单个模块
（7）Current file当前文件
include JDK and … 包含jdk和其他的第三方jar
link to JDK documentation…链接到JDK api
output directy 生成的文档存放的位置
1）private、package、protected、public 生成文档的级别（类和方法）
2）中间的Generate…是选择生成的文档包含的内容，层级树、导航、索引…
3）最右边是生成的文档包含的内容信息，作者版本等信息
Locale 语言类型：zh-CN
Other command line arguments 其他参数
Maximum heep… 最大堆栈