JAVA学习资料（3）————基本语法、标识符、常量、变量类型、引用类型

  说不出一句话，来写博客吧，可能，看到这篇博客的时候，我们会是什么样子呢，想象不到，真的想象不到。这节课啊，还是基础知识，看起来晦涩难懂，如果看不懂，可以先看第四课，或者后面学到看不懂的变量了，再回来看这节课。

一、基本语法

  编写 Java 程序时，应注意以下几点：

• 大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
• 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
• 方法（类中的函数）名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
• 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。
• 主方法（主函数）入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。

二、标识符

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

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

• 所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（KaTeX parse error: Expected 'EOF', got '&' at position 14: ）、或者下划线（_）开始 &̲emsp; 首字符之…）、下划线（_）或数字的任何字符组合
• 关键字不能用作标识符
• 合法标识符举例：age、$salary、_value、__1_value
• 非法标识符举例：123abc、-salary

三、数据类型

1、内置数据类型

  Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

char：

• char类型是一个单一的 16 位 Unicode 字符；
• 最小值是 \u0000（即为 0）；
• 最大值是 \uffff（即为 65535）；
• char 数据类型可以储存任何字符；
• 例子：char letter = ‘A’;。

int：

• int 数据类型是32位、有符号的以二进制补码表示的整数；
• 最小值是 -2,147,483,648（-2^31）；
• 最大值是 2,147,483,647（2^31 - 1）；
• 一般地整型变量默认为 int 类型；
• 默认值是 0 ；
• 例子：int a = 100000, int b = -200000。

long：

• long 数据类型是 64 位、有符号的以二进制补码表示的整数；
• 最小值是 -9,223,372,036,854,775,808（-2^63）；
• 最大值是 9,223,372,036,854,775,807（2^63 -1）；
• 这种类型主要使用在需要比较大整数的系统上；
• 默认值是 0L；
• 例子： long a = 100000L，Long b = -200000L。
• "L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

float：

• float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
• float 在储存大型浮点数组的时候可节省内存空间；
• 默认值是 0.0f；
• 浮点数不能用来表示精确的值，如货币；
• 例子：float f1 = 234.5f。

double：

• double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
• 浮点数的默认类型为double类型；
• double类型同样不能表示精确的值，如货币；
• 默认值是 0.0d；
• 例子：double d1 = 123.4。

（以下内容非重点）
byte：

• byte 数据类型是8位、有符号的，以二进制补码表示的整数；
• 最小值是 -128（-2^7）；
• 最大值是 127（2^7-1）；
• 默认值是 0；
• byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
• 例子：byte a = 100，byte b = -50。

short：

• short 数据类型是 16 位、有符号的以二进制补码表示的整数
• 最小值是 -32768（-2^15）；
• 最大值是 32767（2^15 - 1）；
• Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
• 默认值是 0；
• 例子：short s = 1000，short r = -20000。

boolean：

• boolean数据类型表示一位的信息；
• 只有两个取值：true 和 false；
• 这种类型只作为一种标志来记录 true/false 情况；
• 默认值是 false；
• 例子：boolean one = true。

三、常量

常量在程序运行时是不能被修改的。
在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：
final double PI = 3.1415927;
虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。

四、变量类型

Java语言支持的变量类型有：

• 类变量：独立于函数之外的变量，用 static 修饰。
• 实例变量：独立于函数之外的变量，不过没有 static 修饰。
• 局部变量：类的函数中的变量。

例如：

public class Maomao{
    static int a=0;    // 类变量
    float b=13.14;  // 实例变量
    public void hanshu()
    {
        int c =0;  // 局部变量
    }
}

  这里要注意哦，对于类变量和实例变量，如果不用这个类，那就无法用这个变量，所以这个变量是要通过调用这个类来使用的。
  对于局部变量，如果不用这个函数，或是在这个函数外，那这个局部变量就像个死人一样，什么都做不了，也无法访问

五、引用类型（很少使用，随便看看就好）

• 在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如
  Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
• 对象、数组都是引用数据类型。
• 所有引用类型的默认值都是null。
• 一个引用变量可以用来引用任何与之兼容的类型。
• 例子：Site site = new Site(“Runoob”)。

详细说明如下：

  在 Java 中一切都被视为了对象，但是我们操作的标识符实际上是对象的一个引用(reference)。

//创建一个引用，引用可以独立存在，并不一定需要与一个对象关联
String s;

  通过将这个叫“引用”的标识符指向某个对象，之后便可以通过这个引用来实现操作对象了。
  在 JDK1.2 之前，Java中的定义很传统：如果 reference 类型的数据中存储的数值代表的是另外一块内存的起始地址，就称为这块内存代表着一个引用。
  Java 中的垃圾回收机制在判断是否回收某个对象的时候，都需要依据“引用”这个概念。
  在不同垃圾回收算法中，对引用的判断方式有所不同：
  引用计数法：为每个对象添加一个引用计数器，每当有一个引用指向它时，计数器就加1，当引用失效时，计数器就减1，当计数器为0时，则认为该对象可以被回收(目前在Java中已经弃用这种方式了)。
  可达性分析算法：从一个被称为 GC Roots 的对象开始向下搜索，如果一个对象到GC Roots没有任何引用链相连时，则说明此对象不可用。
  JDK1.2 之前，一个对象只有“已被引用”和"未被引用"两种状态，这将无法描述某些特殊情况下的对象，比如，当内存充足时需要保留，而内存紧张时才需要被抛弃的一类对象。

