Java基础以及变量和运算符、包机制、javadoc生成

目录

• 注释、标识符、关键字
  • 注释
  • 标识符
    • 关键字
    • 标识符注意点
• 数据类型
  • 强类型语言
  • 弱类型语言
  • Java的数据类型
    • 基本类型（primitive type）
      • 数值类型
      • boolean类型
      • 什么是字节
    • 引用类型（reference type）
  • 关于进制
  • 浮点数拓展
  • 字符拓展
  • 转移字符
• 类型转换
  • 强制转换
  • 自动转换
  • 注意点
• 变量、常量
  • 变量
    • 变量作用域
  • 常量
  • 变量的命名规范
• 运算符
  • 二元运算
  • 多类型运算
  • 关系运算符运用
  • 取模
  • 自增自减
  • 数学工具类计算
  • 逻辑运算符
    • 短路运算
  • 位运算
  • 赋值运算符
    • 字符串连接时需要注意：
  • 条件运算符/三元运算符
  • 优先级
• 包机制、JavaDoc
  • 包机制
    • import XXX.XXX.*的含义
  • JavaDoc
    • 用命令生成java文档
    • 用IDEA生成javadoc文档

注释、标识符、关键字

注释

• 平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到注释了

• 注释并不会被执行，是给我们写代码的人看的

• 书写注释是一个非常好的习惯

• 平时写代码一定要注意规范

• java中注释有三种：

  • 单行注释

    //我是一个单行注释
    /*我也是单行注释*/
    

  • 多行注释：可以注释一段文本

    /*
    我是多行注释
    我是多行注释
    我是多行注释
    我是多行注释
    */
    

  • 文档注释

    /**我是文档注释
    *@Description HelloWorld
    *@Author 油炸蘑菇鱼
    *
    */
    

标识符

关键字

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

标识符注意点

• 所有的标识符都应该以字母（A-Z或者a-z）,美元符（$），下划线（_）作为开头
• 首字母之后可以是字母（A-Z或者a-z）,美元符（$），下划线（_）或者数字的任何字符组合
• 不能使用关键字作为变量名或者方法名
• 标识符是大小写敏感的
• 合法标识符举例：

String Ahello4="yuyu";
String hello3="yuyu";
String $hello2="yuyu";
String _hello1="yuyu";

• 非法标识符举例：123abc，-salary，#abc
• 可以使用中文命名，但一般不建议这样去使用，也不建议使用拼音，会有些low

数据类型

强类型语言

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

一旦定义变量为某个数据类型，如果不进行转换则一直都是这个数据类型

特点：安全性高，速度低

弱类型语言

要求变量的使用可以不符合规定，如javascript

特点：安全性低，速度快

Java的数据类型

基本类型（primitive type）

数值类型

整数类型

• byte占1个字节范围：-128~127
• short占2个字节范围：-32768~32767
• int占4个字节范围：-2147483648~2147483647
• long占8个字节范围：-9223372036854775808~9223372036854775807

浮点类型

• float占4个字节

• double占8个字节

字符类型

• char占1个字节

boolean类型

• 占1位其值只有true和false两个

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

//小数:浮点数
float num5=20.1F;//float类型要在数字后面加F
double num6=3.1415926535897932384626433832795028841;

//字符
char name='A';
//字符串，String不是关键词是类
//String namea11 ="yuyu";

//布尔值:是 非
boolean flag=true;
//boolean flag=false;

什么是字节

位（bit）：是计算机内部数据储存的最小单位，11001100是一个八位二进制

字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示

1B（byte，字节）=8bit（位）

字符：是指计算机中使用的字母、数字、字和符号

• 1bit表示1位
• 1Byte表示一个字节 1B=8b
• 1024B=1KB
• 1024KB=1M
• 1024M=1G

引用类型（reference type）

类、接口、数组

引用类型是对象是通过引用来操作的：栈------->堆

关于进制

//整数拓展: 进制 二进制0b 十进制 八进制0 十六进制0x
int i=10;
int i2=010;//八进制0
int i3=0x10;//十六进制0x 0~9 A~F 16

浮点数拓展

float f = 0.1f;//o.1
double d = 1.0/10;//0.1

System.out.println(f==d);//false

float d1=23212323213123132f;
float d2=d1+1;

System.out.println(d1==d2);//true

//float 有限 离散 会舍入误差 会接近但不等于
//最好避免使用浮点数进行比较

字符拓展

char c1='a';
char c2='中';

