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 : //可选
       //语句
}

原文地址：https://www.cnblogs.com/52fhy/p/8232805.html

时间： 2024-10-12 22:02:01

Java笔记：语法基础的相关文章

Java 笔记之基础复习

1.& 与 &&的区别 两个都有逻辑与的功能.但是所不同的是,当&两边的表达式不是boolean类型的时候,&具有位与的功能:&&是短路与,当判断到前一个表达式为false的时候,将不会再去计算后面的表达式. 如: int i = 0; System.out.println((1==0)&(0==(i++))); System.out.println(i); 输出是: false 1 但是, int i = 0; System.out.pri

java笔记--多线程基础

多线程技术 在java中实现多线程技术有两种方式: 1.继承Thread类: 2.实现Runnable接口 这两种方法都需要重写run()方法:通常将一个新线程要运行的代码放在run()方法中(这是创建没有返回值线程的方法)由于java只支持单继承,当类已经继承有其他类时,只能选择实现Runnable接口在启动线程时需要使用Thread类的start()方法,而不是直接使用run()方法: 如: public static void function() { for (int i = 0; i

c++笔记——语法基础1

c++笔记将记载一个温习路径,也算一个快速学习的参考吧!(不一定全面,想到什么就写什么.要学习的同志最好是有权威的书坐镇) 笔记大概会有如下有几个部分:语法基础,使用拓展库,实用工程,补充说明 数据类型: 简单类型:(byte = 8 bit,以下所示为32bit系统,bit不同稍有区别:除ab都可以在类型标识unsigned,表示无符号,一般最高位0表示正,1表示﹣,那么其取值范围也可以类推) a) void: 0byte 无值域 void b) bool: 1byte true/false

Think in Java 笔记_Chapter20_1_Annocation基础语法

/2015年04月05日12:15:05 <张龙老师>_先看看java里面有什么注解(貌似没说注解能干什么)+++[具体的到后面再看完这几章节再做总结]-编译期间类型检查保护,在实际的源代码级别保存所有的信息,对源代码和字节码有强大的检查和操作能力 @Override-复写或者覆盖父类的方法时候需要加上注解 >>>编程思想中说 把isohi当前的方法覆盖超类中方法,方法签名?? @Deprecated-有些方法虽然仍然有效,但是感觉过时了不想再被别人使用,可以加上这个在调用方

Java笔记之基础语法

/* 1 标识符 1.1. 在程序中所定义的一些名称,由26个英文字母大小写,数字0-9,符号:_$组成 1.2 定义合法的标识符规则: a.数字不可以开头 b.不可以使用关键字 c.Java中严格区分大小写,在起名字时,为了提高阅读性,尽量起有意义的名字. 2 常量与变量 2.1 常量:常量表示不能改变的数值 2.2. Java中的常量分类: a.整数常量.所有整数 b.小数常量.所有小数 c.布尔型常量.较为特有,只有2个数值.true false d.字符常量.将一个数字字母或者符号用单引

JAVA的语法基础4

循环提纲 循环语句 1.while循环语句 while循环语句也成为条件判断语句,它的循环方式为利用一个条件来控制是否要继续反复执行这个语句.语法格式如下: while(条件表达式) { 执行语句 } 或 while(逻辑表达式) { 代码(执行语句) break; } 当条件表达式的返回值为真时,则执行"{}"中的语句后,重新判断条件表达式的返回值,直到表达式返回的结果为假时,退出循环. while表达式的括号后面不能加“;”!切记!! 2.do……while循环语句 do……whi

JAVA的语法基础3

语句 1.复合语句 在使用复合语句时要注意,复合语句为局部变量创建了一个作用域,该作用域为程序的一部分,在该作用域中某个变量被创建并能够被使用.如果在某个变量的作用域外使用该变量,则会发生错误. 例题:在项目中创建Compound类,在主方法中定义复合语句块,其中包含另一复合语句块. public  class  Compound{ public static void main(String[] args){ { int y=40; System.out.println("输出y的值:&quo

JavaScript学习笔记——语法基础1.1

一.写在前面的话 1.我们有听说过,在一些地方,会把JavaScript当作入门级编程语言,这是因为它相对易学,易习. 2.JavaScript是一门地地道道的编程语言,既然是一门语言,那就应该有专属于它本身的语法,掌握它的语法势在必行. 3.不要试图去记忆它的所有语法和关键字,事实上,几乎没有人能做到这一点. 4.没有一个人敢说,学JavaScript1年或者几年就能称为不败的神话,坚持下去,会让你走的更远,只有这样,你才可能欣赏到更美的风景. 5.制定一个适合你自己的计划,选择一本适合你的书

JavaScript学习笔记——语法基础1.3

一.操作符 操作符是用来操作数据值的,它包含很多种,通过code我们可以了解它们的特性. 1.算数操作符 算数操作符包括加.减.乘.除四类操作符,除此之外,还有一些比较特殊的存在. var a = 1; var b = 2; var c = a + b; var d = b - a; var e = a * b; var f = b / a; document.write(c + '<br/>'); // 3 document.write(d + '<br/>'); // 1 do

JavaScript学习笔记——语法基础1.2

一.数组 1.通常情况下,一个变量只能有一个值,若想拥有多个值,就需要使用数组,换句话来说,数组是一个特殊的容器,它可以根据需求存放一个或者多个值.2.数组可以用关键字Array来声明,声明的同时,可以设定它的长度length. var myArray = Array(3); document.write(myArray.length); //输出3 3.我们可以在声明数组的同时对它进行填充,也可以在声明之后进行填充,当然,我们需要对新填充的值指定存放位置,需要注意下标是从0开始计数的. Jav