Java笔记：语法基础

更新时间：2018-1-7 10:34:05

更多请查看在线文集：http://android.52fhy.com/java/index.html

---

Hello World

文件名：HelloWorld.java

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

注意：

1、文件名需与类名一致，如果文件名和类名不相同则会导致编译错误

2、区分大小写

3、区分单引号双引号，双引号表示字符串

4、所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。

5、所有的Java 程序由public static void main(String []args)方法开始执行

源文件声明规则

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

• 一个源文件中只能有一个public类
• 一个源文件可以有多个非public类
• 源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是Employee，那么源文件应该命名为Employee.java。
• 如果一个类定义在某个包中，那么package语句应该在源文件的首行。
• 如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。
• import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

类有若干种访问级别，并且类也分不同的类型：抽象类和final类等。

除了上面提到的几种类型，Java还有一些特殊的类，如：内部类、匿名类。

如何编译

javac HelloWorld.java
java HelloWorld

javac 命令用于将 java 源文件编译为 class 字节码文件，如： javac HelloWorld.java。

运行javac命令后，如果成功编译没有错误的话，会出现一个 HelloWorld.class 的文件。

java 命令可以运行 class 字节码文件，如: java HelloWorld。

注意：

java命令后面不要加.class。

如果含有包名，编译的时候需要给出相对路径，运行的时候需要带上包名。例如包名是test，代码在test目录下:

javac test/HelloWorld.java
java test.HelloWorld

Java标识符

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

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

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

首字符之后可以是任何字符的组合

关键字不能用作标识符

标识符是大小写敏感的

Java修饰符

像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：

可访问修饰符 : default, public , protected, private

不可访问修饰符 : final, abstract, strictfp

Java变量

Java中主要有如下几种类型的变量

局部变量

类变量（静态变量）

成员变量（非静态变量）

Java注释

类似于C/C++，Java也支持单行以及多行注释。注释中的字符将被Java编译器忽略。

//这是注释

/**
* 这是注释
*/

Java数组

数组是储存在堆上的对象，可以保存多个同类型变量。

Java中有数组(array)。数组包含相同类型的多个数据。下面方法声明一个整数数组:

int[] a;

在声明数组时，数组所需的空间并没有真正分配给数组。可以在声明的同时，用new来创建数组所需空间:

int[] a = new int[100];

这里创建了可以容纳100个整数的数组。相应的内存分配也完成了。

还可以在声明的同时，给数组赋值。数组的大小也同时确定。

int[] a = new int[] {1, 3, 5, 7, 9};

使用int[i]来调用数组的i下标元素。i从0开始。

Java 基本数据类型

变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。

内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。

因此，通过定义不同类型的变量，可以在内存中储存整数、小数或者字符。

Java的两大数据类型:

• 内置数据类型
• 引用数据类型

内置数据类型

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

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;

