箫遥游

java语言学习

java基础知识

文章目录

java基础知识
- 一、预言
- 二、简介
- 三、环境设置
- 四、基本语法
- 五、对象和类
- 六、基本数据类型
- 七、变量类型
- 八、修饰符
- 九、运算符
- 十、循环控制
- 十一、判断
- 十二、 Numbers类
- 十三、Character 类
- 十四、String类
- 十五、数组

一、预言

Java是一种高级编程语言，最初由Sun Microsystems在1995年发布并在1995年发布。Java运行在各种平台上，如Windows，Mac OS以及各种版本的UNIX。本教程提供了对Java的完整理解。学习Java编程语言时，此参考将带您通过简单实用的方法。

本教程已经为初学者准备，以帮助他们理解与Java编程语言相关的基本到高级概念。

在开始练习此参考文献中提供的各种示例之前，我们假设您已经了解计算机程序和计算机编程语言。

二、简介

Java 简介

Java编程语言最初由Sun Microsystems开发，由James Gosling发起，并于1995年作为Sun Microsystems Java平台（Java 1.0 [J2SE]）的核心组件发布。

Java标准版的最新版本是Java SE 8.随着Java的进步和广泛流行，构建了多种配置以适应各种类型的平台。例如：J2EE for Enterprise Applications，J2ME for Mobile Applications。

新的J2版本分别被重新命名为Java SE，Java EE和Java ME。 Java保证是Write Once，Run Anywhere。

面向对象 - 在Java中，一切都是一个对象。 Java可以很容易地扩展，因为它基于Object模型。
平台无关 - 与许多其他编程语言（包括C和C ++）不同，编译Java时，不会将其编译到特定于平台的计算机，而是编译为独立于平台的字节码。该字节码分布在Web上，并由虚拟机（JVM）在其运行的任何平台上解释。
简单 - Java被设计为易于学习。如果您了解OOP Java的基本概念，则很容易掌握。
安全 - 借助Java的安全功能，它可以开发无病毒，无篡改的系统。认证技术基于公钥加密。
体系结构中立 - Java编译器生成一个与体系结构无关的目标文件格式，这使得编译后的代码可以在多个处理器上执行，并且具有Java运行时系统。
便携式 - 与架构无关并且没有规范的实现依赖方面使Java变得轻松。 Java中的编译器是用ANSI C编写的，具有清晰的可移植边界，这是一个POSIX子集。
强大 - Java努力通过强调编译时错误检查和运行时检查来消除容易出错的情况。
多线程 - 使用Java的多线程功能，可以编写可同时执行多项任务的程序。这种设计特性允许开发人员构建可以流畅运行的交互式应用程序。
解释 - Java字节代码被即时翻译为本地机器指令，并不存储在任何地方。由于链接是一个渐进式和轻量级的过程，所以开发过程更加快速和分析。
高性能 - 通过使用实时编译器，Java可实现高性能。
分布式 - Java是针对互联网的分布式环境而设计的。
动态 - Java被认为比C或C ++更具动态性，因为它旨在适应不断发展的环境。 Java程序可以携带大量的运行时信息，这些信息可用于在运行时验证和解析对对象的访问。
Java的历史

James Gosling于1991年6月发起Java语言项目，用于他的许多机顶盒项目之一。在Gosling办公室外面的一棵橡树后，最初被称为’橡树’的语言也被命名为’Green’，最后被从一系列随机单词中改名为Java。

Sun在1995年发布了第一个Java 1.0公共实现，它承诺编写一次，随处运行（WORA），在流行平台上提供免费运行时间。

2006年11月13日，Sun根据GNU通用公共许可证（GPL）的条款发布了许多Java作为免费和开源软件。

2007年5月8日，Sun完成了这一流程，使Java的所有核心代码免费且开放源代码，除了Sun未拥有版权的一小部分代码之外。

开发工具

为了执行本教程中讨论的示例，您需要至少具有64 MB RAM的Pentium 200-MHz计算机（建议使用128 MB RAM）。

您还需要以下软件 -

Linux 7.1或Windows XP / 7/8操作系统
Java JDK 8
Microsoft记事本或任何其他文本编辑器
本教程将提供使用Java创建GUI，网络和Web应用程序的必要技能。

下一章将指导您如何获取Java及其文档。最后，它指导您如何安装Java并准备开发Java应用程序的环境。

三、环境设置

Java 开发环境配置

在本章中，我们将为大家介绍如何搭建Java开发环境。

本地环境设置

如果您仍然愿意为Java编程语言设置您的环境，那么本节将指导您如何在您的机器上下载和设置Java。以下是设置环境的步骤。

Java SE可以从链接下载Java免费获得。您可以根据您的操作系统下载一个版本。

按照说明下载Java并运行.exe以在您的机器上安装Java。一旦你在你的机器上安装了Java，你将需要设置环境变量来指向正确的安装目录 -

为Windows设置路径

假设你已经在c：\ Program Files \ java \ jdk目录中安装了Java -

右键单击“我的电脑”并选择“属性”。
点击“高级”选项卡下的“环境变量”按钮。
现在，改变’Path’变量，以便它也包含Java可执行文件的路径。例如，如果路径当前设置为’C:\WINDOWS\SYSTEM32’，则更改路径为’C:\WINDOWS\SYSTEM32; c:\Program Files\java\jdk\bin’。
为Linux，UNIX，Solaris和FreeBSD设置路径

应将环境变量PATH设置为指向已安装Java二进制文件的位置。如果您在执行此操作时遇到问题，请参阅您的shell文档。

例如，如果你使用bash作为你的shell，那么你应该在你的’.bashrc: export PATH = /path/to/java:$PATH’。

流行的Java编辑器

要编写Java程序，您需要一个文本编辑器。市场上还有更复杂的IDE。但现在，您可以考虑以下其中一项 -

记事本 - 在Windows机器上，您可以使用任何简单的文本编辑器，如记事本（推荐用于本教程），TextPad。
Netbeans - 开源和免费的Java IDE，可从https://www.netbeans.org/index.html下载。
Eclipse - eclipse开源社区开发的Java IDE，可以从https://www.eclipse.org/下载。

Java 基本语法

当我们考虑Java程序时，它可以被定义为通过调用彼此的方法进行通信的对象的集合。现在让我们简单地看一下类，对象，方法和实例变量的含义。

对象 - 对象具有状态和行为。例如：狗有状态 - 颜色，名称，品种以及行为，如摇尾巴，吠叫，吃东西。一个对象是一个类的实例。
类 - 一个类可以被定义为一个模板/蓝图，描述该类型的对象支持的行为/状态。
方法 - 一种方法基本上是一种行为。一个类可以包含许多方法。它是在写逻辑的方法中，操纵数据并执行所有操作。
实例变量 - 每个对象都有其独特的一组实例变量。对象的状态由分配给这些实例变量的值创建。
第一个Java程序

让我们看看一个简单的代码，它将打印出Hello World这个词。

例子

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    */

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

我们来看看如何保存文件，编译和运行程序。请按照后续步骤 -

打开记事本并添加上面的代码。
将该文件保存为：MyFirstJavaProgram.java。
打开一个命令提示符窗口并转到您保存该类的目录。假设它是C：\。
键入’javac MyFirstJavaProgram.java’，然后按回车键编译您的代码。如果代码中没有错误，命令提示符会将您带到下一行（假设：路径变量已设置）。
现在，输入’java MyFirstJavaProgram’来运行你的程序。
您将能够在窗口上看到“Hello World”。
输出

C:\> javac MyFirstJavaProgram.java
C:\> java MyFirstJavaProgram 
Hello World

基本语法

编写Java程序时，应注意以下几点：

大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。
类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。
主方法入口：所有的Java 程序由public static void main(String []args)方法开始执行。
Java标识符

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

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

所有的标识符都应该以字母（A-Z或者a-z）,美元符（ $或者下划线（_）开始首字符之后可以是字母（A-Z或者a-z）,美元符（$ ）、下划线（_）或数字的任何字符组合
关键字不能用作标识符
标识符是大小写敏感的
合法标识符举例：age、$salary、_value、__1_value
非法标识符举例：123abc、-salary
Java修饰符

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

访问控制修饰符 : default, public , protected, private
非访问控制修饰符 : final, abstract, strictfp
在后面的章节中我们会深入讨论Java修饰符。

Java变量

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

局部变量
类变量（静态变量）
成员变量（非静态变量）
Java数组

数组是储存在堆上的对象，可以保存多个同类型变量。在后面的章节中，我们将会学到如何声明、构造以及初始化一个数组。

Java枚举

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

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

例子

class FreshJuice {
   enum FreshJuiceSize{ SMALL, MEDIUM, LARGE }
   FreshJuiceSize size;
}

public class FreshJuiceTest {

   public static void main(String args[]) {
      FreshJuice juice = new FreshJuice();
      juice.size = FreshJuice.FreshJuiceSize.MEDIUM ;
      System.out.println("Size: " + juice.size);
   }
}

