Java自学（二、Java基础语法）

最新推荐文章于 2024-06-15 18:04:35 发布

IPostYellow

最新推荐文章于 2024-06-15 18:04:35 发布

阅读量167

点赞数

分类专栏： Java自学文章标签： java

本文链接：https://blog.csdn.net/Doraemon_Nobita/article/details/115227389

版权

Java自学专栏收录该内容

15 篇文章 1 订阅

订阅专栏

记录自己在狂神说java中的学习情况，文章里有自己学习的理解和扩展，新手难免有理解偏差或者错误，恳请大佬指正。

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

注释

编写代码的时候，使用注释来标记自己的项目中的一些注意点。

注释并不会被执行，是写给开发人员看的。

**书写注释是一个非常好的习惯而且是非常必要的习惯。**不然不出一周你可能就看不懂自己的代码了。

Java注释种类

单行注释

public class HelloWorld {
    public static void main(String[] args) {
        // 单行注释：可以注释一行文字
        // 输出一个Hello，World！
        System.out.println("Hello,World!");
    }标识符
}

多行注释

public class HelloWorld {
    public static void main(String[] args) {
        /*
          多行注释：可以注释多行文字
          输出一个Hello，World！
        */
        System.out.println("Hello,World!");
    }
}

文档注释

public class HelloWorld {
    public static void main(String[] args) {
        /**
         * @Description HelloWorld
         * @Author 黄宝奇
         */
        System.out.println("Hello,World!");
    }
}

标识符和关键字

Java有一些约定俗成的关键字，这些关键字有它特殊的用途。Java里的常见关键字有：

abstract	assert	boolen	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throw	throws
transient	try	void	volatile	while

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

// HelloWorld就是类名
public class HelloWorld {
    // main是方法名
    public static void main(String[] args) {
        // hello是变量名
        String hello="Hello";
        System.out.println("Hello,World!");
    }
}

注意：

所有的标识符都应该以字母（A-Z或者a-z），美元符（$）或者下划线（_）开头
首字符之后可以是字母（A-Z或者a-z），美元符（$）、下划线（_）或者数字的任何字符组合
不能使用关键词作为类名、变量名或者方法名
标识符是大小写敏感的（变量Man和变量man是两个变量）
合法标识符举例：age、$salary、_value、__1_value
非法标识符举例：123abc、-salary、#abc
可以使用中文命名或者拼音，但是十分不建议！！！

2.数据类型

强类型语言：要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用（比如Java和C++）

弱类型语言：变量可以不定义直接使用（比如Python和JavaScript）

Java是一种强类型语言，每个变量都必须声明其类型，对比Python来说，java这种方式更安全，但是一般弱类型语言会有其他的方法去保证变量的类型不会出错。

Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域

type varName [=value] [{,varName[=value]}];
// 数据类型 变量名 [=值];可以使用逗号隔开来声明多个同类型变量。 注意：[内容]表示内容可以出现0次或者1次。

注意事项：

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

Java的数据类型分为两大类：（和python不同的是，因为python是没有数字大小范围限制的，所以python的变量占的字节数不是固定的，会随着内容的改变而改变）

基本类型（primitive type）
- 数值类型
  - 整数类型
    - byte占1个字节范围：-2^7~27-1
    - short占2个字节范围：-2^15~215-1
    - int占4个字节范围：-2^31~231-1
    - long占8个字节范围：-2^63~263-1
  - 浮点类型
    - float占4个字节
    - double占8个字节
  - 字符类型
    - char占2个字节
- boolean类型:占一位只有true和false两个

Java八大基本数据类型

基本类型	大小	最小值	最大值	包装器类型
`boolean`	1/8字节			Boolean
`char`	2字节	Unicode0	Unicode2^16-1	Character
`byte`	1字节	-2^8	2^8-1	Byte
`short`	2字节	-2^15	2^15-1	Short
`int`	4字节	-2^31	2^31-1	Integer
`long`	8字节	-2^63	2^63-1	Long
`float`	4字节			Float
`Double`	8字节			Double