int：int数据类型是32位、有符号的以二进制补码表示的整数；最小值是-2,147,483,648（-2^{31）；最大值是`2,147,485,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;

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;

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

boolean one = true;

char：char类型是一个单一的16位Unicode字符；最小值是\u0000（即为0）；最大值是\uffff（即为65,535）；char数据类型可以储存任何字符；例子：

char letter = 'A';

示例：

public class PrimitiveTypeTest {
    public static void main(String[] args) {
        // byte
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);
        System.out.println("包装类：java.lang.Byte");
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);
        System.out.println();  

        // short
        System.out.println("基本类型：short 二进制位数：" + Short.SIZE);
        System.out.println("包装类：java.lang.Short");
        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);
        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);
        System.out.println();  

        // int
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);
        System.out.println("包装类：java.lang.Integer");
        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);
        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);
        System.out.println();  

        // long
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);
        System.out.println("包装类：java.lang.Long");
        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);
        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);
        System.out.println();  

        // float
        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);
        System.out.println("包装类：java.lang.Float");
        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);
        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);
        System.out.println();  

        // double
        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);
        System.out.println("包装类：java.lang.Double");
        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);
        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);
        System.out.println();  

        // char
        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);
        System.out.println("包装类：java.lang.Character");
        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
        System.out.println("最小值：Character.MIN_VALUE="
                + (int) Character.MIN_VALUE);
        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
        System.out.println("最大值：Character.MAX_VALUE="
                + (int) Character.MAX_VALUE);
    }
}

引用类型

引用类型变量由类的构造函数创建，可以使用它们访问所引用的对象。这些变量在声明时被指定为一个特定的类型，比如String、Employee、Pubby等。变量一旦声明后，类型就不能被改变了。

对象、数组都是引用数据类型。

所有引用类型的默认值都是null。

一个引用变量可以用来引用与任何与之兼容的类型。

例子：

Site site = new Site("Runoob");

注意：8个基本类型是值类型，其他都是引用。String类型是引用类型，然而这个引用类型比较特殊，它指向一个字符串，这个字符串的值不能够改变。

Java常量

常量在程序运行时，不会被修改的量。

在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：

final double PI = 3.1415927;

虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。

和其他语言一样，Java的字符串常量也是包含在双引号之间的字符序列。下面是字符串型字面量的例子：

"Hello World"
"two\nlines"
"\"This is in quotes\""

字符串常量和字符常量都可以包含任何Unicode字符。例如：

char a = '\u0001';
String a = "\u0001";

Java枚举

Java 5.0引入了枚举，枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的bug。

例如，我们为果汁店设计一个程序，它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。

FreshJuiceTest.java

class FreshJuice{
	enum FreshJuiceSize {S,M,L}
	FreshJuiceSize size;
}

public class FreshJuiceTest{
	public static void main(String[] args){
			FreshJuice juice = new FreshJuice();
			juice.size = FreshJuice.FreshJuiceSize.M;

			System.out.print(juice.size);
	}
}

Java 空行

空白行，或者有注释的的行，Java编译器都会忽略掉。

Java 对象和类

Java作为一种面向对象语言。支持以下基本概念：

多态

继承

封装

抽象

类

对象

实例

方法

重载

Java中的类

通过下面一个简单的类来理解下Java中类的定义：

public class Dog{
   String breed;
   int age;
   String color;
   static int a = 0;

   void barking(){
   		int b;
   }

   void hungry(){
   }

   void sleeping(){
   }
}

一个类可以包含以下类型变量：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。例如b。

成员变量（实例变量）：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。例如breed,age,color。

类变量（或静态变量）：类变量也声明在类中，方法体之外，但必须声明为static类型。例如a。

构造方法

每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。

在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

下面是一个构造方法示例：

public class Puppy{
   public Puppy(){
   }

   public Puppy(String name){
      // 这个构造器仅有一个参数：name
   }

   //普通方法
   public void say(){
   		System.out.println("hello");
   }
}

创建对象

对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：

声明：声明一个对象，包括对象名称和对象类型。

实例化：使用关键字new来创建一个对象。

初始化：使用new创建对象时，会调用构造方法初始化对象。

下面是一个创建对象的例子：

public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数：name
      System.out.println("Passed Name is :" + name );
   }
   public static void main(String []args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

编译并运行上面的程序，会打印出下面的结果：

Passed Name is :tommy

通过.符号访问实例变量和方法:

myPuppy.say();

实例：

public class Puppy{
   int puppyAge;
   public Puppy(String name){
      // 这个构造器仅有一个参数：name
      System.out.println("Passed Name is :" + name );
   }

   public void setAge( int age ){
       puppyAge = age;
   }

   public int getAge( ){
       System.out.println("Puppy's age is :" + puppyAge );
       return puppyAge;
   }

   public static void main(String []args){
      /* 创建对象 */
      Puppy myPuppy = new Puppy( "tommy" );
      /* 通过方法来设定age */
      myPuppy.setAge( 2 );
      /* 调用另一个方法获取age */
      myPuppy.getAge( );
      /*你也可以像下面这样访问成员变量 */
      System.out.println("Variable Value :" + myPuppy.puppyAge );
   }
}

编译时如果提示：警告：编码GBK的不可映射字符

可以加编码：

javac Puppy.java -encoding UTF-8
java Puppy

注意本例中成员变量没有加this。

this是指的对象本身，通过this可以调用本对象拥有的所有方法和属性，当然不加this也可以调用。

一般用this的情况：

当局部变量与成员变量相同名时,例如 this,x = x;this.x 是个成员变量，而x是个局部变量

在myeclipse下用this可以提示后面的方法或者成员变量

在内部类或匿名内部类中使用this来指向内部类本身

将类本省作为参数传递

Java包

包主要用来对类和接口进行分类。当开发Java程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。

使用import导入包,使用package定义包。

如果一个类定义在某个包中，那么package语句应该在源文件的首行。

如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。

例如，下面的命令行将会命令编译器载入java_installation/java/io路径下的所有类

import java.io.*;

Java 修饰符

Java语言提供了很多修饰符，主要分为以下两类：

访问修饰符

非访问修饰符

修饰符用来定义类、方法或者变量，通常放在语句的最前端。

访问控制修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java支持4种不同的访问权限。

默认的，也称为 default，在同一包内可见，不使用任何修饰符。

私有的，以 private 修饰符指定，在同一类内可见。

共有的，以 public 修饰符指定，对所有类可见。

受保护的，以 protected 修饰符指定，对同一包内的类和所有子类可见。

访问控制和继承

请注意以下方法继承的规则：

父类中声明为public的方法在子类中也必须为public。

父类中声明为protected的方法在子类中要么声明为protected，要么声明为public。不能声明为private。

父类中声明为private的方法，不能够被继承。

非访问修饰符

为了实现一些其他的功能，Java也提供了许多非访问修饰符。

static修饰符，用来创建类方法和类变量。

Final修饰符，用来修饰类、方法和变量，final修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

Abstract修饰符，用来创建抽象类和抽象方法。一个类不能同时被abstract和final修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。抽象类可以包含抽象方法和非抽象方法。

Synchronized和volatile修饰符，主要用于线程的编程。Synchronized关键字声明的方法同一时间只能被一个线程访问。

继承

在Java中，一个类可以由其他类派生。如果你要创建一个类，而且已经存在一个类具有你所需要的属性或方法，那么你可以将新创建的类继承该类。

利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（subclass）。

接口

在Java中，接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。

接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。

Java 运算符

计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组：

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

关系运算符: == != > < >= <=

位运算符: & | ^ ~ << >> >>>

逻辑运算符: && || !

赋值运算符: = += -= *= /= (%)= <<= >>= &= |= ^=

其他运算符: ( ? : ) instanceOf

Java 循环结构

Java中有三种主要的循环结构：

while循环

do…while循环

for循环

while循环

while是最基本的循环，它的结构为：

while( 布尔表达式 ) {
	//循环内容
}

do…while循环

do…while循环和while循环相似，不同的是，do…while循环至少会执行一次。

do {
       //代码语句
}while(布尔表达式);

for循环

for循环执行的次数是在执行前就确定的。语法格式如下：

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

Java增强for循环

Java5引入了一种主要用于数组的增强型for循环。

Java增强for循环语法格式如下:

for(声明语句 : 表达式)
{
   //代码句子
}

示例：

public class Test {

   public static void main(String args[]){
      int [] numbers = {10, 20, 30, 40, 50};

      for(int x : numbers ){
         System.out.print( x );
         System.out.print(",");
      }
      System.out.print("\n");
      String [] names ={"James", "Larry", "Tom", "Lacy"};
      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}

break关键字

break主要用在循环语句或者switch语句中，用来跳出整个语句块。

break跳出最里层的循环，并且继续执行该循环下面的语句。

continue关键字

continue适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

在for循环中，continue语句使程序立即跳转到更新语句。

在while或者do…while循环中，程序立即跳转到布尔表达式的判断语句。

Java 分支结构

顺序结构只能顺序执行，不能进行判断和选择，因此需要分支结构。

Java有两种分支结构：

if语句

switch语句

if语句

一个if语句包含一个布尔表达式和一条或多条语句。

If语句的用语法如下：

if(布尔表达式)
{
   //如果布尔表达式为true将执行的语句
}

if...else语句

if语句后面可以跟else语句，当if语句的布尔表达式值为false时，else语句块会被执行。

if…else的用法如下：

if(布尔表达式){
   //如果布尔表达式的值为true
}else{
   //如果布尔表达式的值为false
}

if...else if...else语句

if(布尔表达式 1){
   //如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
   //如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
   //如果布尔表达式 3的值为true执行代码
}else {
   //如果以上布尔表达式都不为true执行代码
}

switch语句

switch语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

switch语法格式如下：

switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}