上面的例子将产生以下的结果

输出

Size: MEDIUM
注意：枚举可以单独声明或者声明在类里面。方法、变量、构造函数也可以在枚举中定义。

Java关键字

以下列表显示了Java中的保留字。这些保留字不能用作常量或变量或任何其他标识符名称

abstract assert boolean break
byte case catch char
class const continue default
do double else enum
extends final finally float
for goto if implements
import instanceof int interface
long native new package
private protected public return
short static strictfp super
switch synchronized this throw
throws transient try void
volatile while
Java注释

Java支持非常类似于C和C ++的单行和多行注释。 Java编译器会忽略任何注释中可用的所有字符。

例子

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    * This is an example of multi-line comments.
    */

   public static void main(String []args) {
      // This is an example of single line comment
      /* This is also an example of single line comment. */
      System.out.println("Hello World");
   }
}

输出

Hello World
使用空白行

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

继承

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

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

接口

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

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

四、基本语法

Java 基本语法

当我们考虑Java程序时，它可以被定义为通过调用彼此的方法进行通信的对象的集合。现在让我们简单地看一下类，对象，方法和实例变量的含义。

让我们看看一个简单的代码，它将打印出Hello World这个词。

例子

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    */

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

我们来看看如何保存文件，编译和运行程序。请按照后续步骤 -

C:\> javac MyFirstJavaProgram.java
C:\> java MyFirstJavaProgram 
Hello World

基本语法

编写Java程序时，应注意以下几点：

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

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

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

访问控制修饰符 : default, public , protected, private
非访问控制修饰符 : final, abstract, strictfp
在后面的章节中我们会深入讨论Java修饰符。

Java变量

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

局部变量
类变量（静态变量）
成员变量（非静态变量）
Java数组

数组是储存在堆上的对象，可以保存多个同类型变量。在后面的章节中，我们将会学到如何声明、构造以及初始化一个数组。

Java枚举

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

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

例子

class FreshJuice {
   enum FreshJuiceSize{ SMALL, MEDIUM, LARGE }
   FreshJuiceSize size;
}

public class FreshJuiceTest {

   public static void main(String args[]) {
      FreshJuice juice = new FreshJuice();
      juice.size = FreshJuice.FreshJuiceSize.MEDIUM ;
      System.out.println("Size: " + juice.size);
   }
}

上面的例子将产生以下的结果

输出

Size: MEDIUM
注意：枚举可以单独声明或者声明在类里面。方法、变量、构造函数也可以在枚举中定义。

Java关键字

以下列表显示了Java中的保留字。这些保留字不能用作常量或变量或任何其他标识符名称

Java支持非常类似于C和C ++的单行和多行注释。 Java编译器会忽略任何注释中可用的所有字符。

例子

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    * This is an example of multi-line comments.
    */

   public static void main(String []args) {
      // This is an example of single line comment
      /* This is also an example of single line comment. */
      System.out.println("Hello World");
   }
}

输出

Hello World
使用空白行

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

继承

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

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

接口

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

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

五、对象和类

Java 对象和类

Java是一种面向对象的语言。作为一种具有面向对象功能的语言，Java支持以下基本概念 -

多态性
继承
封装
抽象
类
对象
实例
方法
消息解析
在本章中，我们将研究概念 - 类和对象。

对象 - 对象具有状态和行为。例如：狗有状态 - 颜色，名称，品种和行为 - 摇尾巴，吠叫，吃东西。一个对象是一个类的实例。
类 - 类是一个模板，它描述一类对象的行为和状态。
Java中的对象

现在让我们深入研究什么是对象。如果我们考虑现实世界，我们可以在我们周围发现许多物体，汽车，狗，人等等。所有这些物体都有一个状态和一个行为。

如果我们考虑一只狗，那么它的状态是 - 名称，品种，颜色，行为是 - 吠叫，摇尾巴，跑步。

如果您将软件对象与真实世界的对象进行比较，则它们具有非常相似的特征。

软件对象也有一个状态和一个行为。软件对象的状态存储在字段中，行为通过方法显示。

因此，在软件开发中，方法根据对象的内部状态进行操作，并且通过方法完成对象到对象的通信。

Java中的类

一个类是创建单个对象的蓝图。

以下是一堂课的样本。

例子

public class Dog {
  String breed;
  int age;
  String color;

  void barking() {
  }

  void hungry() {
  }

  void sleeping() {
  }
}

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

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。
一个类可以拥有多个方法，在上面的例子中：barking()、hungry()和sleeping()都是Dog类的方法。

构造方法

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

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

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

    public class Puppy {
	    public Puppy() {
    }
    public Puppy(String name) {
    	// This constructor has one parameter, name.
    	}
    }

创建对象

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

声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字new来创建一个对象。
初始化：使用new创建对象时，会调用构造方法初始化对象。
下面是一个创建对象的例子：

public class Puppy {
    public Puppy(String name) {
      // This constructor has one parameter, name.
      System.out.println("Passed Name is :" + name );
    }

    public static void main(String []args) {
      // Following statement would create an object myPuppy
      Puppy myPuppy = new Puppy( "tommy" );
    }

}

输出

Passed Name is :tommy
访问实例变量和方法

通过已创建的对象来访问成员变量和成员方法，如下所示：

/* First create an object */
ObjectReference = new Constructor();

/* Now call a variable as follows */
ObjectReference.variableName;

/* Now you can call a class method as follows */
ObjectReference.MethodName();
例子

这个例子解释了如何访问一个类的实例变量和方法。

public class Puppy {
    int puppyAge;

    public Puppy(String name) {
    // This constructor has one parameter, name.
    System.out.println("Name chosen 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) {
    /* Object creation */
    Puppy myPuppy = new Puppy( "tommy" );
    
    /* Call class method to set puppy's age */
    myPuppy.setAge( 2 );
    
    /* Call another class method to get puppy's age */
    myPuppy.getAge( );
    
    /* You can access instance variable as follows as well */
    System.out.println("Variable Value :" + myPuppy.puppyAge );
    }

}

编译并运行上面的程序，产生如下结果:

Name chosen is :tommy
Puppy’s age is :2
Variable Value :2
源文件声明规则

在本节的最后部分，我们将学习源文件的声明规则。当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。

一个源文件中只能有一个public类
一个源文件可以有多个非public类
源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是Employee，那么源文件应该命名为Employee.java。
如果一个类定义在某个包中，那么package语句应该在源文件的首行。
如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。
import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。
类有若干种访问级别，并且类也分不同的类型：抽象类和final类等。这些将在访问控制章节介绍。

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

Java包

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

Import语句

在Java中，如果给出一个完整的限定名，包括包名、类名，那么Java编译器就可以很容易地定位到源代码或者类。Import语句就是用来提供一个合理的路径，使得编译器可以找到某个类。

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

import java.io.*;
一个简单的例子

在该例子中，我们创建两个类：Employee 和 EmployeeTest。

首先打开文本编辑器，把下面的代码粘贴进去。注意将文件保存为 Employee.java。

Employee类有四个成员变量：name、age、designation和salary。该类显式声明了一个构造方法，该方法只有一个参数。

import java.io.*;
public class Employee {

    String name;
    int age;
    String designation;
    double salary;
    
    // This is the constructor of the class Employee
    public Employee(String name) {
    this.name = name;
    }
    
    // Assign the age of the Employee  to the variable age.
    public void empAge(int empAge) {
    age = empAge;
    }
    
    /* Assign the designation to the variable designation.*/
    public void empDesignation(String empDesig) {
    designation = empDesig;
    }
    
    /* Assign the salary to the variable salary.*/
    public void empSalary(double empSalary) {
    salary = empSalary;
    }
    
