Java基础语法

注释

Java中注释有三种：

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

image.png

标识符

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

  • 关键字

image.png

  • 表示类名的标识符用大写字母开始。
    • 如：Man, GoodMan
  • 表示方法和变量的标识符用小写字母开始，后面的描述性词以大写开始。
    • 如：eat(),eatFood()
    • //驼峰命名法

关于 Java 标识符，有以下几点需要注意：

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

  • 可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，很Low。

    1. public class Demo01{
    2. public static void main(String[] args){
    3.   String 王者荣耀 = "最强王者";
    4.   System.out.println(王者荣耀);
    5. } 
    6. }

    数据类型

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

    1、强弱类型语言

    强类型语言也称为强类型定义语言。要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用。
    弱类型语言也称为弱类型定义语言。与强类型定义相反。像vb，php等就属于弱类型语言

    2、数据类型

    Java数据类型分为两大类：

  • 基本类型（primitive type）

  • 引用类型（reference type）
    • 【注：引用数据类型的大小统一为4个字节，记录的是其引用对象的地址！】

image.png
image.png

  1. public class Demo02 {
  2.     public static void main(String[] args) {
  3.         //整数
  4.         byte num1 = 10;
  5.         //短整型
  6.         short num2 = 20;
  7.         //整型 —— 最常用
  8.         int num3 = 30;
  9.         //长整型
  10.         //long类型要在数字后面加L
  11.         long num4 = 30L;
  13.         //浮点数
  14.         //float类型要在数字后面加F
  15.         float num5 = 1.2F;//单精度
  16.         double num6 = 3.1415926;//双精度
  18.         //字符
  19.         //单字符
  20.         char name = 'A';
  21.         //字符串，String不是关键字，是类
  22.         //String name2 = "wang jin";
  24.         //布尔值:是非
  25.         boolean flag1 = true;
  26.         boolean flag2 = false;
  27.     }
  28. }
  • Java语言的整型常数默认为int型，浮点数默认是Double
    • 位（bit）：是计算机内部数据储存的最小单位，11001100是一个八位二进制数。
    • 字节（byte）：是计算机中 数据处理 的基本单位，习惯上用大写 B 来表示,
      • 1B（byte,字节）= 8bit（位）
    • 字符：是指计算机中使用的字母、数字、字和符号
      • 1bit表示1位，1Byte表示一个字节 1B=8b。1024B=1KB1024KB=1M1024M=1G.
    • ASCIIS码：1个英文字母（不分大小写）= 1个字节的空间1个中文汉字 = 2个字节的空间1个ASCII码 = 一个字节
    • UTF-8编码：1个英文字符 = 1个字节英文标点 = 1个字节1个中文（含繁体） = 3个字节中文标点 = 3个字节
    • Unicode编码：1个英文字符 = 2个字节英文标点 = 2个字节1个中文（含繁体） = 2个字节中文标点 = 2个字节
    • 32位操作系统只可以使用32位的cpu，而64位的CPU既可以安装32位操作系统也可以安装64位操作系统。
    • 寻址能力简单点说就是支持的内存大小能力，64位系统最多可以支达128 GB的内存，而32位系统最多只可以支持4G内存。
    • 32位操作系统只可以安装使用32位架构设计的软件，而64位的CPU既可以安装使用32位软件也可以安装使用64位软件。

3、整数拓展

计算机中存在很多进制问题：二进制、十进制、八进制、十六进制

  • 二进制数，以0b开头。
  • 十进制整数，如：99, -500, 0。
  • 八进制整数，要求以 0 开头，如：015。
  • 十六进制数，要求 0x 或 0X 开头，如：0x15 。

image.png

4、浮点数拓展

浮点类型float, double的数据不适合在不容许舍入误差的金融计算领域。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。

  1. public static void main(String[] args) {
  2.     float f = 0.1f;
  3.     double d = 1.0/10;
  4.     System.out.println(f==d); //false
  6.     float d1 = 2313131212323342f;
  7.     float d2 = d1 + 1;
  8.     System.out.println(d1==d2); //true
  9. }