public class HelloWorld {
    public static void main(String[] args) {
        // 八大数据基本类型,如果记不得范围，可以去比如int对应的类Integer里面有对应的最大值和最小值
        // 整数
        int num1=10;
        byte num2 = 20;
        short num3 = 30;
        long num4 = 30L;// long类型在数字后面加个L

        // 小数：浮点数
        float num5 = 50.1F; //
        double num6 = 3.1415265358;

        // 字符
        //char name='AB';会报错
        char name = 'A'; //必须使用单引号
        // 字符串 注意String不是关键字，是一个类
        String name1 = "AVASDAS";

        // 布尔值
        boolean flag = true;
    }
}

引用类型（reference type）
- 类
- 接口
- 数组

整数扩展

二进制0b，八进制0，十六进制0x

public class NumExtend {
    public static void main(String[] args) {
        int i=10;
        int i2=010;
        int i3=0x10;
        int i4=0b10;
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);
    }
}

浮点数扩展

银行业务怎么表示？钱怎么表示？float和double是有问题的。

float 占4个字节，也就是32位，其中符号位占1位，指数位占8位，小数位占23位。

double占8个字节，也就是64位，其中符号位占1位，指数位占11位，小数位占52位。

指数位决定了大小范围。小数位决定了计算精度。

像23位能表示最大的十进制为2^23次方，约等于十进制的7位，严格来说，精度只能保证十进制的6位运算。

53位，则2^53次方，能保证十进制的15位运算。

        // 浮点数扩展
        // 银行业务怎么表示？ BigDecimal 数学工具类
        // float 有限的、离散的、舍入误差、大约、接近但不等于
        float f=0.1f; //0.1
        double d=1.0/10;//0.1
        System.out.println(f==d);//false
        System.out.println(f==0.1); //false,默认0.1是double类型的
        System.out.println(f==(float)0.1);//true
        float d1=23131312312312313f;
        float d2=d1+1;
        System.out.println(d1==d2);//true

字符扩展

所有字符的本质还是数字，是编码的

        char c1 = 'a';
        char c2 = '中';
        char c3 = 97;
        System.out.println(c1);// a
        System.out.println((int) c1);//强制转换 97
        System.out.println(c2);// 中
        System.out.println((int) c2);//强制转换 20013
        System.out.println(c3); //a

3.类型转换

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

强制转换的优先级从低到高和变量类型占用的字节高低是一致的，如下：

低--------------------------------------高
byte,short,char->int->long->float->double

运算中，不同类型的数据线转化为同一类型，然后进行计算

强制类型转换

从高到低需要自己强制类型转换。（类型）变量名高–》低

自动类型转换

从低到高自动转换类型。低–》高

注意：类型转换可能出现的问题

内存溢出（高容量转低容量的时候，低容量没有这么多空间存储）
精度丢失（小数转整数小数就没了）

public class ChangeType {
    public static void main(String[] args) {
        int i=128;
        byte b=(byte)i;//内存溢出了，值完全变了
        System.out.println(i); //128
        System.out.println(b); //-128
        int i1=128;
        double b1=i; //自动转换
        System.out.println(i1);
        System.out.println(b1);
        /*
        * 注意点：
        * 1.不能对布尔值进行转换
        * 2.不能把对象类型转化为不相干的类型
        * 3.在把高容量转换到低容量的时候，强制转换
        * 4.转换的时候可能存在内存溢出或者精度问题
        */
        // 小知识：JDK7以后，数字之间可以用下划线分割，这个下划线不会被输出，只是很符合人看的习惯 比如 int money = 10_0000_0000;
    }
}

内存溢出

public class CacheOver {
    public static void main(String[] args) {
        int money=10_0000_0000;
        int year=20;
        int total=money*year; //-1474836480,计算的时候溢出了
        long totals=money*year; // 依然是-1474836480，因为计算的时候money和year都是int,是先计算再转换成long的
        System.out.println(total);
        System.out.println(totals);
        long total3=money*((long)year); //先把一个数转换成long
        System.out.println(total3); // 2000000000
    }
}