    /* Print the Employee details */
    public void printEmployee() {
    System.out.println("Name:"+ name );
    System.out.println("Age:" + age );
    System.out.println("Designation:" + designation );
    System.out.println("Salary:" + salary);
    }

}

程序都是从main方法开始执行。为了能运行这个程序，必须包含main方法并且创建一个实例对象。

下面给出EmployeeTest类，该类实例化2个 Employee 类的实例，并调用方法设置变量的值。

将下面的代码保存在 EmployeeTest.java文件中。

import java.io.*;
public class EmployeeTest {

public static void main(String args[]) {
/* Create two objects using constructor */
Employee empOne = new Employee("James Smith");
Employee empTwo = new Employee("Mary Anne");

// Invoking methods for each object created
empOne.empAge(26);
empOne.empDesignation("Senior Software Engineer");
empOne.empSalary(1000);
empOne.printEmployee();

empTwo.empAge(21);
empTwo.empDesignation("Software Engineer");
empTwo.empSalary(500);
empTwo.printEmployee();
}

}
编译这两个文件并且运行 EmployeeTest 类，可以看到如下结果：

输出

C:\> javac Employee.java
C:\> javac EmployeeTest.java
C:\> java EmployeeTest
Name:James Smith
Age:26
Designation:Senior Software Engineer
Salary:1000.0
Name:Mary Anne
Age:21
Designation:Software Engineer
Salary:500.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,483,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。
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。
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’;
引用类型

在Java中，引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
对象、数组都是引用数据类型。
所有引用类型的默认值都是null。
一个引用变量可以用来引用任何与之兼容的类型。
例子：Site site = new Site(“Runoob”)。
Java 常量

常量在程序运行时是不能被修改的。

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

字面量可以赋给任何内置类型的变量。例如：

byte a = 68;
char a = ‘A’
byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。

当使用常量的时候，前缀 0 表示 8 进制，而前缀 0x 代表 16 进制, 例如：

int decimal = 100;
int octal = 0144;
int hexa = 0x64;
和其他语言一样，Java的字符串常量也是包含在两个引号之间的字符序列。下面是字符串型字面量的例子：

“Hello World”
“two\nlines”
““This is in quotes””
字符串常量和字符常量都可以包含任何Unicode字符。例如：

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

七、变量类型

java 变量类型

一个变量为我们提供了我们的程序可以操纵的命名存储。 Java中的每个变量都有一个特定的类型，它决定了变量内存的大小和布局; 可以存储在该存储器中的值的范围; 以及可以应用于该变量的一组操作。

您必须先声明所有变量，然后才能使用它们。以下是变量声明的基本形式 -

data type variable [ = value][, variable [ = value] …] ;
这里的数据类型是Java的数据类型之一，变量是变量的名称。要声明指定类型的多个变量，可以使用逗号分隔的列表。

以下是Java中变量声明和初始化的有效示例 -

例子

int a, b, c;         // Declares three ints, a, b, and c.
int a = 10, b = 10;  // Example of initialization
byte B = 22;         // initializes a byte type variable B.
double pi = 3.14159; // declares and assigns a value of PI.
char a = 'a';        // the char variable a iis initialized with value 'a'

本章将解释Java语言中可用的各种变量类型。 Java中有三种变量 -

局部变量
实例变量
类/静态变量
局部变量

局部变量在方法，构造函数或块中声明。
在输入方法，构造函数或块时会创建局部变量，并且一旦变量退出方法，构造函数或块，该变量就会被销毁。
访问修饰符不能用于局部变量。
局部变量只在声明的方法，构造函数或块中可见。
局部变量在内部以堆栈级别实现。
局部变量没有默认值，因此应声明局部变量并在首次使用之前分配初始值。
例子

在这里，年龄是一个局部变量。这是在pupAge（）方法内定义的，其范围仅限于此方法。

public class Test {
   public void pupAge() {
      int age = 0;
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }

   public static void main(String args[]) {
      Test test = new Test();
      test.pupAge();
   }
}

这将产生以下结果 -

Puppy age is: 7
例子

下面的例子没有初始化就使用age，所以在编译时会出现错误。

public class Test {
   public void pupAge() {
      int age;
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }

   public static void main(String args[]) {
      Test test = new Test();
      test.pupAge();
   }
}

这会在编译时产生以下错误 -

Test.java:4:variable number might not have been initialized
age = age + 7;
^
1 error
实例变量

实例变量声明在一个类中，但在方法、构造方法和语句块之外；
当一个对象被实例化之后，每个实例变量的值就跟着确定；
实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
实例变量可以声明在使用前或者使用后；
访问修饰符可以修饰实例变量；
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
例子

import java.io.*;
public class Employee {

   // this instance variable is visible for any child class.
   public String name;

   // salary  variable is visible in Employee class only.
   private double salary;

   // The name variable is assigned in the constructor.
   public Employee (String empName) {
      name = empName;
   }

   // The salary variable is assigned a value.
   public void setSalary(double empSal) {
      salary = empSal;
   }

   // This method prints the employee details.
   public void printEmp() {
      System.out.println("name  : " + name );
      System.out.println("salary :" + salary);
   }

   public static void main(String args[]) {
      Employee empOne = new Employee("Ransika");
      empOne.setSalary(1000);
      empOne.printEmp();
   }
}

这将产生以下结果 -

name : Ransika
salary :1000.0
类/静态变量

类变量也称为静态变量，在类中以static关键字声明，但必须在方法构造方法和语句块之外。
无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
静态变量在程序开始时创建，在程序结束时销毁。
与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
静态变量可以通过：ClassName.VariableName的方式访问。
类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。
例子

import java.io.*;
public class Employee {

   // salary  variable is a private static variable
   private static double salary;

   // DEPARTMENT is a constant
   public static final String DEPARTMENT = "Development ";

   public static void main(String args[]) {
      salary = 1000;
      System.out.println(DEPARTMENT + "average salary:" + salary);
   }
}

这将产生以下结果 -

Development average salary:1000
注意：如果其他类想要访问该变量，可以这样访问：Employee.DEPARTMENT。

八、修饰符

Java 修饰符

修饰符是您添加到这些定义以更改其含义的关键字。 Java语言有多种修饰符，包括以下内容 -

Java访问修饰符
非访问修饰符
要使用修饰符，可以将其关键字包含在类，方法或变量的定义中。修饰符在语句的其余部分之前，如下例所示。

public class className {
// ...
}

private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;

public static void main(String[] arguments) {
// body of method
}

访问控制修饰符

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

default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

private : 在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）

public : 对所有类可见。使用对象：类、接口、变量、方法

protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）。

默认访问修饰符-不使用任何关键字

使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。

如下例所示，变量和方法的声明可以不使用任何修饰符。

String version = "1.5.1";

boolean processOrder() {
  return true;
}

私有访问修饰符-private

私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。

声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。

Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。

下面的类使用了私有访问修饰符：

public class Logger {
    private String format;

    public String getFormat() {
      return this.format;
    }
    
    public void setFormat(String format) {
      this.format = format;
    }

}

实例中，Logger 类中的 format 变量为私有变量，所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量，定义了两个 public 方法：getFormat() （返回 format的值）和 setFormat(String)（设置 format 的值）

公有访问修饰符-public

被声明为 pub50lic 的类、方法、构造方法和接口能够被任何其他类访问。

如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。

以下函数使用了公有访问控制：

public static void main(String[] arguments) {
  // ...
}

Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类。

受保护的访问修饰符-protected

protected 需要从以下两个点来分析说明：

子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；

子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。

protected 访问修饰符不能修饰类和接口，方法和成员变量能够声明为 protected，但是接口的成员变量和成员方法不能声明为 protected。

子类能访问 protected 修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。

下面的父类使用了 protected 访问修饰符，子类重写了父类的 openSpeaker() 方法。

class AudioPlayer {
  protected boolean openSpeaker(Speaker sp) {
    // implementation details
  }
}

class StreamingAudioPlayer {
  boolean openSpeaker(Speaker sp) {
    // implementation details
  }
}

在这里，如果我们将openSpeaker（）方法定义为私有的，那么它将不能从AudioPlayer以外的任何其他类访问。如果我们把它定义为公开的话，那么它就可以被所有的外部世界所接受。但是我们的意图是只将这个方法暴露给它的子类，这就是为什么我们使用了protected修饰符。

访问控制和继承

继承方法的以下规则被执行 -

在超类中公开的方法也必须在所有子类中公开。
在超类中声明保护的方法必须受保护或在子类中公开; 他们不能是私人的。
私有的方法根本不会被继承，所以对它们没有规则。
非访问修饰符

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

static 修饰符，用来修饰类方法和类变量。
final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract 修饰符，用来创建抽象类和抽象方法。
synchronized 和 volatile 修饰符，主要用于线程的编程。
static 修饰符

静态变量

static关键字用于创建独立于为该类创建的任何实例的变量。不管类的实例数量如何，只存在一个静态变量副本。

静态变量也称为类变量。局部变量不能被声明为静态的。

静态方法

static关键字用于创建独立于为该类创建的任何实例的方法。

静态方法不使用任何它们在其中定义的类的任何对象的实例变量。静态方法从参数中获取所有数据，并从这些参数计算出某些内容，而不参考变量。

类变量和方法可以使用类名后面跟一个点和变量或方法的名称来访问。

例子

静态修饰符用于创建类方法和变量，如下例所示 -

public class InstanceCounter {

   private static int numInstances = 0;

   protected static int getCount() {
      return numInstances;
   }

   private static void addInstance() {
      numInstances++;
   }

   InstanceCounter() {
      InstanceCounter.addInstance();
   }

   public static void main(String[] arguments) {
      System.out.println("Starting with " + InstanceCounter.getCount() + " instances");

      for (int i = 0; i < 500; ++i) {
         new InstanceCounter();
      }
      System.out.println("Created " + InstanceCounter.getCount() + " instances");

   }
}

这将产生以下结果 -

Started with 0 instances
Created 500 instances
final 修饰符

final 变量

final 变量能被显式地初始化并且只能初始化一次。被声明为 final 的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变，但是里面的值可以改变。

final 修饰符通常和 static 修饰符一起使用来创建类常量。

例子

public class Test {
   final int value = 10;

