Java基础语法_注释、标识符、关键字_数据类型_什么是字节_类型转换_变量、常量_运算符_包机制_JavaDoc

注释、标识符、关键字

代码量较少时注释还能看懂代码,当代码复杂起来就需要注释来帮助识别代码的作用

注释不会被执行,是专门给人看的

书写注释是一个非常好的习惯,大公司都会要求员工写注释,方便管理

注释有三种:

单行注释:

只能注释一行文本

使用方式:

在代码前加上 // 即可

演示:

public class Hello{
    public static void main(String[] args){
        System.out.println("Hello World!");
      //System.out.println("吃我一拳!");
    }
}

多行注释:

可以注释一段文本

使用方式:

在代码前加上 /* ,在代码后加上* / ,

演示:

public class Hello{
    public static void main(String[] args){
        System.out.println("Hello World!");
      	/*
      	System.out.println("吃我一拳!");
        System.out.println("说话就是找茬!");
        System.out.println("先打一拳!打的时候再把问题问个遍!");
        */
        System.out.println("Hello World!");
    }
}

JavaDoc文档注释:

拥有参数功能

使用方式:

在代码前加上 /** ,在代码后加上 */

演示:

public class Hello{
    public static void main(String[] args){
        System.out.println("Hello World!");
      /*System.out.println("吃我一拳!");
        System.out.println("吃我两拳!");
        System.out.println("吃我三拳!");*/
        System.out.println("Hello World!");
    }
}

标识符

关键字

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

所有的标识符都允许以字母(A-Z或者a-z),美元符号($),或者下划线(_)开始

首字符之后可以是字母(A-Z或者a-z),美元符号($),下划线(_)或数字的任何字符组合

不能使用关键字作为变量名或方法名

标识符是大小写敏感的

合法标识符举例:age,$$$$$Salary_, _value, __1_value

非法标识符举例: 123abc, -salary, #abc

可以使用中文命名,但是一般不建议这样去使用,也不建议使用拼音

  /*
  public表示访问修饰符
  class表示类关键字
  HelloWorld是这个类的名字
  */
public class HelloWorld{
      /*
      static表示静态修饰符
      void表示方法无返回值
      main表示main接口函数
      String[] args是main函数的形式参数
      String[]表示字符串数组
      String是它的类型
      []是数组
      args表示数组名字
      */
    public static void main(String][] args){
          /*
        	System是Java提供的的一个最终类,该类有多种执行方法,此处用到out
        	.是操作符
        	out表示输出
        	println输出到控制台并换行
        	print表示输出到控制台
        	ln是换行符
        	("")引号内是要输出的信息
        	以 ; 号结尾
          */
        System.out.println("Hello World!");
    }
}

修饰符不存在先后顺序

数据类型

强类型语言

要求变量的使用要严格符合规定,所有变量都必须先定义后才能使用

Java和C++都是强类型语言,一旦定义了某个数据类型如果不经过转换他就永远是这个类型

强类型语言很严谨,可以避免很多错误,安全性更高,兼顾了安全,效率也就有所降低

弱类型语言

变量使用不严格要求符合规定

JavaScript就是弱类型语言,JS能使用的很随意是因为编辑器在后端做了更严谨的转换

Java的基本数据类型分为两大类

基本类型(primitive type)

public class Demo{
    public static void main(String[] args){
        //八大基本数据
        
        //整数
        int num1 = 10;//最常用
        byte num2 = 20;//常用于拷贝数据
        short num3 = 30;
        long num4 = 30L;//在数据之后加上大写L或者小写l用以判断数据类型
        
        //小数
        float num5 = 50.1F;//在数据之后加上大写F或者小写f用以判断数据类型
        double num6 = 3.141592653589793238462643;//
        
        //字符
        char name = "猹";
        
        //字符串,String不是关键字,类
        //String name = "野猹琳";
        
        //布尔值:是 非
        boolean flag = true;
        //boolean flag = false;
    }
}

引用类型(reference type)

除了基本数据类型外,其他的都是引用数据类型

类,接口,数组都是引用类型

什么是字节

位(bit) : 是计算机 内部数据 储存的最小单位, 11001100是一个八位二进制数.

字节(byte) : 是计算机中 数据处理 的基本单位,习惯上用大写 B 来表示

1B (byte,字节) = 8bit(位)

字符 : 是指计算机中使用的字母,数字,字和符号

1bit 表示1位

1Byte表示一个字节 1B = 8b.

1024B = 1KB

1024KB = 1M

1024M = 1G

1024G = 1T

类型转换

由于Java是强类型语言,所以要进行一些必要运算时,需要用到类型转换.

浮点数类型的精度一定高于整形

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

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

强制类型转换

转换格式:

变量类型 变量名 = (变量类型)(变量值)

