标签：Java 变量 int 基础 System 语法类型 println out

注释

单行注释

//单行注释
//输入一个Hello World!

多行注释：可以注释一段文字 /* 注释 */

//多行注释：可以注释一段文字 /*  注释  */
/*
多行注释
多行注释
多行注释
*/

文档注释：JavaDoc

/**
* @Description HelloWorld
* @Author 爱吃麻辣烫的妹纸
*/

⭐️注意：

书写注释是一个非常好的习惯；
平时写代码一定要注意规范。

标识符

关键字

数据类型：boolean, byte, char, double, float, int, long, short；
流程控制：break, case, continue, default, do, else, for, if, return, switch, while；
修饰符：abstract, final, native, private, protected, public, static, synchronized, transient, volatile；
类和接口：class, extends, implements, interface, new；
异常处理：catch, finally, throw, throws, try；
包相关：import, package；
其他：this, super, instanceof, void, assert (自Java 1.4 起), enum (自Java 5 起), non-sealed (自Java 15 起), sealed (自Java 15 起)。

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

⭐️注意：

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

数据类型

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

强类型安全，效率高。
弱类型语言：它的数据类型是可以被忽略的语言，与强类型定义相反。（javaScript）

弱类型更灵活，但是效率低，而且出错概率高。

Java的数据类型

基本类型（primitive type）：基本类型共有八种，其中包括六种数值型与两个非数值型。

数据类型	大小（单位：bit/位）	所属包装类	最小范围	最大范围
byte	8	java.lang.Byte	-128	+127
short	16	java.langShort	-32768	+32767
int	32	java.lang.Integer	-2^31	+2^31-1
long	64	java.lang.Long	-2^63	+2^63-1
float	32	java.lang.Float	-3.4 * 10^38	+3.4 * 10^38
double	64	java.lang.Double	-1.7 * 10^308	+1.7 * 10^308
char	16	java.lang.Character	0	65535
boolean	1	java.lang.Boolean	只有"true"和"false"两个取值

代码：

// 八大基本数据类型

// 整型
byte num1 = 10; //最常用
short num2 = 20;
int num3 = 30;
long num4 = 30L; //Long类型要在数字后边加个L

// 浮点型：小数
float num5 = 50.1F; //float类型要在数字后边加个F
double num6 = 50.1;

// 字符型
char name = 'A';
// 字符串,String是类不是关键字
String name1 = "ABC";

// 布尔型：是非
boolean flag = true;
boolean flag1 = false;

引用类型（reference type）：除了基本数据类型之外的数据类型。

类，接口，数组等。

Java基本数据类型扩展

特殊需要加后缀的数据类型

Long num1 = 30L; //long类型要在数字后面加个L
float num2 = 50.1F; //float类型要在数字后面加个F

整数：二进制（0b），八进制（0），十进制，十六进制（0x）。

int i1 = 0b10; //二进制 2
int i2 = 010; //八进制 8
int i3 = 10; //十进制 10
int i4 = 0x10; //十六进制 31
//十六进制数码：0~9 A~F

浮点数：最好完全避免使用浮点数进行比较。float和double类型数据计算时会有舍入误差，得到的计算结果是大约数，接近但不等于。所以需要精确数值的数据，如银行业务数据等，不可以使用float和double类型，需要使用BigDecimal（数学工具类）来表示。
```
float f1 = 0.1f;
double f2 = 0.1;
System.out.println(f1==f2);//结果为false

float f3 = 123472894782374287f;
float f4 = f3 +1;
System.out.println(f3==f4);//结果为true
```

字符：所有字符的本质还是数字，Unicode编码方式，数字与字符一一对应（0~65535）。

char c1 = 'a';
char c2 = '中';
System.out.println((int)(c1));//结果为97
System.out.println((int)(c2));//结果为20013

char c3 = '\u0061';
System.out.println(c3);//结果为a