   // The following are examples of declaring constants:
   public static final int BOXWIDTH = 6;
   static final String TITLE = "Manager";

   public void changeValue() {
      value = 12;   // will give an error
   }
}

final 方法

类中的 final 方法可以被子类继承，但是不能被子类修改。

声明 final 方法的主要目的是防止该方法的内容被修改。

如下所示，使用 final 修饰符声明方法。

public class Test {
   public final void changeName() {
      // body of method
   }
}

final 类

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

例子

public final class Test {
   // body of class
}

abstract 修饰符

抽象类

抽象类永远不能实例化。如果一个类被声明为抽象的，那么唯一的目的是扩展这个类。

一个类不能既抽象又最终（因为最终的类不能被扩展）。如果一个类包含抽象方法，那么该类应该被声明为抽象的。否则，将会抛出一个编译错误。

抽象类可能包含抽象方法和普通方法。

abstract class Caravan {
   private double price;
   private String model;
   private String year;
   public abstract void goFast();   // an abstract method
   public abstract void changeColor();
}

抽象方法

抽象方法是一种没有任何实现声明的方法。方法体（实现）由子类提供。抽象方法永远不可能是最终的或严格的。

任何扩展抽象类的类都必须实现超类的所有抽象方法，除非子类也是一个抽象类。

如果一个类包含一个或多个抽象方法，那么该类必须声明为抽象。抽象类不需要包含抽象方法。

抽象方法以分号结尾。例如：public abstract sample（）;

例子

public abstract class SuperClass {
   abstract void m();   // abstract method
}

class SubClass extends SuperClass {
   // implements the abstract method
   void m() {
      .........
   }
}

synchronized 修饰符

synchronized关键字用于指示某个方法一次只能由一个线程访问。同步修饰符可以与四种访问级别修饰符中的任何一种一起应用。

例子

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

transient 修饰符

序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。

该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

例子

public transient int limit = 55;   // will not persist
public int b;   // will persist

volatile 修饰符

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

一个 volatile 对象引用可能是 null。

例子

public class MyRunnable implements Runnable {
   private volatile boolean active;

   public void run() {
      active = true;
      while (active) {   // line 1
         // some code here
      }
   }

   public void stop() {
      active = false;   // line 2
   }
}

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

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

九、运算符

Java 运算符

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

算术运算符
关系运算符
位运算符
逻辑运算符
赋值运算符
其他运算符
算术运算符

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。

表格中的实例假设整数变量A的值为10，变量B的值为20 −

操作符描述例子
+（加）加法 - 相加运算符两侧的值. A + B 等于 30

（减）减法 - 左操作数减去右操作数. A - B 等于 -10

（乘）乘法 - 相乘操作符两侧的值. A * B 等于 200
/ (除) 除法 - 左操作数除以右操作数. B / A 等于 2
% (取模) 取模 - 左操作数除以右操作数的余数. B % A 等于 0
++ (Increment) 自增: 操作数的值增加1. B++ 等于 21
– (Decrement) 自减: 操作数的值减少1. B-- 等于 19
以下程序是演示算术运算符的简单示例。将以下Java程序复制并粘贴到Test.java文件中，并编译并运行此程序 -

例子

public class Test {

   public static void main(String args[]) {
      int a = 10;
      int b = 20;
      int c = 25;
      int d = 25;

      System.out.println("a + b = " + (a + b) );
      System.out.println("a - b = " + (a - b) );
      System.out.println("a * b = " + (a * b) );
      System.out.println("b / a = " + (b / a) );
      System.out.println("b % a = " + (b % a) );
      System.out.println("c % a = " + (c % a) );
      System.out.println("a++   = " +  (a++) );
      System.out.println("b--   = " +  (a--) );
    
      // Check the difference in d++ and ++d
      System.out.println("d++   = " +  (d++) );
      System.out.println("++d   = " +  (++d) );

   }
}

这将产生以下结果 -

a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++ = 10
b-- = 11
d++ = 25
++d = 27
关系运算符

下表为Java支持的关系运算符

表格中的实例整数变量A的值为10，变量B的值为20 -

操作符描述例子
== (等于) 检查如果两个操作数的值是否相等，如果相等则条件为真. (A == B) 为假.
!= (不等于) 检查如果两个操作数的值是否相等，如果值不相等则条件为真. (A != B) 为真.

(大于) 检查左操作数的值是否大于右操作数的值，如果是那么条件为真. (A > B) 非真.
< (小于) 检查左操作数的值是否小于右操作数的值，如果是那么条件为真. (A < B) 为真.
= (大于等于) 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真. (A >= B) 为假.
<= (小于等于) 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真. (A <= B) 为真.
以下程序是演示关系运算符的简单示例。将以下Java程序复制并粘贴到Test.java文件中并编译并运行该程序。

例子

public class Test {

   public static void main(String args[]) {
      int a = 10;
      int b = 20;

      System.out.println("a == b = " + (a == b) );
      System.out.println("a != b = " + (a != b) );
      System.out.println("a > b = " + (a > b) );
      System.out.println("a < b = " + (a < b) );
      System.out.println("b >= a = " + (b >= a) );
      System.out.println("b <= a = " + (b <= a) );

   }
}

这将产生以下结果 -

a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false
位运算符

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。

位运算符作用在所有的位上，并且按位运算。假设a = 60，b = 13;它们的二进制格式表示将如下 -

A = 0011 1100

B = 0000 1101

A&b = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011
下表列出了位运算符的基本运算,假设整数变量A的值为60和变量B的值为13 -

操作符描述例子
＆如果相对应位都是1，则结果为1，否则为0 （A＆B），得到12，即0000 1100
| 如果相对应位都是0，则结果为0，否则为1 （A | B）得到61，即 0011 1101
^ 如果相对应位值相同，则结果为0，否则为1 （A ^ B）得到49，即 0011 0001
〜按位补运算符翻转操作数的每一位，即0变成1，1变成0。（〜A）得到-61，即1100 0011
<< 按位左移运算符。左操作数按位左移右操作数指定的位数。 A << 2得到240，即 1111 0000

按位右移运算符。左操作数按位右移右操作数指定的位数。 A >> 2得到15即 1111

按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 A>>>2得到15即0000 1111
以下程序是演示按位运算符的简单示例。将以下Java程序复制并粘贴到Test.java文件中并编译并运行此程序 -

例子

public class Test {

   public static void main(String args[]) {
      int a = 60; /* 60 = 0011 1100 */
      int b = 13; /* 13 = 0000 1101 */
      int c = 0;

      c = a & b;        /* 12 = 0000 1100 */
      System.out.println("a & b = " + c );
    
      c = a | b;        /* 61 = 0011 1101 */
      System.out.println("a | b = " + c );
    
      c = a ^ b;        /* 49 = 0011 0001 */
      System.out.println("a ^ b = " + c );
    
      c = ~a;           /*-61 = 1100 0011 */
      System.out.println("~a = " + c );
    
      c = a << 2;       /* 240 = 1111 0000 */
      System.out.println("a << 2 = " + c );
    
      c = a >> 2;       /* 15 = 1111 */
      System.out.println("a >> 2  = " + c );
    
      c = a >>> 2;      /* 15 = 0000 1111 */
      System.out.println("a >>> 2 = " + c );

   }
}

这将产生以下结果 -

a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15
a >>> 2 = 15
逻辑运算符

下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假

操作符描述例子
&& 称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。（A && B）为假。
| | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。（A | | B）为真。
！称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。！（A && B）为真。
下面的简单示例程序演示了逻辑运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序 -

例子

public class Test {

   public static void main(String args[]) {
      boolean a = true;
      boolean b = false;

      System.out.println("a && b = " + (a&&b));
      System.out.println("a || b = " + (a||b) );
      System.out.println("!(a && b) = " + !(a && b));

   }
}

这将产生以下结果 -

a && b = false
a || b = true
!(a && b) = true
赋值运算符

下面是Java语言支持的赋值运算符 -

操作符描述例子
= 简单的赋值运算符，将右操作数的值赋给左侧操作数 C = A + B将把A + B得到的值赋给C

= 加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 C + = A等价于C = C + A

= 减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 C - = A等价于C = C -
A

= 乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 C * = A等价于C = C * A
/ = 除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 C / = A等价于C = C / A
（％）= 取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数 C％= A等价于C = C％A
<< = 左移位赋值运算符 C << = 2等价于C = C << 2

= 右移位赋值运算符 C >> = 2等价于C = C >> 2
＆= 按位与赋值运算符 C＆= 2等价于C = C＆2
^ = 按位异或赋值操作符 C ^ = 2等价于C = C ^ 2
| = 按位或赋值操作符 C | = 2等价于C = C | 2
以下程序是演示赋值运算符的简单示例。将以下Java程序复制并粘贴到Test.java文件中。编译并运行这个程序 -

例子

public class Test {