主要理由：由于字长有限，浮点数能够精确表示的数是有限的，因而也是离散的。浮点数一般都存在舍入误差，很多数字无法精确表示，其结果只能是接近，但不等于；二进制浮点数不能精确的表示0.1、0.01、0.001这样10的负次幂。并不是所有的小数都能可以精确的用二进制浮点数表示。

  • 最好完全避免使用浮点数比较 !
  • 大数值：Java.math下面的两个有用的类：BigInteger和BigDecimal，这两个类可以处理任意长度的数值。BigInteger实现了任意精度的整数运算。BigDecimal实现了任意精度的浮点运算。

浮点数使用总结：

  • 默认是double
  • 浮点数存在舍入误差，很多数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。
  • 避免比较中使用浮点数

    5、字符拓展

    单引号用来表示字符常量。
    例如：‘A’是一个字符，它与“A”是不同的，“A”表示一个字符串。
    char 类型用来表示在Unicode编码表中的字符。

    所以的字符本质还是数字。

【代码演示：字符转int看结果】

  1. public static void main(String[] args) {
  2.     char c1 = 'a';
  3.     char c2 = '中';
  4.     System.out.println(c1);
  5.     //强制转换
  6.     System.out.println((int) c1); //97
  7.     System.out.println(c2);
  8.     //强制转换
  9.     System.out.println((int) c2); //20013
  10. }

Unicode编码被设计用来处理各种语言的所有文字，它占2个字节，可允许有65536个字符。Unicode具有从0到65535之间的编码，通常用从’u0000’到’uFFFF’之间的十六进制值来表示（前缀为u表示Unicode）

  1. char c3 = '\u0061';
  2. System.out.println(c3); //a

Java 语言中还允许使用转义字符 ‘’ 来将其后的字符转变为其它的含义，有如下常用转义字符：
image.png

6、布尔值拓展

  • boolean类型（一位，不是一个字节），就是0|1
  • boolean类型有两个值，true和false,不可以 0 或非 0 的整数替代 true 和 false ，这点和C语言不同。

  • boolean 类型用来判断逻辑条件，一般用于程序流程控制。

    1. boolean flag = false;
    2. if(flag){
    3. // true分支
    4. }else{
    5. // false分支
    6. }

    【编码规范：很多新手程序员喜欢这样写】

    1. if (is == true && un == false ) {...}

    只有新手才那么写。对于一个熟练的人来说，应该用如下方式来表示：

    1. if ( is && !un ) {....}

    要习惯去掉所有的==fasle 和 ==true。
    Less is More！代码要精简易读！

    类型转换

  • 强制类型转换

  • 自动类型转换

Java是强类型语言，所以进行有些运算的时候，需要类型转换。整型、实型（常量）、字符型数据可以混合运算。
运算中，不同类型的数据先转化为同一类型，然后进行运算。
转换从低级到高级（根据容量来看）。

  1. 低 ------------------------------------> 高
  2. byte,short,char—> int —> long—> float —> double

数据类型转换必须满足如下规则：

  • 不能对boolean类型进行类型转换。
  • 不能把对象类型转换成不相关类的对象。
  • 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
  • 转换过程中可能导致溢出或损失精度，例如： ```java int i =128; byte b = (byte)i;//内存溢出

//因为byte类型是8位，最大值为127，所以当int强制转换为byte类型时，值128就会导致溢出。

  2. - 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：
  3. ```java
  4. (int)23.7 == 23;
  5. (int)-45.89f == -45

1、自动类型转换

自动类型转换：容量小的数据类型可以自动转换为容量大的数据类型。
例如: short数据类型的位数为16位，可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。

  1. public class ZiDongLeiZhuan{
  2.   public static void main(String[] args){
  3.       char c1='a';//定义一个char类型
  4.       int i1 = c1;//char自动类型转换为int
  5.       System.out.println("char自动类型转换为int后的值等于"+i1);
  6.       char c2 = 'A';//定义一个char类型
  7.       int i2 = c2+1;//char 类型和 int 类型计算
  8.       System.out.println("char类型和int计算后的值等于"+i2);
  9.   }
  10. }

2、强制类型转换

