有的小伙伴看到后不理解，为什么是 String[] args，这个 args 是干嘛的？

String[] args 可以看出来它是一个数组。在命令行中比如运行 Test.class 文件,你可以这样写：

java Test runoob

相当于给数组传入了一个 runoob 字符串。也可以打印出来，可以作为简单的输入。

例如：

public class Test {
    public static void main(String[] args) {
        System.out.println(args[0]);
    }
}

运行以上实例，输出结果如下：

$ javac Test.java
$ java Test runoob
runoob

此处注意，main 是一个程序的入口，一个 java 程序运行必须而且有且仅有一个 main 方法。

args[0] 是你传入的第一个参数，args[1]是传入的第二个参数，以此类推。

Java 程序利用 main 函数中 args 参数实现参数的传递(传递空格处理)

public class Test
{
    public static void main(String []args)
    {
        System.out.println(args[0]);
        System.out.println(args[1]);
        System.out.println(args[2]);
    }
}

用控制台编译运行：

$ javac Test.java
$ java Test aaa bbb ccc 
aaa
bbb
ccc

注意：三个参数之间用空格隔开！

如果要输出空格怎么办？

只需要在包含空格的参数上，使用双引号 "" 即可。

实例运行：

$ java Test aaa "b   bb" ccc
aaa
b   bb
ccc

        Java语言其实是有个曾用名的~叫Oak，而且起这个名字的时候也是很随心的，只是因为看到了窗口外的一颗橡树（只是因为面向窗外多看了你一眼~），所以就叫为Oak，但Oak这个名字已经被注册。最后他们以Java这个名字命名了这个语言，据说是Sun公司的程序猿们都很喜欢喝咖啡，而且对爪哇岛的一种咖啡印象很深，所以就有了Java这个经典的名字和咖啡的图标。

"I named Java," said Kim Polese, then the Oak product manager and now CEO of Marimba Inc. "I spent a lot of time and energy on naming Java because I wanted to get precisely the right name. I wanted something that reflected the essence of the technology: dynamic, revolutionary, lively, fun. Because this programming language was so unique, I was determined to avoid nerdy names. I also didn't want anything with 'Net' or 'Web' in it, because I find those names very forgettable. I wanted something that was cool, unique, and easy to spell and fun to say.yin'yong

补充下面向对象程序设计的 3 个主要特征：封装性、继承性、多态性。

封装性（encapsulation）：封装是一种信息隐蔽技术，它体现于类的说明，是对象的重要特性。封装使数据和加工该数据的方法（函数）封装为一个整体，以实现独立性很强的模块，使得用户只能见到对象的外特性（对象能接受哪些消息，具有哪些处理能力），而对象的内特性（保存内部状态的私有数据和实现加工能力的算法）对用户是隐蔽的。封装的目的在于把对象的设计者和对象的使用者分开，使用者不必知晓其行为实现的细节，只须用设计者提供的消息来访问该对象。

继承性：继承性是子类共享其父类数据和方法的机制。它由类的派生功能体现。一个类直接继承其他类的全部描述，同时可修改和扩充。继承具有传递性。继承分为单继承（一个子类有一父类）和多重继承（一个类有多个父类）。类的对象是各自封闭的，如果没继承性机制，则类的对象中的数据、方法就会出现大量重复。继承不仅支持系统的可重用性，而且还促进系统的可扩充性。

多态性：对象根据所接收的消息而做出动作。同一消息被不同的对象接受时可产生完全不同的行动，这种现象称为多态性。利用多态性用户可发送一个通用的信息，而将所有的实现细节都留给接受消息的对象自行决定，如是，同一消息即可调用不同的方法。例如：同样是 run 方法，飞鸟调用时是飞，野兽调用时是奔跑。多态性的实现受到继承性的支持，利用类继承的层次关系，把具有通用功能的协议存放在类层次中尽可能高的地方，而将实现这一功能的不同方法置于较低层次，这样，在这些低层次上生成的对象就能给通用消息以不同的响应。在 OOPL 中可通过在派生类中重定义基类函数（定义为重载函数或虚函数）来实现多态性。

在配置环境变量中：

设置JAVA_HOME:

一是为了方便引用，比如，JDK安装在C:\jdk1.6.0目录里，则设置JAVA_HOME为该目录路径, 那么以后要使用这个路径的时候, 只需输入%JAVA_HOME%即可, 避免每次引用都输入很长的路径串;

二则是归一原则, 当JDK路径改变的时候, 仅需更改JAVA_HOME的变量值即可, 否则,就要更改任何用绝对路径引用JDK目录的文档, 要是万一没有改全, 某个程序找不到JDK, 后果是可想而知的----系统崩溃!

三则是第三方软件会引用约定好的 JAVA_HOME 变量, 不然, 你不能正常使用该软件。

在系统环境变量那一栏中点 -> 新建 JAVA_HOME （JAVA_HOME指向的是JDK的安装路径）

path 变量

path 变量使得我们能够在系统中的任何地方运行java应用程序，比如 javac、java、javah 等等,这就要找到我们安装 JDK 的目录，

假设我们的JDK安装在 C:\jdk1.6.0 目录下,那么在 C:\jdk1.6.0\bin 目录下就是我们常用的 java 应用程序,我们就需要把 C:\jdk1.6.0\bin 这个目录加到 path 环境变量里面。

classpath 变量

classpath 环境变量，是当我们在开发java程序时需要引用别人写好的类时，要让 java 解释器知道到哪里去找这个类。通常，sun 为我们提供了一些额外的丰富的类包，一个是 dt.jar，一个是 tools.jar，这两个 jar 包都位于 C:\jdk1.6.0\lib 目录下，所以通常我们都会把这两个 jar 包加到我们的 classpath 环境变量中 set classpath=.;C:\jdk1.6.0\lib\tools.jar;C:\jdk1.6.0\lib\dt.jar。

注意在完成配置环境变量后测试JDK是否安装成功时键入命令：java -version

为什么要配置 Java 的环境变量呢？如果不搭建环境怎么运行 Java 程序呢?

下面将会演示在没有搭建环境变量的时候怎么运行 Java 程序，本次演示使用的是 1.6 版本的 JDK，还有就是 Windows 的命令提示符。

在安装好 JDK 的前提下，我们在 E:\Test 路径下建一个 Hello.java 的文件，里面就是简单的 Hello World 代码：

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

然后打开命令提示符：切换盘符至 E 盘的 Test 路径下，如图所示，接着运行下面的命令：

其中双引号引起来的是本机的 jdk 安装路径，javac 是编译 Hello.java 文件的指令，运行上面的指令之后会在 E:\Test 的目录下生成 Hello.class 文件，接着使用下面的命令运行 .class 文件，并输出结果：

当我们按照上文说的方法配置好环境变量之后就可以，我们只需要在 E:\Test 路径下输入 javac Hello.java 和 java Hello 这两条命令就可以轻松完成 Hello World! 的输出。

这也说明了我们设置的 Java 环境变量是很有用的，就是能让我们在任何路径之下让我们都能使用 javac 和 java 这两条命令，而不用在前面附带冗长的 JDK 安装路径，能更方便我们工作。

先安装JDK1.8版本后，想要更改JDk版本，直接去修改系统变量JAVA_HOME的话会发现不起作用：原因是安装JDK1.8版本时，会在C:\ProgramData\Oracle\Java目录中生成一些配置文件，并同时将此目录写到环境变量中的Path中，所以我们应该去把系统变量Path中的C:\ProgramData\Oracle\Java\javapath删除了，这样问题就解决了！

一、命名规范

1、 项目名全部小写

2、 包名全部小写

3、 类名首字母大写，如果类名由多个单词组成，每个单词的首字母都要大写。如：public class MyFirstClass{}

4、 变量名、方法名首字母小写，如果名称由多个单词组成，每个单词的首字母都要大写。如：

int index=0;
public void toString(){}

5、 常量名全部大写

如：

public static final String GAME_COLOR="RED";

6、所有命名规则必须遵循以下规则：

• 1)、名称只能由字母、数字、下划线、$符号组成
• 2)、不能以数字开头
• 3)、名称不能使用JAVA中的关键字。
• 4)、坚决不允许出现中文及拼音命名。

