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)    收藏  举报