强制类型转换，又被称为造型，用于显式的转换一个数值的类型。
在有可能丢失信息的情况下进行的转换是通过造型来完成的，但可能造成精度降低或溢出。
强制类型转换的语法格式：(type)var ，运算符“()”中的type表示将值var想要转换成的目标数据类型。条件是转换的数据类型必须是兼容的。

  1. public static void main(String[] args) {
  2.     double x = 3.14;
  3.     int nx = (int)x; //值为3
  5.     char c = 'a';
  6.     int d = c+1;
  7.     System.out.println(d); //98
  8.     System.out.println((char)d); //b
  9. }

当将一种类型强制转换成另一种类型，而又超出了目标类型的表示范围，就会被截断成为一个完全不同的值，溢出。

  1. public static void main(String[] args) {
  2.     int x = 300;
  3.     byte bx = (byte)x; //值为44
  4.     System.out.println(bx);
  5. }

image.png

3、常见错误和问题

  • 操作比较大的数时，要留意是否溢出，尤其是整数操作时；

    1. public static void main(String[] args) {
    2.   int money = 1000000000; //10亿
    3.   int years = 20;
    4.   int total = money*years; //返回的是负数
    5.   long total1 = money*years; //返回的仍然是负数。默认是int，因此结果会转成int值，再转成long。但是已经发生了数据丢失
    6.   long total2 = money*((long)years); //先将一个因子变成long，整个表达式发生提升。全部用long来计算。
    7.   System.out.println(total);
    8.   System.out.println(total1);
    9.   System.out.println(total2);
    10. }

  • L和l 的问题

    • 不要命名名字为l的变量
    • long类型使用大写L不要用小写。
      1. public static void main(String[] args) {
      2. int l = 2;
      3. long a = 23451l;
      4. System.out.println(l+1); //3
      5. System.out.println(a); //23451
      6. }
      image.png

      4、JDK7拓展

  • JDK7新特性: 二进制整数

由于我们在开发中经常使用二进制整数，因此JDK7为我们直接提供了二进制整数的类型：只要 以 0b 开头 即可。

  1. int a = 0b0101;
  • JDK7新特性：下划线分隔符

对于特别长的数字，JDK7为我们提供了下划线分隔符，可以按照自己的习惯进行分割。

  1. int b = 1_2234_5678;
  2. public static void main(String[] args) {
  3.     int a = 0b0101;
  4.     int b = 1_2345_7893;
  5.     System.out.println(a); //5
  6.     System.out.println(b); //123457893
  7. }

变量 常量

1、变量（variable）

  • Java是一种强类型语言，每个变量都必须声明其类型。
  • Java变量是程序中最基本的存储单元，其要素包括变量名、变量类型和作用域。

  • 变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储单元，声明格式为：

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

    注意事项：

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

  • 变量名必须是合法的标识符。
  • 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

【演示】

  1. int a, b, c; // 声明三个int型整数：a、 b、c
  2. int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
  3. byte z = 22; // 声明并初始化 z
  4. String s = "runoob"; // 声明并初始化字符串 s
  5. double pi = 3.14159; // 声明了双精度浮点型变量 pi
  6. char x = 'x'; // 声明变量 x 的值是字符 'x'。

编码规范：虽然可以在一行声明多个变量，但是不提倡，逐一声明每一个变量可以提高程序可读性。

2、变量作用域

变量根据作用域可划分为三种：

  • 类变量（静态变量： static variable）：独立于方法之外的变量，用 static 修饰。
  • 实例变量（成员变量：member variable）：独立于方法之外的变量，不过没有 static 修饰。
  • 局部变量（lacal variable）：类的方法中的变量。
    1. public class Variable{
    2.   static int allClicks=0; // 类变量
    3.   String str="hello world"; // 实例变量
    4.   public void method(){
    5.   int i =0; // 局部变量
    6.   }
    7. }

    局部变量

    方法或语句块内部定义的变量。生命周期是从声明位置开始到”}”为止。
    在使用前必须先声明和初始化(赋初值)。
    局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
    1. public static void main(String[] args) {
    2.   int i;
    3.   int j = i+5 ; // 编译出错，变量i还未被初始化
    4.   System.out.println(j);
    5. }
    6. 修改为：
    7. public static void main(String[] args) {
    8.   int i=10;
    9.   int j = i+5 ;
    10.   System.out.println(j);
    11. }

    实例变量

    方法外部、类的内部定义的变量。从属于对象，生命周期伴随对象始终。
    如果不自行初始化，他会自动初始化成该类型的默认初始值。
    （数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false）
    1. public class Test {
    2.   // 这个实例变量对子类可见
    3.   public String name;
    4.   // 私有变量，仅在该类可见
    5.   private double salary;
    6.   ...
    7. }

    静态变量

    使用static定义。从属于类，生命周期伴随类始终，从类加载到卸载。
    如果不自行初始化，它会自动初始化成该类型的默认初始值。
    （数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false）
    1. public class Employee {
    2.   //salary是静态的私有变量
    3.   private static double salary;
    4.   // DEPARTMENT是一个常量
    5.   public static final String DEPARTMENT = "开发人员";
    6.   public static void main(String[] args){
    7.   salary = 10000;
    8.   System.out.println(DEPARTMENT+"平均工资:"+salary);
    9.   }
    10. }