四种引用类型

  所以在 JDK.1.2 之后，Java 对引用的概念进行了扩充，将引用分为了：强引用(Strong Reference)、软引用(Soft Reference)、弱引用(Weak Reference)、虚引用(Phantom Reference)4 种，这 4 种引用的强度依次减弱。

一，强引用

  Java中默认声明的就是强引用，比如：
  Object obj = new Object(); //只要obj还指向Object对象，Object对象就不会被回收
  obj = null; //手动置null

  只要强引用存在，垃圾回收器将永远不会回收被引用的对象，哪怕内存不足时，JVM也会直接抛出OutOfMemoryError，不会去回收。如果想中断强引用与对象之间的联系，可以显示的将强引用赋值为null，这样一来，JVM就可以适时的回收对象了

二，软引用

  软引用是用来描述一些非必需但仍有用的对象。在内存足够的时候，软引用对象不会被回收，只有在内存不足时，系统则会回收软引用对象，如果回收了软引用对象之后仍然没有足够的内存，才会抛出内存溢出异常。这种特性常常被用来实现缓存技术，比如网页缓存，图片缓存等。
  在 JDK1.2 之后，用java.lang.ref.SoftReference类来表示软引用。
  下面以一个例子来进一步说明强引用和软引用的区别：
  在运行下面的Java代码之前，需要先配置参数 -Xms2M -Xmx3M，将 JVM 的初始内存设为2M，最大可用内存为 3M。
  首先先来测试一下强引用，在限制了 JVM 内存的前提下，下面的代码运行正常

public class TestOOM 
{
		public static void main(String[] args) 
		{
		testStrongReference();
		}
		
		private static void testStrongReference() 
		{
		// 当 new byte为 1M 时，程序运行正常
		byte[] buff = new byte[1024 * 1024 * 1];
		}
}

  但是如果我们将
  byte[] buff = new byte[1024 * 1024 * 1];
  替换为创建一个大小为 2M 的字节数组
  byte[] buff = new byte[1024 * 1024 * 2];
  则内存不够使用，程序直接报错，强引用并不会被回收

  接着来看一下软引用会有什么不一样，在下面的示例中连续创建了 10 个大小为 1M 的字节数组，并赋值给了软引用，然后循环遍历将这些对象打印出来。

public class TestOOM 
{
private static List list = new ArrayList<>();
public static void main(String[] args) {
testSoftReference();
}
private static void testSoftReference() {
for (int i = 0; i < 10; i++) {
byte[] buff = new byte[1024 * 1024];
SoftReference sr = new SoftReference<>(buff);
list.add(sr);
}
System.gc(); //主动通知垃圾回收
for(int i=0; i < list.size(); i++){
Object obj = ((SoftReference) list.get(i)).get();
System.out.println(obj);
}

  我们发现无论循环创建多少个软引用对象，打印结果总是只有最后一个对象被保留，其他的obj全都被置空回收了。
  这里就说明了在内存不足的情况下，软引用将会被自动回收。
  值得注意的一点 , 即使有 byte[] buff 引用指向对象, 且 buff 是一个strong reference, 但是 SoftReference sr 指向的对象仍然被回收了，这是因为Java的编译器发现了在之后的代码中, buff 已经没有被使用了, 所以自动进行了优化。
  如果我们将上面示例稍微修改一下：

private static void testSoftReference() {
byte[] buff = null;
for (int i = 0; i < 10; i++) {
buff = new byte[1024 * 1024];
SoftReference sr = new SoftReference<>(buff);
list.add(sr);
}
System.gc(); //主动通知垃圾回收
for(int i=0; i < list.size(); i++){
Object obj = ((SoftReference) list.get(i)).get();
System.out.println(obj);
}
System.out.println("buff: " + buff.toString());
}

  则 buff 会因为强引用的存在，而无法被垃圾回收，从而抛出OOM的错误。
  如果一个对象惟一剩下的引用是软引用，那么该对象是软可及的(softly reachable)。垃圾收集器并不像其收集弱可及的对象一样尽量地收集软可及的对象，相反，它只在真正 “需要” 内存时才收集软可及的对象。

三，弱引用

  虚引用是最弱的一种引用关系，如果一个对象仅持有虚引用，那么它就和没有任何引用一样，它随时可能会被回收，在 JDK1.2 之后，用 PhantomReference 类来表示，通过查看这个类的源码，发现它只有一个构造函数和一个 get() 方法，而且它的 get() 方法仅仅是返回一个null，也就是说将永远无法通过虚引用来获取对象，虚引用必须要和 ReferenceQueue 引用队列一起使用。
  那么传入它的构造方法中的 ReferenceQueue 又是如何使用的呢？

四，引用队列(ReferenceQueue)

  引用队列可以与软引用、弱引用以及虚引用一起配合使用，当垃圾回收器准备回收一个对象时，如果发现它还有引用，那么就会在回收对象之前，把这个引用加入到与之关联的引用队列中去。程序可以通过判断引用队列中是否已经加入了引用，来判断被引用的对象是否将要被垃圾回收，这样就可以在对象被回收之前采取一些必要的措施。

  与软引用、弱引用不同，虚引用必须和引用队列一起使用。