Java基础以及变量和运算符、包机制、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)
 退格(BS) ，将当前位置移到前一列
f 换页(FF)，将当前位置移到下页开头
换行(LF) ，将当前位置移到下一行开头
回车(CR) ，将当前位置移到本行开头
水平制表(HT) （跳到下一个TAB位置）
v 垂直制表(VT)
代表一个反斜线字符'''
' 代表一个单引号（撇号）字符
" 代表一个双引号字符
? 代表一个问号
空字符(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的文件夹

最后效果：

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/Sawye-sxy/p/12924291.html