System.out.println(c1);//a
System.out.println((int)c1);//强制转换 97
System.out.println(c2);//中
System.out.println((int)c2);//强制转换 20013
//所有的字符本质还是数字
//编码 Unicode 2字节 0~65536 

char c3='\u0061';

System.out.println(c3);//a

所有的字符本质还是数字

转移字符

\a	响铃(BEL)
\b	退格(BS) ，将当前位置移到前一列
\f	换页(FF)，将当前位置移到下页开头
\n	换行(LF) ，将当前位置移到下一行开头
\r	回车(CR) ，将当前位置移到本行开头
\t	水平制表(HT) （跳到下一个TAB位置）
\v	垂直制表(VT)
\	代表一个反斜线字符'''
\ '	代表一个单引号（撇号）字符
\ "	代表一个双引号字符
?	代表一个问号
\0	空字符(NUL)
\ddd	1到3位八进制数所代表的任意字符
\xhh	十六进制所代表的任意字符

类型转换

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

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

强制转换

高--低 （类型）变量名

int i=128;
byte b=(byte)i;//内存溢出

System.out.println(i);//128
System.out.println(b);//内存溢出 -128

自动转换

低--高

int i=128;
double b=i;

System.out.println(i);//128
System.out.println(b);//128.0

注意点

1. 不能对布尔值进行转换
2. 不能把对象类型转换为不相干的类型
3. 再把高容量的转换到低容量的时候，需要强制转换
4. 转换的时候后可能存在内存溢出，或者精度问题！

System.out.println((int)23.7);//23
System.out.println((int)-45.89f);//-45

溢出问题：

计算时先把一个数转换为新类型可以避免溢出

//JDK7新特性，数字之间可以用下划线分割
int money=10_0000_0000;
int years=20;
int total=money*years;//-1474836480，计算的时候溢出了
long total2=money*years;//默认是int，转换之前已经存在问题了
System.out.println(total2);//-1474836480
long total3=money*(long)years;//先把一个数转换为long
System.out.println(total3);//20000000000

实践案例：

char c='a';
int d=c+1;
System.out.println(d);//98
System.out.println((char)d);//b

变量、常量

变量

变量是什么：就是可以变化的量

java是一种强类型语言，每个变量度必须声明其类型

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

char c='a';
int a=1;
//不要用以下方式命名
//int a,b,c;
//int a=1,b=2,c=3;

注意事项：

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

变量作用域

• 类变量：加static都是从属于类的变量
• 实例变量：从属于对象（类），如果不进行初始化，这个类型的默认值都为0或者0.0；布尔值默认是false，除了基本类型，其余的默认值都是null
• 局部变量：必须声明和初始化值，只在方法里有用

public class Demo003 {
    //类变量
    static double salary =2500;

    //实例变量
    String name;
    int age;
    //main方法
    public static void main(String[] args) {
        //局部变量
        int i=10;

        //变量类型 变量名字=new Demo003();
        Demo003 demo003 = new Demo003();

        System.out.println(demo003.age);//0
        System.out.println(demo003.name);//null
    }
}

常量

• 常量（Constant）：初始化（initialize）后不能再改变的值，不会变动的值
• 所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不孕系被改变。

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

public class Demo004 {
    //final为修饰符，可以在static前或者后，不存在先后顺序
    static final double PI =3.14;
    public static void main(String[] args) {
        System.out.println(PI);//3.14
    }
}

变量的命名规范

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

运算符

java语言支持如下运算符：

• 算术运算符：+，-，*，/，%，++，--
• 赋值运算符：=
• 关系运算符：>，<，>=，<=，==，!=
• 逻辑运算符：与&&，或||，非!
• 位运算符：&，|，^，~，>>，<<，>>>
• 条件运算符：？，：
• 扩展赋值运算符：+=，-=，*=，/=

二元运算

package operator;

public class Demo001 {
    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
    }
}

多类型运算

如果有高类型的，则结果为高类型：

package operator;

public class Demo002 {
    public static void main(String[] args) {
        long a =123123123123123L;
        int b = 123;
        short c =10;
        byte d=8;

        System.out.println(a+b+c+d);//Long 123123123123264
        System.out.println(b+c+d);//int 141
        System.out.println(c+d);//int 18
        System.out.println((double) c+d);//double 18.0

    }
}

关系运算符运用

public class Demo003 {
    public static void main(String[] args) {
        //关系运算符返回的结果：正确，错误 布尔值
        int a =10;
        int b =20;

        System.out.println(a>b);//false
        System.out.println(a<b);//true
        System.out.println(a==b);//false
        System.out.println(a!=b);//true
    }
}

取模

    //取余 模运算
    int c = 21;

    System.out.println(c%a);//c/a      21/10=2....1

自增自减

public class Demo004 {
    public static void main(String[] args) {
        //++ -- 自增 自减 一元运算符
        int a=3;
        int b=a++;//执行完这行代码后，先给b赋值，再自增
        //a=a+1
        System.out.println(a);//4
        //a++ a=a+1
        int c=++a;//执行完这行代码前，先自增，再给c赋值

        System.out.println(a);//5
        System.out.println(b);//3
        System.out.println(c);//5
    }
}

数学工具类计算

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

逻辑运算符

• 逻辑与运算：两个变量都为真，结果才为真true
• 逻辑或运算：两个变量有一个为真，则结果为真true

public class Demo005 {
    public static void main(String[] args) {
        //与(and) 或（or） 非（取反）
        boolean a=true;
        boolean b=false;

        System.out.println("a && b:"+(a&&b));//a && b:false 逻辑与运算：两个变量都为真，结果才为真true
        System.out.println("a || b:"+(a||b));//a || b:true 逻辑或运算：两个变量有一个为真，则结果为真true
        System.out.println("!(a && b):"+!(a&&b));//!(a && b):true 如果是真，则变为假，如果是假，则变为真
    }
}

短路运算

//短路运算
int c=5;
boolean d=(c<4)&&(c++<4);//因为c<4为false，则进行短路运算，逻辑与右边就没有进行运算直接输出结果

System.out.println(c);//5
System.out.println(d);//false

位运算

public class Demo006 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101

        A&B A与B =0000 1100 如果都有1，则写1，取余写0
        A|B A或B =0011 1101 如果有1，则写1
        A^B AB异或 =0011 0001 如果两个位置相同为0，否则为1
        ~B 非A即B =1111 0010 与B取反

        2*8怎么运算更快 = 16 =2*2*2*2
        <<左移    *2
        >>右移    /2

        0000 0000     0
        0000 0001     1
        0000 0010     2
        0000 0011     3
        0000 0100     4
        0000 1000     8
        0001 0000     16
         */

        System.out.println(2<<3);//16
    }
}

赋值运算符

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

        a+=b;//a = a+b 10+20
        a-=b;//a = a-b 30-20
        a*=b;//a = a*b 10*20
        a/=b;//a = a/b 200/20

        System.out.println(a);// 10
    }
}

字符串连接时需要注意：

//字符串连接符   +  ,  String
System.out.println(""+a+b);//1020
System.out.println(a+b+"");//30
//字符串在前面则后面的int都变为string，若运算在前则先进行运算

条件运算符/三元运算符

// x ? y : z
//如果x==true，则结果为y，否则结果为z
int score =80;
String type = score <60 ?"不及格":"及格";
System.out.println(type);//及格

优先级

加()可以进行优先运算

包机制、JavaDoc

包机制

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

• 包语句的语法格式为：

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

• 一般利用公司域名导致作为包名；

大家可以用com.自己的名字.xxx创建自己的多级包方便管理。

如果新建包发现无法自己分成多级包，则在齿轮中取消选择Compact Middle Packages

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

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

就比如想要用Date，则需要导入Date包，可以按alt+enter进行补全

注：import 必须在 package下面

import XXX.XXX.*的含义

import com.shenxiaoyu.base.*;//导入这个包下所有的类

JavaDoc

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

java8官方API入口：英文 中文

参数信息

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

加在类上是类的注释，加在方法上是方法的注释

/**
 * @author shenxiaoyu
 * @version 1.0
 * @since 1.8
 */
public class Doc {
    String name;

    /**
     * @author shenxiaoyu
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
}

用命令生成java文档

找到要生成文档的文件夹，然后在路径栏全面加上“cmd空格路径”然后回车进入命令窗口

在命名窗口输入javadoc -encoding UTF-8 -charset UTF-8 Doc.java

在当前文件夹下会生成一些文件，点击index.html可以查看文档

用IDEA生成javadoc文档

在工具栏中找到 Tool，然后再子菜单中找到 Generate JavaDoc

参数值为：-encoding UTF-8 -charset UTF-8 -windowtitle "test"

这里我点的whole project，后面的output directory是生成要生成javadoc的文件夹

最后效果：