   public static void main(String args[]) {
      int a = 10;
      int b = 20;
      int c = 0;

      c = a + b;
      System.out.println("c = a + b = " + c );
    
      c += a ;
      System.out.println("c += a  = " + c );
    
      c -= a ;
      System.out.println("c -= a = " + c );
    
      c *= a ;
      System.out.println("c *= a = " + c );
    
      a = 10;
      c = 15;
      c /= a ;
      System.out.println("c /= a = " + c );
    
      a = 10;
      c = 15;
      c %= a ;
      System.out.println("c %= a  = " + c );
    
      c <<= 2 ;
      System.out.println("c <<= 2 = " + c );
    
      c >>= 2 ;
      System.out.println("c >>= 2 = " + c );
    
      c >>= 2 ;
      System.out.println("c >>= 2 = " + c );
    
      c &= a ;
      System.out.println("c &= a  = " + c );
    
      c ^= a ;
      System.out.println("c ^= a   = " + c );
    
      c |= a ;
      System.out.println("c |= a   = " + c );

   }
}

这将产生以下结果 -

c = a + b = 30
c += a = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a = 5
c <<= 2 = 20
c >>= 2 = 5
c >>= 2 = 1
c &= a = 0
c ^= a = 10
c |= a = 10
其他运算符

Java语言还支持的其他一些运算符。

条件运算符（?:）

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

variable x = (expression) ? value if true : value if false
例子

public class Test {

   public static void main(String args[]) {
      int a, b;
      a = 10;
      b = (a == 1) ? 20: 30;
      System.out.println( "Value of b is : " +  b );

      b = (a == 10) ? 20: 30;
      System.out.println( "Value of b is : " + b );

   }
}

这将产生以下结果 -

Value of b is : 30
Value of b is : 20
instanceof 运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

( Object reference variable ) instanceof (class/interface type)
如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。

例子

public class Test {

   public static void main(String args[]) {

      String name = "James";
    
      // following will return true since name is type of String
      boolean result = name instanceof String;
      System.out.println( result );

   }
}

这会产生以下结果＆minus;

true
如果被比较的对象兼容于右侧类型,该运算符仍然返回true。

class Vehicle {}

public class Car extends Vehicle {

   public static void main(String args[]) {

      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result );

   }
}

这会产生以下结果＆minus;

true
Java运算符优先级

当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。

例如，（1+3）＋（3+2）*2，这个表达式如果按加号最优先计算，答案就是 18，如果按照乘号最优先，答案则是 14。

再如，x = 7 + 3 * 2;这里x得到13，而不是20，因为乘法运算符比加法运算符有较高的优先级，所以先计算3 * 2得到6，然后再加7。

下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。

类别操作符关联性
后缀 () [] . (点操作符) 左到右
一元 + + - ！〜从右到左
乘性 * /％左到右
加性 + - 左到右
移位 >> >>> << 左到右
关系 >> = << = 左到右
相等 == != 左到右
按位与＆左到右
按位异或 ^ 左到右
按位或 | 左到右
逻辑与 && 左到右
逻辑或 | | 左到右
条件？：从右到左
赋值 = + = - = * = / =％= >> = << =＆= ^ = | = 从右到左
逗号，

十、循环控制

Java 循环控制

当您需要多次执行一段代码时，可能会出现这种情况。通常，语句按顺序执行：首先执行函数中的第一个语句，然后执行第二个语句，依此类推。

编程语言提供了各种控制结构，允许更复杂的执行路径。

循环语句允许我们多次执行语句或语句组，以下是大多数编程语言中循环语句的一般形式 -

Java编程语言提供以下类型的循环来处理循环要求。

序号循环 & 描述
1 while 循环
在给定条件为真时重复一个语句或一组语句。它在执行循环体之前测试条件。

2 for 循环
多次执行一系列语句并缩写管理循环变量的代码。

3 do…while 循环
像while语句一样，只是它在循环体的末尾测试条件。

while 循环

只要给定条件为真，Java编程语言中的while循环语句会重复执行目标语句。

while循环的语法是 -

while(Boolean_expression) {
    // Statements
}

在这里，语句可以是单个语句或一组语句。条件可以是任何表达式，true表示任何非零值。

执行时，如果boolean_expression结果为true，那么循环内的动作将被执行。只要表达结果为真，这将继续。

当条件变为假时，程序控制传递到循环后面的行。

流程图

在这里，while循环的关键点是循环可能永远不会运行。当表达式被测试并且结果为false时，循环体将被跳过，while循环之后的第一条语句将被执行。

例子

public class Test {
    

    public static void main(String args[]) {
        int x = 10;
    
        while( x < 20 ) {
            System.out.print("value of x : " + x );
            x++;
            System.out.print("\n");
        }
    }

}

这将产生以下结果 −

value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19
for 循环

for循环是一个重复控制结构，它允许您高效地编写需要执行特定次数的循环。

当你知道一个任务要重复多少次时，for循环很有用。

for循环的语法是

for(initialization; Boolean_expression; update) {
    // Statements
}

这是for循环中的控制流程

初始化步骤首先执行，并且只执行一次。此步骤允许您声明和初始化任何循环控制变量，并且此步骤以分号（;）结束。
接下来，评估布尔表达式。如果它是真的，则循环的主体被执行。如果它为假，循环的主体将不会执行，并且控制跳转到for循环之后的下一个语句。
在执行for循环的主体之后，控件跳回到update语句。这个语句允许你更新任何循环控制变量。这个声明可以在最后用分号留空。
布尔表达式现在再次被评估。如果它是真的，则循环执行并重复该过程（循环体，然后更新步骤，然后布尔表达式）。布尔表达式为false后，for循环终止。
流程图

例子

下面是Java中for循环的示例代码。

public class Test {
    

    public static void main(String args[]) {
    
        for(int x = 10; x < 20; x = x + 1) {
            System.out.print("value of x : " + x );
            System.out.print("\n");
        }
    }

}

这将产生以下结果 −

value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19
do…while 循环

do … while循环类似于while循环，除了do … while循环保证至少执行一次。

以下是do … while循环的语法 -

do {
    // Statements
}while(Boolean_expression);

请注意，布尔表达式出现在循环的结尾，因此循环中的语句在布尔测试之前执行一次。

如果布尔表达式为true，则控制返回执行语句，并且循环中的语句再次执行。这个过程重复，直到布尔表达式为假。

流程图

例子

public class Test {
    

    public static void main(String args[]) {
        int x = 10;
    
        do {
            System.out.print("value of x : " + x );
            x++;
            System.out.print("\n");
        }while( x < 20 );
    }

}

这将产生以下结果 −

value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19
循环控制语句

循环控制语句从其正常序列中执行。当执行离开作用域时，在该作用域中创建的所有自动对象都将被销毁。

Java支持以下控制语句。

序号控制语句 & 描述
1 break 语句
终止循环或切换语句并将执行转移到循环或切换后的语句。

2 continue 语句
使循环跳过其正文的其余部分，并在重复之前立即重新测试其条件。

break 语句

Java编程语言中的break语句有以下两种用法 -

当在循环中遇到break语句时，循环立即终止，程序控制在循环之后的下一个语句处重新开始。
它可以用于在switch语句中终止一个case（在下一章中会介绍）。
break语法是任何循环内的单个语句 -

break;
流程图

例子

public class Test {
    

    public static void main(String args[]) {
        int [] numbers = {10, 20, 30, 40, 50};
    
        for(int x : numbers ) {
            if( x == 30 ) {
                break;
            }
            System.out.print( x );
            System.out.print("\n");
        }
    }

}

这将产生以下结果 −

10
20
continue 语句

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

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

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

语法

continue 就是循环体中一条简单的语句

continue;
流程图

例子

public class Test {
    

    public static void main(String args[]) {
        int [] numbers = {10, 20, 30, 40, 50};
    
        for(int x : numbers ) {
            if( x == 30 ) {
                continue;
            }
            System.out.print( x );
            System.out.print("\n");
        }
    }

}

这将产生以下结果 −

10
20
40
50
Java中的增强循环

从Java 5开始，增强的for循环被引入。这主要用于遍历包含数组的元素的集合。

语法

以下是增强for循环的语法 -

for(declaration : expression) {
    // Statements
}

声明 - 新声明的块变量的类型与您正在访问的数组元素兼容。该变量将在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(",");
        }
    }

}

这将产生以下结果 -

10, 20, 30, 40, 50,
James, Larry, Tom, Lacy,

十一、判断

Java 判断

决策制定结构有一个或多个条件需要由程序进行评估或测试，以及如果条件被确定为真时要执行的一个或多个语句，并且可选地在确定条件时执行其他语句是假的。

以下是大多数编程语言中典型决策结构的一般形式 -

Java编程语言提供以下类型的决策声明。