4.变量、常量

变量

变量：变量就是可以变化的量~

Java是一种强类型语言，每个变量都必须声明其类型。

Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

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

注意：

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

public class Vars {
    public static void main(String[] args) {
        //int a,b,c; //可以用逗号隔开定义相同类型的变量
        int a = 1, b = 1, c = 1; //不太建议这样写，程序可读性不强
        String name = "hbq";
        char x = 'X';
        double pi = 3.14;
    }
}

变量作用域

类变量
实例变量
局部变量

public class Variable {
    //属性：变量
    // 类变量：从属于类，可以在类里直接输出
    static double salary = 2500;//

    // 实例变量：从属于对象，要把类实例化后才能使用。除了基本类型，其他默认都是null
    String name; //实例变量如果没有赋值直接输出，默认值是null
    int age; //实例变量如果没有赋值直接输出，默认值是0
    boolean vi; //实例变量布尔值默认是false

    // main方法
    public static void main(String[] args) {
        //局部变量
        int i = 10; //局部变量只在这个方法内有用
        System.out.println(i);

        Variable var = new Variable();//创建一个Variable实例
        System.out.println(var.name);
        System.out.println(var.age);
        System.out.println(var.vi);
        System.out.println(salary);
    }
}

常量

常量：初始化后不能再改变的值

所谓常量可以理解成一种特殊的变量，他的值被设定以后，在程序运行过程中不允许被改变

规范：常量名一般使用大写字母

public class Consts {
    // 使用final定义一个常量，必须初始化
    // 修饰符不区分先后顺序，这条语句等价于 final static double PI=3.14;
    static final double PI = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);
    }
}

变量的命名规范

所有变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线 MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMan
方法名：首字母小写和驼峰原则：run(),runRun()

5.基本运算符

算术运算符：+,-,*,/,%,++,–

public class Operator {
    public static void main(String[] args) {
        // 二元运算符
        // ctrl+D：复制当前行到下一行
        int a = 10;
        int b = 20;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / (double) b);
        long aa = 123456412313123L;
        int ba = 123;
        short c = 10;
        byte d = 8;
        // byte、short、char用运算符运算后自动转化为int类型
        System.out.println(aa + ba + c + d); // long类型
        System.out.println(ba + c + d); //int类型
        System.out.println(c + d); //int类型
        // 一元运算符
        System.out.println(a++); //先执行再自增
        System.out.println(++a); //先自增再执行
    }
}

赋值运算符：=
关系运算符：>,<,>=,<=,==,!=,instanceof

public class Operator {
    public static void main(String[] args) {
        //关系运算符返回结果：正确，错误 是一个布尔值
        int a=10;
        int b=20;
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
    }
}

逻辑运算符：&&,||,!

public class Operator {
    public static void main(String[] args) {
        //短路运算,&&中前面为假了，则不执行后面的了，||中前面为真了，则不执行后面的了
        int c = 5;
        boolean d = (c < 4) && (c++ < 4);
        System.out.println(d);
        System.out.println(c);
    }
}

位运算符：&.|,^,~,>>,<<,>>>

//位运算
/*
 * A= 0011 1100
 * B= 0000 1101
 * A&B 两个都为1才为1，否则为0 结果：0000 1100
 * A|B 两个都为0才为0，否则为1 结果：0011 1101
 * A^B 相同为0，不相同为1 结果：0011 0001
 * ~B 按位取反，1变0，0变1 结果：1111 0010
 * 2*8怎么运算最快
 * 2<<4 (2的4次方)
 * <<左移相当于乘2
 * >>右移相当于整除2
 * >>是带符号右移，正数右移最高位补0，负数右移最高位补1。
 * 4>>1 结果是2 -4>>1 结果是-2
 * >>>是无符号右移。无论是正数还是负数，最高位通通补0（可能出现问题）
 * 对于正数>>和>>>没有区别
 * 对于负数
 * -2>>>1 结果为2147483647 -1>>>1 结果也为2147483647
 * -2的二进制编码为 1000 0000 0000 0000 0000 0000 0000 0010的补码+1
 * 也就是 1111 1111 1111 1111 1111 1111 1111 1110
 * 右移一位变成0111 1111 1111 1111 1111 1111 1111 1111 为2的31次方-1（2^30+2^29+...+2^1+2^0）
 * */

