003-Java基础

Java基础

• 1.Java注释
• 2.Java关键字
• 3.Java基本数据类型
• 4. Java标识符
• 5. Java常量变量
• 6. Java运算符
• 7. Java包装类

源码项目地址: https://gitee.com/jack0240/JavaSE.git
/ src / chapter003 包下面

1.Java注释

/**
 *  这个是文档注释, 对类/方法/常量等的说明
 *  JavaSE 第三章
 */
public class Chapter003 {
    /**
     * 程序执行入口
     */
    public static void main(String[] args) {
        // 单行注释 对语句/变量等进行说明, 一般在语句上方
        System.out.println("这是单行注释:// 前面有个空格哟");
        /*
        这是多行注释 使用比较少
         */
        System.out.println("这是单行注释:/*注释内容在里面*/");

        System.out.println("这是文档注释:/**注释内容在里面*/");
    }
}

2.Java关键字

引用菜鸟教程https://www.runoob.com/java/java-basic-syntax.html
这里大概有个印象, 后面代码会有讲解

类别	关键字	说明
访问控制	private	私有的
	protected	受保护的
	public	公共的
	default	默认
类、方法和变量修饰符	abstract	声明抽象
	class	类
	extends	扩充,继承
	final	最终值,不可改变的 常量定义
	implements	实现（接口）
	interface	接口
	native	本地，原生方法（非 Java 实现）
	new	创建对象
	static	静态
	strictfp	严格,精准
	synchronized	线程,同步
	transient	短暂
	volatile	易失
程序控制语句	break	跳出当前循环
	case	定义一个值以供 switch 选择
	continue	继续下一次循环
	default	默认
	do	运行
	else	否则
	for	循环
	if	如果
	instanceof	类型识别
	return	返回
	switch	根据值选择执行
	while	循环
错误处理	assert	断言表达式是否为真
	catch	捕捉异常
	finally	有没有异常都执行
	throw	抛出一个异常对象
	throws	声明一个异常可能被抛出
	try	捕获异常
包相关	import	引入
	package	打包
八大基本类型	boolean	布尔型
	byte	字节型
	char	字符型
	short	短整型
	int	整型
	long	长整型
	float	单精度浮点
	double	双精度浮点
变量引用	super	父类,超类
	this	本类
	void	无返回值
保留关键字	goto	是关键字，但不能使用
	const	是关键字，但不能使用
	null	空

3.Java基本数据类型

参考菜鸟教程:https://www.runoob.com/java/java-basic-datatypes.html

public class Point02 {
    /**
     * 程序执行入口
     */
    public static void main(String[] args) {
        dateType();
    }

    // 类变量不需要初始化值, 在加载类时会填充默认值
    boolean defaltBoolean;
    /**
     * Java里面的变量需要申请内存进行存储的, 和C/C++一样
     * 每个类型的变量所需的内存不一样, 所有导致存储的大小和能力不同
     * Java 分为两大数据类型(这里我们先讨论基本数据类型)
     *       1.基本数据类型
     *       2.引用数据类型
     */
    public static void dateType(){
        /**
         *  byte
         *  8位二进制
         *  最小值是 -128（-2^7）
         *  最大值是 127（2^7-1）
         *  默认值是 0
         */
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);
        System.out.println("包装类：java.lang.Byte");
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);
        System.out.println();

        /**
         * short
         * 16 位二进制
         * 最小值是 -32768（-2^15）
         * 最大值是 32767（2^15 - 1）
         * 默认值是 0
         */
        System.out.println("基本类型：short 二进制位数：" + Short.SIZE);
        System.out.println("包装类：java.lang.Short");
        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);
        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);
        System.out.println();

        /**
         * int
         * 32 位二进制
         * 最小值是 -2,147,483,648（-2^31）
         * 最大值是 2,147,483,647（2^31 - 1）
         * 默认值是 0
         */
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);
        System.out.println("包装类：java.lang.Integer");
        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);
        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);
        System.out.println();

        /**
         * long
         * 64 位二进制
         * 最小值是 -9,223,372,036,854,775,808（-2^63）
         * 最大值是 9,223,372,036,854,775,807（2^63 -1）
         * 默认值是 0L
         */
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);
        System.out.println("包装类：java.lang.Long");
        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);
        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);
        System.out.println();

        /**
         * float
         * 32 位二进制
         * 默认值是 0.0f
         */
        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);
        System.out.println("包装类：java.lang.Float");
        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);
        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);
        System.out.println();

        /**
         * double
         * 64 位二进制
         * 默认值是 0.0
         */
        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);
        System.out.println("包装类：java.lang.Double");
        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);
        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);
        System.out.println();

        /**
         * boolean
         * 1 位二进制
         * 默认值是 false
         */
        // 方法里面的变量必须初始化值分配空间, 不然编译器无法通过
        boolean defaltBoolean = false;
        System.out.println("基本类型：boolean 默认值 : " + defaltBoolean);

        /**
         * char
         * 16 位 Unicode 字符(可以是中文)
         * Java采用的就是Unicode编码 也就是说变量名可以是中文 但是没人这么做
         * 最小值是 \u0000（即为0）
         * 最大值是 \uffff（即为65,535）
         */
        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);
        System.out.println("包装类：java.lang.Character");
        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
        System.out.println("最小值：Character.MIN_VALUE=" + (int) Character.MIN_VALUE);
        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
        System.out.println("最大值：Character.MAX_VALUE=" + (int) Character.MAX_VALUE);
    }

}

