标签：运算符 String int 基础 System 语法 println JavaSE out

1. 注释

平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到一个注释了，注释就类似于我们上学时候写的笔记，我们看着笔记就知道自己写的什么东西了！在程序中也是如此。我们来看一下Java中的注释怎么写，看以下代码：

public class HelloWorld {
/*
多行注释
这是我们Java程序的主入口，
main方法也是程序的主线程。
*/
public static void main(String[] args) {
//单行注释
//输出HelloWorld！
System.out.println("Hello,World!");

注释并不会被执行，是给我们写代码的人看的，书写注释是一个非常好的习惯，在很多大公司都是强制要求各位去进行编写注释！

Java中的注释有三种：

• 单行注释：只能注释当前行，以//开始，直到行结束

//输出Hello World

• 多行注释：注释一段文字，以/*开始， */结束！

/*
    这是我们Java程序的主入口，
    main方法也是程序的主线程
*/

• 文档注释：用于生产API文档，配合JavaDoc。

/*
* @Description HelloWorld类
* @Author syh
**/

2. 标识符

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

表示方法和变量的标识符用小写字母开始，后面的描述性词以大写开始。

// 驼峰命名法：首字母小写/大写，后面单词首字母大写
如： monthSalary, StudentName

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

• 所有的标识符都应该以字母（A-Z 或者 a-z）,美元符、或者下划线 开始

• 首字符之后可以是字母（A-Z 或者 a-z）,美元符、下划线 或数字的任何字符组合

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

• 标识符是大小写敏感的

• 合法标识符举例：age、$salary、_value、__1_value

• 非法标识符举例：123abc、-salary、#abc

【 JAVA不采用通常语言使用的ASCII字符集，而是采用unicode这样的标准的国际字符集。因此，这里的字母的含义：可以表示英文、汉字等等。】 【可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，很Low】

3. 数据类型

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

1. 强弱类型语言

1. 强类型语言也称为强类型定义语言。要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用。 Java、.NET、C++等都是强制类型定义的。也就是说，一旦一个变量被指定了某个数据类型，如果不经过转换，那么它就永远是这个数据类型了。

2. 弱类型语言也称为弱类型定义语言。与强类型定义相反。像vb，php等就属于弱类型语言

2. 数据类型

Java的数据类型分为两大类：基本类型（primitive type）和引用类型 （reference type）

 

 

2.1 整型

public static void main(String[] args){
    //整型
    int i1=100;
    //长整型
    long i2=998877665544332211L;
    //短整型
    short i3=235;
}

Java语言的整型常数默认为int型

• 整型拓展

在我们计算机中存在很多进制问题，十进制，八进制，十六进制等等的问题，他们怎么表示呢？

十进制整数，如：99, -500, 0。
八进制整数，要求以 0 开头，如：015。
十六进制数，要求 0x 或 0X 开头，如：0x15 。
​
//演示：
int i=10;
int i2=010;
int i3=0x10;
System.out.println(i); //10
System.out.println(i2); //8
System.out.println(i3); //16

2.2 浮点型

//浮点型
float f1=(float)3.5; //单精度
float f2=3.5f; //单精度
​
double d1=3.5; //双精度
double d2=3;

【金融面试问：银行金融业务用什么类型表示？】 浮点类型float, double的数据不适合在不容许舍入误差的金融计算领域。 如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。

主要理由： 由于字长有限，浮点数能够精确表示的数是有限的，因而也是离散的。浮点数一般都存在舍入误差，很多数字无法精确表示，其结果只能是接近，但不等于；二进制浮点数不能精确的表示0.1,0.01,0.001这样10的负次幂。并不是所有的小数都能可以精确的用二进制浮点数表示。 最好完全避免使用浮点数比较 ! 大数值：Java.math下面的两个有用的类：BigInteger和BigDecimal，这两个类可以处理任意长度的数值。BigInteger实现了任意精度的整数运算。BigDecimal实现了任意精度的浮点运算。

浮点数使用总结：

1. 默认是double

2. 浮点数存在舍入误差，很多数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需 要使用BigDecimal类。

3. 避免比较中使用浮点数

2.3 字符型

//单字符
char f='女';
char m='男';

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

Unicode编码被设计用来处理各种语言的所有文字，它占2个字节，可允许有65536个字符； 【科普：2字节=16位 2的16次方=65536，我们用的Excel原来就只有这么多行，并不是无限的】

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

public static void main(String[] args) {
    char c1 = 'a';
    char c2 = '中';
    System.out.println(c1);
    System.out.println((int) c1); //97
    System.out.println(c2);
    System.out.println((int) c2); //20013

    /* 
    Unicode具有从0到65535之间的编码，他们通常用从’u0000’到’uFFFF’之间的十六进制		值来表示（前缀为u表示Unicode）
    */
    char c3 = '\u0061';
	System.out.println(c3); //a
}

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

\b	\n	\r	\t	\"	\'	\\
退格（backspace	换行	回车	制表符（tab）	双引号	单引号	反斜杠
\u0008	\u000a	\u000d	\u0009	\u0022	\u0027	\u005c

2.4 布尔型

//布尔类型 boolean true真/false假
boolean isPass = true;
boolean isOk = false;
boolean isBig = 5 > 8;
if( isPass ){
System.out.println( "通过了" );
}
else{
System.out.println( "未通过" );
}

boolean类型（一位，不是一个字节），就是0|1 boolean类型有两个值，true和false,不可以 0 或非 0 的整数替代 true 和 false ，这点和C语言不同。 boolean 类型用来判断逻辑条件，一般用于程序流程控制。

boolean flag = false;
if(flag){
// true分支
}else{
// false分支
}

//【编码规范：很多新手程序员喜欢这样写】
if (is == true && un == false ) {...}
//只有新手才那么写。对于一个熟练的人来说，应该用如下方式来表示：
if ( is && !un ) {....}
//这点都不难理解吧。所以要习惯去掉所有的==fasle 和 ==true。Less is More！！ 代码要精简易读！

3. 类型转换

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

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

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

• 不能对boolean类型进行类型转换。

• 不能把对象类型转换成不相关类的对象。

• 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

• 转换过程中可能导致溢出或损失精度，例如：

int i =128;
byte b = (byte)i;
// byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。

• 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：

(int)23.7 == 23;
(int)-45.89f == -45

3.1 自动类型转换

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

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

【解析：c1 的值为字符 a ,查 ASCII 码表可知对应的 int 类型值为 97， A 对应值为 65，所以i2=65+1=66。】

3.2 强制类型转换

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

条件是转换的数据类型必须是兼容的。

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

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

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

3.3 常见错误和问题

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

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

2. L和l 的问题：

• 不要命名名字为l的变量

• long类型使用大写L不要用小写

3.4 JDK7拓展

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

int a = 0b0101：

JDK7新特性：下划线分隔符 在实际开发和学习中，如果遇到特别长的数字，读懂它令人头疼！JDK7为我们提供了下划线分隔符，可 以按照自己的习惯进行分割。

int b = 1_2234_5678;

我们很容易就知道这是1亿2234万5678啦！ 非常符合国人的习惯！

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

4. 变量、常量

4.1 变量（variable）

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

Java是一种强类型语言，每个变量都必须声明其类型。 Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。 变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储单元，声明格式为：

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

注意事项：

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

• 变量名必须是合法的标识符。

• 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

【演示】

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

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

4.2 变量作用域

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

• 类变量（静态变量： static variable）：独立于方法之外的变量，用 static 修饰。

• 实例变量（成员变量：member variable）：独立于方法之外的变量，不过没有 static 修饰。

• 局部变量（local variable）：类的方法中的变量。

public class Variable{
    static int allClicks=0; // 类变量
    String str="hello world"; // 实例变量
    public void method(){
    int i =0; // 局部变量
	}
}

4.3.1 局部变量

方法或语句块内部定义的变量。生命周期是从声明位置开始到”}”为止。 在使用前必须先声明和初始化(赋初值)。 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

public static void main(String[] args) {
    int i;
    int j = i+5 ; // 编译出错，变量i还未被初始化
    System.out.println(j);
}
//修改后
public static void main(String[] args) {
    int i=10;
    int j = i+5 ;
    System.out.println(j);
}

4.3.2 实例变量

方法外部、类的内部定义的变量。 从属于对象，生命周期伴随对象始终。 如果不自行初始化，他会自动初始化成该类型的默认初始值 （数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false）

public class Test {
    // 这个实例变量对子类可见
    public String name;
    // 私有变量，仅在该类可见
    private double salary;
    ...
}

4.3.3 静态变量

使用static定义。 从属于类，生命周期伴随类始终，从类加载到卸载。 (注：讲完内存分析后我们再深入！先放一放这个概念！) 如果不自行初始化，他会自动初始化成该类型的默认初始值 （数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false）

public class Employee {
    //salary是静态的私有变量
    private static double salary;
    // DEPARTMENT是一个常量
    public static final String DEPARTMENT = "开发人员";
    public static void main(String[] args){
        salary = 10000;
        System.out.println(DEPARTMENT+"平均工资:"+salary);
    }
}

4.3 常量

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

final 常量名=值;
final double PI=3.14;
final String LOVE="hello";

常量名一般使用大写字符。 程序中使用常量可以提高代码的可维护性。例如，在项目开发时，我们需要指定用户的性别，此时可以定义一个常量 SEX，赋值为 "男"，在需要指定用户性别的地方直接调用此常量即可，避免了由于用户的不规范赋值导致程序出错的情况。

4.4 变量的命名规范

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

2. 类成员变量：首字母小写和驼峰原则 : monthSalary

3. 局部变量：首字母小写和驼峰原则

4. 常量：大写字母和下划线：MAX_VALUE

5. 类名：首字母大写和驼峰原则: Man, GoodMan

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

5. 运算符

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

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

• 赋值运算符 =

• 关系运算符: >，<，>=，<=，==，!= instanceof

• 逻辑运算符: &&，||，!

• 位运算符: &，|，^，~ ， >>，<<，>>> (了解！！！)

• 条件运算符 ？：

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

5.1 二元运算符

两个操作数，来看看我们小时候的数学运算；

public static void main(String[] args) {
    int a = 10;
    int b = 20;
    int c = 25;
    int d = 25;
    System.out.println("a + b = " + (a + b) );
    System.out.println("a - b = " + (a - b) );
    System.out.println("a * b = " + (a * b) );
    System.out.println("b / a = " + (b / a) );
}

整数运算 如果两个操作数有一个为Long, 则结果也为long 没有long时，结果为int。即使操作数全为short,byte，结果也是int.

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

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

public static void main(String[] args) {
    float a = 3.14565F;
    double b = 3.194546464;
    float c = 1.3123123F;
    System.out.println(a+b); //double类型
    System.out.println(b+c); //double类型
    System.out.println(a+c); //float类型
}

关系运算符 返回布尔值！

5.2 取模运算

就是我们小学的取余；5%3 余 2 其操作数可以为浮点数,一般使用整数。如：5.9%3.9=2.000000004 要点： 负数%负数＝负数； 负数%正数＝负数； 正数%负数＝正数；

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

【注：一般都是正整数运算，进行结果的判断！】

5.3 一元运算符

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

public static void main(String[] args) {
    int a = 3;
    int b = a++; //执行完后,b=3。先给b赋值，再自增。
    int c = ++a; //执行完后,c=5。先自增,再给b赋值
}

注意：Java中的乘幂处理

public static void main(String[] args) {
    int a = 3^2; //java中不能这么处理， ^是异或符号。
    double b = Math.pow(3, 2);
}

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

5.4逻辑运算符

逻辑与：&&和&，逻辑或：||和|，逻辑非：！。

【演示】

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

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

【演示】

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

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

5.5 位运算符

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

A = 0011 1100
B = 0000 1101
-----------------
A&b = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011

右移一位相当于除2取商。

左移一位相当于乘2。

【常见面试题：int a=2*8怎样运算效率最快？】

解析：

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

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

这个方法确实高效率的。我来解释一下： 2的二进制是10 在32位存储器里面是0000 0000 0000 0010 左移三位后变成 0000 0000 0001 0000 也就是16 解释一下，在系统中运算是以二进制的形式进行的。相比来说俩个二进制数相乘运算比移位运算慢一些。 位操作是程序设计中对位模式按位或二进制数的一元和二元操作。 在许多古老的微处理器上， 位运算比加减运算略快， 通常位运算比乘除法运算要快很多。 在现代架构中， 情况并非如此:位运算的运算速度 通常与加法运算相同(仍然快于乘法运算). 详细的需要了解计算机的组成原理！

5.6 扩展运算符

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

5.7 字符串连接符

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

//字符串
String s1="Hello 中文!";
String s2=1+""; //转换成String

//int
int c = 12;
System.out.println("c=" + c);

//注意区别
System.out.println("" + 5 + 10); // "510"
System.out.println(10 + 5 + ""); // "15"

3.8 三目条件运算符

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

x ? y : z

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

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

三元运算符在真实开发中十分的常见，大家可以多练习使用，之后我们会讲解分支语句，可以利用三元运算符做到更加精简代码！便于理解！

3.9 运算符优先级

我们小学都学过：先加减，后乘除，所以优先级我们并不陌生。 当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。 下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。

大家不需要去刻意的记住，表达式里面优先使用小括号来组织！！方便理解和使用，不建议写非常冗余的代码运算！

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

6. 包机制

6.1 问题发现

存在这样一个问题：当定义了多个类的时候，可能会发生类名的重复问题。 解决方式：在java中采用包机制处理开发者定义的类名冲突问题。 就好比我们平时的用电脑，一个文件夹下不能存在同名的文件，我们要是有这样的需求，但是又不想换名字，我们就可以考虑使用新建一个文件夹来存放！在我们的Java中也是这样的。

6.2 包的作用

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

• 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。

• 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。

• 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。 Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

包语句的语法格式为：

package pkg1[. pkg[. pkg3...]];

例如，一个Something.java文件它的内容：

package net.java.util;

public class Something{
...
}

那么它的路径应该是 net/java/util/Something.java 这样保存的。 package(包) 的作用是把不同的java 程序分类保存，更方便的被其他 java 程序调用。

一个包（package）可以定义为一组相互联系的类型（类、接口、枚举和注释），为这些类型提供访问保护和命名空间管理的功能。 以下是一些 Java 中的包：

• java.lang- 打包基础的类

• java.io- 包含输入输出功能的函数

开发者可以自己把一组类和接口等打包，并定义自己的包。而且在实际开发中这样做是值得提倡的，当你自己完成类的实现之后，将相关的类分组，可以让其他的编程者更容易地确定哪些类、接口、枚举和注释等是相关的。

由于包创建了新的命名空间（namespace），所以不会跟其他包中的任何名字产生命名冲突。使用包这种机制，更容易实现访问控制，并且让定位相关类更加简单。

6.3 创建包

创建包的时候，你需要为这个包取一个合适的名字。之后，如果其他的一个源文件包含了这个包提供的类、接口、枚举或者注释类型的时候，都必须将这个包的声明放在这个源文件的开头。

包声明应该在源文件的第一行，每个源文件只能有一个包声明，这个文件中的每个类型都应用于它。 如果一个源文件中没有使用包声明，那么其中的类，函数，枚举，注释等将被放在一个无名的包（unnamed package）中。 一般利用公司域名倒置作为包名； 例子： www.baidu.com 包名：com.baidu.www

bbs.baidu.com 包名：com.baidu.bbs

blog.baidu.com 包名：com.baidu.blog

我们平时也可以按照自己的公司域名去写，比如：com.syh.utils

6.3.1 IDEA解决在某个包下创建多个子包，子包不在同一级问题

解决方法：

6. 4 import 关键字

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

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

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

com.syh.blogs.Hello hello = new com.syh.blogs.Hello()

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

import java.io.*;

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

import com.syh.blogs.Hello;

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

7. JavaDoc

7.1 简介

JavaDoc是一种将注释生成HTML文档的技术，生成的HTML文档类似于Java的API，易读且清晰明了。在简略介绍JavaDoc写法之后，再看一下在Intellij Idea 中如何将代码中的注释生成HTML文档。

javadoc是Sun公司提供的一个技术，它从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档。也就是说，只要在编写程序时以一套特定的标签作注释，在程序编写完成后，通过Javadoc就可以同时形成程序的开发文档了。

javadoc命令是用来生成自己API文档的，使用方式：使用命令行在目标文件所在目录输入javadoc +文件名.java。

先看一段样例代码：

/** 这是一个Javadoc测试程序
  * @author syh
  * @version 1.0
  * @since 1.5
  */
public class HelloWorld {
    public String name;
    /**
    * @param name 姓名
    * @return 返回name姓名
    * @throws Exception 无异常抛出
    * */
    public String function(String name) throws Exception{
        return name;
    }
}

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

7.2 命令行生成Doc

//在文件目录下的命令行窗口，输入指令：
javadoc -encoding UTF-8 -charset UTF-8 FileName.java

//解决GBK乱码问题，在中间添加编码设置
encoding UTF-8 -charset UTF-8

7.3 IDEA生成Doc

 

 

 

回顾及总结

这一章，我们学习了Java的基础

• 安装使用了IDEA

• 使用注释

• 了解了Java的关键字

• 数据类型

• 怎么定义一个变量

• 怎么操作这些变量

• 如何生成一篇完整的文档

以后这些东西在我们的生活中会天天遇到！ 不积跬步，无以至千里；不积小流，无以成江海！ 一生二，二生三，三生万物！ 一切一切都说明了基础的重要性！ 所以，简单的东西，不要忽略，高手之间的区分，就在于这些细节方面的东西！

参考

【狂神说Java】

标签：运算符,String,int,基础,System,语法,println,JavaSE,out
来源： https://www.cnblogs.com/syh52/p/16675779.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。