JAVA基本语法

编写JAVA程序时，应注意以下五点：

  • 大小写敏感：不做过多解释，比如hello和Hello是不同的
  • 类名：对所有类来说，类名的首字母应该大写。建议采用“驼峰命名法”，就是说如果由若干单词组成的类名，每个单词的首字母应该大写，比如CuteFlyingPig。
  • 方法名：所有的方法名都应该以小写字母开头。同样采用“驼峰”命名法，比如pigCanFlay();
  • 源文件名：源文件名必须和类名相同。当保存文件时，应该使用类名作为文件名保存（万分注意：JAVA大小写敏感！JAVA大小写敏感！JAVA大小写敏感！），文件后缀名为.java。否则，文件名和类名不一致会导致编译错误。
  • 主方法入口：左右的Java程序都是由public static void main(String[] args)方法开始执行的。

Java 对象和类

Java作为一种面向对象语言，支持以下基本概念：多态、继承、封装、抽象、类、对象、实例、方法、重载等。

源文件声明规则

当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则：

  • 一个源文件智能有一个public类
  • 一个源文件可以有多个非public类
  • 源文件的名称应该和public类的类名保持一致。例如，源文件中public类的类名是Nantong，那么源文件import语句应该在源文件中的最前面
  • import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

Java 基本数据类型

Java的两大数据类型：内置数据类型、引用数据类型。

实际上，Java中还存在另外一种基本数据类型void，它也有对应的包装类java.lang.Void，不过我们无法直接对他们进行操作。

类型默认值

下表列出了Java各个类型的默认值：

数据类型

默认值

数据类型 默认值
byte 0
short 0
int 0
long 0L
float 0.0f
double 0.0d
char 'u0000'
String (or any object) null
boolean false

引用类型

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

Java 常量

Java语言支持一些特殊的转义字符序列。

符号 字符含义
\n 换行 (0x0a)
\r 回车 (0x0d)
\f 换页符(0x0c)
\b 退格 (0x08)
\0 空字符 (0x20)
\s 字符串
\t 制表符
\" 双引号
\' 单引号
\\ 反斜杠
\ddd 八进制字符 (ddd)
\uxxxx 16进制Unicode字符 (xxxx)

自动类型转换

整型、实型（常量）、字符型数据可以混合运算。在运算中。不同类型的数据先转化为同一类型，然后进行运算。转换从低级到高级：

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

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

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

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

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

  • 转换过程中可能导致溢出或损失精度，例如(因为byte类型是8位，最大值是127,所以当int强制转换为byte类型时，值128会导致溢出):

    int i = 128;
    byte b = (byte)i;

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

    (int)45.6 == 45;
    (int)-88.33f == -88;

自动类型转换必须满足转换前的数据类型的位数要低于转换后的数据类型。

Java 变量类型

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

  • 类变量（静态变量）：独立于方法之外的变量，用static修饰，但必须在方法之外。
  • 实例变量：独立于方法之外的变量，不过没有用static修饰。实例变量可以声明在使用前或者使用后。
  • 局部变量：类的方法中的变量，局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用

Java 修饰符

Java的修饰符主要分为两类：访问修饰符和非访问修饰符。

访问修饰符具体访问权限如下表所示：

访问控制表
修饰符 当前类 同一包内 子孙类(同一包) 子孙类(不同包) 其他包
public Y Y Y Y Y
protected Y Y Y Y/N（说明） N
default Y Y Y N N
private Y N N N N

final 类：final类不能被继承，没有类能继承final类的任何特性。

抽象类：抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。一个类不能同时被abstract和final修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。抽象类可以包含抽象方法和非抽象方法。
比如：

abstract class Caravan{
   private double price;
   private String model;
   private String year;
   public abstract void goFast(); //抽象方法
   public abstract void changeColor();
}

抽象方法：抽象方法是一种没有任何实现的方法，该方法的具体实现由子类提供。抽象方法不能被声明为final和static。任何继承抽象类的子类必须实现父类的所有抽象方法，除非子类也是抽象类。抽象类可以不包括抽象方法。抽象方法的声明以分号结尾，例如public abstract sample();。

public abstract class SuperClass{
    abstract void m(); //抽象方法
}
 
class SubClass extends SuperClass{
     //实现抽象方法
      void m(){
          .........
      }
}

synchronized 修饰符

synchronized关键字声明的方法同一时间只能被一个线程访问。synchronized修饰符可以应用于四个访问修饰符。

public synchronized void showDetails(){
.......
}

transient 修饰符

序列化的对象包含被transient修饰的实例变量时，java虚拟机（JVM）跳过该特定的变量。
该修饰符包含在定义变量的语句中，用来预处理变量和类的数据类型。

public transient int limit = 55;   // 不会持久化
public int b; // 持久化

volatile 修饰符

volatile修饰的成员在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内训。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
一个volatil对象可能是null。

public class MyRunnable implements Runnable
{
    private volatile boolean active;
    public void run()
    {
        active = true;
        while (active) // 第一行
        {
            // 代码
        }
    }
    public void stop()
    {
        active = false; // 第二行
    }
}

通常情况下，在一个线程调用 run() 方法（在 Runnable 开启的线程），在另一个线程调用 stop() 方法。 如果 第一行 中缓冲区的 active 值被使用，那么在 第二行 的 active 值为 false 时循环不会停止。

但是以上代码中我们使用了 volatile 修饰 active，所以该循环会停止。