3.1 Java数据类型之间的转换

public class Point03 {
    /**
     * 程序执行入口
     */
    public static void main(String[] args) {
        /**
         * 类型转换分为 自动类型转换 和 强制类型转换
         * 转换从低级到高级:
         * byte,short,char—> int —> long—> float —> double
         */
        byte byteVar = 1;
        // 自动转换, 小容器倒进大容器, 值还是不变的.
        int intVar = byteVar;
        // byte-->int====1
        System.out.println("byte-->int====" + intVar);

        // 强制转换, 大容器倒进小容器, 会导致精度丢失.
        float floatVar = 666.666f;
        intVar = 666;
        byteVar = (byte) intVar;
        intVar = (int) floatVar;
        // int-->byte====-102
        System.out.println("int-->byte====" + byteVar);
        // float-->int====666
        System.out.println("float-->int====" + intVar);
    }
}

4. Java标识符

Java中取类名, 变量名, 方法名等时需要注意的规则,名字不是乱取的。

• 开头 : 所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开头
• 结尾 : 首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合结尾
• 关键字不能用作标识符
• 标识符是大小写敏感的
• 标识符可以是中文, 但没人这么干

/***********标识符举例***********/
        int 你好 = 1;
        double _i_ = 10;
        float aaaaaaaaaaa = 88f;
        char $$$$hhhhhh$$$ = 99;
        boolean hh6666 = false;

5. Java常量变量

Java 变量/常量

• 局部变量/常量
• 类变量/常量（静态）
• 成员变量/常量（非静态）

带final关键字的就是常量, 一般用大写字母 下划线分隔

public class Point04 {
    /**
     *  成员变量（非静态变量）
     */
    int memberVar;
    /**
     * 类变量（静态变量）
     */
    static int memberStaticVar;
    /**
     * 声明成员常量
     * 必须要赋初值
     */
    final int MEMBER_VAR = 1;
    /**
     * 静态常量
     * 必须要赋初值
     */
    public static final double MEMBER_STATIC = 0;

    public static void main(String[] args) {
        /***********常量变量***********/
        // 局部变量, 使用时需要初始化
        int localVar = 0;
        // 声明局部常量
        final double LOCAL_VAR = 0;

        // 成员变量必须要new出一个对象来使用
        Point04 p = new Point04();

        System.out.println("memberVar===" + p.memberVar);
        System.out.println("memberStaticVar===" + memberStaticVar);
        System.out.println("localVar===" + localVar);

        System.out.println("MEMBER_VAR===" + p.MEMBER_VAR);
        System.out.println("MEMBER_STATIC===" + MEMBER_STATIC);
        System.out.println("LOCAL_VAR===" + LOCAL_VAR);
    }
}

6. Java运算符

参考博客https://blog.csdn.net/shuaigexiaobo/article/details/88535745

初始化 a = 10, b = 20;

6.1 算数运算

操作符	描述	例子
+	加法	a+ b 等于 30
-	减法	a– b 等于 -10
*	乘法	a* b等于200
/	除法	b / a等于2
％	取余 - 左操作数除以右操作数的余数	b%a等于0
++	自增: 操作数的值增加1	a++ 或 ++a 等于 11
–	自减: 操作数的值减少1	b-- 或 --b 等于 19

6.2 关系运算

操作符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A == B）为假。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A> B）为假。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A <B）为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A> = B）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A <= B）为真。

6.3 逻辑运算