语句描述
if语句
一个if语句由一个布尔表达式和一个或多个语句组成。

if…else 语句
一个if语句可以跟随一个可选的else语句，当布尔表达式为false时执行该语句。

嵌套 if 语句
您可以在另一个if或else if语句中使用if或else if语句。

switch 语句
switch语句允许测试一个变量是否与值列表相等。

if语句

一个if语句由一个布尔表达式和一个或多个语句组成。

以下是if语句的语法 -

if(Boolean_expression) {
// Statements will execute if the Boolean expression is true
}
如果布尔表达式的计算结果为true，那么将执行if语句内的代码块。如果不是，则会在if语句结束后（在大括号后）执行第一组代码。

流程图

例子

public class Test {
    

    public static void main(String args[]) {
        int x = 10;
    
        if( x < 20 ) {
            System.out.print("This is if statement");
        }
    }

}

这将产生以下结果 −

This is if statement.
if…else 语句

一个if语句可以跟随一个可选的else语句，当布尔表达式为false时执行该语句。

以下是if … else语句的语法 -

if(Boolean_expression) {
    // Executes when the Boolean expression is true
}else {
    // Executes when the Boolean expression is false
}

如果布尔表达式的计算结果为true，那么将执行if代码块，否则将执行代码块。

流程图

例子

public class Test {
    

    public static void main(String args[]) {
        int x = 30;
    
        if( x < 20 ) {
            System.out.print("This is if statement");
        } else {
            System.out.print("This is else statement");
        }
    }

}

这将产生以下结果 −

This is else statement
if…else if…else 语句

一个if语句可以跟随一个可选的else if … else语句，这对使用单个if … else if语句测试各种条件非常有用。

当使用if，else if，else语句时，有几点需要注意。

一个if可以有零个或另一个，它必须在任何其他if之后。
一个if可以有零到其他许多if，它们必须在else之前。
一旦其他成功，其余的其他if或else都将被测试。
以下是if…if else…else语句的语法 -

if(Boolean_expression 1) {
    // Executes when the Boolean expression 1 is true
    }else if(Boolean_expression 2) {
    // Executes when the Boolean expression 2 is true
    }else if(Boolean_expression 3) {
    // Executes when the Boolean expression 3 is true
    }else {
    // Executes when the none of the above condition is true.
}

例子

public class Test {
    

    public static void main(String args[]) {
        int x = 30;
    
        if( x == 10 ) {
            System.out.print("Value of X is 10");
        }else if( x == 20 ) {
            System.out.print("Value of X is 20");
        }else if( x == 30 ) {
            System.out.print("Value of X is 30");
        }else {
            System.out.print("This is else statement");
        }
    }

}

这将产生以下结果 −

Value of X is 30
嵌套 if 语句

嵌套if-else语句总是合法的，这意味着您可以在另一个if或else语句中使用if或else if语句。

嵌套的if … else的语法如下所示 -

if(Boolean_expression 1) {
    // Executes when the Boolean expression 1 is true
    if(Boolean_expression 2) {
    // Executes when the Boolean expression 2 is true
    }
}

你可以嵌套else if … else，就像我们嵌套if语句一样。

例子

public class Test {
    

    public static void main(String args[]) {
        int x = 30;
        int y = 10;
    
        if( x == 30 ) {
            if( y == 10 ) {
                System.out.print("X = 30 and Y = 10");
            }
        }
    }

}

这将产生以下结果 −

X = 30 and Y = 10
switch 语句

switch语句允许测试一个变量是否与值列表相等。每个值都被称为一个案例，并且检查每个案例中打开的变量。

增强for循环的语法是 -

switch(expression) {
    case value :
    // Statements
    break; // optional
    

    case value :
    // Statements
    break; // optional
    
    // You can have any number of case statements.
    default : // Optional
    // Statements

}

以下规则适用于switch语句 -

switch语句中使用的变量只能是整数，可转换整数（byte，short，char），字符串和枚举。
switch中可以有任意数量的case语句。每个案例后面跟着要比较的值和一个冒号。
案例的值必须与switch中的变量具有相同的数据类型，并且它必须是常量或文字。
当接通的变量等于一个case时，这个case后面的语句将会执行，直到到达break语句。
当达到break语句时，开关终止，并且控制流程跳转到switch语句后面的下一行。
并非所有情况下都需要包含break。如果没有break，则控制流程将落入后续案例，直至达到一个break。
switch语句可以有一个可选的默认情况，它必须出现在交换机的末尾。如果没有任何一种情况属实，默认情况下可用于执行任务。默认情况下不需要break。
流程图

例子

public class Test {
    

    public static void main(String args[]) {
        // char grade = args[0].charAt(0);
        char grade = 'C';
    
        switch(grade) {
            case 'A' :
                System.out.println("Excellent!");
                break;
            case 'B' :
            case 'C' :
                System.out.println("Well done");
                break;
            case 'D' :
                System.out.println("You passed");
            case 'F' :
                System.out.println("Better try again");
                break;
            default :
                System.out.println("Invalid grade");
        }
        System.out.println("Your grade is " + grade);
    }

}

编译并运行上述程序。这将产生以下结果 -

Well done
Your grade is C
? : 运算符(三元运算符)

我们已经在前面的章节中讲解了条件运算符 ? :，可以用来替代 if…else 语句。它的一般形式如下：

Exp1 ? Exp2 : Exp3;
其中，Exp1、Exp2 和 Exp3 是表达式。请注意，冒号的使用和位置。

? 表达式的值是由 Exp1 决定的。如果 Exp1 为真，则计算 Exp2 的值，结果即为整个 ? 表达式的值。如果 Exp1 为假，则计算 Exp3 的值，结果即为整个 ? 表达式的值。

为了确定整个表达式的值，首先评估exp1。

如果exp1的值为真，则Exp2的值将是整个表达式的值。

如果exp1的值为false，则评估Exp3并将其值变为整个表达式的值。

十二、 Numbers类

Java - Numbers类

通常，当我们使用Numbers时，我们使用诸如byte，int，long，double等原始数据类型。

例子

int i = 5000;
float gpa = 13.65;
double mask = 0xaf;

但是，在开发过程中，我们遇到了需要使用对象而不是基本数据类型的情况。为了实现这一点，Java提供了包装类。

所有包装类（整型，长型，字节型，双精度型，浮点型，短型）都是抽象类Number的子类。

包装类的对象包含或包装其各自的原始数据类型。将原始数据类型转换为对象称为装箱，这由编译器负责。因此，在使用包装类时，您只需将基元数据类型的值传递给Wrapper类的构造函数即可。

并且Wrapper对象将被转换回原始数据类型，并且这个过程被称为拆箱。 Number类是java.lang包的一部分。

以下是装箱和拆箱的例子 -

public class Test {
    

    public static void main(String args[]) {
        Integer x = 5; // boxes int to an Integer object
        x =  x + 10;   // unboxes the Integer to a int
        System.out.println(x);
    }

}

这将产生以下结果 −

15
当x被分配一个整数值时，编译器会将该整数装箱，因为x是整数对象。稍后，x将被拆箱，以便它们可以作为整数添加。

Number方法

以下是Number类的所有子类实现的实例方法的列表 -

序号方法 & 描述
1 xxxValue()
将 Number 对象转换为xxx数据类型的值并返回。
2 compareTo()
将number对象与参数比较。
3 equals()
判断number对象是否与参数相等。
4 valueOf()
返回一个 Number 对象指定的内置数据类型
5 toString()
以字符串形式返回值。
6 parseInt()
将字符串解析为int类型。
7 abs()
返回参数的绝对值。
8 ceil()
返回大于等于( >= )给定参数的的最小整数。
9 floor()
返回小于等于（<=）给定参数的最大整数。
10 rint()
返回与参数最接近的整数。返回类型为double。
11
round()
它表示四舍五入，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12，Math.round(-11.5) 的结果为-11。

12 min()
返回两个参数中的最小值。
13 max()
返回两个参数中的最大值。
14 exp()
返回自然数底数e的参数次方。
15 log()
返回参数的自然数底数的对数值。
16 pow()
返回第一个参数的第二个参数次方。
17 sqrt()
求参数的算术平方根。
18 sin()
求指定double类型参数的正弦值。
19 cos()
求指定double类型参数的余弦值。
20 tan()
求指定double类型参数的正切值。
21 asin()
求指定double类型参数的反正弦值。
22 acos()
求指定double类型参数的反余弦值。
23 atan()
求指定double类型参数的反正切值。
24 atan2()
将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。
25 toDegrees()
将参数转化为角度。
26 toRadians()
将角度转换为弧度。
27 random()
返回一个随机数。
xxxValue() 方法

描述

该方法将调用方法的Number对象的值转换为从该方法返回的基本数据类型。

语法

这是每种基本数据类型的单独方法 -

byte byteValue()
short shortValue()
int intValue()
long longValue()
float floatValue()
double doubleValue()
参数