3、常量

常量(Constant)：初始化(initialize)后不能再改变值。
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

  1. final 常量名=值;
  2. final double PI=3.14; final String LOVE="hello";
  • 常量名一般使用大写字符。

  • 程序中使用常量可以提高代码的可维护性。

    4、变量的命名规范

  • 所有变量、方法、类名：见名知意

  • 类成员变量：首字母小写和驼峰原则 : monthSalary
  • 局部变量：首字母小写和驼峰原则
  • 常量：大写字母和下划线：MAX_VALUE
  • 类名：首字母大写和驼峰原则: Man, GoodMan

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

    运算符

    运算符operator
    Java 语言支持如下运算符：

  • 算术运算符: +，-，*，/，%，++，—

  • 赋值运算符 =
  • 关系运算符: >，<，>=，<=，==，!= instanceof
  • 逻辑运算符: &&，||，!
  • 位运算符: &，|，^，~ ， >>，<<，>>> (了解！！！)
  • 条件运算符 ？：

  • 扩展赋值运算符:+=，-=，*=，/=

    1、二元运算符

    整数运算

  • 如果两个操作数有一个为Long, 则结果也为long

  • 没有long时，结果为int。即使操作数全为shot、byte，结果也是int.

    1. public static void main(String[] args) {
    2.   long a = 1231321311231231L;
    3.   int b = 1213;
    4.   short c = 10;
    5.   byte d = 8;
    6.   System.out.println((a+b+c+d)); //Long类型
    7.   System.out.println((b + c + d));//Int类型
    8.   System.out.println((c + d));//Int类型
    9. }

    浮点运算
    如果两个操作数有一个为double, 则结果为double.只有两个操作数都是float, 则结果才为float.

    1. public static void main(String[] args) {
    2.   float a = 3.14565F;
    3.   double b = 3.194546464;
    4.   float c = 1.3123123F;
    5.   System.out.println(a+b); //double类型
    6.   System.out.println(b+c); //double类型
    7.   System.out.println(a+c); //float类型
    8. }

    关系运算符
    返回布尔值
    image.png

    2、取模运算

    其操作数可以为浮点数,一般使用整数。如：5.9%3.9=2.000000004
    要点：

  • 负数%负数＝负数；

  • 负数%正数＝负数；

  • 正数%负数＝正数；

    1. public static void main(String[] args) {
    2.   System.out.println(9 % 4); //1
    3.   System.out.println(-9 % -4); //-1
    4.   System.out.println(-10 % 4); //-2
    5.   System.out.println(9 % -4); //1
    6. }

    3、一元运算符

    自增（++）自减（—）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数，分为前缀和后缀两种。

    1. public static void main(String[] args) {
    2.   int a = 3;
    3.   int b = a++; //执行完后,b=3。先给b赋值，再自增。
    4.   int c = ++a; //执行完后,c=5。先自增,再给b赋值
    5. }
    6. 注意：java中的乘幂处理
    7. public static void main(String[] args) {
    8.   int a = 3^2; //java中不能这么处理， ^是异或符号。
    9.   double b = Math.pow(3, 2);
    10. }

    Math类提供了很多科学和工程计算需要的方法和常数。特殊的运算都需要运用到方法!

    4、逻辑运算符

    逻辑与：&&和&
    逻辑或：||和|
    逻辑非：！
    image.png
    【演示】 

    1. public static void main(String[] args) {
    2.   boolean a = true;
    3.   boolean b = false;
    4.   System.out.println("a && b = " + (a&&b));
    5.   System.out.println("a || b = " + (a||b) );
    6.   System.out.println("!(a && b) = " + !(a && b));
    7. }

    逻辑与和逻辑或采用短路的方式。从左到右计算，如果确定值则不会再计算下去。在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。

  • 逻辑与只要有一个为false, 则直接返回false.

  • 逻辑或只要有一个为true, 则直接返回true;