转义字符：所有的ASCII码都可以用"\"加数字(一般是8进制数字)来表示。而C中定义了一些字母前加"\"来表示常见的那些不能显示的ASCII字符，如\0,\t,\n等，就称为转义字符，因为后面的字符，都不是它本来的ASCII字符意思了。

转义字符	意义	ASCII码值（十进制）
\a	响铃(BEL)	007
\b	退格(BS) ，将当前位置移到前一列	008
\f	换页(FF)，将当前位置移到下页开头	012
\n	换行 (LF)，将当前位置移到下一行开头	010
\r	回车 (CR) ，将当前位置移到本行开头	013
\t	水平制表 (HT) （跳到下一个TAB位置）	009
\v	垂直制表(VT)	011
\\	代表一个反斜线字符’\'	092
\’	代表一个单引号（撇号）字符	039
\’’	代表一个双引号字符	034
\0	空字符(NULL)	000
\ddd	1到3位八进制数所代表的任意字符	三位八进制
\xhh	1到2位十六进制所代表的任意字符	二位十六进制代码：

代码：

//转义字符
//\t 制表符
//\n 换行
System.out.println("Hello\tWorld!"); //输出表格
System.out.println("Hello\nWorld!"); //输出换行

字符串比较：同样用String类创建相同的字符的对象是不相等的。

String sc = "hello,world";
String sd = "hello,world";
System.out.println(sc==sd);//相同 输出true
//对象 从内存分析
String sa = new String("hello,world");
String sb = new String("hello,world");
System.out.println(sa==sb); //这里的比较的是地址 所以不相同，输出false

布尔值：常用于条件判断。

boolean flag = true;
if(flag==true){}  //新手
if(flag){}        //老手 
//上两行代码实现的功能一样
//Less is More! 代码要精简易读

Java的数据类型转换

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

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

数据类型容量：

低--------------------------------------------------------------高

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

强制类型转换：数据类型由高到低转换，需要强制转换。

//高->低 强制转换 格式：(类型)变量名 
int a = 128;
byte b = (byte)a; //byte(-128~127) 内存溢出
System.out.println(a); //输出128
System.out.println(b); //输出-128

自动类型转换：数据类型由低到高转换，不需要强制转换。

//自动转换 低->高
int a = 128;
double c = a;
System.out.println(c); //输出128.0

⭐️注意：

不能对布尔值进行转换。
不能把对象类型转换为不相干的类型。
在把高容量数据类型转换到低容量数据类型时，需要强制转换，反之，则可以自动转换。
转换的时候可能存在内存溢出，或者精度问题。

代码：

//操作比较大的数的时候，注意溢出问题
//JDK7新特性，数字之间可以用下划线分割
int money = 10_0000_0000;
System.out.println(money); //输出1000000000
int years = 20;
int total = money * years; 
System.out.println(total);//输入结果为-1474836480，计算的时候溢出了

long total2 = money * years;
System.out.println(total2);
//两个int类型数据计算完之后的结果依然是int类型，所以数据在转换之前就出问题了
//输出结果还是-1474836480

//正确转换方法
long total3 = money * (long)years;
System.out.println(total3); //输出20000000000

变量、常量、作用域

变量

变量是什么？就是可以变化的量！

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

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

type varName [=value] [{,varName[=value]}];
//数据类型变量名=值;
//可以使用逗号隔开来声明多个同类型变量,但是这样做会影响程序的可读性，最好还是一行声明一个变量。

⭐️注意：

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

变量作用域

类变量：从属于类。
实例变量：从属于对象；如果实例变量不自行初始化，那么这个变量的值即为变量类型的默认值。

数据类型默认值

整型 0

浮点型 0.0

布尔型 false

字符型 ‘\u0000’

其他类型 null
局部变量：必须声明和初始化。

数据类型	默认值
整型	0
浮点型	0.0
布尔型	false
字符型	‘\u0000’
其他类型	null

代码：

public class Demo {

    //类变量 static
    static double salary = 2500;

    //属性：变量