操作符	描述	例子
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（true && false）为假。
||	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（true || false）为真。
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	！（false && true）为真。

6.4 位运算

操作符	描述	例子
＆	按位与, 如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
|	按位或, 如果相对应位都是0，则结果为0，否则为1	（A
^	异或, 如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

public class Point05 {

    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        // 算数运算
        System.out.println("a + b = " + (a + b));
        System.out.println("a - b = " + (a - b));
        System.out.println("a * b = " + (a * b));
        System.out.println("a / b = " + (a / b));
        System.out.println("a % b = " + (a % b));
        System.out.println("a++ = " + a++ + ", ++a = "+ ++a);
        System.out.println("a-- = " + a-- + ", --a = "+ --a);

        // 关系运算
        System.out.println("a == b  is  " + (a == b));
        System.out.println("a != b  is  " + (a != b));
        System.out.println("a > b  is  " + (a > b));
        System.out.println("a < b  is  " + (a < b));
        System.out.println("a >= b  is  " + (a >= b));
        System.out.println("a <= b  is  " + (a <= b));

        // 逻辑运算
        boolean flagA = true;
        boolean flagB = false;

        System.out.println("true && false  is  " + (flagA && flagB));
        System.out.println("true || false  is  " + (flagA || flagB));
        System.out.println("!true  is  " + (!flagA));

        // 位运算
        System.out.println("a 的二进制: " + Integer.toBinaryString(a));
        System.out.println("b 的二进制: " + Integer.toBinaryString(b));
        System.out.println("a & b  =  " + (a & b));
        System.out.println("a | b  =  " + (a | b));
        System.out.println("a ^ b  =  " + (a ^ b));
        System.out.println("~a  =  " + (~a));
        System.out.println("a << 2  =  " + (a <<2));
        System.out.println("a >> 2  =  " + (a >>2));
        System.out.println("a >>> 2 =  " + (a >>>2));
    }
}

7. Java包装类

参考链接: https://www.cnblogs.com/lyq-biu/p/10778109.html

/**
     * 包装类的使用介绍
     * 参考链接: https://www.cnblogs.com/lyq-biu/p/10778109.html
     */
    public static void packaging(){
        //1.自动装箱
        int t1=1;
        Integer t2=t1;
        //2.手动装箱
        Integer t3=new Integer(t1);
        System.out.println("int类型t1="+t1);
        System.out.println("自动装箱，Integer类型对象t2="+t2);
        System.out.println("手动装箱，Integer类型t3="+t3);

        //1.自动拆箱
        int t4=t2;
        //2.手动拆箱
        //通过intValue()方法返回int值，还可以利用其他方法装换为其他类型
        int t5=t2.intValue();
        System.out.println("自动拆箱,int型t4="+t4);
        System.out.println("手动拆箱,int型t5="+t5);

        //基本数据类型转换为字符串
        String str=Integer.toString(t1);
        System.out.println("int转换为String："+str);
        //字符串转换为基本数据类型
        //通过paerInt方法
        int it=Integer.parseInt(str);
        //通过valeOf,先把字符串转换为包装类然后通过自动拆箱
        int it1=Integer.valueOf(str);



        Integer one=new Integer(100);
        Integer two=new Integer(100);
        //one和对two是两个不同的对象，==在比较对象时比较的是内存地址，两个是不同的空间，放的值相同
        System.out.println("one==two:"+(one==two));
        Integer three=100;//自动装箱
        /* Integer three=Integer.valueOf(100);
         * 这时缓存区没有，就会构造一个
         */
        System.out.println("three==100:"+(three==100));//自动拆箱
        Integer four=100;
        /*实际执行的是    Integer four=Integer.valueOf(100); 这时缓存区有，就会直接取
         * Java为了提高拆装箱效率，在执行过程中提供了一个缓存区（对象池）【类似于常量数组】，
         * 如果传入的参数是，-128<参数<127会直接去缓存查找数据，如果有久直接产生，如果没有就隐式调用new方法产生
         */
        System.out.println("three==four:"+(three==four));
        Integer five=200;
        System.out.println("five==200:"+(five==200));
        Integer six=200;
        //注：这里为200，超出了缓存区范围，所以都需要构建
        System.out.println("five==six:"+(five==six));
        /*
         * 输出：
         *     one==two:false
            three==100:true
            three==four:true
            five==200:true
            five==six:false
         */
    }

本文地址：https://blog.csdn.net/WeiHao0240/article/details/109106474