Java总结：语法基础

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
lines"
""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("
");
      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 : //可选
       //语句
}
```
相关阅读:
C语言中字符串常用函数--strcat，strcpy
linux下core dump【总结】
C语言memset()函数：将内存的前n个字节设置为特定的值
 const的理解、const指针、指向const的指针
 C99标准的新特性
 ISO C语言新标准(C11)
哪个版本的gcc才支持c11
不使用session，借助redis实现验证码
 google浏览器截图工具 Open Screenshot（代码截图）
springmvc+jpa实现分页的两种方式
原文地址：https://www.cnblogs.com/52fhy/p/8232805.html

Java总结：语法基础

Hello World

如何编译

Java标识符

Java修饰符

Java变量

Java注释

Java数组

Java 基本数据类型

内置数据类型

引用类型

Java常量

Java枚举

Java 空行

Java 对象和类

Java中的类

构造方法

创建对象

Java包

Java 修饰符

访问控制修饰符

非访问修饰符

继承

接口

Java 运算符

Java 循环结构

while循环

do…while循环

for循环

Java增强for循环

break关键字

continue关键字

Java 分支结构

if语句

if...else语句

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

switch语句