这里是参数的细节 -

所有这些都是默认方法并且不接受任何参数。
返回值

此方法返回签名中给出的原始数据类型。
例子

public class Test {
    

    public static void main(String args[]) {
        Integer x = 5;
    
        // Returns byte primitive data type
        System.out.println( x.byteValue() );
    
        // Returns double primitive data type
        System.out.println(x.doubleValue());
    
        // Returns long primitive data type
        System.out.println( x.longValue() );
    }

}

这将产生以下结果 -

5
5.0
5
compareTo() 方法

compareTo() 方法用于将 Number 对象与方法的参数进行比较。可用于比较 Byte, Long, Integer等。

该方法用于两个相同数据类型的比较，两个不同类型的数据不能用此方法来比较。

语法

public int compareTo( NumberSubClass referenceName )
参数

referenceName – 可以是一个 Byte, Double, Integer, Float, Long 或 Short 类型的参数。

返回值

如果指定的数与参数相等返回0。

如果指定的数小于参数返回 -1。

如果指定的数大于参数返回 1。

例子

public class Test {
    

    public static void main(String args[]) {
        Integer x = 5;
    
        System.out.println(x.compareTo(3));
        System.out.println(x.compareTo(5));
        System.out.println(x.compareTo(8));
    }

}

这将产生以下结果 -

1
0
-1
equals() 方法

equals() 方法用于判断 Number 对象与方法的参数进是否相等。

语法

public boolean equals(Object o)
参数

– 任何对象。

返回值

如果参数不是null并且是具有相同类型和相同数值的对象，则该方法返回True。对于Java API文档中描述的Double和Float对象有一些额外的要求。

实例

public class Test {
    

    public static void main(String args[]) {
        Integer x = 5;
        Integer y = 10;
        Integer z =5;
        Short a = 5;
    
        System.out.println(x.equals(y));
        System.out.println(x.equals(z));
        System.out.println(x.equals(a));
    }

}

编译以上程序，输出结果为：

false
true
false

十三、Character 类

Java Character 类

通常，当我们使用字符时，我们使用原始数据类型char。

例子

char ch = 'a';

// Unicode for uppercase Greek omega character
char uniChar = '\u039A';

// an array of chars
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };

然而在开发中，我们遇到了需要使用对象而不是基本数据类型的情况。为了实现这一点，Java为原始数据类型char提供了包装类Character。

Character类提供了许多有用的类（即静态）方法来处理字符。您可以使用Character构造函数创建Character对象 -

Character ch = new Character(‘a’);
在某些情况下，Java编译器也会为您创建一个Character对象。例如，如果您将一个原始字符传递给期望对象的方法，编译器会自动将该字符转换为一个字符。如果转换以其他方式进行，此功能称为自动装箱或取消装箱。

例子

// Here following primitive char 'a'
// is boxed into the Character object ch
Character ch = 'a';

// Here primitive 'x' is boxed for method test,
// return is unboxed to char 'c'
char c = test('x');

转义序列

以反斜杠（\）开头的字符是转义序列，对编译器有特殊意义。

在本教程中，换行符（\ n）在System.out.println（）语句中经常用于在打印字符串之后前进到下一行。

下表显示了Java转义序列 -

转义序列描述
\t 在文中该处插入一个tab键
\b 在文中该处插入一个后退键
\n 在文中该处换行
\r 在文中该处插入回车
\f 在文中该处插入换页符
’ 在文中该处插入单引号
" 在文中该处插入双引号
\ 在文中该处插入反斜杠
当在打印语句中遇到转义序列时，编译器会相应地解释它。

例子

如果你想把引号放在引号内，你必须在内部引号上使用转义序列\“，

public class Test {
    

    public static void main(String args[]) {
        System.out.println("She said \"Hello!\" to me.");
    }

}

这将产生以下结果 −

She said “Hello!” to me.
Character 方法

下面是Character类的方法 -

b序号 b方法与描述
1 isLetter()
是否是一个字母
2 isDigit()
是否是一个数字字符
3 isWhitespace()
是否是一个空格
4 isUpperCase()
是否是大写字母
5 isLowerCase()
是否是小写字母
6 toUpperCase()
指定字母的大写形式
7 toLowerCase()
指定字母的小写形式
8 toString()
返回字符的字符串形式，字符串的长度仅为1
有关方法的完整列表，请参阅java.lang.Character API规范。

十四、String类

Java String 类

在Java编程中广泛使用的字符串是一系列字符。在Java编程语言中，字符串被视为对象。

Java平台提供了String类来创建和操作字符串。

创建字符串

创建字符串最直接的方法是编写 -

String greeting = "Hello world!";

只要遇到代码中的字符串文字，编译器就会在这种情况下创建一个字符串对象“Hello world！”。

与任何其他对象一样，您可以使用new关键字和构造函数创建String对象。 String类有11个构造函数，它们允许您使用不同的来源（如字符数组）提供字符串的初始值。

例子

public class StringDemo {
    

    public static void main(String args[]) {
        char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.' };
        String helloString = new String(helloArray);
        System.out.println( helloString );
    }

}

这将产生以下结果 −

hello.
注 − String类是不可变的，所以一旦创建了String对象就不能改变。如果需要对字符串进行大量修改，则应使用字符串缓冲区和字符串生成器类。

字符串长度

用于获取关于对象的信息的方法被称为访问器方法。一个可以用于字符串的存取方法是length（）方法，它返回字符串对象中包含的字符数。

以下程序是length（）方法String类的一个示例。

例子

public class StringDemo {

    public static void main(String args[]) {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length();
        System.out.println( "String Length is : " + len );
    }

}

这将产生以下结果 −

String Length is : 17
连接字符串

String类包含一个连接两个字符串的方法 −

string1.concat(string2);
这将返回一个新的字符串，该字符串是string1，并在末尾添加了string2。您也可以使用字符串文字的concat（）方法，如 −

"My name is ".concat(“Zara”);
字符串通常与+运算符连接在一起， −

“Hello,” + " world" + “!”
这导致了 −

“Hello, world!”
让我们看看下面的例子 −

例子

public class StringDemo {
    

    public static void main(String args[]) {
        String string1 = "saw I was ";
        System.out.println("Dot " + string1 + "Tod");
    }

}

这将产生以下结果 −

Dot saw I was Tod
创建格式字符串

你有printf（）和format（）方法来打印带格式数字的输出。 String类有一个等效的类方法format（），它返回一个String对象而不是一个PrintStream对象。

使用String的静态格式（）方法可以创建可以重用的格式化字符串，而不是一次性打印语句。例如，而不是 -

例子

System.out.printf("The value of the float variable is " +
    "%f, while the value of the integer " +
    "variable is %d, and the string " +
    "is %s", floatVar, intVar, stringVar);
你可以写 −

String fs;
fs = String.format("The value of the float variable is " +
    "%f, while the value of the integer " +
    "variable is %d, and the string " +
    "is %s", floatVar, intVar, stringVar);
System.out.println(fs);

字符串方法

这里是String类支持的方法列表 -

SN(序号) 方法描述
1 char charAt(int index)
返回指定索引处的 char 值。
2 int compareTo(Object o)
把这个字符串和另一个对象比较。
3 int compareTo(String anotherString)
按字典顺序比较两个字符串。
4 int compareToIgnoreCase(String str)
按字典顺序比较两个字符串，不考虑大小写。
5 String concat(String str)
将指定字符串连接到此字符串的结尾。
6 boolean contentEquals(StringBuffer sb)
当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真。
7 static String copyValueOf(char[] data)
返回指定数组中表示该字符序列的 String。
8 static String copyValueOf(char[] data, int offset, int count)
返回指定数组中表示该字符序列的 String。
9 boolean endsWith(String suffix)
测试此字符串是否以指定的后缀结束。
10 boolean equals(Object anObject)
将此字符串与指定的对象比较。
11 boolean equalsIgnoreCase(String anotherString)
将此 String 与另一个 String 比较，不考虑大小写。
12 byte[] getBytes()
使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
13 byte[] getBytes(String charsetName)
使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
14 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符从此字符串复制到目标字符数组。
15 int hashCode()
返回此字符串的哈希码。
16 int indexOf(int ch)
返回指定字符在此字符串中第一次出现处的索引。
17 int indexOf(int ch, int fromIndex)
返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
18 int indexOf(String str)
返回指定子字符串在此字符串中第一次出现处的索引。
19 int indexOf(String str, int fromIndex)
返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
20 String intern()
返回字符串对象的规范化表示形式。
21 int lastIndexOf(int ch)
返回指定字符在此字符串中最后一次出现处的索引。
22 int lastIndexOf(int ch, int fromIndex)
返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
23 int lastIndexOf(String str)
返回指定子字符串在此字符串中最右边出现处的索引。
24 int lastIndexOf(String str, int fromIndex)
返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
25 int length()
返回此字符串的长度。
26 boolean matches(String regex)
告知此字符串是否匹配给定的正则表达式。
27 boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
测试两个字符串区域是否相等。
28 boolean regionMatches(int toffset, String other, int ooffset, int len)
测试两个字符串区域是否相等。
29 String replace(char oldChar, char newChar)
返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
30 String replaceAll(String regex, String replacement)
使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
31 String replaceFirst(String regex, String replacement)
使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
32 String[] split(String regex)
根据给定正则表达式的匹配拆分此字符串。
33 String[] split(String regex, int limit)
根据匹配给定的正则表达式来拆分此字符串。
34 boolean startsWith(String prefix)
测试此字符串是否以指定的前缀开始。
35 boolean startsWith(String prefix, int toffset)
测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
36 CharSequence subSequence(int beginIndex, int endIndex)
返回一个新的字符序列，它是此序列的一个子序列。
37 String substring(int beginIndex)
返回一个新的字符串，它是此字符串的一个子字符串。
38 String substring(int beginIndex, int endIndex)
返回一个新字符串，它是此字符串的一个子字符串。
39 char[] toCharArray()
将此字符串转换为一个新的字符数组。
40 String toLowerCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
41 String toLowerCase(Locale locale)
使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
42 String toString()
返回此对象本身（它已经是一个字符串！）。
43 String toUpperCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
44 String toUpperCase(Locale locale)
使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
45 String trim()
返回字符串的副本，忽略前导空白和尾部空白。
46 static String valueOf(primitive data type x)
返回给定data type类型x参数的字符串表示形式。
String Buffer and String Builder类