【演示】

  1. public static void main(String[] args){
  2.     int a = 5;//定义一个变量；
  3.     boolean b = (a<4)&&(a++<10);
  4.     System.out.println("使用短路逻辑运算符的结果为"+b);
  5.     System.out.println("a的结果为"+a);
  6. }

解析： 该程序使用到了短路逻辑运算符(&&)，首先判断 a<4 的结果为 false，则 b 的结果必定是 false，所以不再执行第二个操作 a++<10 的判断，所以 a 的值为 5。

5、位运算符

Java定义了位运算符，应用于整数类型(int)、长整型(long)、短整型(short)、字符型(char)和字节型(byte)等类型。位运算符作用在所有的位上，并且按位运算。

  1. A = 0011 1100
  2. B = 0000 1101
  3. -----------------
  4. A&b = 0000 1100
  5. A | B = 0011 1101
  6. A ^ B = 0011 0001
  7. ~A= 1100 0011

image.png
右移一位相当于除2取商。
左移一位相当于乘2。
【常见面试题：int a=2*8怎样运算效率最快？】
【解析】

  1. public static void main(String[] args) {
  2.     System.out.println(2 << 3);
  3. }

用移位运算 int a=2<<3：a就是2乘以8，最后结果是16。 这是最省内存、最有效率的方法。

这个方法确实高效率的。我来解释一下：2的二进制是10 在32位存储器里面是0000 0000 0000 0010 左移三位后变成 0000 0000 0001 0000 也就是16

解释一下，在系统中运算是以二进制的形式进行的。相比来说俩个二进制数相乘运算比移位运算慢一些。位操作是程序设计中对位模式按位或二进制数的一元和二元操作。 在许多古老的微处理器上， 位运算比加减运算略快， 通常位运算比乘除法运算要快很多。 在现代架构中， 情况并非如此:位运算的运算速度通常与加法运算相同(仍然快于乘法运算). 详细的需要了解计算机的组成原理！

6、拓展运算符

image.png

  1. public static void main(String[] args) {
  2.     int a=10;
  3.     int b=20;
  4.     a+=b; // a = a + b
  5.     System.out.println(a+":"+b);
  6. }

7、字符串连接符

“+” 运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串然后再进行连接。

  1. //字符串
  2. String s1="Hello 中文!";
  3. String s2=1+""; //转换成String
  4. //int
  5. int c = 12;
  6. System.out.println("c=" + c);

8、三目条件运算符

三目条件运算符，语法格式：

  1. x ? y : z

其中x为boolean类型表达式，先计算x的值，若为true，则整个三目运算的结果为表达式y的值，否则整个运算结果为表达式z的值。

  1. public static void main(String[] args) {
  2.     int score = 80;
  3.     String type = score < 60 ? "不及格" : "及格";
  4.     System.out.println("type= " + type);
  5. }

9、运算符优先级

下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。
image.png
表达式里面优先使用小括号来组织！！方便理解和使用，不建议写非常冗余的代码运算！

  1. public static void main(String[] args) {
  2.     boolean flag = 1<4*5&&122>3||'q'+3<5;
  3.     System.out.println(flag);
  4. }

包机制

1、问题发现

存在这样一个问题：当定义了多个类的时候，可能会发生类名的重复问题。
解决方式：在java中采用包机制处理开发者定义的类名冲突问题。

2、包的作用

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

  • 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
  • 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。

  • 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

    Java 使用包（package）机制是为了防止命名冲突、访问控制、提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。
    包语句的语法格式为：

    1. package pkg1[．pkg2[．pkg3…]];

    例如,一个Something.java 文件它的内容:

    1. package net.java.util;
    2. public class Something{
    3. ...
    4. }

    那么它的路径应该是 net/java/util/Something.java 这样保存的。
    package(包) 的作用是把不同的java 程序分类保存，更方便的被其他 java 程序调用。
    一个包（package）可以定义为一组相互联系的类型（类、接口、枚举和注释），为这些类型提供访问保护和命名空间管理的功能。

