Java语法基础

1.注释

  • 注释是一种对代码的解释,让自己或者别人能更容易看懂代码
  • 注释并不会被执行,是给我们写代码的人看的
  • 书写注释是一种非常好的习惯

Java中的注释有三种

  • 单行注释
  • 多行注释
  • 文档注释

单行注释

int num =300;// 定义一个int型变量num赋值300

注:注释的双斜线与注释内容之间有且仅有一个空格。

多行注释

 /*
 多行注释
 多行注释
 */

文档注释

文档注释参数

标签 描述
@author 标识一个类的作者
@version 指定类的版本
@since 标记当引入一个特定的变化时
@param 说明一个方法的参数
@return 说明返回值类型
@throws 标志一个类抛出的异常
/**
* @author runoob
* @version 1.2
*/

2.标识符和关键字

关键字 含义
private 一种访问控制方式:私用模式
protected 一种访问控制方式:保护模式
public 一种访问控制方式:共用模式
abstract 表明类或者成员方法具有抽象属性
class
extends 表明一个类型是另一个类型的子类型,这里常见的类型有类和接口
final 用来说明最终属性,表明一个类不能派生出子类,或者成员方法不能被覆盖,或者成员域的值不能被改变
implements 表明一个类实现了给定的接口
interface 接口
native 用来声明一个方法是由与计算机相关的语言(如C/C++/FORTRAN语言)实现的
new 用来创建新实例对象
static 表明具有静态属性
strictfp 用来声明FP_strict(单精度或双精度浮点数)表达式遵循IEEE 754算术规范
synchronized 表明一段代码需要同步执行
transient 声明不用序列化的成员域
volatile 表明两个或者多个变量必须同步地发生变化
break 提前跳出一个块
continue 回到一个块的开始处
return 从成员方法中返回数据
do 用在do-while循环结构中
while 用在循环结构中
if 条件语句的引导词
else 用在条件语句中,表明当条件不成立时的分支
for 一种循环结构的引导词
instanceof 用来测试一个对象是否是指定类型的实例对象
switch 分支语句结构的引导词
case 用在switch语句之中,表示其中的一个分支
default 默认,例如,用在switch语句中,表明一个默认的分支
try 尝试一个可能抛出异常的程序块
catch 用在异常处理中,用来捕捉异常
throw 抛出一个异常
throws 声明在当前定义的成员方法中所有需要抛出的异常
import 表明要访问指定的类或包
package
boolean 基本数据类型之一,布尔类型
byte 基本数据类型之一,字节类型
char 基本数据类型之一,字符类型
double 基本数据类型之一,双精度浮点数类型
float 基本数据类型之一,单精度浮点数类型
int 基本数据类型之一,整数类型
long 基本数据类型之一,长整数类型
short 基本数据类型之一,短整数类型
null
true 正确
false 错误
super 表明当前对象的父类型的引用或者父类型的构造方法
this 指向当前实例对象的引用
void 声明当前成员方法没有返回值
goto 保留关键字,没有具体含义
const 保留关键字,没有具体含义

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

标识符注意点

  • 所有的标识符都应该以字母(A-Z或者a-z),美元符($),下划线(_)开头,(不能以数字开头!!)

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

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

  • 标识符是大小写敏感的

public class one {
    public static void main(String[] args) {
        /* 变量名以下划线、美元符、大小写字母开头 */
        int _num1 = 100;
        int $num2 = 200;
        int num3 = 300;
        int Num4 = 400;
        /* 标识符大小写敏感,temp和Temp是不同的 */
        String temp = "abcde";
        String Temp = "abcde";
    }
}

编码规约要求代码中的命名均不能以下划线或美元符号开始,也不能以下划线或美元符号结束。

3.数据类型

Java是强类型语言(要求变量的使用要严格符合规定,所有变量都必须先定义才能使用)

Java的数据类型分为基本类型、引用类型

基本数据类型

数据类型 占用字节数 范围
byte 1 -128 ~ 127
short 2 -32768 ~ 32767
int 4 -2147483648 ~ 2147483647
long 8 -9223372036854775808 ~ 9223372036854775807
float 4 1.4E-45 ~ 3.402823E38
double 8 4.9E-324 ~ 1.7976931348623157E308
char 2 0 ~ 66535
boolean 1位(bit) 其值只有true和false
public class helloworld {
    public static void main(String[] args) {
        /* 八大基本数据类型 */
        byte num1 = 100;
        short num2 = 200;
        int num3 = 300;
        long num4 = 400L;// 定义long型数据时数字后面加L
        float num5 = 3.1F;// 定义float型数据时数字后面加F
        double num6 = 3.14;
        char x ='a';
        boolean flag =true;
    }
}

