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数据类型表示一位的信息;只有两个取值:truefalse;这种类型只作为一种标志来记录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 : //可选
       //语句
}
posted @ 2018-01-07 23:11 飞鸿影 阅读(...) 评论(...) 编辑 收藏