以下是一些 Java 中的包：

  • java.lang-打包基础的类
  • java.io-包含输入输出功能的函数

开发者可以自己把一组类和接口等打包，并定义自己的包。而且在实际开发中这样做是值得提倡的，当你自己完成类的实现之后，将相关的类分组，可以让其他的编程者更容易地确定哪些类、接口、枚举和注释等是相关的。
由于包创建了新的命名空间（namespace），所以不会跟其他包中的任何名字产生命名冲突。使用包这种机制，更容易实现访问控制，并且让定位相关类更加简单。

3、创建包

创建包的时候，需要为包取一个合适的名字。之后，如果其他的一个源文件包含了这个包提供的类、接口、枚举或者注释类型的时候，都必须将这个包的声明放在这个源文件的开头。
包声明应该在源文件的第一行，每个源文件只能有一个包声明，这个文件中的每个类型都应用于它。
如果一个源文件中没有使用包声明，那么其中的类、函数、枚举、注释等将被放在一个无名的包（unnamed package）中。
一般利用公司域名倒置作为包名；
例：
www.baidu.com 包名：com.baidu.www
bbs.baidu.com 包名：com.baidu.bbs
blog.baidu.com 包名：com.baidu.blog

4、import关键字

为了能够使用某一个包的成员，需要在 Java 程序中明确导入该包。使用 “import” 语句可完成此功能。
在 java 源文件中 import 语句应位于 package 语句之后，所有类的定义之前，可以没有，也可以有多条，其语法格式为：

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

如果在一个包中，一个类想要使用本包中的另一个类，那么该包名可以省略。
要是要用到其他包下的类，就必须要先导包！
如果两个类重名，需要导入对应的包，否则就需要写出完整地址：

  1. com.kuang.dao.Hello hello = new com.kuang.dao.Hello()

用 import 关键字引入，使用通配符 “*” , 导入io包下的所有类！

  1. import java.io.*;

【不建议这样使用，因为会全局扫描，影响速度！】
使用 import 关键字引入指定类:

  1. import com.kuang.Hello;

【注意】类文件中可以包含任意数量的 import 声明。import 声明必须在包声明之后，类声明之前。
【编码规范：推荐参考阿里巴巴开发手册编程规范】
下载地址：阿里巴巴开发手册

JavaDoc

1、简介

JavaDoc是一种将注释生成HTML文档的技术，生成的HTML文档类似于Java的API，易读且清晰明了。
javadoc是Sun公司提供的一个技术，它从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档。javadoc命令是用来生成自己API文档的。
使用方式：使用命令行在目标文件所在目录输入 javadoc -encoding UTF-8 -charset UTF-8 文件名.java。

  1. /** 这是一个Javadoc测试程序
  2. * @author Kuangshen
  3. * @version 1.0
  4. * @since 1.5
  5. * */
  6. public class HelloWorld {
  7.     public String name;
  8.     /**
  9.     * @param name 姓名
  10.     * @return 返回name姓名
  11.     * @throws Exception 无异常抛出
  12.     * */
  13.     public String function(String name) throws Exception{
  14.         return name;
  15.     }
  16. }

稍微解释一下：

  • 以 /* 开始，以 / 结束。
  • @author 作者名
  • @version 版本号
  • @since 指明需要最早使用的jdk版本
  • @param 参数名
  • @return 返回值情况
  • @throws 异常抛出情况

    2、命令行生成Doc

    在文件目录下打开终端，输入以下命令回车即可生成JavaDoc文档。
    1. javadoc -encoding UTF-8 -charset UTF-8 文件名.java
    2. //解决GBK乱码问题，在中间添加编码设置

    3、使用IDEA生产javaDoc

  1. 首先我们需要新建一个文件夹用于存放JavaDoc的文件,接下来点击IntelliJ IDEA顶部的Tools菜单，选择Generate JavaDoc选项，如下图所示:

image.png

  1. 如下图

image.png