条件运算符号（条件?选项1:选项2）

public class Operator {
    public static void main(String[] args) {
        // 三元运算符
        // x?y:z 如果x==true,则结果为y，否则结果为z
        int score = 80;
        String type = score < 60 ? "不及格" : "及格";
        System.out.println(type);
        score=50;
        type= score < 60 ? "不及格" : "及格";
        System.out.println(type);
    }
}

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

public class Operator {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        a += b; // 相当于a=a+b;
        a -= b; // 相当于a=a-b;
        System.out.println(a); // 10
        // 在+号的运算中。只要出现了String类型，则全部都转化成String类型
        System.out.println("" + a + b);// 1020
        // 但是如果如果String类型在+号后面（+是从左到右运算的），不会影响前面的+号运算
        System.out.println(a + b + "");// 30
        System.out.println(a + b + "" + a + b); // 301020
    }
}

幂运算：Math包里pow(2,3)

运算符优先级

优先级越小越先执行，结合性是指优先级相同的时候，从左开始算还是从右开始算

优先级	运算符	结合性
1	()、[]、{}	左->右
2	!、+、-、~、++、–(一元运算符,这里的+是正数,-是负数)	右->左
3	*、/、%	左->右
4	+、- (二元运算符，正儿八经的加减)	左->右
5	<<、>>、>>>	左->右
6	<、<=、>、>=、`instanceof`	左->右
7	==、!=	左->右
8	&	左->右
9	^	左->右
10	\|	左->右
11	&&	左->右
12	\|\|	左->右
13	?:	右->左
14	=、+=、-=、*=、/=、&=、\|=、^=、~=、<<=、>>=、>>>=	右->左

6.包机制、JavaDoc

包机制（就是文件夹）

为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。

包语句的语法格式为：

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

一般利用公司域名倒置作为包名; com.hbq.blog.www

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

import package1[.package2...].(classname|*);

package com.hbq.base;
import java.util.Date;//导入了这个Date才可以使用Date类
public class PackagesUse {
    Date s;
}

JavaDoc

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

参数信息

@author 作者名

@version 版本号

@since 指明需要最早使用的jdk版本

@param 参数名

@return 返回值情况

@throws 异常抛出情况

package com.hbq.api;
//加在类的上面就是类注释
/**
 * @author hbq
 * @version 1.0
 * @since 1.8
 */
public class myapi {
    String name;
    //加在方法名上面就是方法注释
    /**
     * @author hbq
     * @param name
     * @return name
     * @throws Exception
     */
    public String test(String name) throws Exception {
        return name;
    }
}

在编写好文档注释后，进入到该文件的目录的控制台。键入如下命令：

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

此处的-encoding和-charset用于保证里面的中文字符不会乱码

最后生成一系列的html文件，打开index.html文件，显示如下：

在这里插入图片描述

或者通过idea的Tools栏下的Generate JavaDoc
在这里插入图片描述

注意框框里的编码，不然会报错。

IPostYellow

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java自学（二、Java基础语法）

记录自己在狂神说java中的学习情况，文章里有自己学习的理解和扩展，新手难免有理解偏差或者错误，恳请大佬指正。Java自学（二、Java基础语法）1.注释、标识符、关键字注释Java注释种类标识符和关键字2.数据类型整数扩展浮点数扩展字符扩展3.类型转换强制类型转换自动类型转换注意：类型转换可能出现的问题4.变量、常量变量变量作用域常量变量的命名规范5.基本运算符运算符优先级6.包机制、JavaDoc包机制（就是文件夹）JavaDoc1.注释、标识符、关键字注释编写代码的时候，使用注释来标记自己的项
复制链接

扫一扫