二、注释规范

1、类注释

在每个类前面必须加上类注释，注释模板如下：

/**
* Copyright (C), 2006-2010, ChengDu Lovo info. Co., Ltd.
* FileName: Test.java
* 类的详细说明
*
* @author 类创建者姓名
* @Date    创建日期
* @version 1.00
*/

2、属性注释

在每个属性前面必须加上属性注释，注释模板如下：

/** 提示信息 */
private String strMsg = null;

在每个方法前面必须加上方法注释，注释模板如下：

/**
* 类方法的详细使用说明
*
* @param 参数1 参数1的使用说明
* @return 返回结果的说明
* @throws 异常类型.错误代码 注明从此类方法中抛出异常的说明
*/

4、构造方法注释

在每个构造方法前面必须加上注释，注释模板如下：

/**
* 构造方法的详细使用说明
*
* @param 参数1 参数1的使用说明
* @throws 异常类型.错误代码 注明从此类方法中抛出异常的说明
*/

5、方法内部注释

在方法内部使用单行或者多行注释，该注释根据实际情况添加。

如：

//背景颜色
Color bgColor = Color.RED

一个完整的Java。源程序应该包括下列部分：

•  package语句，该部分至多只有一句，必须放在源程序的第一句。
•  import语句，该部分可以有若干import语句或者没有，必须放在所有的类定义之前。
•  public classDefinition，公共类定义部分，至多只有一个公共类的定义，Java语言规定该Java源程序的文件名必须与该公共类名完全一致。
•  classDefinition，类定义部分，可以有0个或者多个类定义。
• interfaceDefinition，接口定义部分，可以有0个或者多个接口定义。

例如：