    //实例变量：从属于对象；
    //如果实例变量不自行初始化，那么这个变量的值即为变量类型的默认值；
    //所有数值类型默认值都是0或者0.0
    //字符型：默认值是\u0000
    //布尔型：默认值false
    //除了基本类型其余的默认值都是null
    String name;
    int age;

    //main方法
    public static void main(String[] args) {

        //局部变量：必须声明和初始化
        int i = 10;
        System.out.println(i); //输出10

        //引用实例变量
        //变量类型 变量名 = new Demo();
        Demo demo = new Demo();
        System.out.println(demo.name); //输出null
        System.out.println(demo.age); //输出0

        //引用类变量
        System.out.println(salary); //输出2500.0
    }

    //其他方法
    public void add(){

    }
}

常量

常量(Constant) : 初始化(initialize)后不能再改变的值! 不会变动的值。

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

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

public class Demo {
    
    //常量定义：final 常量名=值;
    //常量名一般使用大写字符
    //修饰符（数据类型之前），不存在先后顺序
    static final double PI = 3.14159265358979323846;

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

变量的命名规范

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

运算符

运算符类型

算术运算符：加（+），减（-），乘（*），除（/），取模（%），自增（++），自减（--）
赋值运算符：=
关系运算符：大于（>），小于（<），大于等于（>=），小于等于（<=），等于（==），不等于（!=），instanceof（对象是否为类的实例）
逻辑运算符：逻辑与（&&），逻辑或（||），逻辑非（!）
位运算符：按位取反（~），按位与（&），按位或（|），异或（^），右移（>>），左移（<<），无符号右移（>>>）
条件运算符：（? :）
扩展的赋值运算符：+=，-=，*=，/=

代码：

public class Demo {
    public static void main(String[] args) {
        /*
        二元运算符
        */
        //ctrl+d:复制当前行到下一行
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;
        System.out.println(a+b); //输出30
        System.out.println(a-b); //输出-10
        System.out.println(a*b); //输出200
        System.out.println(a/b); //输出0
        //类型为整数的变量运算结果为小数时，需要对运算的变量进行类型转换
        System.out.println(a/(double)b); //输出0.5
        
        //字符串连接符 +
        //字符串连接符连接的两个操作数只要有一个是String类型，就会把其他操作数都转换成String再进行连接
        System.out.println(""+a+b); //输出1020
        System.out.println(a+b+""); //输出30 a和b先计算，计算的结果再与""相加
        
        long a1 = 123123123123L;
        int b1 = 123;
        short c1 = 1;
        byte d1 = 8;

        //如果运算中有一个操作数为Long类型，那计算的结果就是Long类型。
        //如果运算中有一个操作数为Double类型，那计算的结果就是Double类型。
        System.out.println(a1+b1+c1+d1); //Long
        System.out.println(b1+c1+d1); //Int
        System.out.println(c1+d1); //Int
        
        //关系运算符返回的结果：正确/错误 布尔值
        int a2 = 10;
        int b2 = 20;
        int c2 = 21;

        System.out.println(a2<b2); //输出true
        System.out.println(a2>b2); //输出false
        System.out.println(a2==b2); //输出false
        System.out.println(a2!=b2); //输出true

        //取余，模运算
        int a3 = 10;
        int c3 = 21;
        System.out.println(c3%a3); //输出1
        
        //逻辑运算符
        //与（and）或（or）非（取反）
        boolean a4 = true;
        boolean b4 = false;
        //逻辑与运算：两边操作数都为true，结果才为true
        System.out.println("a4 && b4:"+(a4 && b4)); //输出false
        //逻辑或运算：两边操作数有一边为true，结果就为true
        System.out.println("a4 || b4:"+(a4 || b4)); //输出true
        //逻辑非运算：如果是true，则为false；如果是false，则为true。
        System.out.println("!(a4 && b4):"+!(a4 && b4)); //输出true

        //短路运算
        //当逻辑与运算符左边操作数为假时，程序即判定结果为假，不再判断右边的真假。
        //当逻辑或运算符左边操作数为真时，程序即判定结果为真，不再判断右边的真假。
        int c4 = 5;
        boolean d4 = (c4<4)&&(c4++<4);
        System.out.println(d4); //输出false
        System.out.println(c4); //输出5，c没有自增1
        
        /*
         位运算符
         A = 0011 1100
         B = 0000 1101
         -----------------
         A&B = 0000 1100
         A|B = 0011 1101
         A^B = 0011 0001
         ~B = 1111 0010

         二进制
         0000 0000     0
         0000 0001     1
         0000 0010     2
         0000 0011     3
         0000 0100     4
         0000 1000     8
         0001 0000     16
         运算效率极高
         << 左移 左移一位等于乘2
         >> 右移 右移一位等于除2
         */
        System.out.println(2<<3);
        
        /*
        一元运算符
        */
        //自增++ 自减--
        int a5 = 3;
        //a5++等同于a5=a5+1
        //执行完这行代码后，先给b5赋值，a5再自增
        int b5 = a5++;
        //++a5等同于a5=a5+1
        //执行完这行代码后，a5先自增，再给c5赋值
        int c5 = ++a5;

        System.out.println(a5);
        System.out.println(b5);
        System.out.println(c5);

        //自增自减运算符用于循环
        for (int i = 0; i < 5; i++) {

        }
        
        /*
        三元运算符
        */
        // x ? y : z
        //如果x==true，则结果为y，否则结果为z
        int score = 80;
        String type = score < 60? "不及格":"及格"; //if语句
        System.out.println(type); //输出及格

        /*
        幂运算 2^3 2*2*2=8
        */
        //很多运算我们会使用一些工具类来操作，如Math类
        double pow = Math.pow(2,3);
        System.out.println(pow);

    }
}

运算符优先级

⭐️注意：表达式中需要的话优先使用括号来组织，会更清晰。

包机制

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

包语句的语法格式：
```
package pkg1[.pkg2[.pkg ...]];
```

导入包：

import pkg1[.pkg2[.pkg ...]].(classname|*); //*是通配符，表示导入这个包下所有的类

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

例如，www.baidu.com 包名为com.baidu.www
IDEA中控制包展示方式的选项为“Compact Middle Packages”

代码：

package com.mlt.operator; //声明类所在的包，必须写在类的第一行

import java.util.Date; //导入java.util包下的Date类
import java.util.*; //导入java.util包下所有的类

public class Demo {
    public static void main(String[] args) {

    }
}

JavaDoc生成文档

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

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

代码：

package com.mlt.base;

//类注释
/**
 * @author 爱吃麻辣烫的妹纸
 * @version 1.0
 * @since 1.8
 */
public class Doc {

    String name;

    //方法注释
    /**
     * @author 爱吃麻辣烫的妹纸
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
}

通过命令行生成JavaDoc文档

在java类文件所在目录中打开cmd，执行命令：javadoc 参数 java类文件名。

//-encoding是java代码编码，-charset是对生成文档所用的编码，-windowtitle就是对应html的<title>标签
//UTF-8是针对Unicode的一种可变长度字符编码，防止生成的文档出现乱码
javadoc -encoding UTF-8 -charset UTF-8 -windowtitle "doc" Doc.java

通过IDEA生成JavaDoc文档

"Tools"->"Generate JavaDoc"->设置参数->"OK"

传递给javadoc的参数：-encoding UTF-8 -charset UTF-8 -windowtitle "test"

标签：Java,变量,int,基础,System,语法,类型,println,out
From： https://www.cnblogs.com/spicy-hot-pot/p/18342146

3.Java基础语法

注释

标识符

关键字

数据类型

Java的数据类型

Java基本数据类型扩展

Java的数据类型转换

变量、常量、作用域

变量

变量作用域

常量

变量的命名规范

运算符

运算符类型

运算符优先级

包机制

JavaDoc生成文档

相关文章

赞助商

阅读排行