当需要对字符串进行大量修改时，使用StringBuffer和StringBuilder类。

与字符串不同，StringBuffer和String构建器类型的对象可以一遍又一遍地修改，而不会留下很多新的未使用的对象。

StringBuilder类是从Java 5开始引入的，StringBuffer和StringBuilder的主要区别在于StringBuilders方法不是线程安全的（不同步）。

建议尽可能使用StringBuilder，因为它比StringBuffer快。但是，如果线程安全是必要的，最好的选择是StringBuffer对象。

例子

public class Test {
    

    public static void main(String args[]) {
        StringBuffer sBuffer = new StringBuffer("test");
        sBuffer.append(" String Buffer");
        System.out.println(sBuffer);
    }

}

这将产生一下结果 −

test String Buffer
StringBuffer 方法

以下是 StringBuffer 类支持的主要方法 -

序号方法描述
1 public StringBuffer append(String s)
将指定的字符串追加到此字符序列。
2 public StringBuffer reverse()
将此字符序列用其反转形式取代。
3 public delete(int start, int end)
移除此序列的子字符串中的字符。
4 public insert(int offset, int i)
将 int 参数的字符串表示形式插入此序列中。
5 replace(int start, int end, String str)
使用给定 String 中的字符替换此序列的子字符串中的字符。
下面的列表里的方法和 String 类的方法类似 -

序号方法描述
1 int capacity()
返回当前容量。
2 char charAt(int index)
返回此序列中指定索引处的 char 值。
3 void ensureCapacity(int minimumCapacity)
确保容量至少等于指定的最小值。
4 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符从此序列复制到目标字符数组 dst。
5 int indexOf(String str)
返回第一次出现的指定子字符串在该字符串中的索引。
6 int indexOf(String str, int fromIndex)
从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
7 int lastIndexOf(String str)
返回最右边出现的指定子字符串在此字符串中的索引。
8 int lastIndexOf(String str, int fromIndex)
返回 String 对象中子字符串最后出现的位置。
9 int length()
返回长度（字符数）。
10 void setCharAt(int index, char ch)
将给定索引处的字符设置为 ch。
11 void setLength(int newLength)
设置字符序列的长度。
12 CharSequence subSequence(int start, int end)
返回一个新的字符序列，该字符序列是此序列的子序列。
13 String substring(int start)
返回一个新的 String，它包含此字符序列当前所包含的字符子序列。
14 String substring(int start, int end)
返回一个新的 String，它包含此序列当前所包含的字符子序列。
15 String toString()
返回此序列中数据的字符串表示形式。

十五、数组

Java 数组

Java提供了一个数据结构，该数组存储相同类型元素的固定大小的顺序集合。数组用于存储数据集合，但将数组视为相同类型的变量集合通常更有用。

您不需要声明单个变量，如number0，number1，…和number99，而是声明一个数组变量，如数字和使用数字[0]，数字[1]和…，数字[99]来表示个体变量。

本教程介绍了如何声明数组变量，创建数组和使用索引变量处理数组。

声明数组变量

要在程序中使用数组，必须声明一个变量来引用该数组，并且必须指定该变量可以引用的数组的类型。这里是声明一个数组变量的语法 -

语法

dataType[] arrayRefVar;   // preferred way.
or
dataType arrayRefVar[];  // works but not preferred way.

注 - 样式dataType [] arrayRefVar是首选。样式dataType arrayRefVar []来自C / C ++语言，并被Java采纳以适应C / C ++程序员。

例子

以下代码片段是此语法的示例 -

double[] myList;   // preferred way.
or
double myList[];   // works but not preferred way.

创建数组

您可以通过使用以下语法使用新运算符来创建一个数组 -

语法

arrayRefVar = new dataType[arraySize];
上面的语法语句做了两件事 -

一、使用 dataType[arraySize] 创建了一个数组。
二、把新创建的数组的引用赋值给变量 arrayRefVar。
数组变量的声明，和创建数组可以用一条语句完成，如下所示 -

dataType[] arrayRefVar = new dataType[arraySize];
另外，你还可以使用如下的方式创建数组。

dataType[] arrayRefVar = {value0, value1, …, valuek};
数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1。

例子

下面的语句首先声明了一个数组变量 myList，接着创建了一个包含 10 个 double 类型元素的数组，并且把它的引用赋值给 myList 变量。

double[] myList = new double[10];
下面的图片代表数组myList。在这里，myList包含十个double值，索引从0到9.

访问数组

访问数组元素时，我们经常使用for循环或foreach循环，因为数组中的所有元素都是相同类型，并且数组的大小已知。

例子

这里是一个完整的例子，展示了如何创建，初始化和处理数组 -

public class TestArray {
    

    public static void main(String[] args) {
        double[] myList = {1.9, 2.9, 3.4, 3.5};
    
        // Print all the array elements
        for (int i = 0; i < myList.length; i++) {
            System.out.println(myList[i] + " ");
            }
    
        // Summing all elements
        double total = 0;
        for (int i = 0; i < myList.length; i++) {
            total += myList[i];
        }
        System.out.println("Total is " + total);
    
        // Finding the largest element
        double max = myList[0];
        for (int i = 1; i < myList.length; i++) {
            if (myList[i] > max) max = myList[i];
        }
        System.out.println("Max is " + max);
    }

}

这将产生以下结果 −

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5
foreach 循环

JDK 1.5引入了一个新的for循环，称为foreach循环或增强for循环，使您可以在不使用索引变量的情况下顺序遍历整个数组。

例子

以下代码显示数组myList中的所有元素 -

public class TestArray {
    

    public static void main(String[] args) {
        double[] myList = {1.9, 2.9, 3.4, 3.5};
    
        // Print all the array elements
        for (double element: myList) {
            System.out.println(element);
        }
    }

}

这将产生以下结果 −

1.9
2.9
3.4
3.5
将数组传递给方法

就像您可以将原始类型值传递给方法一样，您也可以将数组传递给方法。例如，以下方法在int数组中显示元素 -

例子

public static void printArray(int[] array) {
    for (int i = 0; i < array.length; i++) {
        System.out.print(array[i] + " ");
    }
}

你可以通过传递一个数组来调用它。例如，以下语句调用printArray方法来显示3,1,2,6,4和2 -

例子

printArray(new int[]{3, 1, 2, 6, 4, 2});

从方法返回数组

一个方法也可以返回一个数组。例如，下面的方法返回一个数组，它是另一个数组的反转 -

例子

public static int[] reverse(int[] list) {
    int[] result = new int[list.length];
    

    for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
        result[j] = list[i];
    }
    return result;

}

Arrays 类

java.util.Arrays类包含各种静态方法，用于排序和搜索数组，比较数组和填充数组元素。这些方法对于所有基元类型都是重载的

序号方法和说明
1 public static int binarySearch(Object[] a, Object key)
用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
2 public static boolean equals(long[] a, long[] a2)
如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
3 public static void fill(int[] a, int val)
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
4 public static void sort(Object[] a)
对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

已更新，未完待续。。。

java语言学习

java基础知识

文章目录

一、预言

二、简介

三、环境设置

四、基本语法

五、对象和类

六、基本数据类型

七、变量类型

八、修饰符

九、运算符

十、循环控制

十一、判断

十二、 Numbers类

十三、Character 类

十四、String类

十五、数组

你可能感兴趣的:(java,java,unix,jvm)