package javawork.helloworld;
/*把编译生成的所有．class文件放到包javawork.helloworld中*/
import java awt.*;
//告诉编译器本程序中用到系统的AWT包
import javawork.newcentury;
/*告诉编译器本程序中用到用户自定义的包javawork.newcentury*/
 public class HelloWorldApp{...｝
/*公共类HelloWorldApp的定义，名字与文件名相同*/ 
class TheFirstClass｛...｝;
//第一个普通类TheFirstClass的定义 
interface TheFirstInterface{......}
/*定义一个接口TheFirstInterface*/

package语句：由于Java编译器为每个类生成一个字节码文件，且文件名与类名相同因此同名的类有可能发生冲突。为了解决这一问题，Java提供包来管理类名空间，包实 提供了一种命名机制和可见性限制机制。

byte 取值范围

Java 中，byte 占一个字节，取值范围为何是 -128~127？（-2^7~2^7-1）

计算机是用二进制来表示数据的，一个字节也就是 8 个比特位，其中最高位表示符号位（0 正 1 负）。

故 byte 的取值范围为 1000 0000 到 0111 1111。

在 Java 中，是采用补码来表示数据的。

正数的补码和原码相同，负数的补码是在原码的基础上各位取反然后加 1。

1000 000 是补码，减一然后按位取反得到其原码 1000 0000。（减一得 0111 1111，再按位取反得 1000 0000）

因为是负数，所以最小的 byte 值为 -2^7=-128。

0111 1111 的十进制为 2^7-1=127（等比序列求和）。

byte 是一个字节，共有 2^8=256 种可能性，也就是 -128~127。

其他基本数据类型同理：

char 没有负值，占两个字节，所以取值范围是 0~2^16-1（65535）。

java因强制要求类名（唯一的public类）和文件名统一，因此在引用其它类时无需显式声明。在编译时，编译器会根据类名去寻找同名文件。

为什么JAVA文件中只能含有一个Public类?

java 程序是从一个 public 类的 main 函数开始执行的，(其实是main线程)，就像 C 程序 是从 main() 函数开始执行一样。 只能有一个 public 类是为了给类装载器提供方便。 一个 public 类只能定义在以它的类名为文件名的文件中。

每个编译单元(文件)都只有一个 public 类。因为每个编译单元都只能有一个公共接口，用 public 类来表现。该接口可以按照要求包含众多的支持包访问权限的类。如果有一个以上的 public 类，编译器就会报错。 并且 public类的名称必须与文件名相同(严格区分大小写)。 当然一个编译单元内也可以没有 public 类。

类变量类型：

1.局部变量：在方法、构造方法、语句块中定义的变量。其声明和初始化在方法中实现，在方法结束后自动销毁

public class  ClassName{
    public void printNumber（）{
        int a;
    }
    // 其他代码
}

2.成员变量：定义在类中，方法体之外。变量在创建对象时实例化。成员变量可被类中的方法、构造方法以及特定类的语句块访问。

public class  ClassName{
    int a;
    public void printNumber（）{
        // 其他代码
    }
}

3.类变量：定义在类中，方法体之外，但必须要有 static 来声明变量类型。静态成员属于整个类，可通过对象名或类名来调用。

public class  ClassName{
    static int a;
    public void printNumber（）{
        // 其他代码
    }
}

Sometimes, you want to have variables that are common to all objects. This is accomplished with the static modifier. Fields that have the static modifier in their declaration are called static fields or class variables. They are associated with the class, rather than with any object.

以上是 Oracle 对于静态的定义。大意为，有时候，你想拥有所有对象通用的变量。 这是通过静态修改器完成的。 在其声明中具有静态修饰符的字段称为静态字段或类变量。 他们与类相关，而不是与任何对象相关联。

成员变量和局部变量区别

1.声明位置不同

成员变量也就是属性，在类中声明的。

局部变量，在方法中声明或代码块中声明。

2.初始值不同

成员变量如果没有赋值则是有默认值的，数据类型不同则默认值不同。

局部变量是没有默认值，也就是说必须先声明，再赋值，最后才使用。

3.在一个类中，局部变量可以与成员变量同名，但是局部变量优先,如果非要访问成员变量的属性，则必须使用 this.color

this 代表当前这个对象，也就是当前谁调用这个方法则这个对象就是谁。

对象与引用区别

对象是具体的一个实例，如：new Student(); new 表示创建一个对象，并在堆内存中开辟一块空间。

引用名称是存放的对象的地址。

更多内容参考：Java 中 this 和 super 的用法总结。

• this 指向对象本身的指针，形参与成员名字重名，用 this 来区分。
• super 超（父）类对象的一个指针。

对构造函数对引用：

class Person { 
    public static void prt(String s) { 
       System.out.println(s); 
    } 
   
    Person() { 
       prt("父类·无参数构造方法： "+"A Person."); 
    }//构造方法(1) 
    
    Person(String name) { 
       prt("父类·含一个参数的构造方法： "+"A person's name is " + name); 
    }//构造方法(2) 
} 
    
public class Chinese extends Person { 
    Chinese() { 
       super(); // 调用父类构造方法（1） 
       prt("子类·调用父类”无参数构造方法“： "+"A chinese coder."); 
    } 
    
    Chinese(String name) { 
       super(name);// 调用父类具有相同形参的构造方法（2） 
       prt("子类·调用父类”含一个参数的构造方法“： "+"his name is " + name); 
    } 
    
    Chinese(String name, int age) { 
       this(name);// 调用具有相同形参的构造方法（3） 
       prt("子类：调用子类具有相同形参的构造方法：his age is " + age); 
    } 
    
    public static void main(String[] args) { 
       Chinese cn = new Chinese(); 
       cn = new Chinese("codersai"); 
       cn = new Chinese("codersai", 18); 
    } 
}

运行结果：

父类·无参数构造方法： A Person.
子类·调用父类”无参数构造方法“： A chinese coder.
父类·含一个参数的构造方法： A person's name is codersai
子类·调用父类”含一个参数的构造方法“： his name is codersai
父类·含一个参数的构造方法： A person's name is codersai
子类·调用父类”含一个参数的构造方法“： his name is codersai
子类：调用子类具有相同形参的构造方法：his age is 18

错误： CMD 编译 Java 源文件时出现的编码 GBK 的不可映射字符的错误。

办法：使用 javac -encoding UTF-8 .java 指定编码形式。

原因：由于 JDK 是国际版的，在编译的时候，如果我们没有用 -encoding 参数指定 JAVA 源程序的编码格式，则 java.exe 首先获得我们才做系统默认采用的编码格式，也即在编译 JAVA 程序时，若我们不指定源程序文件的编码格式，JDK 首先获得操作系统的 file.encoding 参数（它保存的就是操作系统默认的编码格式，如 win2k，他的值为 GBK），然后 JDK 就把我们的 JAVA 源程序从 file.encoding 编码格式转化为 JAVA 内部默认的 UNICODE 格式放到内存中。之后，javac 把转换后的 UNICODE 格式的文件进行编译成 class 类文件，此时 .class 文件是 UNICODE 编码的，它暂放在内存中，紧接着，JDK 将此以 UNICODE 编码编译后的 .class 文件保存到操作系统中形成我们见到的 .class 文件。但我们不加设置就编译时，相当于使用了参数: javac -encoding gbk xx.java，就会出现不兼容的情况。

简单说下类和对象。

以 LOL 为例。

首先，比如 lol 中的英雄，它就是一个类。因为所有的英雄都有对应的属性。例如：

public class Hero {
    String name; //名字
    int attackDamage; //物理攻击
    int abilityPower; //法术强度
    int armor; //护甲
    int magicResistance; //魔抗
    float attackSpeed; //攻击速度
    int cooldownReduction; //冷却缩减
    int criticalStrike; //暴击率
    int moveSpeed; //移动速度
    int hp; //血量
    int mp; //蓝量
}

除了属性，英雄还有行为。比如拆塔，坑队友，K头，跳舞等。

public class Hero {
    public void DestroyTower(){
        System.out.println("正在拆塔");
    }
    public void Keng(){
        System.out.println("坑了一下队友");
    }
    public void Kb(){
        System.out.println("抢到了一个人头");
    }
    public void Dance(){
        System.out.println("正在跳舞");
    }
}

对象就是指具体的英雄，比如德玛(garen)。就可以在 main 方法中 new 一个对象。

public static void main(String[] args) {
    Hero garen = new Hero();
    garen.name = "盖伦";
    garen.attackDamage = 71;
    garen.abilityPower = 0;
    garen.armor = 36;
    garen.magicResistance = 32;
    garen.attackSpeed = 0.69f;
    garen.cooldownReduction = 0;
    garen.criticalStrike = 0;
    garen.moveSpeed = 350;
    garen.hp = 600;
    garen.mp = 0;
}

long g = (long)9223372036854775807;
long h = (long)-9223372036854775808;

或者

long g = 9223372036854775807;
long h = -9223372036854775808;

会出现以下报错信息：

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
The literal 9223372036854775807 of type int is out of range
The literal 9223372036854775808 of type int is out of range 

溢出了~

解决方法在数值后面加上 L：

long value = 9223372036854775807L;

short a = 1;
short b = 2;

那么 a+b 是什么类型？

答：在java的世界里，如果比int类型小的类型做运算，java在编译的时候就会将它们统一强转成int类型。当是比int类型大的类型做运算，就会自动转换成它们中最大类型那个。

数据类型转换的补充

1、包装类过渡类型转换

一般情况下，我们首先声明一个变量，然后生成一个对应的包装类，就可以利用包装类的各种方法进行类型转换了。例如：

当希望把float型转换为double型时：

float f1=100.00f;
Float F1=new Float(f1);
double d1=F1.doubleValue();//F1.doubleValue()为Float类的返回double值型的方法

简单类型的变量转换为相应的包装类，可以利用包装类的构造函数。即：Boolean(boolean value)、Character(char value)、Integer(int value)、Long(long value)、Float(float value)、Double(double value)

而在各个包装类中，总有形为××Value()的方法，来得到其对应的简单类型数据。利用这种方法，也可以实现不同数值型变量间的转换，例如，对于一个双精度实型类，intValue()可以得到其对应的整型变量，而doubleValue()可以得到其对应的双精度实型变量。

2、字符串与其它类型间的转换

其它类型向字符串的转换

• 调用类的串转换方法:X.toString();
• 自动转换:X+"";
• 使用String的方法:String.valueOf(X);

3、字符串作为值,向其它类型的转换

1、先转换成相应的封装器实例,再调用对应的方法转换成其它类型

例如，字符中"32.1"转换double型的值的格式为:new Float("32.1").doubleValue()。也可以用:Double.valueOf("32.1").doubleValue()

2、静态parseXXX方法

String s = "1";
byte b = Byte.parseByte( s );
short t = Short.parseShort( s );
int i = Integer.parseInt( s );
long l = Long.parseLong( s );
Float f = Float.parseFloat( s );
Double d = Double.parseDouble( s );

3、Character的getNumericValue(char ch)方法

4、Date类与其它数据类型的相互转换

整型和Date类之间并不存在直接的对应关系，只是你可以使用int型为分别表示年、月、日、时、分、秒，这样就在两者之间建立了一个对应关系，在作这种转换时，你可以使用Date类构造函数的三种形式：

• Date(int year, int month, int date)：以int型表示年、月、日
• Date(int year, int month, int date, int hrs, int min)：以int型表示年、月、日、时、分
• Date(int year, int month, int date, int hrs, int min, int sec)：以int型表示年、月、日、时、分、秒

在长整型和Date类之间有一个很有趣的对应关系，就是将一个时间表示为距离格林尼治标准时间1970年1月1日0时0分0秒的毫秒数。对于这种对应关系，Date类也有其相应的构造函数：Date(long date)。

获取Date类中的年、月、日、时、分、秒以及星期你可以使用Date类的getYear()、getMonth()、getDate()、getHours()、getMinutes()、getSeconds()、getDay()方法，你也可以将其理解为将Date类转换成int。

而Date类的getTime()方法可以得到我们前面所说的一个时间对应的长整型数，与包装类一样，Date类也有一个toString()方法可以将其转换为String类。

有时我们希望得到Date的特定格式，例如20020324，我们可以使用以下方法，首先在文件开始引入：

import java.text.SimpleDateFormat;

java.util.Date date = new java.util.Date();
//如果希望得到YYYYMMDD的格式
SimpleDateFormat sy1=new SimpleDateFormat("yyyyMMdd");
String dateFormat=sy1.format(date);
//如果希望分开得到年，月，日
SimpleDateFormat sy=new SimpleDateFormat("yyyy");
SimpleDateFormat sm=new SimpleDateFormat("MM");
SimpleDateFormat sd=new SimpleDateFormat("dd");
String syear=sy.format(date);
String smon=sm.format(date);
String sday=sd.format(date);

总结：

1、只有 boolean 不参与数据类型的转换

2、自动类型的转换：

• a.常数在表数范围内是能够自动类型转换的
• b.数据范围小的能够自动数据类型大的转换（注意特例）
• float 到 int，float 到 long，double 到 int，double 到 long 等由浮点类型转换成整数类型时，是不会自动转换的，不然将会丢失精度。
• c.引用类型能够自动转换为父类的
• d.基本类型和它们包装类型是能够互相转换的

3、强制类型转换：用圆括号括起来目标类型，置于变量前

包装类 Integer 的自动封装

Integer a = 1;

int 类型在赋值到 Integer 类时，会自动封装，调用 Integer 的 valueOf(int i) 方法。

Integer a = Integer.valueOf(1);

/**
 * Returns an {@code Integer} instance representing the specified
 * {@code int} value.  If a new {@code Integer} instance is not
 * required, this method should generally be used in preference to
 * the constructor {@link #Integer(int)}, as this method is likely
 * to yield significantly better space and time performance by
 * caching frequently requested values.
 *
 * This method will always cache values in the range -128 to 127,
 * inclusive, and may cache other values outside of this range.
 *
 * @param  i an {@code int} value.
 * @return an {@code Integer} instance representing {@code i}.
 * @since  1.5
 */
public static Integer valueOf(int i) {
    assert IntegerCache.high >= 127;
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

当 i >= -128 && i <= 127 时，Integer.valueOf(i) 会将 i 存储在内部类 IntegerCache的static final Integer cache[]里，这一字节的缓存内存地址是静态的，返回值即:

IntegerCache.cache[i + (-IntegerCache.low)]

因此:

Integer a = 1; 
Integer b = 1;

a 和 b 的引用都指向同一个对象，即 a == b。