实例:

• 当一个类型向 容量 比他小的类型进行转换时发生的问题:

public static void main(String[] args){
	int i = 128;
	byte b = (byte)i;
	System.out.println("i = " + i);//输出为 128
    System.out.println("b = " + b);//内存溢出,输出为 -128
}

因为byte的最大容量是-128~127之间 , i 的数值为128超出了byte类型的最大容量,128-127＝1,多出的1从-128开始,所以b返回的是-128,实际上如果 i = 129,那么b会等于-127.

• 当一个类型向 精度 比他小的类型进行转换时发生的问题:

System.out.println((int)23.7);//精度丢失,输出为 23
System.out.println((int)-45.89f);//精度丢失,输出为 -45

int是整形,没保存小数点后的数据,强制将浮点数类型转换为整形时会丢失精度

• 转换时的内存溢出问题:

操作较大的数的时候,注意溢出问题

JDK7新特性 数字之间可以用下划线分割

int money = 10_0000_0000;
int years = 20;
int total = money*years;
long total2 = money*years;
long total3 = money * ((long)years);//先把一个数转换为long
System.out.println("total = " + total);//输出为 total = -1474836480,计算的时候内存溢出了
System.out.println("total2 = " + total2);//依旧输出为 total2 = -1474836480,类型默认int,转换是在计算之后完成的,转换之前已经存在问题了
System.out.println("total3 = " + total3);//输出为 total2 = -1474836480,先把一个数据转换为long这样默认类型就会按最高的来计算,就不会出现内存溢出了

当计算之后的数据会导致内存溢出时,先将其中一个数据的类型转换为更大容量的类型,这样就能避免计算后内存溢出导致的数据出错了

自动类型转换

由低向高转换时会自动转换,不会丢失精度,不需要添加额外代码

int t = 1239;
double d = t;
System.out.println("t = " + t);//输出为 1239
System.out.println("d = " + d);//输出为 1239.0

字符的强制转换

字符本质也是数字也就是整形

char C = 'a';
int d2 = C + 1;
char C2 = (char)d2;
System.out.println("C = " + C);//输出为 C = a
System.out.println("d2 = " + d2);//输出为 d2 = 98
System.out.println("C2 = " + C2);//输出为 C2 = b

a 在Unicode编码表后面排的是 b, C＋1 = 98 强制转换为char类型输出为 b 验证了char字符类型的本质

总结:

不能对布尔值进行转换

不能吧对象类型转换为不相干的类型

在把高容量转换为大低容量的时候是强制转换

转换的时候可能存在内存溢出,或者精度问题

变量、常量

变量就是可以变化的量

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

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

type varName [=value] [{,varName[=value]}];

//数据类型 变量名 = 值;可以使用逗号隔开来声明多个同类型变量

每个变量都有类型,类型可以是基本类型,也可以是引用类型

变量名必须是合法的标识符

变量声明是一条完整的语句,因此每一个声明都必须以分号结束

命名规范

所有变量,方法,类名: 见名知意

类成员变量:首字母小写和驼峰原则: monthSalary 除了第一个单词以外, 后面的单词首字母大写

局部变量:首字母小写和驼峰原则

常量 : 大写字母和下划线:MAX_VALUE

类名: 首字母大写和驼峰原则: Man,GoodMan

方法名: 首字母小写和驼峰原则: run() runRun()

命名规范方便大家阅读,大家都用一个规范才能更快辨别代码作用

变量的作用域

public class Variable{
    static int allClicks = 0;//类变量
    String str = "Hello World";//实例变量
    public void method(){
        int i = 0;//局部变量,只在当前的代码块{}生效
    }
}

类变量

每建立一个类就是建立了一个新的类型,这个类型和int char double这些类似

类变量写在类里面的,需要加static静态修饰符关键字

作用域

只在当前的代码块{}生效

实例变量

实例变量不加static静态修饰符

作用域

在类里面,方法外面

实例变量,从属于对象

使用方式

变量类型 变量名 = new 变量所在的类的类名(); 用这个格式可以将对象实例化(将对象加载到当前内存中)

变量名.在该类型里定义的变量名 = 数值; 用这个格式可以操作实例化对象里声明的变量

变量名.在该类型里定义的方法名(); 用这个格式可以操作实例化对象里的方法

局部变量

局部变量写在方法里

局部变量必须声明和初始化值

实例变量默认值

除了基本类型其余的都是null

布尔值是false

其他类型如果不进行初始化都是0 或0.0

常量

初始化之后就不可改变, 不会变动的值

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

常量名一般使用大写字母.

final 常量类型 常量名 = 值;
final double PI = 3.14;

运算符

Java语言支持如下运算符:

算数运算符:

包含 + 取和, - 取差, * 取积, / 取商, % 取模, ++ 自增, – 自减

实例:

public static void main(String[] args){
    int a = 10;
    int b = 20;
    
    System.out.println(a + b);//输出为 30
    System.out.println(a - b);//输出为 -10
    System.out.println(a * b);//输出为 200
    System.out.println(a / (double)b);//输出为 0.5,计算结果不为整形,转换一个类型为double避免出现数据错误
    System.out.println(a % b);//输出为 10,10除20不能整除,余10,输出为10
    System.out.println(++a);//输出为11,++在前,先自增再输出a的值,输出完成前a的值为11
    System.out.println(a++);//输出为10,++在后,先输出a的值再自增,输出完成后a的值为11
    System.out.println(--a);//输出为9,同自增运算符(++)
    System.out.println(a--);//输出为10,同自增运算符(++)
}

算数运算符扩展:

public static void main(String[] args){
	double z = 9.0;
	float x = 1.1F;
	long a = 123123123123123L;
	int b = 123;
	short c = 10;
	byte d = 8;
	System.out.println(z + x + a + b + c + d);//输出类型为double
	System.out.println(x + a + b + c + d);//输出类型为float
	System.out.println(a + b + c + d);//输出类型为 long;
	System.out.println(b + c + d);//输出类型为 int
	System.out.println(c + d);//输出类型为 int
}

如果计算中有数据的类型级别高于int的数据,那结果类型以级别最高的为准,如果计算中没有int级别以上的类型数据,不论是否有int类型,计算结果都为结果类型都为int,浮点数类型级别永远高于整形类型

赋值运算符:

包含 " = " (赋值)

实例:

public static void main(String[] args){
    int a = 1;
	a = 2;
	System.out.println(a);//输出为 2,后赋值覆盖先赋值
}

关系运算符 :

包含 < 小于, > 大于, <= 小于等于, >= 大于等于, == 等等于, != instanceof不等于

实例:

public static void main(String[] args){
    int a = 10;
    int b = 20;
    int c = 30;
    short d = 10;
    System.out.println(a > b);//输出为 false
    System.out.println(a < b);//输出为 true
    System.out.println(a <= b);//输出为 true
    System.out.println(a >= b);//输出为 false
    System.out.println(a == d);//输出为 true
    System.out.println(a != b);//输出为 true
}

数据进行比较时会自动转换类型进行比较值, 数据比较的结果为布尔值

逻辑运算符:

包含 && 与, || 或, ! 非

实例:

boolean a = true;
boolean b = false;
System.out.println("a && b :" + (a && b));//输出为 false
System.out.println("a || b :" + (a || b));//输出为 true
System.out.println("!(a && b) :" + !(a && b));//输出为 true

逻辑运算符与运算,两个变量结果都为真时输出真,有一个结果为假返回假

逻辑运算符或运算,两个变量只需其中一个为真返回真,两个都为假时返回假

逻辑运算符非运算,取反,结果为真时返回假,结果为假时返回真

短路运算

int x = 5;
boolean y = (x < 4) && (x++ <4);
System.out.println("y = " + y);//y = false
System.out.println("x = " + x);//x = 5 ,x < 4为假,不再检测x++ < 4是否为真,x++未执行

int i = 5;
boolean j = (i < 4) & (i++ <4);
System.out.println("j = " + j);//j = false
System.out.println("i = " + i);//i = 6 ,i < 4为假,依旧检测i++ < 4是否为真,i++执行

int a = 5;
boolean b = (a > 4) || (a++ >4);
System.out.println("b = " + b);//b = true
System.out.println("a = " + a);//a = 5 ,a > 4为真,不再检测a++ > 4是否为真,a++未执行

int n = 5;
boolean m = (n > 4) || (n++ >4);
System.out.println("m = " + n);//m = true
System.out.println("n = " + n);//n = 6 ,n > 4为真,依旧检测n++ > 4是否为真,n++执行

&& (与)运算时判断第一个变量为假时直接输出判断为假,不再执行后续判断
& (与)运算时判断第一个变量为假时输出判断为假,依旧执行后续判断

|| (或)运算时判断第一个变量为真时直接输出判断为真,不再执行后续判断
| (或)运算时判断第一个变量为真时直接输出判断为真,依旧执行后续判断

位运算符:

包含 & 与, | 或, ^ 异或, ~ 取反, >> 算数右移, << 算数左移, >>> 逻辑右移(了解即可! ! ! )

实例:

/*
A = 0011 1100
B = 0000 1101

A & B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~B =	1111 0010
*/

位运算中左右移效率极高

左移一位数值×2,右移一位数值÷2

可能会遇到的面试题

如何快速计算2×8

(2<<3)

逻辑右移:

/*
    A = 0010 0110
A>>>2 =   00 1001 空位会补上0即为
        0000 1001
    B = 1010 0110
B>>>2 =   10 1001 空位依旧会补上0
*/

逻辑右移涉及到源码, 补码,反码,目前的数字源码是三十二位0和1组成的代码,

源码左边的第一位数字用来区分这个数字是正数还是负数,数字是0,那么这串源码表达的是正数,数字是1那么这串源码表达的是负数.

逻辑右移会让源码的前两位空出,并自动补上0,数字为正数的情况下基本不会出什么问题,但是负数的开头是1,右移两位并在前面补上0这个数字不仅从负数变为了正数,甚至在高位会存在一个一,精度完全丢失

对了,没有逻辑左移<<<这个运算符,你打出来会在地三个<号出出现报错\dog.ing

条件运算符:

运算模型

x ? y : z

格式:

变量类型 变量名 = 条件值 判断符号 条件值 ? 输出结果1 : 输出结果2

实例:

int a = 50;
boolean x = a < 60;
String y = "A";
String z = "60";
String type = x ? y : z;
System.out.println(type);//输出为 A

//为方便辨别运算模型,定义了多个变量正常使用时请大家还是尽量使代码精简便于阅读

int a = 70;
int b = a < 60 ? 70 : 60;
System.out.println(b);//输出为 60

需要注意的的点, ? 号左边的是条件判断式(最终取判断式的布尔值使用),右边的是对应输出的结果,用以储存结果所定义的变量类型一定要与最终输出结果的类型保持一致,判断式判断结果为真时输出 : 符号左边的结果,判断式判断结果为假时输出 : 符号右边的结果

赋值运算符:

包含 += , -= , *= , /=

实例:

int a = 10;
int b = 20;
System.out.println("b += a : " + (b += a));//输出为 b += a : 30
System.out.println("b = " + b);            //输出为 b = 30
System.out.println("b -= a : " + (b -= a));//输出为 b -= a : 20
System.out.println("b = " + b);            //输出为 b = 20
System.out.println("b *= a : " + (b *= a));//输出为 b *= a : 200
System.out.println("b = " + b);            //输出为 b = 200
System.out.println("b /= a : " + (b /= a));//输出为 b /= a : 20
System.out.println("b = " + b);            //输出为 b = 20

b += a等同于 b = b + a,运算之后将结果赋值给运算符左边的变量

小课堂: 优先级,连接符拓展

操作级别从上至下依次排列,最上面的是最大优先级,最下面的是最小优先级

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cgC3kbPz-1659510980258)(D:\桌面\狂神说\图片\操作优先级.png)]

运算符号 + 号有时也作为连接符使用

实例:

public stati void main(String[] args){
    int a = 10;
    int b = 20;
    int c = 30;
    int d = 40;
    System.out.println("" + a + b);//输出为 1020
    System.out.println(a + b + "");//输出为 30
    System.out.println(a + b + "" + c);//输出为 3030
    System.out.println(a + b + "" + c + d);//输出为 303040;
}

计算时, 在字符串之后的所有 + 号都为连接符

包机制

包的本质就是文件夹(目录)

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

建包:

包语句的语法格式为:

package pkg1[ . pkg2[ . pkg3...]];//此行必须放在所有代码之前,声明文件所属

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

实例:

package com.baidu.www//百度主站的包名
package com.baidu.baike//百度百科
package com.baidu.wenku//百度文库

导包:

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

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

实例:

导入Java提供的Date类

import java.util.Date//导入java包下的util里的Date类
import java.util.*//导入java包下的util里的所有类, .*是通配符

JavaDoc:

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

他可以根据注释信息生成一个帮助文档

可使用的参数信息:

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

应用场景:

//可以自定义声明作者名,版本号,所需要最早使用的JDK版本
/**
 * @author aaa
 * @version 1.0
 * @since 1.8
 */
public class Test {

    String name;

    /**
     *
     * @param name
     * @return
     * @throws Exception
     */

    //写好方法后在方法的代码前面加上/**,按下回车就会自动生方法的对应属性
    public String test(String name) throws Exception{
        return name;
    }
}

生成API注释文件:

打开有javadoc注释的文件的目录

Shift+右键打开右键菜单

选择"再此处打开PowerShell窗口"

输入 javadoc -encoding UTF-8 -charset UTF-8 Test.java(-encoding UTF-8将编码设定为UTF-8,-charset UTF-8将字符集编码设定为UTF-8,在文件中出现中文时不至于出现乱码,让显示更出色)

打开名为index.html的网页我文件里面就是生成的API文档

最后引用阿里帮助文档里的第一句话送给大家:

无规矩不成方圆 无规范不能协作

不遵守规范写代码,别人就会看不懂你的代码,就没办法与你协作