补充:字符串定义,String不是关键字,是一个类

String temp ="abcde";

引用数据类型

  • 接口

  • 数组

数据类型扩展

位(bit):计算机内部储存的最小单位

字节(byte):计算机中数据处理的基本单位

Java中各种进制的表达方式

二进制 由0,1组成 以0b开头
八进制 由0,1,2,3,4,5,6,7,组成 以0开头
十进制 由0,1,2,3,4,5,6,7,8,9组成 默认整数是十进制
十六进制 由0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f(大小写均可)组成 以0x开头

浮点精度(float、double)运算

public class two {
    public static void main(String[] args) {
        double num1 = 3.14;
        double num2 = 3.13;
        float num3 = 3.14F;
        System.out.println(num1-num2);//理论上结果应该等于0.01
        System.out.println(num1==num3);//理论上3.14=3.14为true
    }
}

运行结果

0.010000000000000231
false

为什么浮点精度运算会有问题

Java中常见的转义字符

转义字符 意义
\b 退格(BS) ,将当前位置移到前一列
\f 换页(FF),将当前位置移到下页开头
\n 换行(LF) ,将当前位置移到下一行开头
\r 回车(CR) ,将当前位置移到本行开头
\t 水平制表(HT) (跳到下一个TAB位置)
\v 垂直制表(VT)
\ 代表一个反斜线字符'''
\ ' 代表一个单引号(撇号)字符
\ " 代表一个双引号字符
\0 空字符(NULL)
\ddd 1到3位八进制数所代表的任意字符
\uhhhh Unicode转义字符(\u+四个十六进制数字)
注意:区分,斜杠:"/" 与 反斜杠:"\" ,此处不可互换

类型转换

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

低——————————————————————————————————————————————高
byte , short , char < int < long < float < double

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

  • 优先级由高→低,需强制转换
  • 优先级由低→高,会自动转换
public class three {
    public static void main(String[] args) {
        int num1 = (int)3.14;// 3.14为double型数据,优先级:int低于double,需强制转换
        double num2 = 1;// 1位int型数据,优先级:double高于int,会自动转换
        System.out.println(num1);
        System.out.println(num2);
    }
}

输出结果

3
1.0

注意:1. 不能对布尔值(boolean)进行运算

​ 2.不能把对象类型转换为不相干的类型

​ 3.在把高容量转换为低容量的时候,强制转换

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

public class three {
    public static void main(String[] args) {
        /* 精度问题:强制转换不会四舍五入 */
        System.out.println((int)3.14);// 输出为3
        System.out.println((int)5.89);// 输出为5

        /* 操作数比较大的时候注意溢出问题 */
        int salary = 10_0000_0000;// JDK7新特性,数字之间可以用下划线分割
        int year = 10;
        int total = salary*year;
        System.out.println(total);// 输出为1410065408,计算的时候溢出了

        long total1 = salary*year;// 默认是int型,在计算的时候溢出了
        System.out.println(total1);// 输出为1410065408

        long total2 = (long)salary*year;// 先把一个数转换为long型,再计算就不会溢出
        System.out.println(total2);// 输出为10000000000
    }
}

输出结果

3
5
1410065408
1410065408
10000000000

变量

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

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

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

注意:1.每个变量都有类型,可以使基本数据类型,也可以是引用数据类型
2.变量名必须是合法的标识符
3.变量声明是一条完整的语句,因此每一个声明都必须以分号结束

变量的命名规范

  • 所有变量、方法、类名:见名知意
  • 类成员变量:首字母小写和驼峰规则,如monthSalary、lastName
  • 局部变量:首字母小写和驼峰规则
  • 常量:大写字母加下划线,如MAX_VALUE
  • 类名:首字母大写和驼峰规则,如Man、GoodMan
  • 方法名:首字母小写和驼峰规则

常量

常量(Constant):初始化后不能再改变的值

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

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

常量名一般用大写字母

作用域

变量的作用域

  • 类变量
  • 实例变量
  • 局部变量
public class four {
    // 类变量 static
    static double salary = 2500;
    public static void main(String[] args){
        System.out.println(salary);// 2500
    }
}
public class four {
    // 实例变量:从属于对象,如果不自行初始化,将会有默认值
    // 布尔值:默认是false
    // 除了基本数据类型,其余默认值为null
    String name;
    int age;
    public static void main(String[] args){
        // 变量类型 变量名 = new 变量类型();
        four four = new four();
        System.out.println(four.name);// null
        System.out.println(four.age);// 0  
    }
}
public class four {
    public static void main(String[] args){
        //局部变量:必须声明和初始化值
        int i = 10;
        System.out.println(i);// 10    
}

运算符

Java运算符
算术运算符 + ,- ,* ,/ , % , ++ , --
赋值运算符 =
关系运算符 > , < , >= , <= , == , != , instanceof
逻辑运算符 && , || ,!
位运算符 & , |, ^ , ~ , >> , << , >>>
条件运算符 ? :
扩展运算符 += , -= , *= , /=
public class five {
    public static void main(String[] args) {
        /* 算术运算符 */
        int a = 20;
        int b = 10;
        System.out.println(a+b);// 30
        System.out.println(a-b);// 10
        System.out.println(a/b);// 2
        System.out.println(a%b);// 0
        a++;
        System.out.println(a);// 21
        b--;
        System.out.println(b);// 9
        System.out.println(b--);// 9,b先用后减
        System.out.println(++a);// 22,a先加后用

        /* 关系运算符 */
        int x = 50;
        int y = 100;
        System.out.println(x>y);// false
        System.out.println(x<y);// true
        System.out.println(x==y);// false
        System.out.println(x!=y);// true

        /* 逻辑运算符 */
        boolean A = false;
        boolean B = true;
        System.out.println(A&&B);// false,全真为真,若前面为假则后面不执行
        System.out.println(A||B);// true,有假为假,若前面为真则后面不执行
        System.out.println(!(A&&B));// true

        /* 位运算符 */
        /*
        A = 0011 1100
        B = 0000 1101
        ----------------
        A&B = 0000 1100
        A|B = 0011 1101
        A^B = 0011 0001 相同则为0否则为1
        ~B = 1111 0010
        2*8 = 16 2*2*2*2
        <<(左移):*2   >>(右移):/2
        */
        System.out.println(2<<3); // 0000 0010 -> 0001 0000
        System.out.println(0b10000);// 16

        /* 条件运算符 */
        //x:y?z
        //如果x为真 则结果为y 否则结果为z
        int score = 80;
        String type = score>60?"及格":"不及格";
        System.out.println(type);// 及格

        /* 扩展赋值运算符 */
        int q = 30;
        q+=5;// q=q+5
        q-=5;// q=q-5
        q*=5;// q=q*5
        q/=5;// q=q/5
    }
}

补充:字符串连接符

public class six {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        /* 字符串连接符 + String */
        System.out.println(""+a+b);// 1020
        System.out.println(a+b+"");// 30
    }
}

Java运算符优先级

优先级 运算符 结合性
1 ()、[]、{} 从左向右
2 !、+、-、~、++、-- 从右向左
3 *、/、% 从左向右
4 +、- 从左向右
5 «、»、>>> 从左向右
6 <、<=、>、>=、instanceof 从左向右
7 ==、!= 从左向右
8 & 从左向右
9 ^ 从左向右
10 | 从左向右
11 && 从左向右
12 || 从左向右
13 ?: 从右向左
14 =、+=、-=、*=、/=、&=、|=、^=、~=、«=、»=、>>>= 从右向左

包机制

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

包语句的语法格式:

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

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

import package1[.package2].(classname|*)//其中*表示通配符 即全部

JavaDoc

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

参数信息

  • @author 作者名
  • @version 版本号
  • @since 指明需要最早使用的jdk版本
  • @param 参数名
  • @return 返回值情况
  • @throws 异常抛出情况
使用Dos命令
javadoc 参数(-encoding UTF-8 -charset utf-8) java文件

使用IDEA生成JavaDoc文档

1.IDEA 的 JavaDoc 生成功能在菜单 Tools>>Generate JavaDoc

2.点击上述菜单后会生成 JavaDoc 的对话框

3.即可生成简单的Doc文档

4.回到生成的文件路径,可以看到生成的文档

5.打开即可看到生成的超文本

posted @ 2021-01-18 23:40  火车上的老头  阅读(130)  评论(0)    收藏  举报