StudyTonight-Java-中文教程-一-

StudyTonight Java 中文教程（一）

原文：StudyTonight

协议：CC BY-NC-SA 4.0

Java 核心

Java 基础

Java 简介

原文：https://www.studytonight.com/java/overview-of-java.php

Java 是世界上最重要和使用最广泛的计算机语言之一，它多年来一直保持着这种区别。不像其他一些计算机语言，它们的影响力随着时间的推移而减弱，而 Java 的影响力却在增长。

Java 是一种高级的、健壮的、面向对象的、安全稳定的编程语言，但它不是一种纯面向对象的语言，因为它支持像 int、char 等基本数据类型。

Java 是一种独立于平台的语言，因为它有运行时环境，即 JRE 和 API。这里，平台是指运行应用的硬件或软件环境。

Java 代码被编译成字节代码或独立于机器的代码。这个字节码在 JVM (Java 虚拟机)上运行。

语法是 Java 和 C/C++几乎一样。但是 java 不支持像指针这样的低级编程功能。Java 中的代码总是以类和对象的形式编写的。

截至 2020 年，Java 是使用中最流行的编程语言之一，尤其是对于客户端-服务器 web 应用。据估计，世界上大约有 900 万 Java 开发人员。

Java 的创建

Java 是由詹姆斯·戈林、帕特里克·诺顿、迈克·谢里丹于 1991 年在太阳微系统公司开发的。开发第一个工作版本花了 18 个月。

最初的名字是 Oak ，但在 1995 年更名为 Java ，因为 Oak 是另一家科技公司的注册商标。

Java 的历史

Java 最初是为交互式电视设计的，但这项技术在当时的数字有线电视行业非常先进。Java 历史是从绿队开始的。绿色团队启动了一个项目，为电视等数字设备开发一种语言。但它最适合互联网编程。一段时间后，网景公司加入了 Java 技术。

创建 Java 编程语言的目标是它应该“简单、健壮、可移植、独立于平台、安全、高性能、多线程、面向对象、可解释和动态”。

Java 是由詹姆斯·戈林、帕特里克·诺顿、迈克·谢里丹于 1991 年在太阳微系统公司开发的。开发第一个工作版本花了 18 个月。詹姆斯·戈林也被称为 Java 之父。

最初，Java 被詹姆斯·高斯林称为“绿色对话”，当时的文件扩展名是“T2”。gt 。

后来，橡树被开发为绿色团队项目的一部分。橡树是力量的象征，在美国、罗马尼亚等许多国家，橡树也是国树。

橡树在 1995 年更名为 Java，因为橡树已经是橡树科技的商标。在选择 Java 这个词之前，团队建议了很多名字，比如动态、革命、丝绸、雷震、 DNA 等。

Java 是印度尼西亚的一个岛屿，这里出产了第一种咖啡或者我们称之为 Java 咖啡。Java 咖啡是一种浓缩咖啡豆。詹姆斯·高斯林在办公室附近喝咖啡时选择了这个名字。

JAVA 这个词没有首字母缩略词。这只是一个名字。

1995 年，Java 是《时代》杂志评选的最佳产品之一。

Java 版本历史

这里我们列出了 Java 的所有版本以及这些版本中引入的主要特性。

This is the first version, but it has unstable API and ABIs.
This is the first version, but there are unstable APIs and APIs.

|
| JDK 1.0 | 橡树 | 1996 年 1 月 |

The first stable edition

|
| JDK 1.1 | | 1997 年 2 月 |

AWT event modeling and reorganization.
Added inner class, Java bean, JDBC, RMI, reflection, JIT.
Added inner class, Java bean, JDBC, RMI, reflection, JIT.

|
| J2SE 1.2 | 操场 | 1998 年 12 月 |

JDK was replaced by J2SE.
Strictfp keyword is supported.
Swing API integrated with core class.
Assemble the frame.

|
| J2SE 1.3 | 红隼 | 2000 年 5 月 |

Hotspot JVM contains
RMI has been modified.
JNDI(Java Naming and Directory Interface) support
JPDA(Java Platform Debugger Architecture).
Contains proxy classes.

|
| J2SE 1.4 | 梅林 | 2002 年 2 月 |

Assertion keywords are supported.
Regular expressions are supported.
Support abnormal links.
Support abnormal links.
内含 Java 网站启动.
支持 API 首选项.

|
| J2SE 5.0 | 泰格 | 2004 年 9 月 |

Contains generics, metadata, auto-boxing/unboxing, enumeration, variables.
Each cycle is enhanced.
Support static import.

|
| Java SE 6 | 野马 | 2006 年 12 月 |

Win9x version is supported.
Support scripting language.
Improve the swing performance.
Support JDBC 4.0
Upgrade JAXB to 2.0.
And GUI JVM.

|
| Java SE 7 | 海豚 | 2011 年 7 月 |

Support dynamic language in JVM.
Contains 64-bit pointers.
Support serial switch.
Support resource management in test block.
Supports binary integer text quantity.
Underline in numeric text is supported.
Multiple exceptions are supported.
Contains the input/output library of.

|
| Java se 8(lt) | | 2014 年 3 月 |

Support JSR 335 and JEP 126.
Supports unsigned integers.
Support date and time API.
包含 JavaFX .
支持 Windows XP .

|
| Java SE 9 | | 2017 年 9 月 |

Supports multiple gigabyte heaps.
Contains a garbage collector.

|
| Java SE 10 | | 2018 年 3 月 |

Support local variable type inference.
Support local variable type inference.
Contains application classes.

|
| Java se 11(lt) | | 2018 年 9 月 |

Bug repair is supported.
Support transport layer security.

|
| Java SE 12 | | 2019 年 3 月 |

Support JVM constant API.

|
| Java SE 13 | | 2019 年 9 月 |

Update switch expression.
Contains text blocks.
Support legacy socket API.

|
| Java SE 14 | | 2020 年 3 月 |

Support event flow.
改进了 NullPointerException .
Clear concurrent mark clearing (CMS) in garbage collector.

|
| Java SE 15 | | 2020 年 9 月 | |
| Java SE 16 | | 2021 年 3 月 | |
| Java se 17(lt) | | 2021 年 9 月 | |

Java 的演变

Java 最初是作为 Java 1.0 推出的，但在最初发布后不久，Java 1.1 就推出了。Java 1.1 重新定义了事件处理，增加了新的库元素。

在 Java 1.2 中增加了 Swing 和 Collection 框架，从 Thread 类中弃用suspend()、resume()和stop()方法。

没有对 Java 1.3 进行重大更改，但是下一个版本 Java 1.4 包含了几个重要的更改。关键字assert，介绍了链式异常和基于通道的输入输出系统。

Java 1.5 被称为 J2SE 5 ，它增加了以下主要新功能:

无商标消费品
释文
汽车尾气与汽车尾气排放
列举
对于每个循环
Varargs
静态导入
格式化输入输出
并发实用程序

下一个主要版本是 Java SE 7 ，其中包括许多新的变化，例如:

现在字符串可以用来控制 Switch 语句。
多重捕捉异常
资源试用语句
二进制整数文字
数字文字中的下划线等。

Java SE 8 于 2014 年 3 月 18 日发布。JAVA 8 中引入的一些主要新特性是，

Lambda 表达式
新收集包java.util.stream提供流 API。
增强的安全性
包含纳斯霍恩 Javascript 引擎
并行数组排序
JDBC-ODBC 桥已被拆除等。

Java SE 9 于 2017 年 9 月发布。JAVA 9 中引入的一些主要新特性是，

平台模块系统(项目拼图)
接口私有方法
尝试-使用资源
匿名类
@SafeVarargs 注释
集合工厂方法
过程 API 改进

Java SE 10 于 2018 年 3 月发布。JAVA 10 中引入的一些主要新特性是，

支持局部变量类型推断。
支持局部变量类型推断。
包括应用类。

Java SE 11 于 2018 年 9 月发布。JAVA 11 中引入的一些主要新特性是，

支持错误修复。
包括长期支持(LTS)。
支持传输层安全性。

Java SE 12 于 2019 年 3 月发布。JAVA 12 中引入的一些主要新特性是，

支持 JVM 常量 API。
包括光盘档案。

Java SE 13 于 2019 年 9 月发布。JAVA 13 中引入的一些主要新特性是，

更新了开关表达式。
包括文本块。
支持传统套接字 API。

Java SE 14 于 2020 年 3 月发布。JAVA 14 中引入的一些主要新特性是，

支持事件流。
改进的 NullPointerException。
垃圾收集器中并发标记清除的移除。

Java 的应用

Java 广泛应用于世界和人类生活的各个角落。Java 不仅用于软件，而且广泛用于硬件控制软件组件的设计。每年有超过 9.3 亿次 JRE 下载，30 亿部手机运行 java。

以下是 Java 的一些其他用法:

开发桌面应用
Linkedin.com、Snapdeal.com 等网络应用
像安卓这样的移动操作系统
嵌入式系统
机器人和游戏等。

Java 应用的类型

以下是我们可以使用 Java 开发的不同类型的应用:

1.独立应用

独立应用是运行在独立计算机进程上而不添加任何文件进程的应用。独立的应用也被称为 Java GUI 应用或桌面应用，它使用一些标准的 GUI 组件，如 AWT(抽象窗口工具包)、swing 和 JavaFX，并且这个组件被部署到桌面上。这些组件有按钮、菜单、表格、图形用户界面小部件工具包、三维图形等。使用这个组件开发了一个传统的软件，可以安装在每台机器上。

示例:媒体播放器、杀毒、油漆、POS 计费软件等。

2.网络应用

网络应用是客户端运行的客户端-服务器软件应用。Servlets、struts、JSP、Spring、hibernate 等。用于开发客户端-服务器应用。电子商务应用也是用 java 开发的，使用的是电子商务平台，即 Bullerfe。

示例:邮件、电商网站、银行网站等。

3.企业应用

企业应用是中间件应用。在整个企业中使用软件和硬件系统技术和服务。它是为企业领域设计的，例如银行业务系统。

例:电子商务、会计、银行信息系统等。

4.移动应用

对于移动应用，Java 使用 ME 或 J2ME 框架。这个框架是跨平台的，可以跨手机和智能手机运行应用。Java 也为 Android 中的应用开发提供了平台。

例: WhatsApp、Xender 等。

下载 JDK

要在您的系统中运行 Java 程序，您必须从这里下载并安装【JDK 工具包】 (推荐的 Java 版本是 Java 11，但您可以下载 Java 13 或 Java 14)。

Java 特性

原文：https://www.studytonight.com/java/features-of-java.php

创建 Java 背后的主要原因是将可移植性和安全性特性引入计算机语言。除了这两个主要特征之外，还有许多其他特征在塑造这种杰出语言的最终形式中发挥了重要作用。这些特点是:

1)简单

Java 很容易学习，语法也相当简单、干净、易懂。C++中令人困惑和模糊的概念要么在 Java 中被忽略，要么以一种更简洁的方式被重新实现。

Eg : 指针和操作符重载在 java 中并不存在，但曾经是 C++的重要组成部分。

2)面向对象

在 java 中，所有的东西都是有一些数据和行为的对象。Java 可以很容易地扩展，因为它是基于对象模型的。以下是面向对象程序设计的一些基本概念。

目标
班级
遗产
多态性
抽象
包装

3)稳健

Java 主要通过强调编译时错误检查和运行时检查来努力消除容易出错的代码。但是 Java 改进的主要领域是内存管理和错误处理异常，引入了自动垃圾收集器和异常处理。

4)平台独立

不像其他编程语言，如 C，C++等被编译成特定平台的机器。Java 保证是一次编写、随处运行的语言。

在编译时，Java 程序被编译成字节码。这种字节码是独立于平台的，可以在任何机器上运行，另外这种字节码格式也提供了安全性。任何具有 Java 运行时环境的机器都可以运行 Java 程序。

Java is platform Independent Language

5)安全

说到安全性，Java 永远是首选。借助 java 安全特性，它使我们能够开发无病毒、无脾气的系统。Java 程序总是在 Java 运行时环境中运行，与系统操作系统几乎没有交互，因此更安全。

6)多线程

Java 多线程特性使得编写可以同时完成许多任务的程序成为可能。多线程的好处是，它利用相同的内存和其他资源同时执行多个线程，就像在打字时，语法错误会被检查一样。

7)建筑中性

编译器生成的字节码与特定的计算机体系结构无关，因此 Java 程序在任何机器上都很容易解释。

8)便携式

Java 字节码可以携带到任何平台。没有依赖于实现的功能。与存储相关的一切都是预定义的，例如:原始数据类型的大小

9)高性能

Java 是一种解释语言，所以它永远不会像 C 或 C++这样的编译语言那样快。但是，Java 通过使用即时编译器实现了高性能。

10)分布式

Java 也是一种分布式语言。程序可以设计成在计算机网络上运行。Java 有一个特殊的类库，用于使用 TCP/IP 协议进行通信。与 C/C++相比，在 Java 中创建网络连接非常容易。

JAVA 8 的新特性

下面提到的是作为 Java 8 版本的一部分进行的一些核心升级。快速浏览一下就可以了，我们稍后会详细探讨。

通过提供Optional类功能、Lamda 表达式、流等，提高了生产率。
易用性
改进的多语种编程。apolygot是一个程序或脚本，以在多种编程语言中有效的形式编写，并且它在多种编程语言中执行相同的操作。所以 Java 现在支持这种类型的编程技术。
提高安全性和性能。

JAVA 11 的新特性

Java 11 是一个推荐的 LTS 版本的 Java，它包括各种重要的特性。这些功能包括现有主题中的新增和升级。快速浏览一下就可以了，我们稍后会详细探讨。

包括对 Unicode 10.0.0 的支持
超文本传输协议客户端已经标准化
编译器线程的惰性分配
将区域设置数据更新为 Unicode CLDR 版本 33
JEP 331 低开销堆分析
JEP 181 基于嵌套的访问控制
增加了智能池电子商务支持(RFC 5639)
增强的密钥存储机制
JEP 332 传输层安全性 1.3
JEP 330 启动单文件源代码程序

Java 版本

Java Editions 或者我们可以说这个平台是一个程序的集合，它帮助开发和运行用 Java 编程语言编写的程序。Java Editions 包括执行引擎、编译器和一组库。由于 Java 是独立于平台的语言，因此它不特定于任何处理器或操作系统。

1.Java 标准版

Java 标准版是一个计算平台，用于开发和部署桌面和服务器环境中使用的可移植代码。Java 标准版也被称为 Java 2 平台，标准版(J2SE)。

Java 标准版有各种各样的 API，如 Java 类库等。Java SE 的最佳实现是甲骨文公司的 Java 开发工具包(JDK)。

2.Java 微版

Java Micro Edition 是一个计算平台，用于为嵌入式和移动设备开发和部署可移植代码。Java 微版又称 Java 2 平台微版(J2ME)。Java 微版是由太阳微系统公司设计的，后来甲骨文公司在 2010 年收购了它。

例:微控制器、传感器、网关、手机、打印机等。

3.Java 企业版

Java 企业版是一组规范，通过分布式计算和网络服务等功能扩展了 Java SE 8。Java 企业版的应用运行在参考运行时上。该参考运行时处理事务、安全性、可伸缩性、并发性和要部署的组件的管理。Java 企业版又称 Java 2 平台企业版(J2EE)，目前已更名为 Jakarta EE。

例:电子商务、会计、银行信息系统。

4.应用

JavaFX 用于创建桌面应用，也用于创建丰富的互联网应用(RIA)，这些应用可以在各种设备上运行。JavaFX 几乎已经取代 Swing 成为 Java 标准版的标准 GUI 库。支持桌面计算机和网络浏览器。

设置 Java 环境和类路径

原文：https://www.studytonight.com/java/setting-classpath-for-java.php

一个环境变量是计算机上的一个动态“对象”，它存储一个值(像键值对)，可以被 Windows 中的一个或多个软件程序引用。与 java 一样，我们将设置一个名为“ java 的环境变量，其值将是 Java 目录中存在的 /bin 目录的路径。因此，每当一个程序需要 Java 环境时，它都会寻找 java 环境变量，该变量将为它提供执行目录的路径。

设置窗口路径 ( 2000/XP/vista/Window 7，8 )

假设你已经在 C:\程序文件/ Java / JDK 目录中安装了 Java

第一步:右键点击我的电脑，选择属性。

setting classpath in java

第二步:进入高级系统设置选项卡。

setting classpath in java

第三步:点击环境变量按钮。

setting classpath in java

步骤 4 :现在改变路径变量，使其也包含 JDK 安装目录的路径。

setting classpath in java

例如:-更改C:\窗口/系统 32。至C:\ windows/system 32；c:\程序文件/ Java/ JDK 。

为 95/98/ME 窗口设置路径

假设您已经在 C:\程序文件\ java\ JDK 目录中安装了 Java，请执行以下操作:

第一步:编辑 C:\autoexec.bat 文件，并在末尾增加以下一行。

SET PATH =% PATH% C:\ PROGRAM FILE/JAVA/JDK/bin

为 Linux、Unix、Solaris、免费 BSD 设置路径

第 1 步:环境变量路径应该设置为已经安装了 java 二进制文件的点。如果你做这个有困难，参考你的外壳。

例如:如果你使用 bash 作为你的外壳，那么你可以在末尾添加下面一行

bash mc: export PATH=/ Path/to/java

我们建议您下载最新的 Java 11 版本。Java 11 是 LTS(长期支持)版本，目前被广泛使用。您可以参考我们的逐步安装指南来安装 Java 11。

推荐 Java 版本: 下载最新版本的 JDK

Java JVM、JDK 和 JRE

原文：https://www.studytonight.com/java/component-of-java.php

在本教程中，我们将介绍什么是 Java 虚拟机，什么是 JRE 和 JDK。

java 虚拟机(JVM)是一个提供运行时环境来执行 Java 字节代码的虚拟机。JVM 不理解 Java 的错别字，这就是为什么你编译你的*.java文件来获得包含 JVM 可以理解的字节码的*.class文件。

JVM 控制每个 Java 程序的执行。它支持自动异常处理、垃圾收集堆等功能。

JVM 架构

JVM architecture in Java

类加载器:类加载器加载要执行的类。

方法区:将类前结构存储为常量池。

堆:堆是分配对象的内存区域。

栈:局部变量和部分结果存储在这里。每个线程在创建时都有一个私有的 JVM 栈。

程序寄存器:程序寄存器保存当前正在执行的 JVM 指令的地址。

原生方法栈:包含应用中使用的所有原生。

执行引擎:执行引擎控制类的方法中包含的指令的执行。

原生方法接口:原生方法接口在执行过程中给出了 java 代码和原生代码之间的接口。

本机方法库:本机库由执行本机代码所需的文件组成。

JDK 和 JRE 的区别

JRE:Java 运行时环境(JRE)提供库、Java 虚拟机和其他组件来运行用 Java 编程语言编写的小程序和应用。JRE 不包含用于开发小程序和应用的工具和实用程序，如编译器或调试器。

What is JRE

JDK:JDK 也叫 Java 开发工具包，是 JRE 的超集，包含了 JRE 中的所有东西，加上开发小程序和应用所必需的编译器和调试器等工具。

What is JDK

Java HelloWorld 程序

原文：https://www.studytonight.com/java/first-java-program.php

用 Java 创建 Hello World 程序不是一个单行程序。它由各种其他代码行组成。因为 Java 是一种面向对象语言，所以它需要在类中编写代码。让我们看一个简单的 java 程序。

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

让我们了解上述程序的组成及其要点。

类 : class 关键字用于在 Java 中声明类

public :是访问说明符。公共意味着这个功能对所有人都是可见的。

static : static 又是一个用来让一个函数静态的关键字。要执行静态函数，您不必创建类的对象。这里的 main() 方法由 JVM 调用，不为类创建任何对象。

void :是返回类型，表示这个函数不会返回任何东西。

main : main()方法是一个 Java 程序中最重要的方法。这是被执行的方法，因此所有的逻辑都必须在 main()方法中。如果 java 类没有 main()方法，就会导致编译错误。

String[] args :表示类型为 String，名称为 args 的数组。我们将在 Java 数组部分讨论更多关于数组的内容。

System.out.println :这是用来在控制台上打印任何东西的，比如 C 语言的 printf 。

编译和运行第一个 Java 程序的步骤

第一步:打开一个文本编辑器，如上写代码。

步骤 2: 将文件保存为 Hello.java

第三步:打开命令提示符，转到保存第一个 java 程序的目录，假设它保存在 C 驱动器中。

第四步:输入javac Hello.java并按回车键(回车键)编译你的代码。这个命令将调用 Java 编译器，要求它编译指定的文件。如果代码中没有错误，命令提示符将带您进入下一行。

第五步:现在在命令提示符下输入java Hello运行你的程序。

第六步:你会看到你好世界程序打印在你的命令提示符下。

编写 Java 程序的方法

以下是编写 Java 程序的一些方法:

改变修饰符和方法的顺序是 Java 接受的。

语法:静态公共 void main(String as[])

示例:

	 class Hello
{
	static public void main(String as[])
	{
	System.out.println ("Welcome to Studytonight");
	}
}

Output of First Program

使用 Eclipse 的 Hello World 程序

Eclipse 是一个 IDE，用于开发应用。它是由 eclipse 基金会设计开发的，如果你没有 Eclipse 下载，那就按照这个下载链接从这里下载 Eclipse从这里我们将看到如何使用 eclipse IDE 创建和运行 hello world 程序。它需要以下步骤，包括创建项目、类文件、编写代码、运行代码等。

运行 Eclipse 并创建项目

打开 eclipse 启动，然后创建新项目。要创建项目，点击文件菜单，选择 Java 项目选项。它将打开一个窗口，询问项目名称。提供项目名称，然后单击“完成”按钮。见下面截图。

eclipse-program

创建项目后，我们可以在左侧栏中看到新创建的项目，如下所示。

eclipse-program

创建 Java 类

现在通过在项目和上右键单击选择类文件选项来创建 Java 类文件。它将打开一个窗口询问类名，提供类名并点击完成按钮。

eclipse-program

写你好世界

上面创建的类文件包括一些代码行，也包括主方法。现在我们需要写一个 print 语句来打印 Hello World 消息。

eclipse-program

运行程序

现在通过从菜单栏中选择运行菜单或使用 Ctrl+F11 按钮组合来运行程序。运行后，它会将 Hello World 打印到程序窗口底部的控制台上。

eclipse-program

这是一个简单的程序，我们在这里运行，同时使用 IDE，我们可以创建和构建大规模的应用。如果你是一个初学者，并且不熟悉 Eclipse，那么不要担心它很容易操作，只要按照上面的步骤来创建程序。

现在让我们看看运行时会发生什么

写完你的 Java 程序后，你什么时候会试着编译它。编译器将对您的程序执行一些编译操作。

一旦成功编译成字节码(。类文件)由编译器生成。

class-file at runtime in Java

编译后您将尝试何时运行字节代码(。类文件)，在运行时执行以下步骤:-

类加载器加载 java 类。它是 JVM Java 虚拟机的子系统。
字节码验证器检查代码片段中是否有可能侵犯对象访问权限的非法代码。
解释器读取字节代码流，然后逐步执行指令。

Java 中的变量

原文：https://www.studytonight.com/java/variable.php

在本教程中，我们将学习 Java 变量、各种类型的变量以及理解 Java 变量的代码示例。

什么是变量？

当我们想存储任何信息时，我们把它存储在计算机的一个地址中。我们没有记住存储信息的复杂地址，而是命名了那个地址。地址的命名被称为变量。变量是内存位置的名称。

换句话说，变量是在程序执行期间用来存储任何类型的值的名称。

要在 Java 中声明变量，我们可以使用以下语法

 datatype variableName;

这里，数据类型指的是变量的类型，可以是任何类型: int，float 等。变量名称可以是任何类似的: empId、金额、价格等。

Java 编程语言主要定义了三种变量。

实例变量
静态变量(类变量)
局部变量

Java 中的实例变量

实例变量是在类内部声明但在任何方法、构造器或块外部声明的变量。实例变量也是对象变量，通常称为字段或属性。它们被称为对象变量。每个对象都有自己的变量副本，因此，如果一个对象改变了变量的值，它不会影响实例变量。

class Student
{
    String name;
    int age;
}

Here name and age are instance variable of Student class.

Java 中的静态变量

Static 是用 static 关键字声明的类变量。静态变量只初始化一次。静态变量也与 final 关键字一起用于声明常量。

class Student
{
    String name;
    int age;
    static int instituteCode=1101;
}

这里 instituteCode 是一个静态变量。学生类的每个对象将共享 instituteCode 属性。

静态变量的附加点:

静态变量也称为类变量。
静态意味着保持不变。
在 Java 中，这意味着它对于为该类创建的所有实例都是常量。
不需要从对象调用静态变量。
由类名. static_variable_name 调用

注意:静态变量永远不能在方法内部定义，即它永远不能是局部变量。

示例:

假设您创建了两个学生类的对象，并且从一个对象更改了静态变量的值。现在，当您从其他对象打印它时，它将显示已更改的值。这是因为它被声明为静态的，也就是说，它对于创建的每个对象都是不变的。

package studytonight;

class Student{
    int a;
    static int id = 35;

    void change(){

        System.out.println(id);
    }
}

public class StudyTonight {
    public static void main(String[] args) {

        Student o1 = new Student();
        Student o2 = new Student();

        o1.change();

        Student.id = 1;
        o2.change();
    }
}

35 1

Java 中的局部变量

局部变量在方法、构造器或块中声明。局部变量在方法、构造器或块开始时初始化，一旦结束将被销毁。局部变量驻留在栈中。局部变量不使用访问修饰符。

float getDiscount(int price)
{
 float discount;
 discount=price*(20/100);
 return discount;
}

Here discount is a local variable.

Java 中的变量范围

变量的范围决定了它在整个程序中的可访问性。正如我们所看到的，变量是不同的类型，因此它们有自己的范围。

局部变量:局部变量的作用域仅限于声明它的块。例如，在函数中声明的变量只能在该函数中访问。

实例变量:实例变量的范围取决于访问修饰符(公共，私有，默认)。如果变量被声明为私有，那么它只能在类内访问。

如果变量被声明为公共，那么所有人和整个应用都可以访问它。

如果变量被声明为缺省值，则可以在同一个包中访问它。

有关可访问性的更多详细信息，您可以参考我们的详细教程。点击此处了解更多可变范围

示例:

在这个例子中，我们创建了两个变量 a 和 i ，第一个在函数内部声明，第二个在循环内部声明。这两个变量都有自己的声明范围，因此在块外访问会报告错误。

    public class HelloWorld {

    public static void main(String[] args) {

        int a = 10;

        for(int i = 0; i<5; i++) {
            System.out.println(i);
        }

        System.out.println("a = "+a);
        System.out.println("i = "+i); // error

    }

}

错误:找不到符号 I

Java 中的数据类型

原文：https://www.studytonight.com/java/datatypes-and-identifier.php

Java 语言有丰富的数据类型实现。数据类型指定可以存储在标识符中的值的大小和类型。

在 java 中，数据类型分为两类:

原始数据类型
非原始数据类型

1)原始数据类型

原始数据类型可以有八种类型:

一旦一个原始数据类型被声明，它的类型就永远不会改变，尽管在大多数情况下它的值会改变。这八种原始类型可以分为四组

整数

这组包括byte、short、int、long

字节:为 1 字节(8 位)整数数据类型。值的范围从-128 到 127。默认值为零。示例:byte b=10;

短:2 字节(16 位)整数数据类型。值的范围从-32768 到 32767。默认值为零。示例:short s=11;

int : 是 4 字节(32 位)整数数据类型。值范围从-2147483648 到 2147483647。默认值为零。示例:int i=10;

长:8 字节(64 位)整数数据类型。数值范围从-9，223，372，036，854，775，808 到 9，223，372，036，854，775，807。默认值为零。示例:long l=100012;

示例:

让我们创建一个使用Integer类型数据的例子，我们可以了解如何在 java 程序中使用数据类型。

	 package corejava;

public class Demo{      

    public static void main(String[] args) {
    	// byte type
    	byte b = 20;
    	System.out.println("b= "+b);

    	// short type
    	short s = 20;
    	System.out.println("s= "+s);

    	// int type
    	int i = 20;
    	System.out.println("i= "+i);

    	// long type
    	long l = 20;
    	System.out.println("l= "+l);

    }  
}

b= 20 s= 20 i= 20 l= 20

浮点数

该组包括float、double

浮点:是 4 字节(32 位)浮点数据类型。默认值 0.0f .示例:float ff=10.3f;

double : 是 8 字节(64 位)浮点数据类型。默认值 0.0d .示例:double db=11.123;

示例:

在这个例子中，我们使用Float类型和声明的变量来保存浮点值。Float类型对于存储小数点值很有用。

	 public class Demo{      

    public static void main(String[] args) {
    	// float type
    	float f = 20.25f;
    	System.out.println("f= "+f);

    	// double type
    	double d = 20.25;
    	System.out.println("d= "+d);

    }  
}

f= 20.25 d= 20.25

特性

该组代表char，表示字符集内的符号，如字母和数字。

字符:2 字节(16 位)无符号 unicode 字符。范围从 0 到 65，535。示例:char c='a';

`Character`类型示例

Java 中的Character类型使用 2 字节到 unicode 字符。因为它使用 unicode，所以我们可以存储字母表字符、货币字符或 unicode 集合下的其他字符。

    public class Demo {

    public static void main(String[] args) {

        char ch = 'S';
        System.out.println(ch);

        char ch2 = '&';
        System.out.println(ch2);

        char ch3 = '$';
        System.out.println(ch3);

    }

}

新元

布尔代数学体系的

这组表示boolean，这是一种表示真/假值的特殊类型。它们被定义为语言的常量。示例:boolean b=true;

`Boolean`类型示例

Java 中的Boolean类型只能处理两个值，要么是真要么是假。它主要用于条件表达式中，以执行基于条件编程。

    public class Demo {

    public static void main(String[] args) {

        boolean t = true;
        System.out.println(t);

        boolean f = false;
        System.out.println(f);

    }

}

真假

2)非原始(引用)数据类型

引用数据类型用于引用对象。引用变量被声明为特定，且该类型永远不能更改。

例如: String str ，这里 str 是 String 类型的引用变量。字符串是 Java 中的一个类。我们将在后面的“类和对象”一课中详细讨论引用数据类型。

引用类型用于保存对象的引用。对象可以是任何类或实体的实例。

在面向对象系统中，我们处理存储属性的对象。为了引用这些对象，我们使用引用类型。

我们将在后面的“类和对象”一课中详细讨论引用数据类型。

Java 中的标识符

所有 Java 组件都需要名称。用于类、方法、接口和变量的名称称为标识符。标识符必须遵循一些规则。以下是规则:

所有标识符必须以字母(A 到 Z 或 A 到 Z)或货币字符($)或下划线开头。
在第一个字符之后，标识符可以有任何字符组合。
Java 关键字不能作为标识符。
Java 中的标识符区分大小写，foo 和 Foo 是两种不同的标识符。

一些有效的标识符是: int a，class Car，float amount 等。

Java 中的静态块

原文：https://www.studytonight.com/java/static-and-initializer-block.php

在 Java 中，static 关键字主要用于内存的管理。静态关键字可以与变量、方法、块和嵌套类一起使用。程序中的静态块是在主方法之前由 JVM (Java 虚拟机)执行的一组语句。在类加载时，如果我们想执行任何任务，我们可以在静态块中定义该任务，这个任务将在类加载时执行。在一个类中，可以定义任意数量的静态块，这些静态块将从上到下执行。

static block Image

语法:

	 static {
		**********
		**********
		// statements….
		**********
		**********
	}

静态块的示例

执行程序时，静态块在主方法之前执行。写入静态块的语句将首先执行。然而，两者都是静态的。

	 class StaticDemo1
{
	static
	{
		System.out.println("Welcome to studytonight.com");
		System.out.println("This is static block");

	}
	public static void main(String as[])
	{
		System.out.println("This is main() method");
	}
}

static-block-syntax Example

多个静态块的示例

当我们有多个静态块时，每个块按顺序执行。第一个静态块将首先执行。

	 class StaticDemo1
{
	static
	{
		System.out.println("Welcome to studytonight.com");
		System.out.println("This is static block I");

	}
	public static void main(String as[])
	{
		System.out.println("**********************");
		System.out.println("This is main() method");
	}
	static
	{
		System.out.println("**********************");
		System.out.println("This is static block II");

	}
	static
	{
		System.out.println("**********************");
		System.out.println("This is static block III");

	}
}

multiple-static-block-syntax

Java 中的初始化器块

在 Java 中，初始化器块用于初始化实例数据成员。每当创建对象时都会执行初始化程序块。初始值设定项块被复制到 Java 编译器中，然后复制到每个构造器中。初始化块在构造器中的代码之前执行。

示例:

	 class InitializerDemo1
{
	{
		System.out.println("Welcome to studytonight.com");
		System.out.println("This is Initializer block");

	}
	public InitializerDemo1()
	{
		System.out.println("Default Constructor invoked"); 
	}
	public static void main(String as[])
	{
		InitializerDemo1 obj = new InitializerDemo1();
		System.out.println("This is main() method");
	}
}

initializer-block

使用静态和初始值设定项块的示例

在一个 Java 程序中，我们可以同时拥有静态块和初始化块。但是静态块甚至会在初始化器块之前先执行。见下面的例子。

	 public class one extends two {
    static {
System.out.println("inside satic block");
    }

one() {
System.out.println("inside constructor of child");
    }

    {
System.out.println("inside initialization block");
    }

    public static void main(String[] args) {
        new one();
        new one();
System.out.println("inside main");
    }
}

class two{
    static {
System.out.println("inside parent Static block");
    }
    {
System.out.println("inside parent initialisation block");
    }

two() {
System.out.println("inside parent constructor");
    }
}

static-and-initializer

Java 中的类型转换

原文：https://www.studytonight.com/java/type-casting-in-java.php

转换是将一个类型值更改为另一个类型的过程。在 Java 中，我们可以将一种类型的值转换成另一种类型。它被称为类型铸造。

示例:

int x = 10;
byte y = (byte)x;

在 Java 中，类型转换分为两种类型，

加宽铸造(隐式)

widening-type-conversion

缩小铸造(显式完成)

narrowing-type-conversion

加宽或自动类型转换

自动型铸造发生在，

这两种类型是兼容的
目标类型大于源类型

示例:

public class Test
{
    public static void main(String[] args)
    {
      int i = 100;
      long l = i; <font color="green">**//no explicit type casting required**</font>
      float f = l;  <font color="green">**//no explicit type casting required**</font>
      System.out.println("Int value "+i);
      System.out.println("Long value "+l);
      System.out.println("Float value "+f);
    }

}

整数值 100 长数值 100 浮点数值 100.0

收缩或显式类型转换

当您将较大的类型值赋给较小类型的变量时，您需要执行显式类型转换。如果我们不执行强制转换，那么编译器会报告编译时错误。

示例:

public class Test
{
    public static void main(String[] args)
    {
      double d = 100.04;
      long l = (long)d;  <font color="green">**//explicit type casting required**</font>
      int i = (int)l; <font color="green">**//explicit type casting required**</font>

      System.out.println("Double value "+d);
      System.out.println("Long value "+l);
      System.out.println("Int value "+i);
    }

}

双精度值 100.04 长值 100 整数值 100

显式转换的示例

这里，我们还有一个显式转换的例子，double 类型存储为 long，long 存储为 int 等。

  class CastingDemo1
{ 
    public static void main(String[] args) 
    { 
      double d = 120.04;  
      long l = (long)d;   
      int i = (int)l;  
      System.out.println("Double value "+d); 
      System.out.println("Long value "+l);  
      System.out.println("Int value "+i);  
    }  
}

casting-demo Image

int 和 double 转换为字节的示例

这里，我们使用显式类型转换将 int 和 double 类型转换为Byte类型。

  class Demo2
{ 
    public static void main(String args[])  
    {  
      byte b;  
      int i = 355;  
      double d = 423.150; 
      b = (byte) i; 
      System.out.println("Conversion of int to byte: i = " + i + " b = " + b);  
      System.out.println("*************************************************"); 
      b = (byte) d;        
      System.out.println("Conversion of double to byte: d = " + d + " b= " + b);
  } 
}

Output of conversion-example

Java `If Else`语句

原文：https://www.studytonight.com/java/conditional-statement.php

在 Java 中，if 语句用于测试条件。该条件与返回 true 的语句匹配，否则返回 false。If 语句有四种类型，它们是:

例如，如果我们想创建一个程序来测试正整数，那么我们必须测试这个整数是否大于零。

在这种情况下，if 语句很有帮助。

Java 中有四种类型的 if 语句:

如果语句
if-else 语句
如果-否则-如果梯子
嵌套 if 语句

如果语句

if 语句是一个基于条件的语句，仅在提供的条件为真时执行。

**If 语句语法:

	 if(condition)
{  
	//code
}

我们可以用下图来理解 if 语句的流程。它表明只有当条件为真时，写在 if 中的代码才会执行。

中频模块数据流图

If Block Flow

示例:

在这个例子中，我们测试学生的分数。如果分数大于 65，那么学生将获得第一名。

	 public class IfDemo1 {  
public static void main(String[] args) 
	{  
	int marks=70;  
	if(marks > 65)
		{  
		System.out.print("First division");  
		}  
	}  
}

if-else-program

if-else 语句

if-else 语句用于测试条件。如果条件为真，如果块执行，否则块执行。

这在我们想要基于假结果执行一些操作的场景中是有用的。

else 块仅在条件为假时执行。

语法:

	 if(condition)
{  
	//code for true  
}
else
{  
	//code for false  
}

在这个框图中，我们可以看到当条件为真时，如果块执行，否则块执行。

If Else 模块的数据流图

IF else DFD Diagram

if else 示例:

在这个例子中，我们测试学生分数，如果分数大于 65，那么如果块执行，否则块执行。

	 public class IfElseDemo1 {  
	public static void main(String[] args) 
	{  
		int marks=50;  
		if(marks > 65)
		{  
			System.out.print("First division");  
		}  
		else
		{  
			System.out.print("Second division");  
		}
	}  
}

if else program

如果-否则-如果阶梯语句

在 Java 中，if-else-if 梯形语句用于测试条件。它用于测试多个语句中的一个条件。

当我们有多个条件要执行时，建议使用 if-else-if 梯形。

语法:

	 if(condition1)
{  
	//code for if condition1 is true  
}
else if(condition2)
{  
	//code for if condition2 is true  
}  
else if(condition3)
{  
	//code for if condition3 is true  
}  
...  
else
{  
	//code for all the false conditions   
}

它包含多个条件，如果任何条件为真，则执行，否则执行 else 块。

If 否则 If 块的数据流图

DFD of if-else-if block

示例:

这里，我们正在测试学生成绩，并根据获得的成绩显示结果。如果分数大于 50 分，学生将得到他的分数。

	 public class IfElseIfDemo1 {  
public static void main(String[] args) {  
int marks=75;  
    if(marks<50){
System.out.println("fail");  
    }  
    else if(marks>=50 && marks<60){
System.out.println("D grade");  
    }  
    else if(marks>=60 && marks<70){
System.out.println("C grade");  
    }  
    else if(marks>=70 && marks<80){
System.out.println("B grade");  
    }  
    else if(marks>=80 && marks<90){
System.out.println("A grade");  
}else if(marks>=90 && marks<100){  
System.out.println("A+ grade");  
}else{  
System.out.println("Invalid!");  
    }  
}  
}

if-else-if-output

嵌套 if 语句

在 Java 中，嵌套 if 语句是另一个 if 内部的 if。在这种情况下，当外部块为真时，在另一个 if 块内部创建一个 if 块，然后只执行内部块。

语法:

	 if(condition)
{    
     		//statement
     if(condition)
{  
             //statement 
    }    
}

嵌套 If 块的数据流图

nested-if DFD

示例:

	 public class NestedIfDemo1 {    
public static void main(String[] args) 
{      
int age=25;  
int weight=70;    
if(age>=18)
{    
if(weight>50)
{  
System.out.println("You are eligible");  
}    
}    
}	
}

Nested If block Output

Java `switch`语句

原文：https://www.studytonight.com/java/switch-statement.php

在 Java 中，switch 语句用于从多个条件中执行一条语句。它类似于 if-else-if 梯子。

Switch 语句由基于条件的案例和默认案例组成。

在 switch 语句中，表达式可以是字节、短、char 和 int 类型。

从 JDK-7，枚举，字符串也可以用于开关情况。

以下是使用 switch 语句时的一些规则:

可以有一个或 N 个案例。
案例中的值必须是唯一的。
案例的每个语句都可以有一个 break 语句。它是可选的。

语法:

下面是用 Java 声明开关大小写的语法。

	 switch(expression)
{    
case value1:    
 			//code for execution;    
 			break;  //optional  
case value2:    
 // code for execution
 break;  //optional  
......    
......
......
......
Case value n:
// code for execution
 break;  //optional  

default:     
 code for execution when none of the case is true;    
}

交换块的数据流图

switch block DFD

示例:使用整数值

在本例中，我们使用 int 类型值来匹配案例。本示例基于数值返回日期。

	 public class SwitchDemo1{ 
    public static void main(String[] args) 
    { 
int day = 3; 
        String dayName; 
        switch (day) { 
        case 1: 
dayName = "Today is Monday"; 
            break; 
        case 2: 
dayName = "Today is Tuesday"; 
            break; 
        case 3: 
dayName = "Today is Wednesday"; 
            break; 
        case 4: 
dayName = "Today is Thursday"; 
            break; 
        case 5: 
dayName = "Today is Friday"; 
            break; 
        case 6: 
dayName = "Today is Saturday"; 
            break; 
        case 7: 
dayName = "Today is Sunday"; 
            break; 
        default: 
dayName = "Invalid day"; 
            break; 
        } 
System.out.println(dayName); 
    } 
}

output switch Example

在 Switch 语句中使用枚举的示例

正如我们已经说过的，Java 允许在开关情况下使用枚举。所以我们正在创建一个元音字母的枚举，并在 switch case 中使用它的元素。

	 public class SwitchDemo2{      
       public enumvowel{a, e, i, o, u}    
       public static void main(String args[])    
       {    
vowel[] character= vowel.values();    
           for (vowel Now : character)    
           {    
                switch (Now)    
                {    
                    case a:    
System.out.println("'a' is a Vowel");    
                        break;    
                    case e:    
System.out.println("'e' is a Vowel");    
                        break;    
                    case i:    
System.out.println("'i' is a Vowel");    
                        break;         
                    case o:    
System.out.println("'o' is a Vowel");    
                        break;    
                    case u:    
System.out.println("'u' is a Vowel");    
                        break;    
                    default:    
System.out.println("It is a consonant");    
                }    
            }    
        }    
}

output-enum-switch program output

例:开关箱内的串

由于 Java 允许在开关情况下使用字符串值，所以我们使用字符串来创建一个基于字符串的开关情况示例。

	 public static void main(String[] args) {  
    String name = "Mango";  
    switch(name){  
    case "Mango":  
        System.out.println("It is a fruit");  
        break;  
    case "Tomato":  
        System.out.println("It is a vegitable");  
        break;  
    case "Coke":  
        System.out.println("It is cold drink");  
    }  
}  
}

这是一种水果

例:无断路开关情况

Break 语句用于中断程序的当前执行。在开关情况下，断开用于终止开关情况的执行并将控制转移到开关情况的外部。

在开关情况下可选择使用断开。让我们看看如果我们不利用休息时间会发生什么。

	 public class Demo{      

    public static void main(String[] args) {  
        String name = "Mango";  
        switch(name){  
        case "Mango":  
            System.out.println("It is a fruit");  
        case "Tomato":  
            System.out.println("It is a vegitable");  
        case "Coke":  
            System.out.println("It is cold drink");  
        }  
    }
}

这是水果，这是蔬菜，这是冷饮

See, if we don’t use break, it executes all the cases after matching case.

Java 循环

原文：https://www.studytonight.com/java/loops-in-java.php

循环是编程的一个重要概念，它允许遍历语句序列。

循环被设计为执行特定的代码块，直到指定的条件为真或者集合的所有元素(数组、列表等)都被完全遍历。

loop 最常见的用途是执行重复的任务。例如，如果我们想打印一个数字的表格，那么我们需要写 10 次 print 语句。但是，我们可以通过使用循环对单个 print 语句执行同样的操作。

循环被设计为执行其块，直到指定的条件为真。

基于循环结构，Java 主要提供了三个循环。

for 循环
while 循环
边循环边做

我们将在下面详细解释每个循环。

用于循环

for 循环用于重复执行部分程序。当执行次数固定时，建议使用 for 循环。For 循环可以分为两种类型。

**1. for 循环
2. loop 每个循环

对于循环语法:

下面是在 Java 中声明 for 循环的语法。

	 for(initialization;condition;increment/decrement)
{  
//statement 
}

对于循环参数:

要创建 for 循环，我们需要设置以下参数。

1)初始化

这是初始部分，我们为循环设置初始值。它在循环开始时只执行一次。如果我们不想设置初始值，它是可选的。

2)条件

它用于在每次执行时测试条件。继续执行，直到条件为假。它是可选的，如果我们不指定，循环将是无限的。

3)声明

它是循环体，每次都执行，直到条件为假。

4)递增/递减

它用于设置循环的增量或减量。

for 循环的数据流图

这个流程图显示了循环的流程。这里我们可以理解循环的流程。

for loop DFD

循环示例

在本例中，循环的初始值被设置为 1，并将其增加 1，直到条件为真并执行 10 次。

	 public class ForDemo1
{  
public static void main(String[] args) 
	{  
		int n, i;
		n=2;
		for(i=1;i<=10;i++)
		{  
			System.out.println(n+"*"+i+"="+n*i);  
		}  
}  	
}

for-loop-output

循环嵌套示例

循环可以嵌套，在另一个循环内创建的循环称为嵌套循环。有时根据需求，我们必须创建嵌套循环。

通常，嵌套循环用于迭代表格数据。

	 public class ForDemo2
{  
public static void main(String[] args) 
{  
for(inti=1;i<=5;i++)
{  
for(int j=1;j<=i;j++)
{  
				System.out.print("* ");  
}  
System.out.println(); 
}  
}  
}

nested-for-loop program

每个循环

在 Java 中，for 循环用于遍历数组或集合元素。在这个循环中，不需要递增或递减运算符。

for-每个循环语法

下面是在 Java 中为每个循环声明的语法。

	 for(Type var:array)
{  
//code for execution
}

示例:

在这个例子中，我们使用 for-each 循环遍历数组元素。for-当数组对象中没有元素时，每个循环自动终止。

	 public class ForEachDemo1
{  
public static void main(String[] args) 
		{    
			inta[]={20,21,22,23,24};   
			for(int i:a)
{  
				System.out.println(i);  
			}  
}  
}

for-each-loop

当循环

像 for 循环一样，while 循环也用于重复执行代码。控制语句。它用于多次迭代程序的一部分。当迭代次数不固定时，则使用 while 循环。

语法:

	 while(condition)
{  
//code for execution
}

While 模块的数据流图

while loop DFD

示例:

在本例中，我们使用 while 循环打印 1 到 10 个值。在第一步中，我们设置条件变量，然后测试条件，如果条件为真，执行循环体，并将变量增加 1。

	 public class WhileDemo1
{  
	public static void main(String[] args) 
	{  
		inti=1;  
		while(i<=10)
		{  
			System.out.println(i);  
			i++;  
		}  
	}  
}

while-loop-output

无限循环示例

条件表达式总是返回真值的 while 循环称为无限 while 循环。我们也可以通过在循环中传递真文字来创建无限循环。

创建无限循环时要小心，因为它会引发内存溢出问题。

	 public class WhileDemo2 
{  
	public static void main(String[] args) 
	{  
		while(true)
		{  
		System.out.println("infinitive while loop");  
		}  
	}  
}

infinite-while-loop jpg

边做边循环

在 Java 中，do-while 循环用于一次又一次地执行语句。该循环至少执行一次，因为该循环是在检查条件之前执行的。表示执行循环体的后循环条件评估。

while 和 do-while 循环的主要区别是，在 do while 循环中，条件在执行循环后评估。

语法:

下面是在 Java 中声明 do-while 循环的语法。

	 do
{  
//code for execution 
}
while(condition);

边做边块数据流图

do-while-dfd diagram

示例:

在本例中，我们使用 do while 循环打印从 1 到 10 的值。

	 public class DoWhileDemo1 
{  
public static void main(String[] args) 
{  
inti=1;  
do
{  
System.out.println(i);  
i++;  
}while(i<=10);  
        }  
}

output-of-do-while-program

无限边做边循环的例子

像无限 while 循环一样，我们也可以创建无限 do while 循环。要创建无限 do while 循环，只需通过始终为真的条件。

	 public class DoWhileDemo2 
{  
public static void main(String[] args) 
{  
        do
{  
System.out.println("infinitive do while loop");  
}while(true);  
}  
}

output-of-do-while-infinte-program

Java `break`和`continue`语句

原文：https://www.studytonight.com/java/break-continue-statement-in-java.php

Java break和continue语句用于管理程序流程。我们可以在循环中使用它们来控制循环迭代。这些语句让我们能够控制循环和切换语句，使我们能够跳出循环或者跳过当前循环迭代跳到下一个迭代。

在本教程中，我们将通过示例详细讨论每一个。

break 语句

在 Java 中，break 是用来中断程序当前执行流程的语句。

我们可以在循环中使用 break 语句、开关盒等。

如果在循环内使用中断，那么它将终止循环。

如果在最内循环中使用中断，那么中断将仅终止最内循环，并且执行将从外循环开始。

如果在开关情况下使用 break，那么它将在匹配的情况之后终止执行。使用 break，我们已经在切换案例主题中介绍过了。

语法:

	 jump-statement;    
break;

break语句数据流图

break-statement-DFD

示例:

在本例中，我们在循环中使用了 break，当值为 8 时，循环将终止。

	 public class BreakDemo1 {  
public static void main(String[] args) {  

for(inti=1;i<=10;i++){  
        if(i==8){

            break;  
        }  
System.out.println(i);  	
    }  
}  
}

break-statement-output

使用边循环边磨合的示例

循环可以是任何一个不管是 for 还是 while，break 语句都会这么做。这里，我们在 do while 循环中使用 break。

	 public class BreakDoWhileDemo1
{  
public static void main(String[] args) 
{    
		inti=1;   
		do
{  
			if(i==15)
{  
			i++;  
				break; 
			}  
			System.out.println(i);  
			i++;  
		}while(i<=20);  
 }  
}

break-statement-output-do-while

示例:最里面的循环中断

在这个例子中，我们在最里面的循环中使用中断。但是当 j 等于 2 并且控制转到从下一次迭代开始的外部循环时，循环每次都中断。

	 public class Demo{          
    public static void main(String[] args) {  
    	for(int i=1;i<=2;i++){  
            for (int j = 0; j <=3; j++) {
				if(j==2)
					break;
				System.out.println(j);
			}          
        }  
    }  
}

0 1 0 1

连续语句

在 Java 中，continue 语句用于跳过循环的当前迭代。它立即跳到循环的下一个迭代。我们可以对循环、同时循环和同时循环使用带有的 continue 语句。

	 jump-statement;    
continue;

示例:

在这个例子中，我们在 for 循环中使用了 continue 语句。看，它不会将 5 打印到控制台，因为在第五次迭代中，continue 语句跳过了迭代，这就是 print 语句不执行的原因。

 public class ContinueDemo1
{  
public static void main(String[] args) 
{  
		for(inti=1;i<=10;i++)
		{
			if(i==5)
{
			continue;
			}  
			System.out.println(i);  
		}  
}  
}

output-of-continue-statement

示例:

我们可以使用标签和continue语句来设置流量控制。通过使用标签，我们可以在指定位置转移控制权。

在这个例子中，我们使用标签将控制转移到外部循环。

 public class ContinueDemo2 {  
public static void main(String[] args) {  
xy:  
for(inti=1;i<=5;i++){    
pq:  
for(int j=1;j<=5;j++){    
                        if(i==2&&j==2){
                            continue xy;    
                        }    
System.out.println(i+" "+j);    
                    }    
            }    
}  
}

output-of-continue-statement

示例:在 While 循环中继续

continue 语句可以与 while 循环一起使用来管理程序的流控制。正如我们已经知道的，continue 语句用于跳过循环的当前迭代。这里，如果变量值为 5，它也将跳过执行。

	 public class Demo{      

    public static void main(String[] args) {
    	int i=1;

    	while (i < 10) {
    	  if (i == 5) {
    	    i++;
    	    continue;
    	  }
    	  System.out.println(i);
    	  i++;
    	}
    }  
}

1 2 3 4 6 7 8 9

我们可以看到输出，5 是缺失的，因为在第五次迭代时由于 continue 语句 JVM 跳过了 print 语句。

Java 运算符

原文：https://www.studytonight.com/java/operators-in-java.php

运算符是告诉编译器执行某种操作的符号。Java 提供了一套丰富的操作符来处理各种类型的操作。有时我们需要执行算术运算，然后我们使用加号(+)运算符进行加法，乘法(*)进行乘法等。

运算符始终是任何编程语言必不可少的部分。

Java 操作符可以分为以下几类:

算术运算符
关系运算符
逻辑运算符
按位运算符
赋值运算符
条件运算符
杂项操作员

算术运算符

算术运算符用于执行算术运算，如:加法、减法等，有助于解决数学表达式。下表包含算术运算符。

| 操作员 | 描述 |
| + | 将两个操作数相加 |
| - | 从第一个操作数中减去第二个操作数 |
| * | 乘以两个操作数 |
| / | 分子除以枚举数 |
| % | 除法的余数 |
| ++ | 增量运算符将整数值增加 1 |
| -- | 递减运算符将整数值减少 1 |

示例:

让我们创建一个例子来理解算术运算符及其运算。

    class Arithmetic_operators1{
public static void main(String as[])
    {
        int a, b, c;
        a=10;
        b=2;
        c=a+b;
        System.out.println("Addtion: "+c);
        c=a-b;
        System.out.println("Substraction: "+c);
        c=a*b;
        System.out.println("Multiplication: "+c);
        c=a/b;
        System.out.println("Division: "+c);
        b=3;
        c=a%b;
        System.out.println("Remainder: "+c);
        a=++a;
        System.out.println("Increment Operator: "+a);
        a=--a;
        System.out.println("decrement Operator: "+a);       

    }
}

airthmatic operator Example

关系运算符

关系运算符用于测试操作数或值之间的比较。它可以用来测试两个值是否相等或不相等或小于或大于等。

下表显示了 Java 支持的所有关系运算符。

| 操作员 | 描述 |
| == | 检查两个操作数是否相等 |
| != | 检查两个操作数是否不相等。 |
| > | 检查左边的操作数是否大于右边的操作数 |
| < | 检查左边的操作数是否小于右边的操作数 |
| >= | 检查左操作数是否大于或等于右操作数 |
| <= | 检查左边的操作数是否小于或等于右边的操作数 |

示例:

在这个例子中，我们使用关系运算符来测试比较，如小于、大于等。

    class Relational_operators1{
public static void main(String as[])
    {
        int a, b;
        a=40;
        b=30;
        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) );    
    }
}

relation operator example

逻辑运算符

逻辑运算符用于检查条件表达式。例如，我们可以在 if 语句中使用逻辑运算符来计算基于条件的表达式。我们也可以将它们用于循环来评估条件。

Java 支持以下 3 个逻辑运算符。假设我们有两个变量，它们的值是:a =真和b =假。

| 操作员 | 描述 | 例子 |
| && | 逻辑“与” | (a && b)为假 |
| || | 逻辑或 | (a || b)是真的 |
| ! | 逻辑非 | (!a)是假的 |

示例:

在这个例子中，我们使用逻辑运算符。这些运算符返回真值或假值。

    class Logical_operators1{
public static void main(String as[])
    {
        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));
    }
}

Logical Operator Example

按位运算符

按位运算符用于一点一点地执行操作。

Java 定义了几个按位运算符，可以应用于长整型、整型、短整型、字符型和字节型。

下表显示了 Java 支持的所有按位运算符。

| 操作员 | 描述 |
| & | 按位“与” |
| | | 按位“或” |
| ^ | 按位异或 |
| << | 左移 |
| >> | 右移 |

现在让我们来看看按位&、|和^的真值表

| a | b | a & b | a | b | a ^ b |
| Zero | Zero | Zero | Zero | Zero |
| Zero | one | Zero | one | one |
| one | Zero | Zero | one | one |
| one | one | one | one | Zero |

按位移位运算符移位位值。左操作数指定要移位的值，而右操作数指定值中的位要移位的位置数。两个操作数具有相同的优先级。

Example:

让我们创建一个演示按位运算符工作原理的示例。

a = 0001000
b = 2
a << b = 0100000
a >> b = 0000010

    class Bitwise_operators1{
public static void main(String as[])
    {
        int a = 50; 
        int b = 25; 
        int c = 0;

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

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

        c = a ^ b;        
        System.out.println("a ^ b = " + c );

        c = ~a;           
        System.out.println("~a = " + c );

        c = a << 2;      
        System.out.println("a << 2 = " + c );

        c = a >> 2;       
        System.out.println("a >>2  = " + c );

        c = a >>> 2;     
        System.out.println("a >>> 2 = " + c );
    }
}

bitwise operator example

赋值运算符

赋值运算符用于给变量赋值。它还可以与算术运算符结合使用来执行算术运算，然后将结果赋给变量。Java 支持赋值运算符如下:

| 操作员 | 描述 | 例子 |
| = | 将右侧操作数的值赋给左侧操作数 | a = b |
| += | 将右操作数与左操作数相加，并将结果分配给左操作数 | a+=b同a=a+b |
| -= | 从左操作数中减去右操作数，并将结果分配给左操作数 | a-=b与=a-b相同 |
| *= | 将左操作数与右操作数相乘，并将结果赋给左操作数 | a*=b同a=a*b |
| /= | 用右操作数除左操作数，并将结果分配给左操作数 | a/=b同a=a/b |
| %= | 使用两个操作数计算模数，并将结果分配给左操作数 | a%=b同a=a%b |

示例:

让我们创建一个例子来理解赋值运算符的用法。所有赋值运算符都有从右到左的关联性。

    class Assignment_operators1{
public static void main(String as[])
{
    int a = 30;
    int b = 10;
    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 = 20;
      c = 25;
      c /= a ;
System.out.println("c /= a = " + c );

      a = 20;
      c = 25;
      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 );
    }
}

assignment operator example

杂项操作员

java 语言很少支持其他操作符。

条件运算符

它也被称为三进制运算符，因为它与三个操作数一起工作。它是 if-else 语句的简称。可用于评估布尔表达式，返回真或假的值

epr1 ? expr2 : expr3

示例:

在三元运算符中，如果 epr1 为真，则表达式在问号(？) else 在冒号(:)后求值。见下面的例子。

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

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

conditonal operator example

`instanceOf`运算符

它是一个 java 关键字，用于测试给定的引用是否属于提供的类型。类型可以是类或接口。返回真或假。

示例:

在这里，我们创建了一个存储“今晚学习”的字符串引用变量。因为它存储字符串值，所以我们使用 isinstance 运算符测试它，以检查它是否属于String类。见下面的例子。

    class instanceof_operators1{
public static void main(String as[])
{
      String a = "Studytonight";
boolean b = a instanceof String;
System.out.println( b );
}
}

instance of operator example

Java 数组

原文：https://www.studytonight.com/java/array.php

数组是相似数据类型的集合。数组是一个容器对象，它保存同类类型的值。它也被称为静态数据结构，因为数组的大小必须在声明时指定。

数组从零索引开始，到 n-1 ，其中 n 为数组的长度。

在 Java 中，数组被视为一个对象，存储到堆内存中。它允许存储原始值或参考值。

在 Java 中，数组可以是一维的，也可以是多维的。

数组的特征

它总是被索引。索引从 0 开始。
它是相似数据类型的集合。
它占用一个连续的内存位置。
它允许随机访问元素。

一维数组

一维数组使用单个索引存储元素。只要将数组的索引增加 1，就可以得到数组的所有元素。

数组声明

语法:

datatype[] *arrayName;*;
or
**datatype** arrayName[];

Java 允许通过使用两种声明语法来声明数组，两者都是有效的。

数组名可以是任何有效的数组名，数据类型可以是任何类型: int、float、byte 等。

示例:

int[ ] arr;
char[ ] arr;
short[ ] arr;
long[ ] arr;
int[ ][ ] arr;   // two dimensional array.

数组的初始化

初始化是一个为数组分配内存的过程。在初始化时，我们指定数组的大小来保留内存区域。

初始化语法

 arrayName = new datatype[size]

new运算符用于初始化数组。

arrayName 是数组的名称，new 是用于分配内存的关键字，size 是数组的长度。

我们可以将声明和初始化合并在一条语句中。

Datatype[] arrayName = new datatype[size]

示例:创建数组

让我们创建一个一维数组。

	 class Demo
{
public static void main(String[] args)
  {
    int[] arr = new int[5];
        for(int x : arr)
        {
                System.out.println(x);
        }
   }
}

0 0 0 0 0

在上面的例子中，我们创建了一个数组arr****int 类型并且可以存储 5 元素。我们迭代数组来访问它的元素，它向控制台输出五次零。它打印零是因为我们没有给数组设置值，所以数组的所有元素默认初始化为 0。

设置数组元素

我们可以在初始化时设置数组元素，也可以直接给它的索引赋值。

int[] arr = {10,20,30,40,50};

这里，我们在创建数组时赋值。当我们想要将静态数据存储到数组中时，它非常有用。

或者

arr[1] = 105

这里，我们给数组的 1 索引赋值。当我们想要将动态数据存储到数组中时，它非常有用。

数组示例

在这里，我们使用上面讨论的两种方法为数组赋值。

	 class Demo
{
public static void main(String[] args)
  {
	int[] arr = {10,20,30,40,50}; 
        for(int x : arr)
        {
                System.out.println(x);
        }

     // assigning a value

        arr[1] = 105;
        System.out.println("element at first index: " +arr[1]);
   }
}

第一个索引处的元素:105

访问数组元素

我们可以通过数组的索引值来访问数组元素。通过使用循环或直接索引值。我们可以使用循环，如:for、for-each 或 while 来遍历数组元素。

访问元素的示例

	 class Demo
{
public static void main(String[] args)
  {
	int[] arr = {10,20,30,40,50}; 
        for(int i=0;i<arr.length;i++)
        {
                System.out.println(arr[i]);
        }

        System.out.println("element at first index: " +arr[1]);
   }
}

第一个索引处的元素:20

这里，我们使用循环遍历数组元素，并随机访问一个元素。

注:- 要求数组的长度，可以使用数组对象的 length 属性，如:array_name.length。

多维数组

多维数组与一维数组非常相似。它可以有多行多列，不像一维数组只能有一个行索引。

它将数据表示为表格形式，在表格形式中，数据存储在行和列中。

多维数组声明

datatype[ ][ ] arrayName;

数组初始化

datatype[ ][ ] arrayName = new int[no_of_rows][no_of_columns];

arrayName 是数组的名称， new 是用于分配内存的关键字，no _ of _ rows 和 no_of_columns 都用于设置行列大小元素。

像一维数组一样，我们也可以静态初始化多维数组。

int[ ][ ] arr = {{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15}};

示例:

	 class Demo
{
public static void main(String[] args)
  {
	int arr[ ][ ] = {{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15}};
        for(int i=0;i<3;i++)
        {
        	for (int j = 0; j < 5; j++) {

        		System.out.print(arr[i][j]+" ");
			}
        	System.out.println();

        }

     // assigning a value
        System.out.println("element at first row and second column: " +arr[0][1]);
   }
}

第一行第二列的 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 元素:2

交错数组

交错数组是具有不同列元素数量的数组。在 java 中，交错数组意味着多维数组中的列大小不均匀。

锯齿数组的初始化

参差不齐的数组初始化是不同的小不同。我们必须独立设置每行的列大小。

	 int[ ][ ] arr = new int[3][ ]; 
arr[0] = new int[3];
arr[1] = new int[4];
arr[2] = new int[5];

Jagged Array

Example : Jagged Array

 class Demo
{
public static void main(String[] args)
  {
	int arr[ ][ ] = {{1,2,3},{4,5},{6,7,8,9}};
        for(int i=0;i<3;i++)
        {
        	for (int j = 0; j < arr[i].length; j++) {

        		System.out.print(arr[i][j]+" ");
			}
        	System.out.println();

        }

   }
}

1 2 3 4 5 6 7 8 9

这里我们可以看到行的数量为 3 ，列每一行都不一样。这种类型的数组称为锯齿状数组。

在 Java 中创建对象的不同方法

原文：https://www.studytonight.com/java/ways-to-create-object-in-java.php

Java 是一种面向对象的语言，一切都围绕着对象。一个对象代表一个类的运行时实体，并且是调用类的变量和方法所必需的。

为了创建一个对象，Java 提供了我们将在本主题中讨论的各种方法。

新关键字
新实例
克隆方法
反序列化
NewInstance()方法

1)新关键字

在 Java 中，使用新关键字创建对象是非常流行和常见的。使用此方法，将调用用户或系统定义的默认构造器来初始化实例变量。new 关键字在堆中创建一个内存区域来存储创建的对象。

示例:

在本例中，我们使用 new 关键字创建一个对象。

	 public class NewKeyword
{ 
    String s = "studytonight"; 
    public static void main(String as[])  
    { 
NewKeyword a = new NewKeyword(); 
System.out.println(a.s); 
    } 
}

new-keyword-example

2)新实例

在这种情况下，我们使用类类的静态方法forName()。这个方法会载入类别，并传回类别类型的物件。我们进一步输入所需的类型来获得所需的对象类型。这就是我们在这种情况下所做的。

示例:

您可以看到这个例子，并理解我们通过使用返回类型类对象的 Class.forName() 方法加载了我们的类 NewInstance 。

	 public class NewInstance
{ 
    String a = "studytonight"; 
    public static void main(String[] args) 
    { 
        try
        { 
            Class b = Class.forName("NewInstance"); 
NewInstance c = (NewInstance) b.newInstance(); 
System.out.println(c.a); 
        } 
        catch (ClassNotFoundException e) 
        { 
e.printStackTrace(); 
        } 
        catch (InstantiationException e) 
        { 
e.printStackTrace(); 
        } 
        catch (IllegalAccessException e) 
        { 
e.printStackTrace(); 
        } 
    } 
}

New Instance Image

3)克隆()方法

在 Java 中，对对象调用 clone()。当调用 clone()方法时，JVM 会创建一个新对象，然后将旧对象的所有内容复制到其中。当使用 clone()方法创建对象时，不会调用构造器。为了在程序中使用 clone()方法，类实现了可克隆性，然后定义了 clone()方法。

示例:

在这个例子中，我们使用clone()方法创建一个对象。


	 public class CloneEg implements Cloneable
{ 
    @Override
    protected Object clone() throws CloneNotSupportedException
    { 
        return super.clone(); 
    } 
    String s = "studytonight"; 

    public static void main(String[] args) 
    { 
CloneEg a= new CloneEg(); 
        try
        { 
CloneEg b = (CloneEg) a.clone(); 
System.out.println(b.s); 
        } 
        catch (CloneNotSupportedException e) 
        { 
e.printStackTrace(); 
        } 
    } 
}

cloneEg program example

4)反序列化

在 Java 中，当一个对象被序列化然后反序列化时，JVM 会创建另一个单独的对象。执行反序列化时，JVM 不使用任何构造器来创建对象。

示例:

让我们看一个通过反序列化概念创建对象的例子。

		 import java.io.*; 

class DeserializationEg implements Serializable 
{ 
    private String a; 
DeserializationEg(String name) 
    { 
this.a = a; 
    } 

    public static void main(String[] args) 
    { 
        try
        { 
DeserializationEg b = new DeserializationEg("studytonight"); 
FileOutputStream c = new FileOutputStream("CoreJava.txt"); 
ObjectOutputStream  d = new ObjectOutputStream(c); 
d.writeObject(b); 
d.close(); 
d.close(); 
        } 
        catch (Exception e) 
        { 
e.printStackTrace(); 
        } 
    } 
}

deserialization example

deserialization main

构造器类的 newInstance()方法

在 Java 中，在 java.lang.reflect 包下构造器类位于。我们可以用它来创建对象。构造器类提供了一种可以用来创建对象的方法newInstance()。这个方法也叫做参数化构造器。

示例:

让我们创建一个使用构造器类的 newInstance()方法创建对象的示例。

		 import java.lang.reflect.*;

public class ReflectionEg
{
private String s;
ReflectionEg()
{
}
public void setName(String s)
{
this.s = s;
}
public static void main(String[] args)
{
try
{
Constructor<reflectioneg>constructor = ReflectionEg.class.getDeclaredConstructor();
ReflectionEg r = constructor.newInstance();
r.setName("studytonight");
System.out.println(r.s);
}
catch (Exception e)
{
e.printStackTrace();
}
}
}</reflectioneg>

reflectaion eg Image

Java 命令行参数

原文：https://www.studytonight.com/java/command-line-argument.php

命令行参数是在运行时传递给程序的参数。这是在 Java 中将参数传递给主方法的方式。这些参数存储在String类型参数参数中，该参数是主要的方法参数。

要访问这些参数，您可以简单地遍历循环中的 args 参数，或者使用直接索引值，因为 args 是 String 类型的数组。

例如，如果我们运行一个包含 main 方法的 HelloWorld 类，并在运行时为它提供参数，那么语法如下。

java HelloWorld arg1 arg2 ...

我们可以传递任意数量的参数，因为Parameter类型是数组。让我们看一个例子。

Example

在这个例子中，我们创建了一个类 HelloWorld，在运行程序的过程中，我们提供了命令行参数。

class cmd
{
    public static void main(String[] args)
    {
        for(int i=0;i< args.length;i++)
        {
            System.out.println(args[i]);
        }
    }
}

Execute this program as java cmd 10 20 30

10 20 30

为了基于某种条件或程序逻辑在两者之间终止程序，Java 提供了 exit() ，可用于在任意点终止程序。这里我们用例子讨论一下退出()的方法。

Java `System.exit()`方法

在 Java 中，exit()方法在 java.lang.System 类中。此方法用于退出或终止正在运行的程序。它可以取零或非零值。exit(0)用于成功终止，exit(1)或exit(-1)用于不成功终止。 exit()方法不返回值。

示例:

在这个程序中，我们根据一个条件，使用exit()方法终止程序。

	 import java.util.*; 
import java.lang.*; 

class ExitDemo1
{ 
    public static void main(String[] args) 
    { 
        intx[] = {5, 10, 15, 20, 25, 30, 35, 40, 45, 50}; 

        for (inti = 0; i<x.length; i++) 
        { 
            if (x[i] >= 40) 
            { 
                System.out.println("Program is Terminated..."); 
                System.exit(0); 
            } 
            else
                System.out.println("x["+i+"] = " + x[i]); 
        } 
    } 
}

system-exit-program

Java OOPS 概念

什么是 OOPS

原文：https://www.studytonight.com/java/object-and-classes.php

OOPS 是一种编程方法，它借助于基于现实世界的算法来解决现实生活中的问题。它使用现实世界的方法来解决问题。因此，面向对象技术为编写程序提供了比 C、ALGOL、PASCAL 等过程编程语言更好、更简单的方法。点击这里观看 Java 中 OOPS 概念的视频

Java 是一种面向对象的语言，它支持像类和对象这样的面向对象的概念。在 OOPS 中，数据被视为重要数据，被封装在类中，然后对象在运行时用来访问该数据。

OOPS 提供了优于其他编程范例的优势，包括以下特性。

OOPS 的主要功能

遗产
多态性
包装
抽象

作为一种面向对象的语言，Java 支持上面给出的所有特性。我们将在后面详细讨论所有这些特性。

Java 类

在 Java 中，一切都被封装在类下。类是 Java 语言的核心。它可以被定义为一个描述特定实体的行为和状态的模板。

类定义新的数据类型。一旦定义，这种新类型可以用来创建该类型的对象。

对象是类的一个实例。你也可以称之为逻辑模板类的物理存在。

在 Java 中，要声明一个类类关键字被使用。一个类包含数据和对该数据进行操作的方法。类中定义的数据或变量称为实例变量，对这些数据进行操作的代码称为方法。

因此，实例变量和方法被称为类成员。

Java 类的规则

一个类只能有公共或默认(无修饰符)访问说明符。
可以是抽象的，最终的，也可以是具体的(正常类)。
它必须有类关键字，类后面必须跟一个合法的标识符。
它可以选择只扩展一个父类。默认情况下，它扩展了对象类。
变量和方法在一组大括号中声明。

Java 类可以包含字段、方法、构造器和块。让我们看看一个类的一般结构。

Java 类语法

	 class  class_name {
     field;
     method;
}

一个简单的类例子

假设，学生为一个班级，学生姓名、卷号、年龄均为其字段、信息()为一个方法。那么类将如下所示。

class Student.
{
 String name;
 int rollno;
 int age;
void info(){
 // some code
}
}

这就是一个类的结构。它是一个物体的蓝图。我们可以通过使用对象来调用它的字段和方法。

类内声明的字段称为实例变量。它在运行时创建对象时获取内存。

类中的方法类似于用于执行操作和表示对象行为的函数。

了解了这个类之后，现在让我们来了解什么是对象。

Java 对象

对象是类的实例，而类是对象的蓝图。对象代表类，由属性和行为组成。

属性引用在类中用声明的字段，行为表示类中可用的方法。

在现实世界中，我们可以把物体理解为一部手机，它有自己的属性，如:姓名、费用、颜色等，还有像打电话、聊天等行为。

所以我们可以说物体是一个真实世界的实体。一些现实世界的物体有:球、风扇、汽车等。

有一种在 Java 中创建对象的语法。

Java 对象语法

className variable_name = new className();

这里， className 是类的名称，可以是上面例子中我们声明的:Student。

变量名称是引用变量的名称，用于保存所创建对象的引用。

new 是一个关键字，用于为对象分配内存。

让我们看一个例子来创建我们在上面的类部分中创建的类 Student 的对象。

虽然还有许多其他方法可以创建类的对象。我们已经在单独的主题中详细介绍了这一部分。

示例:对象创建

Student std = new Student();

这里， std 是一个在运行时表示类 Student 的对象。

新的关键字创建对象的实际物理副本，并将其分配给标准变量。它将有物理存在，并在堆区域获得内存。新操作符为对象动态分配内存。

creation of object in java

在这张图片中，我们可以了解一个对象是如何引用内存区域的。

现在让我们通过一个真实的例子来结合理解对象和类。

示例:创建类及其对象

	 public class Student{      

	 String name;
	 int rollno;
	 int age;

	void info(){
	  System.out.println("Name: "+name);
	  System.out.println("Roll Number: "+rollno);
	  System.out.println("Age: "+age);
	}  

	public static void main(String[] args) {
		Student student = new Student();

		// Accessing and property value
		student.name = "Ramesh";
		student.rollno = 253;
		student.age = 25;

		// Calling method
		student.info();

	}
}

名称:拉面卷编号:253 年龄:25

在这个例子中，我们创建了一个类 Student 和一个对象。在这里，您可能会惊讶地看到 main()方法，但不要担心它只是 JVM 开始执行的程序的入口点。

这里，我们使用 main 方法来创建 Student 类的对象，并访问它的字段和方法。

示例:类字段

	 public class Student{      

	 String name;
	 int rollno;
	 int age;

	void info(){
	  System.out.println("Name: "+name);
	  System.out.println("Roll Number: "+rollno);
	  System.out.println("Age: "+age);
	}  

	public static void main(String[] args) {
		Student student = new Student();

		// Calling method
		student.info();

	}
}

名称:空卷号:0 年龄:0

在这种情况下，如果我们没有初始化类字段的值，那么它们将被初始化为它们的默认值。

实例变量的默认值

int，byte，short，long - > 0

浮动，双→ 0.0

字符串或任何引用=空

布尔→假

这些值在运行时的对象创建过程中由 JVM 的默认构造器初始化。

Java 中的方法

原文：https://www.studytonight.com/java/methods-in-java.php

方法类似于其他编程语言中定义的函数。方法描述对象的行为。方法是组合在一起执行操作的语句的集合。

例如，如果我们有一个类 Human，那么这个类应该有像吃饭()，走路()，说话()等描述对象行为的方法。

声明方法类似于函数。请参见用 Java 声明该方法的语法。

return-type methodName(parameter-list)
{
 //body of method
}

返回类型是指方法返回的值的类型。

方法名是一个有效的有意义的名称，代表一个方法的名称。

参数列表代表该方法接受的参数列表。

方法可能有一个可选的 return 语句，用于向调用方函数返回值。

方法示例:

让我们通过一个简单的例子来理解这个方法，这个例子接受一个参数并返回一个字符串值。

public String getName(String st)
{
 String name="StudyTonight";
 name=name+st;
 return name;
}

method definition in java

修饰语:修饰语是方法的访问类型。我们稍后会详细讨论。

返回类型:方法可以返回值。方法返回值的数据类型在方法标题中声明。

方法名称:方法的实际名称。

参数:传递给方法的值。

方法体:定义方法做什么的语句集合。

调用方法

调用方法来执行其中实现的功能。我们可以通过名称调用方法，并将返回值存储到变量中。

String val = GetName(".com")

在追加方法调用期间传递的参数后，它将返回一个值studytonight.com。

返回多个值

在 Java 中，我们可以使用数组从一个方法中返回多个值。我们将所有的值存储到一个想要返回的数组中，然后将其返回给调用者方法。我们必须在创建数组时将返回类型指定为数组。让我们看一个例子。

示例:

下面是一个例子，我们返回一个包含多个值的数组。

  class MethodDemo2{ 
    static int[] total(int a, int b) 
    { 
int[] s = new int[2]; 
s[0] = a + b; 
s[1] = a - b; 
        return s; 
    } 

    public static void main(String[] args) 
    { 
int[] s = total(200, 70); 
System.out.println("Addition = " + s[0]); 
System.out.println("Subtraction = " + s[1]); 
    } 
}

return-multiple-values

从方法返回对象

在某些情况下，可能需要将类的对象返回给调用者函数。在这种情况下，我们必须在方法定义中指定类名。

下面是一个例子，我们从方法调用中获取一个对象。它也可以用来返回数据集合。

示例:

在这个例子中，我们创建了一个方法 get() 返回演示类的对象。

  class Demo{
int a; 
    double b; 
int c; 
Demo(int m, double d, int a) 
    { 
        a = m; 
        b = d; 
        c = a; 
    } 
} 
class MethodDemo4{ 
    static Demo get(int x, int y) 
    { 
        return new Demo(x * y, (double)x / y, (x + y)); 
    } 
    public static void main(String[] args) 
    { 
        Demo ans = get(25, 5); 
System.out.println("Multiplication = " + ans.a); 
System.out.println("Division = " + ans.b); 
System.out.println("Addition = " + ans.c); 
    } 
}

return-multiple-values

方法中的参数与参数

说到方法，重要的是要知道两个术语参数和参数的区别。

参数是一个方法定义的变量，在调用该方法时接收值。参数始终是方法的本地参数，它们在方法之外没有作用域。而参数是调用方法时传递给方法的值。

你可以通过下面的图片来理解它，这个图片用一个程序例子来解释参数和参数。

parameter and argument

`call-by-value`和`call-by-reference`

有两种方法可以将参数传递给方法

按值调用:在这种方法中，参数值的副本被传递给一个方法。对方法内部参数值所做的更改不会影响参数。
按引用调用:在这种引用中，参数被传递给方法。在方法内部所做的任何更改都将影响 agrument 值。

注意:然而在 Java 中并没有引用调用的概念。Java 只支持按值调用。

`call-by-value`示例

让我们看一个例子，在这个例子中，我们将参数传递给一个方法并修改它的值。

public class Test
{
    public void callByValue(int x)
    {
        x=100;
    }
    public static void main(String[] args)
    {
       int x=50;
        Test t = new Test();
        t.callByValue(x);	<font color="green">//function call</font>
        System.out.println(x);
    }

}

Fifty

看，在上例中，传递给方法的值即使在方法中修改后也不会改变。它显示对该值所做的更改是局部的，并且参数作为值调用传递。

Java 是严格按值传递的

原文：https://www.studytonight.com/java/java-is-strictly-pass-by-value.php

在 java 中，Java 是按值传递还是按引用传递是非常混乱的。

当参数的值被复制到另一个变量中时，称为按值传递，当变量的引用被传递给方法时，称为按引用传递。

这是 C 语言的一个特点，在函数调用过程中传递变量的地址，并反映原始变量的变化。

就 Java 而言，我们没有变量地址的概念，一切都是基于对象的。因此，我们可以在方法调用期间传递基元值或对象值。

注意: Java 是严格按值传递的。这意味着在方法调用期间，传递的是值而不是地址。

示例:

下面是一个例子，其中值是通过值传递的，并且在函数内部进行了更改，但是在函数外部的更改不会反映到原始变量值中。

	 class Add
{ 
	int x, y; 
	Add(int i, int j) 
	{ 
		x = i; 
		y = j;
	}  
} 
class Demo
{ 
	public static void main(String[] args) 
	{ 
		Add obj = new Add(5, 10); 
		// call by value
		change(obj.x, obj.y);
		System.out.println("x = "+obj.x); 
		System.out.println("y = "+obj.y);

	} 
	public static void change(int x, int y) 
	{  
		x++;
		y++;
	} 
}

x = 5 y = 10

让我们再举一个例子，一个对象作为值传递给函数，在这个例子中，我们改变了它的变量值，这些改变反映到了原始对象上。这看起来像是通过参考，但我们区分它。在这里，对象的成员被改变，而不是对象。

示例:

下面是一个传递值并反映更改的示例。

	 class Add
{ 
	int x, y; 
	Add(int i, int j) 
	{ 
		x = i; 
		y = j;
	}  
} 
class Demo
{ 
	public static void main(String[] args) 
	{ 
		Add obj = new Add(5, 10); 
		// call by value (object is passed)
		change(obj);
		System.out.println("x = "+obj.x); 
		System.out.println("y = "+obj.y);

	} 
	public static void change(Add add) 
	{  
		add.x++;
		add.y++;
	} 
}

6 11

Java 中的构造器

原文：https://www.studytonight.com/java/constructor-in-java.php

构造器是一种用于初始化对象的特殊方法。每个类都有一个隐式或显式的构造器。

如果我们没有在类中声明一个构造器，那么 JVM 会为这个类构建一个默认的构造器。这就是所谓的默认构造器。

构造器与声明它的类名同名。构造器必须没有显式返回类型。Java 中的构造器不能是抽象的、静态的、最终的或者同步的。构造器不允许使用这些修饰符。

声明构造器的语法

  className (parameter-list){
  code-statements
}

类名是类名，因为构造器名与类名相同。

参数列表是可选的，因为构造器可以参数化，也可以非参数化。

构造器示例

在 Java 中，构造器在结构上看起来像下面程序中给出的。Car 类有一个为实例变量提供值的构造器。

class Car
{
 String name ;
 String model;
 Car( )    **//Constructor**
 {
  name ="";
  model="";
 }
}

构造器的类型

Java 支持两种类型的构造器:

默认构造器
参数化构造器

每次创建新对象时，至少会调用一个构造器。

Car c = new Car()       **//Default constructor invoked**
Car c = new Car(name); **//Parameterized constructor invoked**

默认构造器

在 Java 中，如果一个构造器没有任何参数，它就被称为默认构造器。默认构造器可以是用户定义的，也可以由 JVM 提供。

如果一个类不包含任何构造器，那么在运行时 JVM 会生成一个默认构造器，称为系统定义默认构造器。

如果一个类包含一个不带参数的构造器，那么它被称为用户定义的默认构造器。在这种情况下，JVM 不会创建默认构造器。

创建构造器的目的是初始化对象的状态。

下图显示了 JVM 如何在运行时向类添加构造器。

default-constructor

用户定义默认构造器

程序员在类中定义的构造器称为用户定义的默认构造器。

示例:

在本例中，我们创建了一个与类名同名的构造器。

  class AddDemo1
{  
  AddDemo1()
  {
    int a=10;
    int b=5;
    int c;
    c=a+b;
    System.out.println("*****Default Constructor*****");
    System.out.println("Total of 10 + 5 = "+c);
  }  

  public static void main(String args[])
  {  
    AddDemo1 obj=new AddDemo1();  
  }  
}

default-constructor

构造器重载

像方法一样，构造器也可以重载。重载构造器根据其Parameter类型或参数数量进行区分。构造器重载与方法重载没有太大区别。在方法重载的情况下，您有多个名称相同但签名不同的方法，而在构造器重载中，您有多个签名不同的构造器，但唯一的区别是构造器没有返回类型。

构造器重载示例

class Cricketer
{
 String name;
 String team;
 int age;
 Cricketer ()   **//default constructor**.
 {
  name ="";
  team ="";
  age = 0;
 }
 Cricketer(String n, String t, int a)   **//constructor overloaded**
 {
  name = n;
  team = t;
  age = a;
 }
 Cricketer (Cricketer ckt)     **//constructor similar to copy constructor of c++** 
 {
  name = ckt.name;
  team = ckt.team;
  age = ckt.age;
 }
 public String toString()
 {
  return "this is " + name + " of "+team;
 }
}

Class test:
{
 public static void main (String[] args)
 {
  Cricketer c1 = new Cricketer();
  Cricketer c2 = new Cricketer("sachin", "India", 32);
  Cricketer c3 = new Cricketer(c2 );
  System.out.println(c2);
  System.out.println(c3);
  c1.name = "Virat";
  c1.team= "India";
  c1.age = 32;
  System .out. print in (c1);
 }
}

这是印度的萨钦这是印度的萨钦这是印度的维拉特

构造器链接

构造器链接是从同一个类中的另一个构造器调用一个构造器的过程。由于只能从另一个构造器调用构造器，因此构造器链接用于此目的。

从另一个构造器调用构造器时，使用this关键字。此关键字用于引用当前对象。

让我们看一个理解构造器链接的例子。

  class Test
{
 Test()
 {
  this(10);
 }
 Test(int x)
 {
  System.out.println("x="+x);
 }
public static void main(String arg[])
{
Test object = new Test();
}
}

x=10

当我们想要通过创建类的单个对象来执行多个任务时，使用构造器链接。

在下图中，我们描述了同一类中构造器调用的流程。

constructor-chaining

示例:

让我们再看一个例子来理解构造器链。这里我们已经创建了三个构造器，并通过使用this关键字来调用它们。

  class abc
{
  public abc()
  {
    this(5);
    System.out.println("Default Constructor");
  }
  public abc(int x)
  {
    this(5, 6);
    System.out.println("Constructor with one Parameter");
    System.out.println("Value of x ==> "+x);
  }
  public abc(int x, int y)
  {
    System.out.println("Constructor with two Parameter");
    System.out.println("Value of x and y ==> "+x+" "+y);
  }
}
class ChainingDemo1
{
  public static void main(String as[])
  {
    abcobj = new abc();
  }
}

output-constructor-chaining

私有构造器

在 Java 中，我们可以创建私有构造器来防止类被实例化。这意味着通过声明一个私有构造器，它限制创建该类的对象。

私有构造器用于创建单例类。一个只能有一个对象的类，称为单例类。

在私有构造器中，只能创建一个对象，该对象是在类中创建的，并且所有方法都是静态的。如果类中存在私有构造器，则无法创建对象。一个有私有构造器并且所有方法都是静态的类叫做实用类。

示例:

  final class abc
{
  private abc()
  {}
  public static void add(int a, int b)
  {
    int z = a+b;
    System.out.println("Addition: "+z);
  }
  public static void sub(int x, int y)
  {
    int z = x-y;
    System.out.println("Subtraction: "+z);
  }

}
class PrivateConDemo
{
  public static void main(String as[])
  {
    abc.add(4, 5);
    abc.sub(5, 3);
  }
}

private-constructor

Java 中的访问修饰符

原文：https://www.studytonight.com/java/modifier-in-java.php

访问修饰符是 Java 中用于设置可访问性的关键字。访问修饰符限制另一个类中的类、构造器、数据成员和方法的访问。

Java 语言有四个访问修饰符来控制类及其成员的访问级别。

默认:默认只在同一个包内有作用域
Public: Public 具有随处可见的范围
受保护:受保护在包和所有子类中都有作用域
Private: Private 只在类内有作用域

Java 还支持很多非访问修饰符，比如静态、抽象、同步、原生、易变、瞬态等。我们将在其他教程中介绍这些内容。

Access modifier in java

默认访问修饰符

如果我们没有指定任何访问修饰符，那么它将被视为默认的修饰符。它用于设置包内的可访问性。这意味着我们不能从包外访问它的方法或类。它也被称为包可访问性修饰符。

示例:

在本例中，我们在包 1 中创建了一个演示类，并通过另一个类测试来访问演示类的 show()方法。我们没有提到 show()方法的访问修饰符，这就是它不可访问并在编译时报告错误的原因。

Demo.java

  package package1;

public class Demo {

  int a = 10;
  // default access modifier
  void show() {
    System.out.println(a);
  }

}

Test.java

  import package1.Demo;
public class Test {

  public static void main(String[] args) {
    Demo demo = new Demo();
    demo.show(); // compile error
  }
}

演示类型中的 show()方法不可见

公共访问修饰符

public access 修饰符用于设置变量、方法或类的公共可访问性。任何声明为公共的变量或方法都可以从应用的任何地方访问。

示例:

这里，我们有两个位于两个不同包中的类演示和测试。现在我们想从测试类访问演示类的显示方法。该方法具有公共可访问性，因此运行良好。见下面的例子。

Demo.java

  package package1;

public class Demo {

  int a = 10;
  // public access modifier
  public void show() {
    System.out.println(a);
  }

}

Test.java

  package package2;
import package1.Demo;
public class Test {

  public static void main(String[] args) {
    Demo demo = new Demo();
    demo.show();
  }
}

Ten

受保护的访问修饰符

Protected 修饰符保护变量、方法不被类外部访问。它可以在类内访问，并且在子类(继承)中，无论子级是位于同一个包中的还是某个其他包中的。

示例:

在本例中，Test 类由 Demo 扩展，并被称为受保护的方法 show()，由于继承，现在可以访问该方法。

Demo.java

  package package1;

public class Demo {

  int a = 10;
  // public access modifier
  protected void show() {
    System.out.println(a);
  }

}

Test.java

  package package2;
import package1.Demo;
public class Test extends Demo{

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

Ten

私有访问修饰符

私有修饰符是最受限制的修饰符，只允许在同一个类中访问。我们可以将这个修饰符设置为任何变量、方法甚至构造器。

示例:

在本例中，我们将私有修饰符设置为 show()方法，并尝试从类外部访问该方法。Java 不允许从类外部访问它。

Demo.java

  class Demo {

  int a = 10;
  private void show() {
    System.out.println(a);
  }

}

Test.java

  public class Test {

  public static void main(String[] args) {
    Demo demo = new Demo();
    demo.show(); // compile error
  }
}

演示类型中的 show()方法不可见

修改非访问权限

除了访问修饰符，Java 还提供了非访问修饰符。这些修饰符用于为变量或方法设置特殊属性。

非访问修饰符不会改变变量或方法的可访问性，但会为它们提供特殊的属性。Java 提供了以下非访问修饰符。

最后的
静态
短暂的
同步的
不稳定的

最终修改

最终修改器可以与变量、方法和类一起使用。如果变量被声明为最终，那么我们不能更改它的值。如果方法被声明最终那么它不能被覆盖，如果一个类被声明最终那么我们不能继承它。

静态修改器

静态修饰符用于使字段静态。我们可以用它来声明静态变量、方法、类等。静态可以用来声明类级变量。如果一个方法被声明为静态的，那么我们不需要对象来访问它。我们可以使用静态创建嵌套类。

瞬态修改器

当一个实例变量被声明为瞬态变量时，它的值在对象被序列化时不会持续存在

同步修改器

当一个方法被同步时，它一次只能被一个线程访问。我们将在线程中详细讨论它。

挥发性改性剂

Volatile 修饰符告诉编译器，volatile 变量可能会被程序的其他部分意外更改。可变变量用于多线程程序。 volatile 关键字不能与方法或类一起使用。它只能与变量一起使用。

Java 中的继承

原文：https://www.studytonight.com/java/inheritance-in-java.php

继承是面向对象编程的关键特征之一。继承提供了允许一个类继承另一个类的属性的机制。当一个类扩展另一个类时，它会继承所有非私有成员，包括字段和方法。Java 中的继承最好从父子关系来理解，在 Java 语言中又称为超类(父类)子类(子类)。

继承定义了是一个超级类和它的子类之间的关系。extends和implements关键字在 Java 中用来描述继承。

Inheritance in Java

让我们看看如何扩展关键字来实现继承。表现为超类和子类的关系。

class Vehicle
{
    ......
}
class Car extends Vehicle
{
    .......    //extends the property of vehicle class
}

现在根据上面的例子。在 OOPs 术语中，我们可以说，

车是车的特级。
车是车的子类。
汽车是一种交通工具。

继承的目的

它提高了代码的可重用性，即在父/超/基类中定义的相同方法和变量可以在子/子/派生类中使用。
它通过允许方法覆盖来促进多态性。

继承的弊端

使用继承的主要缺点是两个类(父类和子类)紧密耦合。

这意味着，如果我们更改父类的代码，它将影响到继承/派生父类的所有子类，因此，不能相互独立**。

继承的简单例子

在继续之前，让我们举一个简单的例子，试着更好地理解继承的概念，

class Parent
{
    public void p1()
    {
        System.out.println("Parent method");
    }
}
public class Child extends Parent {

    public void c1()
    {
        System.out.println("Child method");
    }
    public static void main(String[] args)
    {
        Child cobj = new Child();
        cobj.c1();  //method of Child class
        cobj.p1();  //method of Parent class
    }
}

子方法父方法

在上面的代码中，我们有一个类父类，它有一个方法p1()。然后我们创建一个新的类子类，它使用extends关键字继承类父类，并定义自己的方法c1()。现在通过继承类子也可以访问类父的public方法p1()。

继承超类的变量

超类的所有成员隐式继承到子类。成员由类的实例变量和方法组成。

例子

在本例中，子类将访问超类中定义的变量。

class Vehicle
{
    // variable defined
    String vehicleType;
}
public class Car extends Vehicle {

    String modelType;
    public void showDetail()
    {
        vehicleType = "Car";    //accessing Vehicle class member variable
        modelType = "Sports";
        System.out.println(modelType + " " + vehicleType);
    }
    public static void main(String[] args)
    {
        Car car = new Car();
        car.showDetail();
    }
}

跑车

继承的类型

Java 主要只支持下面列出的三种继承类型。

单一继承
多级继承
分级继承

注意:Java 不支持多重继承

我们可以从下图中快速查看继承类型。

Types of Inheritance in Java

单一继承

当一个类扩展到另一个类时，它就形成了单一继承。在下面的例子中，我们有两个类，其中类 A 扩展到类 B，形成单一继承。

    class A{
    int a = 10;
    void show() {
        System.out.println("a = "+a);
    }
}

public class B extends A{

public static void main(String[] args) {
    B b = new B();
    b.show();

    }
}

a=10

在这里，我们可以注意到 show()方法是在类 A 中声明的，但是使用子类 Demo 对象，我们可以调用它。这显示了这两个类之间的继承。

多级继承

当一个类扩展到另一个类时，这个类也扩展了另一个类，形成了多级继承。例如，C 类扩展到 B 类，B 类也扩展到 A 类，A 类和 B 类的所有数据成员和方法现在都可以在 C 类中访问

示例:

    class A{
    int a = 10;
    void show() {
        System.out.println("a = "+a);
    }
}

class B extends A{
    int b = 10;
    void showB() {
        System.out.println("b = "+b);
    }
}

public class C extends B{

public static void main(String[] args) {
    C c = new C();
    c.show();
    c.showB();  
    }
}

a=10 b=10

分级继承

当一个类被两个或多个类扩展时，就形成了层次继承。例如，B 类扩展到 A 类，C 类也扩展到 A 类，在这种情况下，B 和 C 都共享 A 类的属性。

    class A{
    int a = 10;
    void show() {
        System.out.println("a = "+a);
    }
}

class B extends A{
    int b = 10;
    void showB() {
        System.out.println("b = "+b);
    }
}

public class C extends A{

    public static void main(String[] args) {
        C c = new C();
        c.show();
        B b = new B();
        b.show();
    }
}

a = 10 a = 10

为什么 Java 不支持多重继承？

消除歧义。
提供更易维护和清晰的设计。

problem with multiple inheritance

`super`关键字

在 Java 中，super关键字用来指代子类的直接父类。换句话说 super 关键字被子类在需要引用它的直接超类时使用。

example of super keyword in java

使用`super`关键字引用父类属性的子类示例

在这个例子中，我们将只关注访问父类属性或变量。

class Parent
{
    String name;

}
public class Child extends Parent {
    String name;
    public void details()
    {
        super.name = "Parent";  //refers to parent class member
        name = "Child";
        System.out.println(super.name+" and "+name);
    }
    public static void main(String[] args)
    {
        Child cobj = new Child();
        cobj.details();
    }
}

父母和孩子

使用`super`关键字引用父类方法的子类示例

在这个例子中，我们将只关注访问父类方法。

class **Parent**
{
    String name;
    public void details()
    {
      name = "Parent";
        System.out.println(name);
    }
}
public class **Child** extends **Parent** {
    String name;
    public void details()
    {
        super.details();	**//calling Parent class details() method**
        name = "Child";
        System.out.println(name);
    }
    public static void main(String[] args)
    {
        Child cobj = new Child();
        cobj.details();
    }
}

父代子代

子类使用`super`关键字调用父类`constructor`的例子

在这个例子中，我们将着重于访问父类构造器。

class **Parent**
{
    String name;

    public Parent(String n)
    {
        name = n;
    }

}
public class **Child** extends **Parent** {
    String name;

    public Child(String n1, String n2)
    {

        super(n1);       **//passing argument to parent class constructor**
        this.name = n2;
    }
    public void details()
    {
        System.out.println(super.name+" and "+name);
    }
     public static void main(String[] args)
    {
        Child cobj = new Child("Parent","Child");
        cobj.details();
    }
}

父母和孩子

注意:使用 super 关键字从子类调用父类构造器时，super 关键字应该始终是子类的方法/构造器中的第一行。

问:你能在构造器中同时使用`this()`和`super()`吗？

不，因为 super()和 this()都必须是构造器中的第一个语句。因此我们不能一起使用它们。

Java 中的聚合

原文：https://www.studytonight.com/java/aggregation.php

聚合是一个术语，用于指代两个对象之间的单向关系。例如，学生班级可以有参考的地址班级，反之则没有意义。

在 Java 中，聚合表示 HAS-A 关系，这意味着当一个类包含另一个已知有聚合的类的引用时。

HAS-A 关系是基于使用，而不是继承。换句话说，如果类 A 引用了类 B 的一个实例，那么类 A 与类 B 有一种关系

让我们通过一个例子来理解它，并考虑两个班级学生和地址。每个学生都有自己的地址，这使得有关系，但地址有学生没有任何意义。我们可以使用 Java 代码更清楚地理解它。

Class Address{
int street_no;
String city;
String state;
int pin;
Address(int street_no, String city, String state, int pin ){
this.street_no = street_no;
this.city = city;
this.state = state;
this.pin = pin;
}
}

class Student
{
  String name;
  Address ad;
}

在上面的代码中，我们可以看到学生班级与地址班级有-关系。我们也画了一个图像来说明这两个类之间的关系..

Aggregation in Java

Student类有一个类型为Address的实例变量。由于我们在Student类中有一个类型为Address的变量，它可以使用地址引用来调用Address类的方法，在这种情况下，地址引用是ad。

聚合的优势

使用聚合的主要优势是维护代码的可重用性。如果一个实体与某个其他实体有关系，那么只需引用它就可以重用代码。

聚合示例

现在让我们用一个例子来理解它，这里我们创建了两个类作者和图书，图书类通过引用与作者类有关系。现在我们能够得到这两个类的所有属性。

class Author
{
  String authorName;
  int age;
  String place;

  // Author class constructor
  Author(String name, int age, String place)
  {
    this.authorName = name;
    this.age = age;
    this.place = place;
  }
}

class  Book
{
  String name;
  int price;
  // author details
  Author auther;
  Book(String n, int p, Author auther)
  {
    this.name = n;
    this.price = p;
    this.auther = auther;
  }
  public static void main(String[] args) {
    Author auther = new Author("John", 42, "USA");
    Book b = new Book("Java for Begginer", 800, auther);
    System.out.println("Book Name: "+b.name);
    System.out.println("Book Price: "+b.price);
    System.out.println("------------Auther Details----------");
    System.out.println("Auther Name: "+b.auther.authorName);
    System.out.println("Auther Age: "+b.auther.age);
    System.out.println("Auther place: "+b.auther.place);
  }

}

书名:Java for Begginer 书价:800 -作者详情-作者姓名:约翰·作者年龄:42 作者地点:美国

让我们再举一个例子来理解聚合。假设我们还有一个 Publisher 类，那么 Book 类只需将其引用用作 Author 类，就可以重用 Publisher 类的详细信息。让我们用 Java 代码来理解它。

  class Publisher{

  String name;
  String publisherID;
  String city;

  Publisher(String name, String publisherID, String city) {
    this.name = name;
    this.publisherID = publisherID;
    this.city = city;
  }
}

class Author
{
  String authorName;
  int age;
  String place;

  // Author class constructor
  Author(String name, int age, String place)
  {
    this.authorName = name;
    this.age = age;
    this.place = place;
  }
}

class Book
{
  String name;
  int price;
  // author details
  Author auther;
  Publisher publisher;
  Book(String n, int p, Author auther, Publisher publisher )
  {
    this.name = n;
    this.price = p;
    this.auther = auther;
    this.publisher = publisher;
  }
  public static void main(String[] args) {
    Author auther = new Author("John", 42, "USA");
    Publisher publisher = new Publisher("Sun Publication","JDSR-III4", "LA");
    Book b = new Book("Java for Begginer", 800, auther, publisher);
    System.out.println("Book Name: "+b.name);
    System.out.println("Book Price: "+b.price);
    System.out.println("------------Author Details----------");
    System.out.println("Auther Name: "+b.auther.authorName);
    System.out.println("Auther Age: "+b.auther.age);
    System.out.println("Auther place: "+b.auther.place);
    System.out.println("------------Publisher Details-------");
    System.out.println("Publisher Name: "+b.publisher.name);
    System.out.println("Publisher ID: "+b.publisher.publisherID);
    System.out.println("Publisher City: "+b.publisher.city);
  }

}

图书名称:Java for Begginer 图书价格:800 -作者详细信息-作者姓名:John Auther 年龄:42 作者地点:美国-出版商详细信息-出版商名称:Sun Publication 出版商 ID: JDSR-III4 出版商城市:洛杉矶

在 Java 中编写

合成是一种更受限制的聚合形式。组合可以被描述为当一个类包含另一个类时，它依赖于另一个类，以至于如果没有包含的类，它就不能在功能上存在。例如一个类Car没有Engine就不能存在，因为它将不再起作用。

因此单词 Composition 的意思是组成某物的项目，如果我们改变它们所改变的事物的组成，类似地，在 Java 类中，一个类包括另一个类，如果所包括的类为外部类提供核心功能意义，那么这个类被称为 Composition。

class Car
{
  private Engine engine;
  Car(Engine en)
  {
    engine = en;
  }
}

这里通过检查代码，我们可以理解，如果 Car 类与 Engine 类没有关系，那么 Car 就不存在。

组合是一种设计技术，不是 Java 的特性，但是我们可以用 Java 代码来实现。

问:什么时候使用继承和聚合？

当您想要使用任何类的某些属性或行为而不需要修改它或向它添加更多功能时，在这种情况下聚合是一个更好的选择，因为在聚合的情况下，我们只是使用类内的任何外部类作为变量。

然而当你想要使用和修改任何外部类的一些属性或行为，或者可能想要在它上面添加更多的函数时，最好使用继承。

要了解更多关于继承的知识，您可以访问我们这里的详细教程。点击这里查看 Java 中的继承

Java 中的方法重载

原文：https://www.studytonight.com/java/method-and-overloaded-method.php

方法重载是一个概念，允许在同一个类中声明多个同名但参数不同的方法。

Java 支持方法重载，并且总是发生在同一个类中(与方法覆盖不同)。

方法重载是 java 支持多态性的方式之一。多态性是面向对象编程的一个概念，它处理多种形式。稍后我们将在单独的主题中讨论多态性。

方法重载可以通过改变参数数量或者改变参数数据类型来实现。

如果两个或两个以上的方法具有相同的名称和相同的参数表，但返回类型不同，则不能重载。

注意:重载方法可以有不同的访问修饰符，在方法重载中没有任何意义。

方法重载有两种不同的方式。

参数的不同数据类型
不同数量的参数

通过更改参数的数据类型来重载方法。

示例:

在这个例子中，我们有两个 sum()方法，分别接受整型和浮点型参数。

请注意，在同一个类中，我们有两个名称相同但Parameter类型不同的方法

class Calculate
{
  void sum (int a, int b)
  {
    System.out.println("sum is"+(a+b)) ;
  }
  void sum (float a, float b)
  {
    System.out.println("sum is"+(a+b));
  }
  Public static void main (String[] args)
  {
    Calculate  cal = new Calculate();
    cal.sum (8,5);      **//sum(int a, int b) is method is called**.
    cal.sum (4.6f, 3.8f); **//sum(float a, float b) is called**.
  }
}

总和是 13 总和是 8.4

可以看到 sum()方法被重载了两次。第一个接受两个整数参数，第二个接受两个浮点参数。

通过更改参数数量来重载方法。

例:

在这个例子中，我们有两种方法

class Demo
{
  void multiply(int l, int b)
  {
    System.out.println("Result is"+(l*b)) ;
  }
  void multiply(int l, int b,int h)
  {
    System.out.println("Result is"+(l*b*h));
  }
  public static void main(String[] args)
  {
    Demo  ar = new Demo();
    ar.multiply(8,5);   //multiply(int l, int b) is method is called
    ar.multiply(4,6,2);   //multiply(int l, int b,int h) is called
  }
}

结果是 40 结果是 48

在本例中，multiply()方法被重载了两次。第一种方法采用两个参数，第二种方法采用三个参数。

当调用重载方法时，Java 寻找调用该方法的参数与其参数之间的匹配。这种匹配不需要总是精确的，有时当没有找到精确的匹配时，Java 自动类型转换起着至关重要的作用。

类型提升的方法重载示例。

Java 支持自动类型提升，如 int 到 long 或 float 到 double 等。在这个例子中，我们做同样的事情，并调用一个函数，该函数接受一个整数和第二个Long类型参数。在调用时，我们传递了整数值，Java 将第二个参数视为Long类型。见下面的例子。

class Demo
{
 void sum(int l,long b)
 {
  System.out.println("Sum is"+(l+b)) ;
 }
 void sum(int l, int b, int h)
 {
  System.out.println("Sum is"+(l+b+h));
 }
 public static void main (String[] args)
 {
  Demo  ar = new Demo();
  ar.sum(8,5);
 }
}

总和是 13

如果参数的顺序改变，方法重载

我们可以有两个具有相同名称和参数的方法，但是参数的顺序是不同的。

示例:

在这种情况下，方法重载起作用，但是在内部 JVM 将其视为具有不同类型参数的方法

  class Demo{

    public void get(String name,  int id)
   { 
System.out.println("Company Name :"+ name);
  System.out.println("Company Id :"+ id); 
    } 

    public void get(int id, String name)
   { 
System.out.println("Company Id :"+ id); 
  System.out.println("Company Name :"+ name);
    } 
} 

class MethodDemo8{ 
    public static void main (String[] args) { 
  Demo obj = new Demo();
  obj.get("Cherry", 1);
  obj.get("Jhon", 2);
    } 
}

parameter-different-method-overloading

重载主方法

在 Java 中，我们可以使用不同数量和类型的参数重载 main()方法，但是 JVM 只理解原来的 main()方法。

示例:

在本例中，我们创建了三个具有不同Parameter类型的 main()方法。

  public class MethodDemo10{ 
    public static void main(intargs) 
    { 
System.out.println("Main Method with int argument Executing"); 
  System.out.println(args);
    } 
    public static void main(char args) 
    { 
System.out.println("Main Method with char argument Executing");
  System.out.println(args); 
    } 
    public static void main(Double[] args) 
    { 
System.out.println("Main Method with Double Executing"); 
  System.out.println(args);
    } 
    public static void main(String[] args) 
    { 
System.out.println("Original main Executing"); 
  MethodDemo10.main(12);
  MethodDemo10.main('c');
  MethodDemo10.main(1236);
    } 
}

overloading-main

方法重载和空错误

这是处理对象时的一个常见问题，如果同名方法具有引用类型参数，则在传递参数时要小心。

下面是一个示例，在这个示例中，您将知道当方法重载时，空值会如何导致错误。

示例:

空值是所有引用类型的默认值。它给报告错误的 JVM 制造了歧义。

  public class Demo 
{ 
    public void test(Integer i) 
    { 
System.out.println("test(Integer ) "); 
    } 
    public void test(String name) 
    { 
System.out.println("test(String ) "); 
    } 
    public static void main(String [] args) 
    { 
        Demo obj = new Demo();  
obj.test(null); 
    } 
}

对于演示类型，方法测试(整数)不明确

原因:

在上面的例子中出现编译时错误的主要原因是，这里我们有整数和字符串作为参数，它们在 java 中不是原始数据类型，并且这种类型的参数不接受任何空值。当传递空值时，编译器会混淆选择哪个方法，因为上面例子中的两个方法都接受空值。

但是，我们可以解决这个通过具体的引用类型而不是值。

示例:

在这个例子中，我们传递的是特定的类型参数，而不是空值。

   public class MethodDemo9 
{ 
    public void test(Integer i) 
    { 
System.out.println("Method ==> test(Integer)"); 
    } 
    public void test(String name) 
    { 
System.out.println("Method ==> test(String) "); 
    } 
    public static void main(String [] args) 
    { 
        MethodDemo9 obj = new MethodDemo9 ();  
  Integer a = null;
obj.test(a);
  String b = null;
obj.test(b); 
    } 
}

method-overloading-null-error

Java 中的方法覆盖

原文：https://www.studytonight.com/java/method-overriding-in-java.php

方法覆盖是通过具有更具体定义的派生类方法覆盖基类方法的过程。

只有当两个类具有 is-a 关系时，方法覆盖才会执行。这意味着类必须具有继承性。换句话说，它是使用继承关系在两个类之间执行的。

在覆盖中，两个类的方法必须具有相同的名称和相同数量的参数。

方法覆盖也被称为运行时多态性，因为调用方法是由 JVM 在运行时决定的。

覆盖的主要好处是能够定义特定子Class类型的方法。

方法覆盖规则

1.父类和子类的方法名必须相同。

2.子方法的访问修饰符不能比父类方法更严格。

3.不能覆盖私有、最终和静态方法。

4.类之间必须有一种 IS-A 关系(继承)。

方法覆盖示例

下面我们有一个简单的代码示例，有一个父类和一个子类，其中子类将覆盖父类提供的方法。

class Animal
{
    public void eat()
    {
        System.out.println("Eat all eatables");
    }
}

class Dog extends Animal
{
    public void eat()   //eat() method overridden by Dog class.
    {
        System.out.println("Dog like to eat meat");
    }

    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();
    }
}

狗喜欢吃肉

这里可以看到 Dog 类给出了自己的eat()方法的实现。对于方法覆盖，该方法在父类和子类中必须具有相同的名称和相同的类型签名。

注意:静态方法不能被覆盖，因为静态方法以类为界，而实例方法以对象为界。

示例:访问修饰符在子类中的限制性更强

如果子类比父类有更多的受限访问修饰符，Java 不允许方法覆盖。

在下面的例子中，对于子类方法，我们设置了 protected，它比父类中指定的 pubic 更受限制。

    class Animal
{
    public void eat()
    {
        System.out.println("Eat all eatables");
    }
}

class Dog extends Animal
{
    protected void eat()   //error
    {
        System.out.println("Dog like to eat meat");
    }

    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();
    }
}

无法降低从 Animal 继承的方法的可见性。

协变返回类型

从 Java 5 开始，可以通过改变方法的返回类型来覆盖它。如果子类通过改变超类方法的返回类型来覆盖任何方法，那么被覆盖方法的返回类型必须是超类内部原始方法中声明的返回类型的子类型。这是通过更改方法的返回类型来覆盖该方法的唯一方法。

例:

class Animal
{
    Animal getObj()
    {
        System.out.println("Animal object");
        return new Animal();
    }
}

class Dog extends Animal
{
    Dog getObj()     //Legal override after Java5 onward
    {   System.out.println("Dog object");
        return new Dog();
    }

    public static void main(String[] args) {
        new Dog().getObj();
    }
}

狗物体

重载和覆盖的区别

方法重载和方法覆盖似乎是相似的概念，但它们不是。让我们看看它们之间的一些差异:

方法重载	方法覆盖
参数必须不同，名称必须相同。	名称和参数必须相同。
编译时多态性。	运行时多态性。
增加代码的可读性。	提高代码的可重用性。
可以更改访问说明符。	访问说明符不能比原始方法限制更多(可以限制更少)。
这就是编译时间多态性。	这就是运行时多态性。
它在一个类中执行	它是使用继承关系在两个类之间执行的。
它是使用继承关系在两个类之间执行的。	它总是需要继承。
它应该有同名但不同签名的方法。	它应该有相同名称和签名的方法。
它不能有相同的返回类型。	它应该总是具有相同的返回类型。
可以使用静态方法来执行	它不能使用静态方法来执行
它使用静态绑定	它使用动态绑定。
可以更改访问修饰符和非访问修饰符。	不能更改访问修饰符和非访问修饰符。
这是代码细化技术。	这是一种代码替换技术。
定义方法时不使用关键字。	虚拟关键字用在基类中，覆盖关键字用在派生类中。
私有的、静态的、最终的方法可以被重载	私有、静态、最终方法不能重载
没有限制就是抛出条款。	仅限已检查的异常中的限制。
它也被称为编译时多态性或静态多态性或早期绑定	它也被称为运行时多态性或动态多态性或后期绑定
例

                    class OverloadingDemo{  
static int add1(int x,int y){return x+y;}  
static int add1(int x,int y,int z){return x+y+z;}  
}

| 示例:

                    class Demo2{  
void a()
{System.out.println("A");}}  
class b extends c
{void a(){System.out.println("B");}

difference between overloading and overriding

问:我们可以覆盖静态方法吗？用理由解释？

不，我们不能覆盖静态方法。因为静态方法绑定到类，而方法覆盖与对象相关联，即在运行时。

示例:覆盖 toString()

Object 类的 toString()方法用于返回对象的字符串表示形式。

因为对象是所有 java 类的超级类，所以我们可以覆盖它的字符串方法来提供我们自己的字符串表示。

如果我们不覆盖String类并打印对象引用，那么它会以"class_name @ hash code"格式打印一些哈希代码。

下面是一个覆盖对象类的toString()方法的例子。

    class Demo{
    private double a, b;     
    public Demo(double a, double b) 
    { 
    this.a = a; 
    this.b = b; 
    } 
 @Override
    public String toString() 
   { 
        return String.format(a + " + i" + b); 
    }  
}
public class MethodDemo11{ 
    public static void main(String[] args) 
    { 
    Demo obj1 = new Demo(25, 10); 
System.out.println(obj1); 

    } 
}

string-overriding

运行时多态性或动态方法分派

原文：https://www.studytonight.com/java/dynamic-method-dispatch.php

动态方法分派是一种在运行时解析对被覆盖方法的调用的机制。这就是 java 如何实现运行时多态性。当被覆盖的方法被引用调用时，java 根据它引用的对象的类型来决定执行该方法的哪个版本。简单地说，它引用的对象类型决定了将调用哪个版本的覆盖方法。

upcasting in java

Java 中的向上转换

当父类引用变量引用子类对象时，称为上推。在 Java 中，这是可以做到的，并且在多个子类扩展一个父类的情况下很有帮助。在这些情况下，我们可以创建一个父类引用，并将子类对象分配给它。

让我们举个例子来理解它，

class Game
{
 	public void type()
 	{  
 		System.out.println("Indoor & outdoor"); 
 	}
}

Class Cricket extends Game
{
 	public void type()
 	{  
 		System.out.println("outdoor game"); 
	}

 	public static void main(String[] args)
 	{
   		Game gm = new Game();
   		Cricket ck = new Cricket();
   		gm.type();
   		ck.type();
   		gm = ck;	//gm refers to Cricket object
   		gm.type();	//calls Cricket's version of type
 	}
}

室内和室外游戏室外游戏

注意最后一个输出。这是因为语句，gm = ck;。现在gm.type()将调用板球类版本的type()法。因为这里gm指的是蛐蛐对象。

问:Java 中静态绑定和动态绑定的区别？

Java 中的静态绑定发生在编译时，而动态绑定发生在运行时。静态绑定使用类型(类)信息进行绑定，而动态绑定使用类(对象)的实例在运行时解析方法的调用。重载方法使用静态绑定绑定，而覆盖方法在运行时使用动态绑定绑定。

简单来说，静态绑定意味着调用方法的对象类型是由编译器在编译时确定的。而动态绑定是指调用方法的对象类型在运行时由编译器确定。

Java `this`关键字

原文：https://www.studytonight.com/java/this-keyword-in-java.php

在 Java 中， this关键字用来指代一个类的当前对象。我们可以用它来指代班上的任何一个成员。这意味着我们可以通过使用 this关键字来访问任何实例变量和方法。

使用this关键字的主要目的是解决当我们有相同的变量名例如实例和局部变量时的混乱。

我们可以将this关键字用于以下目的。

this关键字是用来指代当前对象的。
this始终是对调用方法的对象的引用。
this可以用来调用当前的类构造器。
this可以作为参数传递给另一个方法。

让我们首先了解this关键字的最一般用法。正如我们所说的，它可以用来区分类中的局部变量和实例变量。

示例:

In this example, we have three instance variables and a constructor that have three parameters with same name as instance variables. Now, we will use this to assign values of parameters to instance variables.

class Demo
{
 Double width, height, depth;
 Demo (double w, double h, double d)
 {
  this.width = w;
  this.height = h;
  this.depth = d;
 }
 public static void main(String[] args) {
	 Demo d = new Demo(10,20,30);
	 System.out.println("width = "+d.width);
	 System.out.println("height = "+d.height);
	 System.out.println("depth = "+d.depth);
 }
}

宽度= 10.0 高度= 20.0 深度= 30.0

这里这个用来初始化当前对象的成员。例如， this.width 指的是当前对象的变量， width 只指在构造器中接收的参数，即调用构造器时传递的参数。

使用此关键字调用构造器

我们可以使用this关键字从另一个函数内部调用构造器

示例:

在本例中，我们使用 this 关键字和参数从非参数化构造器调用参数化构造器。

class Demo
{

 Demo ()
 {
	 // Calling constructor
   this("Studytonight");
 }

 Demo(String str){

	 System.out.println(str);

 }

 public static void main(String[] args) {
	 Demo d = new Demo();
 }
}

今晚学习

使用此关键字访问方法

这是这个允许访问方法的关键字的另一种用法。我们也可以使用对象引用来访问方法，但是如果我们想使用 Java 提供的隐式对象，那么就使用this关键字。

示例:

在这个例子中，我们使用这个来访问 getName()方法，它的工作原理和对象引用一样。见下面的例子

	 class Demo
{
	public void getName()
	{
	 System.out.println("Studytonight");
	}

	public void display()
	{
	 this.getName();
	}

	public static void main(String[] args) {
		Demo d = new Demo();
		d.display();
	}
}

今晚学习

从方法返回当前对象

在这种情况下，当我们想从一个方法返回当前对象时，我们可以用它来解决这个问题。

示例:

在这个例子中，我们创建了一个返回演示类对象的方法显示。为了返回对象，我们使用了this关键字，并将返回的对象存储到 Demo 类型引用变量中。我们使用返回的对象来调用 getName()方法，它工作正常。

	 class Demo
{
	public void getName()
	{
	 System.out.println("Studytonight");
	}

	public Demo display()
	{
	 // return current object
	 return this;
	}

	public static void main(String[] args) {
		Demo d = new Demo();
		Demo d1 = d.display();
		d1.getName();
	}
}

今晚学习

Java 中的垃圾收集

原文：https://www.studytonight.com/java/garbage-collection.php

Java 垃圾回收是释放未使用对象占用的未使用内存的过程。这个过程由 JVM 自动完成，因为它对于内存管理至关重要。

当 Java 程序在 JVM 上运行时，对象是在堆上创建的，堆是程序专用的一部分内存。最终，一些对象将不再需要。

当没有对某个对象的引用时，则认为不再需要该对象，并释放该对象占用的内存。这种技术叫做垃圾收集。

垃圾收集是如何工作的？

垃圾收集是 JVM 的一部分，是由 JVM 完成的自动过程。我们不需要显式标记要删除的对象。然而，我们可以请求 JVM 对一个对象进行垃圾收集，但最终它依赖于 JVM 来调用垃圾收集器。

与 C++不同，没有明确的方法来销毁对象。

在下图中，您可以理解，如果一个对象没有任何引用，它将被 JVM 转储。

garbage collection in java

可以显式强制垃圾收集吗？

不，不能显式强制垃圾收集。我们可以通过调用 System.gc() 方法来请求 JVM 进行垃圾收集。但是这并不能保证 JVM 会执行垃圾收集。

垃圾收集的优势

程序员不需要担心对象的解引用。
它是由 JVM 自动完成的。
提高内存效率并减少内存泄漏的机会。

如果一个对象是非引用的，那么它能够获得垃圾收集。我们可以通过三种方法使一个对象成为非引用对象。

1.将 null 设置为对象引用，这使得它能够进行垃圾收集。例如:

 Demo demo = new Demo();
demo = null; // ready for garbage collection

2.我们可以通过为对象设置新的引用来不引用它，这使得它能够进行垃圾收集。例如

    Demo demo = new Demo();
Demo demo2 = new Demo();
demo2 = demo // referring object

3.匿名对象没有任何引用，所以如果不使用，就可以进行垃圾收集了。

`finalize()`方法

有时，一个对象在被销毁之前需要执行一些特定的任务，例如关闭一个打开的连接或释放任何被占用的资源。为了处理这种情况使用 finalize() 方法。

finalize() 方法是垃圾收集线程在收集对象之前调用。这是任何对象执行清理实用程序的最后机会。

最终确定()方法的签名

protected void finalize()
{
 //finalize-code
}

需要记住的几个要点

它是在 java.lang.Object 类中定义的，因此所有类都可以使用它。
它在对象类中被声明为受保护。
它只被一个名为垃圾收集器的守护线程调用一次。

垃圾收集请求

我们可以请求 JVM 进行垃圾收集，但是何时启动垃圾收集器取决于 JVM。

Java gc() 方法用于显式调用垃圾收集器。但是 gc()方法不能保证 JVM 会执行垃圾收集。它只请求 JVM 进行垃圾收集。该方法存在于系统和运行时类中。

气相色谱()方法示例

让我们举个例子，了解 gc()方法的功能。

public class Test
{

    public static void main(String[] args)
    {
        Test t = new Test();
        t=null;
        System.gc();
    }
    public void finalize()
    {
        System.out.println("Garbage Collected");
    }
}

垃圾收集

Java 中的静态块

原文：https://www.studytonight.com/java/static-in-java.php

Static 是 Java 中的一个关键字，用来声明静态的东西。它可以用来创建变量、方法块或类。

静态变量或方法可以在没有类实例的情况下访问，因为它属于类。静态成员对于类的所有实例都是通用的，但是非静态成员对于类的每个实例都是不同的。让我们研究它如何与变量和方法一起工作。

静态变量

定义为类成员的静态变量可以在没有该类对象的情况下访问。静态变量是初始化一次和在类的不同对象之间共享。具有静态变量的类的所有对象将具有相同的静态变量实例。

注:静态变量用于表示一个类的公共属性。它节省内存。

示例:

假设一家公司有 100 名员工。所有员工都有其唯一的姓名和员工 id，但公司名称将与所有 100 名员工相同。这里公司名称是共同财产。因此，如果创建一个类来存储员工详细信息，那么将 company_name 字段声明为静态的

下面我们有一个带有一个静态变量的简单类，参见示例。

	 class Employee
{
    int eid;
    String name;
    static String company = "Studytonight";

    public void show()
    {
        System.out.println(eid + "-" + name + "-" + company);
    }

    public static void main( String[] args )
    {
        Employee se1 = new Employee();
        se1.eid = 104;
        se1.name = "Abhijit";
        se1.show();

        Employee se2 = new Employee();
        se2.eid = 108;
        se2.name = "ankit";
        se2.show();
    }

}

104-Abhijit-今晚学习 108-ankit-今晚学习

我们可以使用下图来理解它，下图显示了程序使用的不同内存区域，以及静态变量是如何在类的对象之间共享的。

static-block-flow

当我们有一个像这样的类变量，使用 static 关键字定义，那么这个变量只定义一次，并且被这个类的所有实例使用。因此，如果任何一个类实例修改了它，那么这个类的所有其他实例都会改变它。

静态变量与实例变量

下面是静态变量和实例变量之间的一些区别。实例变量是非静态变量，存储在堆中，只能通过对象访问。

示例:静态变量与实例变量

我们举个例子，了解一下区别。

	 public class Test
{
    static int x = 100;
    int y = 100;
    public void increment()
    {
        x++; y++;
    }
    public static void main( String[] args )
    {
        Test t1 = new Test();
        Test t2 = new Test();
        t1.increment();
        t2.increment();
        System.out.println(t2.y);
        System.out.println(Test.x);  //accessed without any instance of class.
    }
}

101 102

查看两个变量的值的差异。静态变量 x 显示了不同对象上 increment() 方法对其所做的更改。而实例变量 y 仅显示了该特定实例上 increment() 方法对其所做的更改。

Java 中的静态方法

方法也可以声明为静态的。静态方法不需要其类的实例来访问。main()方法是静态方法最常见的例子。main()方法被声明为静态的，因为它是在创建类的任何对象之前被调用的。

让我们举个例子

	 class Test
{

  public static void square(int x)
  {  
    System.out.println(x*x);
  }

  public static void main (String[] arg)
  {
    square(8)   //static method square () is called without any instance of class.
  }
}

Sixty-four

Java 中的静态块

静态块用于初始化静态数据成员。静态块甚至在 main()方法之前就执行了。

当类加载到内存中时，它会执行。一个类可以有多个静态块，这些静态块将按照它们被编程的相同顺序执行。

例子

让我们看一个例子，其中我们声明了一个静态块来初始化静态变量。

	 class ST_Employee
{
    int eid;
    String name;
    static String company_name;

    static {
      company_name ="StudyTonight";   //static block invoked before main() method
    }

    public void show()
    {
        System.out.println(eid+" "+name+" "+company_name);
    }
    public static void main( String[] args )
    {
      ST_Employee se1 = new ST_Employee();
      se1.eid = 104;
      se1.name = "Abhijit";
      se1.show();
    }

}

104 Abhijit 研究今晚

不能从静态上下文引用非静态(实例)变量。

当我们试图从像 main 方法这样的静态上下文中访问非静态变量时，java 编译器会抛出一条错误消息非静态变量不能从静态上下文中引用。这是因为非静态变量与类(对象)的实例相关，并且它们是在使用新运算符创建类的实例时创建的。因此，如果我们试图在没有任何实例的情况下访问非静态变量，编译器会抱怨，因为这些变量尚未创建，并且在创建实例并与之关联之前，它们不存在。

例子

让我们举一个从静态上下文访问非静态变量的例子。

	 class Test
{
  int x;
  public static void main(String[] args)
  {
    x = 10;
  }
}

编译器错误:不能从静态上下文引用非静态变量计数

为什么 main()方法在 java 中是静态的？

因为静态方法可以在没有类的任何实例的情况下调用，并且在创建类的任何实例之前调用main()。

Java 最终修改

原文：https://www.studytonight.com/java/final-in-java.php

Final 修饰符用于将字段声明为 final。它可以与变量、方法或类一起使用。

如果我们将一个变量声明为最终的，那么它会阻止的内容被修改。变量的作用就像一个常数。最终字段在声明时必须初始化。

如果我们宣布一个方法为最终，那么它将防止被覆盖。

如果我们宣布一个类为最终，那么它将阻止被继承。我们不能继承 Java 中的最终类。

示例:最终变量

在这个例子中，我们声明了一个最终变量，并在稍后尝试修改它的值。但是最终变量不能被重新分配，所以我们得到编译时错误。

	 public class Test {

	final int a = 10;
	public static void main(String[] args) {
		Test test = new Test();
		test.a = 15; // compile error
		System.out.println("a = "+test.a);
	}
}

错误:无法分配最终的现场测试

最终方法

使用 final 关键字声明的方法称为 final 方法。当我们想要防止方法被覆盖时，它很有用。

示例:最终方法

在这个例子中，我们创建了一个 final 方法 learn()，并试图覆盖它，但是由于 final 关键字，编译器报告了一个错误。

	 class StudyTonight
{
  final void learn()
  {
    System.out.println("learning something new");
  }
}

// concept of Inheritance
class Student extends StudyTonight
{
  void learn()
  {
    System.out.println("learning something interesting");
  }

  public static void main(String args[]) {
    Student object= new Student();
    object.learn();
  }
}

无法覆盖今晚学习的最终方法

这将产生编译时错误，因为该方法被声明为 final，因此不能被覆盖。不要被扩展的关键字所迷惑，我们将在接下来的继承教程中了解到这一点。

让我们再举一个例子，我们也有一个最终变量和方法。

	 class Cloth
{
  final int MAX_PRICE = 999;    //final variable
  final int MIN_PRICE = 699;
  final void display()      //final method
  {
    System.out.println("Maxprice is" + MAX_PRICE );
    System.out.println("Minprice is" + MIN_PRICE);
  }
}

在上面的类中，最大价格和最小价格变量是最终的，因此一旦声明，这些值就不能更改。同样，方法 display()是最终的，这意味着即使某个其他类继承了 Cloth 类，该方法的定义也不能更改。

期末班

一个类也可以被声明为最终类。声明为 final 的类不能被继承。 java.lang 包中的 String 类是最终类的一个例子。

我们可以创建自己的最终类，这样其他类就不能继承它。

示例:期末课堂

在这个例子中，我们创建了最后一个类 ABC，并试图从演示类扩展它。但是由于限制，编译器报告了一个错误。见下面的例子。

	 final class ABC{

	int a = 10;
	void show() {
		System.out.println("a = "+a);
	}

}

public class Demo extends ABC{

	public static void main(String[] args) {

		Demo demo = new Demo();

	}
}

演示类型不能将最终的作业成本分类

Java 空白最终变量

申报时未初始化的最终变量称为空白最终变量。Java 允许在没有初始化的情况下声明一个最终变量，但是它应该只由构造器初始化。这意味着我们只能在构造器中为空的最终变量设置值。

示例:

在这个例子中，我们创建了一个空白的最终变量，并在一个可接受的构造器中初始化它。

	 public class Demo{
	// blank final variable
	final int a;

	Demo(){
		// initialized blank final
		a = 10;
	}

public static void main(String[] args) {

	Demo demo = new Demo();
	System.out.println("a = "+demo.a);

	}
}

a=10

静态空白最终变量

使用 static 关键字声明的空白最终变量称为静态空白最终变量。它只能在静态块中初始化。

静态空白最终变量用于为类创建静态常量。

例子

在这个例子中，我们正在创建静态空白最终变量，该变量在静态块中初始化。我们使用类名来访问那个变量，因为要访问静态变量，我们不需要创建那个类的对象。

	 public class Demo{
	// static blank final variable
	static final int a;

	static{
		// initialized static blank final
		a = 10;
	}

public static void main(String[] args) {

	System.out.println("a = "+Demo.a);

	}
}

a=10

Java `instanceof`运算符和向下转换

原文：https://www.studytonight.com/java/instanceof-operator.php

在 Java 中，的instance 是一个运算符，用于检查对象引用。它检查对象的引用是否属于提供的类型。它返回真或假，如果对象引用是指定的类型，则返回真或假。

我们可以使用 instanceof 运算符来检查对象引用是属于父类、子类还是接口。

它也被称为类型比较运算符，因为它将实例与类型进行比较。

实例的应用

除了测试对象类型，我们还可以将其用于对象向下转换。然而，我们可以使用类型转换来执行向下转换，但是它可能会在运行时引发 ClassCastException。

为了避免异常，我们使用 instanceof 运算符。这样做有助于执行铸造。

当我们进行类型转换时，检查类型转换是否有效总是一个好主意。instanceof 在这里帮助我们。我们总是可以首先使用 instanceof 检查有效性，然后进行类型转换。

下面给出了声明 instanceof 运算符的语法。

语法

(object) instanceof (type)

对象:是对象引用变量。

类型:可以是类，也可以是接口。

举个例子

我们举个例子来了解一下instanceof运算符的用法。这里我们测试的引用类型是 Test 类的类型，它返回 true。

public class Test
{
    public static void main(String[] args)
    {
        Test t = new Test();
        System.out.println(t instanceof Test);
    }
}

真实的

示例:接口引用类型

让我们使用 instanceof 运算符创建一个接口并测试引用类型。如果引用对象引用了正确的接口类型，则该运算符返回。见下面的例子

  interface Callable{
  void call();
}

class Demo implements Callable {
  public void call() {
    System.out.println("Calling...");
  }
  public static void main(String[] args) {

    Callable d = new Demo();
    // Refer to a class
    System.out.println((d instanceof Demo));
    // Refer to an interface
    System.out.println((d instanceof Callable));

  }
}

真实真实

如果引用变量保持为空，则实例返回假。让我们再看一个例子。

  class Demo {

  public static void main(String[] args) {

    Demo d = null;
    System.out.println(d instanceof Demo);

  }
}

错误的

示例:继承

让我们再举一个例子来理解运算符的实例，其中我们创建了 5 个类，其中一些扩展到了另一个类。现在通过创建对象，我们测试引用对象属于哪个类。

  class Parent{}

class Child1 extends Parent{}

class Child2 extends Parent{}

class Demo
{
  public static void main(String[] args)
  {
      Parent p =new Parent();
      Child1 c1 = new Child1();
      Child2 c2 = new Child2();

      System.out.println(c1 instanceof Parent);         //true
      System.out.println(c2 instanceof Parent);         //true
      System.out.println(p instanceof Child1);          //false
      System.out.println(p instanceof Child2);          //false

      p = c1;
      System.out.println(p instanceof Child1);          //true
      System.out.println(p instanceof Child2);          //false

      p = c2;
      System.out.println(p instanceof Child1);          //false
      System.out.println(p instanceof Child2);          //true

   }

}

真真假假真真假假真真假假

Java 中的向下转换

向下转换是使用运算符的实例的优势之一。向下转换是在子类中持有父类的对象引用对象的过程。与上推相反，子代的对象分配给父代类引用对象。

然而，我们可以使用类型转换来执行向下转换，但是它会在运行时抛出类转换异常。所以为了避免这个，我们使用 instanceof 运算符来执行向下转换。

你可以通过下图了解整个过程。

downcasting in java

使用`instanceof`运算符向下转换的示例

**class Parent{ }**

public class **Child** extends **Parent**
{
    public void check()
    {
        System.out.println("Sucessfull Casting");
    }

    public static void show(Parent p)
    {
       if(p instanceof Child)
       {
           Child b1=(Child)p;
           b1.check();
       }
    }

    public static void main(String[] args)
    {

      Parent p=new Child();

      Child.show(p);

      }
}

成功完成铸造

Java 包

原文：https://www.studytonight.com/java/package-in-java.php

包是相关类的集合。Java 使用包将任何 Java 项目中相关的类、接口和子包分组。

我们可以假设 package 是一个用来存储类似文件的文件夹或目录。

在 Java 中，包用于避免名称冲突，控制类、接口和枚举等的访问。使用 package 可以更容易地找到相关的类，并且它还为包含数百个类和其他文件的项目提供了一个良好的结构。

让我们通过一个简单的例子来理解它，假设我们有一些数学相关的类和接口，然后为了将它们收集到一个简单的地方，我们必须创建一个包。

Java 包的类型

包可以是内置的和用户定义的，Java 以存储相关类和子包的 API 的形式提供了一组丰富的内置包。

内置包:数学、util、lang、i/o 等都是内置包的例子。
用户定义包:由用户创建的用于对其项目的类和接口进行分类的 Java 包被称为用户定义包。

Packages in java

如何创建包

用 java 创建一个包非常容易，只需在 java 源文件中包含一个 package 命令，后跟包的名称作为第一条语句。

package mypack;
public class employee 
{
    String empId;
    String name; 
}

上面的语句将在项目目录中创建一个名为 mypack 的包。

Java 使用文件系统目录来存储包。例如，您定义为属于 mypack 包的任何类的.java文件必须存储在名为 mypack 的目录中。

关于包装的其他要点:

包语句必须是程序中的第一个语句，甚至在导入语句之前。
包始终被定义为与包名同名的单独文件夹。
将所有类存储在那个包文件夹中。
我们希望在包之外访问的包的所有类都必须声明为公共的。
包中的所有类必须以 package 语句作为其第一行。
该包的所有类都必须在使用前编译。

Java 包示例

现在让我们通过一个例子来理解包的创建，这里我们创建了一个 leanjava 包，它存储了 FirstProgram 类文件。

//save as FirstProgram.java  
package learnjava;  
public class FirstProgram{  
    public static void main(String args[]) {  
        System.out.println("Welcome to package example");  
    }  
}

如何在包内编译 Java 程序？

这就像编译一个普通的 java 程序。如果您没有使用任何 IDE，您需要按照下面给出的步骤成功编译您的包:

javac -d . FirstProgram.java

-d开关指定生成的类文件的存放目的地。您可以使用任何目录名，如 d:/abc (如果是 windows)等。如果要将包保持在同一个目录内，可以使用.(点)。

如何运行 Java 包程序？

要运行我们使用上述命令编译的编译类，我们还需要指定包名。使用下面的命令运行类文件。

java learnjava.FirstProgram

欢迎使用打包示例

运行程序后，我们会在控制台上看到“欢迎使用包示例”的消息。你可以把它和程序中使用的 print 语句进行比较。

如何导入 Java 包

要将 java 包导入到类中，我们需要使用 java import 关键字，该关键字用于将包及其类访问到 java 程序中。

使用 import 将内置和用户定义的包访问到您的 java 源文件中，以便您的类可以通过直接使用其名称来引用另一个包中的类。

有 3 种不同的方法可以引用不同包中的任何类:

不导入包
导入指定类别的包
导入包含所有类的包

让我们通过例子来理解每一个。

访问没有导入关键字的包

如果使用完全限定名将任何类导入到程序中，那么在程序中只能访问该包的特定类，同一包中的其他类将不可访问。对于这种方法，不需要使用import语句。但是每次访问类或接口时，都必须使用完全限定名。这通常在两个包具有相同名称的类时使用。例如:java.util和java.sql包包含Date class。

例子

在这个例子中，我们在包包中创建了一个类 A，在另一个类 B 中，我们在创建类 A 的对象时访问它

//save by A.java  
package pack;  
public class A {  
    public void msg() {
        System.out.println("Hello");
    }  
}  

//save by B.java  
package mypack;  
class B {  
    public static void main(String args[]) {  
        pack.A obj = new pack.A();  //using fully qualified name  
        obj.msg();  
    }  
}

你好

导入特定类别

包可以有许多类，但有时我们只想访问程序中的特定类。在这种情况下，Java 允许我们指定类名和包名。如果我们使用 import packagename.classname语句，那么只有包中名为 classname 的类可以使用。

示例:

在这个例子中，我们创建了一个存储在包包中的演示类，在另一个测试类中，我们通过导入带有类名的包名来访问演示类。

//save by Demo.java  
package pack;  
public class Demo {  
    public void msg() {
        System.out.println("Hello");
    }  
}  

//save by Test.java  
package mypack;  
import pack.Demo;  
class Test {  
    public static void main(String args[]) {  
        Demo obj = new Demo();  
        obj.msg();  
    }  
}

你好

导入包的所有类

如果我们使用 packagename。*声明，则该包的所有类和接口都可以访问，但是子包中的类和接口将不可用。

import关键字用于使当前包可以访问另一个包的类。

示例:

在这个例子中，我们在 learnjava 包中创建了一个类 First，通过使用 import 关键字在另一个类 Second 中访问它。

//save by First.java  
package learnjava;  
public class First{  
    public void msg() {
        System.out.println("Hello");
    }  
}  

//save by Second.java  
package Java;  
import learnjava.*;    
class Second {  
    public static void main(String args[]) {  
        First obj = new First();  
        obj.msg();  
    }  
}

你好

Java 子包和静态导入

原文：https://www.studytonight.com/java/subpackage-and-static-import.php

在本教程中，我们将学习 Java 中的子包，以及静态导入的概念及其与普通import关键字的不同之处。

Java 中的子包

包内的包称为子包。应该创建它来进一步对包进行分类。

举个例子，Sun 微系统公司已经定义了一个名为 java 的包，它包含了许多类，如系统、字符串、读取器、写入器、套接字等。这些类代表一个特定的组，例如读取器和写入器类用于输入/输出操作，套接字和服务器套接字类用于网络等等。因此，孙将 java 包细分为 lang、net、io 等子包。并将输入/输出相关的类放在 io 包中，将 Server 和 ServerSocket 类放在 net 包中等等。

注意:定义包的标准是域.公司.包如 LearnJava.full.io

示例:

在这个例子中，我们在 Simple.java 文件中创建了一个包和一个子包 corejava 。

package LearnJava.corejava;
class Simple{
  public static void main(String args[]){
   System.out.println("Hello from subpackage");
  }
}

为了编译这个类，我们可以使用与 package 相同的命令。命令如下。

javac -d . Simple.java

要运行存储在创建的子包中的类，我们可以使用下面的命令。

java LearnJava.corejava.Simple

成功编译并执行后，它会将以下输出打印到控制台。

来自子包的你好

Java 中的静态导入

静态导入是扩展导入关键字功能的一个特性。它用于导入类的静态成员。我们都知道静态成员是在类外部与其类名相关联地被引用。使用静态导入，可以直接引用静态成员，而不需要其类名。静态导入语句有两种一般形式。

我们可以导入任何类的单个或多个静态成员。要导入单个静态成员，我们可以使用如下语句。

import static java.lang.Math.sqrt;   //importing static method sqrt of Math class

第二种形式的静态 import 语句，导入一个类的所有静态成员。

import static java.lang.Math.*;   //importing all static member of Math class

不使用静态导入的示例

这是使用类的静态成员的替代方法。在这种情况下，我们不需要使用 import 语句，而是使用类的直接限定名。

public class Test
{
    public static void main(String[] args)
    {
        System.out.println(Math.sqrt(144));
    }
}

Twelve

使用静态导入的示例

在这个例子中，我们使用 import 语句来导入类的静态成员。这里，我们使用*来导入所有静态成员。

import static java.lang.Math.*;
public class Test
{
    public static void main(String[] args)
    {
        System.out.println(sqrt(144));
    }
}

Twelve

Java 抽象类和方法

原文：https://www.studytonight.com/java/abstract-class.php

在本教程中，我们将学习 Java 中的抽象类和方法，以及如何使用抽象类实现抽象。我们还将有一些代码示例。

抽象类

使用抽象关键字声明的类称为抽象类。抽象类可以有也可以没有抽象方法。我们不能创建抽象类的对象。

它用于实现抽象，但它并不提供 100%的抽象，因为它可以有具体的方法。

抽象类必须用抽象关键字声明。
它可以有抽象和非抽象的方法。
它无法实例化。
它用于抽象。

语法:

abstract class class_name { }

抽象方法

在抽象类中没有任何主体的方法被称为抽象方法。方法体将由其子类定义。抽象方法永远不可能是最终的和静态的。任何扩展抽象类的类都必须实现所有的抽象方法。

语法:

abstract return_type function_name (); //No definition

抽象类和方法的注意事项

这里有一些有用的要点要记住:

抽象类不是接口。它们是不同的，我们将在研究接口时研究这一点。
抽象类可以有也可以没有抽象方法。但是如果任何类甚至只有一个抽象方法，那么它必须被声明为抽象的。
抽象类可以有构造器、成员变量和普通方法。
抽象类永远不会被实例化。
当用抽象方法扩展抽象类时，必须在子类中定义抽象方法，或者使子类抽象。

抽象类示例

让我们以抽象类为例，试着理解它们如何在 Java 中使用。

在这个例子中，我们创建了一个抽象类 A，它包含一个方法callme()，使用类 B，我们扩展了这个抽象类。

abstract class A
{
  abstract void callme();
}
class B extends A
{
  void callme()
  {
    System.out.println("Calling...");
  }
  public static void main(String[] args)
  {  
    B b = new B();
    b.callme();
  }
}

打电话...

用非抽象方法抽象类

抽象类也可以有非抽象方法和抽象方法。但是请记住，在扩展类时，要为抽象方法提供定义。

abstract class A
{
  abstract void callme();
  public void show()
  {
    System.out.println("this is non-abstract method");
  }
}

class B extends A
{
  void callme()
  {
    System.out.println("Calling...");
  }
  public static void main(String[] args)
  {
    B b = new B();
    b.callme();
    b.show();
  }

打电话...这是非抽象的方法

使用抽象类的抽象

抽象是 OOPS 的一个重要特性。这意味着隐藏复杂性，只向用户展示功能。抽象类用于提供抽象。虽然它没有提供 100%的抽象，因为它也可以有具体的方法。让我们看看抽象类是如何被用来提供抽象的。

abstract class Vehicle
{
   public abstract void engine();
}
public class Car extends Vehicle {

    public void engine()
    {
        System.out.println("Car engine");
        // car engine implementation
    }

    public static void main(String[] args)
    {
        Vehicle v = new Car();
        v.engine();
    }
}

汽车发动机

这里通过将汽车类型的实例转换为车辆引用，我们隐藏了汽车类型在车辆下的复杂性。现在，Vehicle 引用可以用来提供实现，但它会隐藏实际的实现过程。

何时使用抽象方法&抽象类？

抽象方法通常被声明为两个或多个子类通过不同的实现以不同的方式做类似的事情。这些子类扩展了同一个抽象类，并为抽象方法提供了不同的实现。

抽象类用于在面向对象编程类层次结构的顶部定义行为的一般类型，并使用它的子类来提供抽象类的实现细节。

Java 接口

原文：https://www.studytonight.com/java/java-interface.php

接口是 Java 中用来实现抽象的概念。这是我们实现完全抽象的唯一方法。接口在语法上类似于类，但是您不能创建接口的实例，并且它们的方法是在没有任何主体的情况下声明的。当你创建一个接口时，它定义了一个类可以做什么，而没有说明这个类将如何做。

它只能有抽象方法和静态字段。但是从 Java 8 开始，接口可以有默认和静态方法，从 Java 9 开始，也可以有私有方法。

当一个接口继承另一个接口时扩展使用关键字，而类使用实现关键字继承一个接口。

界面的优势

它支持多重继承
它有助于实现抽象
它可以用来实现松耦合。

语法:

interface interface_name {  
// fields
// abstract/private/default methods
}

界面要点

接口内部的方法不能是静态的、最终的、本机的或严格的。
接口内部声明的所有变量都是隐式公共的、静态的和最终的。
在接口内部声明的所有方法都是隐式公共和抽象的，即使您没有使用 public 或 abstract 关键字。
接口可以扩展一个或多个其他接口。
接口无法实现类。
接口可以嵌套在另一个接口中。

是时候举个例子了！

让我们举一个简单的代码示例，了解什么是接口:

interface Moveable
{
 	int AVERAGE-SPEED = 40;
 	void move();
}

Interface in Java

注意:编译器自动将 Interface 的方法转换为公共的、抽象的，数据成员默认为公共的、静态的、最终的。

接口实现示例

在这个例子中，我们创建了一个接口，并使用一个类来实现。让我们看看如何实现接口。

interface Moveable
{
 	int AVG-SPEED = 40;
 	void move();
}

class Vehicle implements Moveable
{
 	public void move()
 	{
  		System .out. print in ("Average speed is"+AVG-SPEED");
 	}
 	public static void main (String[] arg)
 	{
  		Vehicle vc = new Vehicle();
  		vc.move();
 	}
}

平均速度是 40。

接口支持多重继承

虽然 Java 中的类不支持多重继承，但是一个类可以实现多个接口。

在这个例子中，两个接口由一个显示多重继承实现的类实现。

interface Moveable
{
 	boolean isMoveable();
}

interface Rollable
{
 	boolean isRollable
}

class Tyre implements Moveable, Rollable
{
 	int width;

 	boolean isMoveable()
 	{
  		return true;
 	}

 	boolean isRollable()
 	{
  		return true;
 	}

 	public static void main(String args[])
 	{
  		Tyre tr = new Tyre();
  		System.out.println(tr.isMoveable());
  		System.out.println(tr.isRollable());
 	}
}

真实真实

接口扩展了其他接口

接口可以通过使用 extends 关键字继承到另一个接口。但在这种情况下，接口只是继承，并不提供实现。实现只能由类提供。

interface NewsPaper
{
 	news();
}

interface Magazine extends NewsPaper
{
 	colorful();
}

接口和抽象类的区别？

接口和抽象类都用于实现抽象，但也有一些不同。下面列出了一些差异。

抽象类	连接
抽象类是一个包含一个或多个抽象方法的类，必须由它的子类来实现。	接口是一个包含方法声明但没有实现的 Java 对象。实现接口的类必须为所有方法提供方法定义。
抽象类是一个类前缀，后跟一个抽象关键字和类定义。	接口是一个纯抽象类，以 Interface 关键字开头。
抽象类也可以包含具体的方法。	而接口包含所有抽象方法和最终变量声明。
抽象类在应该实现一些通用方法并且应该由子类实现专门化行为的情况下是有用的。	在应该实现所有属性的情况下，接口很有用。

接口中的默认方法–Java 8

在 Java 8 版本中，接口增加了一个新特性，这是默认方法。默认方法是可以有其主体的方法。这意味着默认方法不是抽象方法，它用于为接口设置一些默认功能。

Java 提供默认关键字来创建默认方法。让我们看一个例子:

interface Abc{  
    // Default method   
    default void msg(){  
        System.out.println("This is default method");  
    }  
    // Abstract method  
    void greet(String msg);  
}  
public class Demo implements Abc{  
    public void greet(String msg){        // implementing abstract method   
        System.out.println(msg);  
    }  
    public static void main(String[] args) {  
    	Demo d = new Demo();  
        d.msg();   // calling default method  
        d.greet("Say Hi");  // calling abstract method  

    }  
}

这是默认方法说嗨

接口中的静态方法——Java 8

从 Java 8 开始，Java 允许将静态方法声明到接口中。静态方法的目的是向接口中添加实用方法。在下面的例子中，我们创建了一个包含静态方法和抽象方法的接口 Abc。见下面的例子。

interface Abc{  
    // static method   
    static void msg(){  
        System.out.println("This is static method");  
    }  
    // Abstract method  
    void greet(String msg);

}  
public class Demo implements Abc{  
    public void greet(String msg){        // implementing abstract method   
        System.out.println(msg);  
    }  
    public static void main(String[] args) {  
    	Demo d = new Demo();  
        Abc.msg();   // calling static method  
        d.greet("Say Hi");  // calling abstract method  

    }  
}

这是静态方法说嗨

私有方法–Java 9

在 Java 9 版本中，增加了一个新特性，允许我们在接口内部声明私有方法。私有方法的目的只是在接口的非抽象方法之间共享一些任务。

在这个例子中，我们创建了一个有默认方法和私有方法的接口 Abc。因为接口外部无法访问私有方法。所以，我们从默认方法调用它。见下面的例子。

interface Abc{  
    // Default method   
    default void msg(){  
         greet();
    }  
    // Private method  
    private void greet() {
    	System.out.println("This is private method"); 
    }

}  
public class Demo implements Abc{    
    public static void main(String[] args) {  
    	Demo d = new Demo();  
        d.msg();   // calling default method  

    }  
}

这是私人方法

Java 嵌套类

原文：https://www.studytonight.com/java/nested-classes.php

在另一个类中定义的类称为嵌套类。嵌套类的范围由其封闭类的范围限定。

语法:

class Outer{
//class Outer members

class Inner{
//class Inner members
}

} //closing of class Outer

Nested classes in Java

嵌套类的优点

这是一种对只在一个地方使用的类进行逻辑分组的方式。
它增加了封装。
它可以产生可读性和可维护性更高的代码。

如果您想创建一个只由封闭类使用的类，那么没有必要为此创建一个单独的文件。相反，您可以将其添加为“内部类”

静态嵌套类

如果嵌套类，即在另一个类中定义的类，应用了静态修饰符，那么它被称为静态嵌套类。既然如此，静态嵌套类只能访问其外部类的静态成员，即它不能直接引用其封闭类的非静态成员。由于这个限制，静态嵌套类很少被使用。

非静态嵌套类

非静态嵌套类是嵌套类中最重要的类型。也叫内班。它可以访问外部类的所有变量和方法，包括它的私有数据成员和方法，并且可以直接引用它们。但反之则不然，即 Outer 类不能直接访问 Inner 类的成员。内部类可以声明为私有、公共、受保护或具有默认访问权限，而外部类只能具有公共或默认访问权限。

关于内部类，需要注意的一点是，它只能在外部类的范围内创建。如果外部类之外的任何代码试图直接实例化内部类，Java 编译器会生成一个错误。

Non-static Nested classes in Java

在方法外部创建的非静态嵌套类称为成员内部类。

在方法内部创建的非静态嵌套类称为局部内部类。如果要调用本地内部类的方法，必须在方法中实例化这个类。我们不能在本地内部类中使用私有、公共或受保护的访问修饰符。只允许使用抽象修饰符和最终修饰符。

内部类示例(成员类)

class Outer
{
  public void display()
  {
    Inner in=new Inner();
    in.show();
  }

  class Inner
  {
    public void show()
    {
      System.out.println("Inside inner");
    }
  }
}

class Test
{
  public static void main(String[] args)
  {
    Outer ot = new Outer();
    ot.display();
  }
}

内部内部

方法内部的内部类示例(本地内部类)

class Outer
{
  int count;
  public void display()
  {
    for(int i=0;i<5;i++)
    {
      //Inner class defined inside for loop
      class inner
      {
        public void show()
        {
          System.out.println("Inside inner "+(count++));
        }
      }
      Inner in=new Inner();
      in.show();
    }
  }
}

class Test
{
  public static void main(String[] args)
  {
    Outer ot = new Outer();
    ot.display();
  }
}

内部 0 内部 1 内部 2 内部 3 内部 4 内部

在外部类之外实例化的内部类示例

class Outer
{
  int count;
  public void display()
  {
    Inner in = new Inner();
    in.show();
  }

  class Inner
  {
    public void show()
    {
      System.out.println("Inside inner "+(++count));
    }
  }
}

class Test
{
  public static void main(String[] args)
  {
    Outer ot = new Outer();
    Outer.Inner in = ot.new Inner();
    in.show();
  }
}

内部 1

匿名类

一个没有名字的类叫做发音类。

interface Animal
{
  void type();
}

public class ATest {
  public static void main(String args[])
  {
    //Annonymous class created
    Animal an = new Animal() {
      public void type()
      {
        System.out.println("Annonymous animal");
      }
    };
    an.type();
  }
}

匿名动物

这里创建了一个实现动物交互的类，它的名字将由编译器决定。这个发音类将提供类型()方法的实现。

Java 具体类、抽象类、最终类、接口之间的区别

原文：https://www.studytonight.com/java/different-classes-and-interface.php

类、接口、抽象类、最终类是 Java 语言的重要组成部分。在讨论它们之间的差异之前，让我们先来简单介绍一下所有这些。这样我们就能知道这些术语指的是什么。

混凝土类

一个实现了所有方法的类，如果没有主体就没有方法，称为具体类。

换句话说，一个只包含非抽象方法的类将被称为具体类。

抽象类

使用抽象关键字声明为抽象的类称为抽象类。抽象包含抽象方法并用于实现抽象，这是 OOP 编程的一个重要特征。无法实例化抽象类。

更多细节，可以参考我们的详细教程。点击此处

连接

接口是一个类的蓝图，用于在 Java 中实现抽象。接口包含抽象方法和默认的私有方法。我们无法创建接口的对象。接口可以用来实现 Java 中的多重继承。

更多细节，可以参考我们的详细教程。点击此处

期末班

Final 类是一个类，它是使用 final 关键字声明的。Final 类用于防止继承，因为我们不能继承 final 类。我们可以创建它的对象，也可以创建静态和非静态方法。

更多细节，可以参考我们的详细教程。点击此处

在这个表中，我们根据一些属性来区分类、抽象类、接口等，如:访问修饰符、静态、非静态等。

| | 混凝土类 | 抽象类 | 期末班 | 连接 |
| 施工方 | 是 | 是 | 是 | 不 |
| 非静态(方法) | 是 | 是 | 是 | 是 |
| 非静态(可变) | 是 | 是 | 是 | 不 |
| 访问修饰符(默认) | 默认 | 默认 | 默认 | 公众 |
| 对象声明 | 是 | 是 | 是 | 是 |
| 实例化 | 是 | 不 | 是 | 不 |
| 关系 | 两者都有 | 信息系统 | 聚合 | 信息系统 |
| 最终声明 | 可能是，也可能不是 | 可能是，也可能不是 | 可能是，也可能不是 | 仅最终 |
| 抽象声明 | 不 | 可能是，也可能不是 | 不 | 完全抽象的 |
| 继承关键字 | 延伸 | 延伸 | 没有继承权 | 工具 |
| 过载 | 是 | 是 | 是 | 是 |
| 覆盖 | 不 | 不 | 不 | 不 |
| 超级关键字 | 是 | 是 | 是 | 不 |
| this关键字 | 是 | 是 | 是 | 是 |
| 字节码 | 。班级 | 。班级 | 。班级 | 。班级 |
| 匿名类 | 不 | 是 | 不 | 是 |
| 用于申报的关键字 | 没有关键字 | 抽象关键字 | final关键字 | 接口关键字 |
| 继承 | 单一的 | 单一的 | 没有继承权 | 多重 |
| 静态变量 | 是 | 是 | 是 | 是 |

Java 字符串处理

Java 字符串处理简介

原文：https://www.studytonight.com/java/string-handling-in-java.php

字符串是表示字符序列的对象。在 Java 中，字符串由位于java.lang包中的String类表示

它可能是 java 库中最常用的类。在 java 中，我们创建的每个字符串实际上都是一个类型为 String 的对象。关于字符串对象需要注意的一点是，字符串对象是不可变的，这意味着一旦创建了字符串对象，它就不能被更改。

Java String 类实现了 Serializable、Comparable 和 CharSequence 接口，我们用下图表示了这个接口。

string-handling-feature

在 Java 中，字符序列接口用于表示一个字符序列。CharSequence 接口由 String、StringBuffer 和 StringBuilder 类实现。这三个类可用于在 java 中创建字符串。

char-string-handling-feature

什么是不可变对象？

状态在创建后不能改变的对象称为不可变对象。String、Integer、Byte、Short、Float、Double 和所有其他包装类对象都是不可变的。

创建字符串对象

字符串可以通过多种方式创建，以下是创建字符串对象的几种方法。

1)使用字符串文字

字符串文字是用双引号" "括起来的简单字符串。字符串文字被视为字符串对象。

public class Demo{    
    public static void main(String[] args) {  
    	String s1 = "Hello Java";
    	System.out.println(s1);
    }  
}

你好 Java

2)使用新关键字

我们可以通过使用 new 操作符为对象分配内存来创建一个新的字符串对象。

public class Demo{    
    public static void main(String[] args) {  
    	String s1 = new String("Hello Java");
    	System.out.println(s1);
    }  
}

你好 Java

每次我们创建字符串文字时，JVM 都会首先检查字符串池。如果字符串文字已经存在于池中，则返回对池实例的引用。如果池中不存在字符串，则会创建一个新的字符串对象，并将其放入池中。字符串对象存储在堆内存中称为字符串常量池的特殊内存区域。

字符串对象及其存储方式

当我们使用字符串文字创建一个新的字符串对象时，该字符串文字被添加到字符串池中，如果它还不存在的话。

String str= "Hello";

Creating String in heap

并且，当我们创建另一个具有相同字符串的对象时，将返回字符串池中已经存在的字符串文字的引用。

String str2 = str;

Creating String in heap

但是如果我们改变新的字符串，它的引用就会被修改。

str2=str2.concat("world");

Creating String in heap

连接字符串

有两种方法可以连接两个或多个字符串。

使用 concat() 方法
使用+运算符

1)使用 concat()方法

Concat()方法用于将两个或多个字符串添加到单个字符串对象中。它是String类方法，并返回一个字符串对象。

public class Demo{    

    public static void main(String[] args) {  
    	String s = "Hello";
    	String str = "Java";
    	String str1 = s.concat(str);
    	System.out.println(str1);
    }  
}

你好 java

2)使用+运算符

Java 使用"+"运算符将两个字符串对象连接成一个。它还可以将数值与字符串对象连接起来。见下面的例子。

public class Demo{    
    public static void main(String[] args) {  
    	String s = "Hello";
    	String str = "Java";
    	String str1 = s+str;
    	String str2 = "Java"+11;
    	System.out.println(str1);
    	System.out.println(str2);
    }  
}

hellojava java 11

字符串比较

为了比较字符串对象，Java 同时提供了方法和运算符。所以我们可以用以下三种方法比较字符串。

使用equals()方法
使用==运算符
通过CompareTo()方法

使用 equals()方法

equals()方法比较两个字符串是否相等。它的一般语法是，

boolean equals (Object str)

例子

它比较字符串的内容。如果字符串匹配，它将返回 true ，否则返回 false 。

public class Demo{    
    public static void main(String[] args) {  
    	String s = "Hell";
    	String s1 = "Hello";
    	String s2 = "Hello";
    	boolean b = s1.equals(s2);    //true
    	System.out.println(b);
    	b =	s.equals(s1) ;   //false
    	System.out.println(b);
    }  
}

真假

使用==运算符

double equal (==)运算符比较两个对象引用，检查它们是否引用同一个实例。这也，将在成功匹配上返回真否则返回假。

public class Demo{    
    public static void main(String[] args) {  
    	String s1 = "Java";
    	String s2 = "Java";
    	String s3 = new String ("Java");
    	boolean b = (s1 == s2);     //true
    	System.out.println(b);
    	b =	(s1 == s3);      //false
    	System.out.println(b);  
    }  
}

真假

说明

我们正在使用新的操作符创建一个新的对象，因此它是在堆的非池内存区域中创建的。s1 指向字符串池中的字符串，而 s3 指向堆中的字符串，因此，当我们比较 s1 和 s3 时，答案是假的。

下图会解释得更清楚。

Data Warehouse Backup

通过`compareTo()`方法

字符串compareTo()方法比较值并返回一个整数值，该整数值告诉比较的字符串是否小于、等于或大于另一个字符串。它根据自然顺序(即字母顺序)比较字符串。它的一般语法是。

语法:

int compareTo(String str)

示例:

public class HelloWorld{    
    public static void main(String[] args) {  
    	String s1 = "Abhi";
    	String s2 = "Viraaj";
    	String s3 = "Abhi";
    	int a = s1.compareTo(s2);     //return -21 because s1 < s2 
    	System.out.println(a);
    	a = s1.compareTo(s3);     //return 0 because s1 == s3 
    	System.out.println(a);
    	a = s2.compareTo(s1);     //return 21 because s2 > s1
    	System.out.println(a);
    }  
}

-21 0 21

Java `String`类函数

原文：https://www.studytonight.com/java/string-class-functions.php

下面指定的方法是 Java 中String类最常用的一些方法。为了更好地理解，我们将借助小代码示例来学习每种方法。

`charAt()`方法

字符串charAt()函数返回位于指定索引处的字符。

public class Demo {
    public static void main(String[] args) {   
        String str = "studytonight";
        System.out.println(str.charAt(2));
    }
}

输出: u

注意:字符串的索引从 0 开始，因此str.charAt(2)表示字符串的第三个字符。

`equalsIgnoreCase()`方法

String equalsIgnoreCase()确定两个 String 相等，忽略它们的大小写(这个方法大小写无关紧要)。

public class Demo {
    public static void main(String[] args) {   
        String str = "java";
        System.out.println(str.equalsIgnoreCase("JAVA"));
    }
}

真实的

`indexOf()`方法

String indexOf()方法返回子串或字符第一次出现的索引。indexOf()方法有四种重载方法:

int indexOf(String str):返回指定子串第一次出现的字符串内的索引。
int indexOf(int ch, int fromIndex):返回指定字符第一次出现的字符串内的索引，从指定的索引开始搜索。
int indexOf(int ch):返回指定字符第一次出现的字符串内的索引。
int indexOf(String str, int fromIndex):从指定的索引开始，返回指定子串第一次出现的字符串内的索引。

示例:

public class StudyTonight {
    public static void main(String[] args) {
        String str="StudyTonight";
        System.out.println(str.indexOf('u'));   //3rd form
        System.out.println(str.indexOf('t', 3));    //2nd form
        String subString="Ton";
        System.out.println(str.indexOf(subString)); //1st form
        System.out.println(str.indexOf(subString,7));   //4th form
    }
}

2 11 5 -1

注意: -1 表示在给定字符串中找不到子字符串/字符。

`length()`方法

字符串length()函数返回字符串中的字符数。

public class Demo {
    public static void main(String[] args) {   
        String str = "Count me";
        System.out.println(str.length());
    }
}

eight

`replace()`方法

字符串replace()方法用指定的新字符替换出现的字符。

public class Demo {
    public static void main(String[] args) {   
        String str = "Change me";
        System.out.println(str.replace('m','M'));
    }
}
;

改变我

`substring()`方法

String substring()方法返回字符串的一部分。substring()方法有两种覆盖方法。

1.公共字符串子字符串(int begin)；

2.公共字符串子串(int begin，int end)；

第一个参数表示子树的起点。如果仅用一个参数调用substring()方法，则子树返回从指定起点到原始字符串末尾的字符。

如果用两个参数调用方法，第二个参数指定子字符串的结束点。

public class Demo {
    public static void main(String[] args) {
        String str = "0123456789";
        System.out.println(str.substring(4));
        System.out.println(str.substring(4,7));        
    }
}

456789 456

`toLowerCase()`方法

String toLowerCase()方法返回将所有大写字符转换为小写的字符串。

public class Demo {
    public static void main(String[] args) {
        String str = "ABCDEF";
        System.out.println(str.toLowerCase());   
    }
}

爵士摇滚

`toUpperCase()`方法

此方法返回将所有小写字符改为大写的字符串。

public class Demo {
    public static void main(String[] args) {
        String str = "abcdef";
        System.out.println(str.toUpperCase());   
    }
}

爵士摇滚

`valueOf()`方法

String类对所有原始数据类型和对象类型使用重载版本的valueOf()方法。

注意: valueOf()功能用于将原始数据类型转换为字符串。

public class Demo {
    public static void main(String[] args) {
         int num = 35;
         String s1 = String.valueOf(num);    //converting int to String
         System.out.println(s1);
         System.out.println("type of num is: "+s1.getClass().getName());   
    }
}

35 num 的类型是:java.lang.String

`toString()`方法

String toString()方法返回一个对象的字符串表示。它在 Object 类中声明，因此可以被任何 java 类覆盖。(对象类是所有 java 类的超级类)。

public class Car {
    public static void main(String args[])
    {
        Car c = new Car();
        System.out.println(c);
    }
    public String toString()
    {
        return "This is my car object";
    }
}

这是我的汽车物件

每当我们试图打印 Car 类的任何对象时，都会调用其toString()函数。

注意:如果我们不覆盖toString()方法直接打印对象，那么它会打印包含一些 hashcode 的对象 id。

`trim()`方法

此方法返回一个字符串，该字符串中的任何前导空格和尾随空格都已被删除。

public class Demo {
    public static void main(String[] args) {
        String str = "   hello  ";
        System.out.println(str.trim());   
    }
}

你好

`contains()`方法

字符串contains()方法用于检查给定字符串中的字符序列。如果找到一个字符串序列，则返回 true，否则返回 false。

    public class Demo {
    public static void main(String[] args) {
         String a = "Hello welcome to studytonight.com";  
         boolean b = a.contains("studytonight.com");  
         System.out.println(b);    
         System.out.println(a.contains("javatpoint"));     
    }
}

真假

`endsWith()`方法

字符串endsWith()方法用于检查字符串是否以给定的后缀结束。当后缀与字符串匹配时返回 true，否则返回 false。

    public class Demo {
    public static void main(String[] args) {
        String a="Hello welcome to studytonight.com";  
        System.out.println(a.endsWith("m"));  
        System.out.println(a.endsWith("com"));       
    }
}

真实真实

`format()`方法

弦format()是一种弦法。它用于给定字符串的格式。

以下是格式说明符及其数据类型:

| 格式规范 | 数据类型 |
| %a | 浮点 |
| %b | 任何类型 |
| %c | 性格；角色；字母 |
| %d | 整数 |
| %e | 浮点 |
| %f | 浮点 |
| %g | 浮点 |
| %h | 任何类型 |
| %n | 没有人 |
| %o | 整数 |
| %s | 任何类型 |
| %t | 日期/时间 |
| %x | 整数 |

    public class Demo {
    public static void main(String[] args) {
        String a1 = String.format("%d", 125);            
        String a2 = String.format("%s", "studytonight");  
        String a3 = String.format("%f", 125.00);        
        String a4 = String.format("%x", 125);            
        String a5 = String.format("%c", 'a');  
        System.out.println("Integer Value: "+a1);  
        System.out.println("String Value: "+a2);  
        System.out.println("Float Value: "+a3);  
        System.out.println("Hexadecimal Value: "+a4);  
        System.out.println("Char Value: "+a5);  
    }
}

整数值:125 字符串值:今晚研究浮点值:125.000000 十六进制值:7d 字符值:a

`getBytes()`方法

字符串getBytes()方法用于获取指定字符串的字节数组。

    public class Demo {
    public static void main(String[] args) {
        String a="studytonight";  
        byte[] b=a.getBytes();  
        for(int i=0;i<b.length;i++)
        {  
            System.out.println(b[i]);  
        }
    }
}

getbyte-example

`getChars()`方法

String getChars()方法用于将字符串的内容复制到一个 char 数组中。

    public class Demo {
    public static void main(String[] args) {
        String a= new String("Hello Welcome to studytonight.com");  
        char[] ch = new char[16];  
        try
        {  
            a.getChars(6, 12, ch, 0);  
            System.out.println(ch);  
        }
        catch(Exception ex)
        {
            System.out.println(ex);
        } 
    }
}

欢迎

`isEmpty()`方法

字符串isEmpty()方法用于检查字符串是否为空。当字符串长度为零时返回 true，否则返回 false。

    public class IsEmptyDemo1
{  
    public static void main(String args[])
    {  
        String a="";  
        String b="studytonight";  
        System.out.println(a.isEmpty());  
        System.out.println(b.isEmpty());  
    }
}

真假

`join()`方法

String join()方法用于连接带有给定分隔符的字符串。给定的分隔符与每个元素一起复制

    public class JoinDemo1
{  
    public static void main(String[] args) 
    { 
    String s = String.join("*","Welcome to studytonight.com");
    System.out.println(s);           
        String date1 = String.join("/","23","01","2020");    
System.out.println("Date: "+date1);    
        String time1 = String.join(":", "2","39","10");  
System.out.println("Time: "+time1);  
    }  
}

欢迎来到 studytonight.com 日期:2020 年 1 月 23 日时间:2:39:10

`startsWith()`方法

String startsWith()是 java 中的一个字符串方法。它用于检查给定的字符串是否以给定的前缀开头。当前缀匹配字符串时返回真，否则返回假。

    public class Demo {
    public static void main(String[] args) {
          String str = "studytonight";  
          System.out.println(str.startsWith("s"));   
          System.out.println(str.startsWith("t"));   
          System.out.println(str.startsWith("study",1));   
    }
}

真假假

字符串方法列表

Java 中的`StringBuffer`类

原文：https://www.studytonight.com/java/stringbuffer-class.php

StringBuffer 类用于创建一个可变的字符串对象。意思是，创建后可以更改。它代表可增长和可写的字符序列。

它类似于 Java 中的 string 类，两者都是用来创建 String 的，但是 stringbuffer 对象是可以更改的。

所以 StringBuffer 类在我们必须对字符串进行大量修改时使用。它也是线程安全的，即多个线程不能同时访问它。StringBuffer 定义了 4 个构造器。

StringBuffer ():它创建一个空的字符串缓冲区，并为 16 个字符保留空间。
StringBuffer (int size):它创建一个空字符串，并接受一个整数参数来设置缓冲区的容量。
StringBuffer (String str):它从指定的字符串创建 StringBuffer 对象。
StringBuffer(charSequence[]ch):它从 charSequence 数组中创建一个 StringBuffer 对象。

示例:创建字符串填充对象

在本例中，我们使用 StrigBuffer 类创建字符串缓冲区对象，并测试其可变性。

public class Demo {

	public static void main(String[] args) {

		StringBuffer sb = new StringBuffer("study");
		System.out.println(sb);
		// modifying object
		sb.append("tonight");
		System.out.println(sb);    // Output: studytonight

	}
}

今晚学习

示例:字符串和字符串缓冲区的区别

在这个例子中，我们正在创建 String 和 stringbuffer 类的对象并修改它们，但是只有 StringBuffer 对象被修改。见下面的例子。

class Test {
 public static void main(String args[])
 {
  String str = "study";
  str.concat("tonight");
  System.out.println(str);      // Output: study

  StringBuffer strB = new StringBuffer("study");
  strB.append("tonight");
  System.out.println(strB);    // Output: studytonight
 }
}

今晚学习

解释:

输出是这样的，因为字符串对象是不可变的对象。因此，如果我们连接在同一个字符串对象上，它不会被改变，但是 StringBuffer 会创建可变对象。因此，它可以被改变。

StringBuffer 类的重要方法

以下方法是 StringBuffer 类中一些最常用的方法。

追加()

这个方法将把任何类型数据的字符串表示连接到 StringBuffer 对象的末尾。append()方法有几种重载形式。

StringBuffer append(String str)
StringBuffer append(int n)
StringBuffer append(Object obj)

每个参数的字符串表示被附加到 StringBuffer 对象。

public class Demo {
	public static void main(String[] args) {
		StringBuffer str = new StringBuffer("test");
		str.append(123);
		System.out.println(str);
	}
}



插入()

此方法将一个字符串插入另一个字符串。以下是insert()法的几种形式。

StringBuffer insert(int index, String str)
StringBuffer insert(int index, int num)
StringBuffer insert(int index, Object obj)

这里第一个参数给出了字符串将被插入的位置的索引，第二个参数的字符串表示被插入到 StringBuffer 对象中。

public class Demo {
	public static void main(String[] args) {
		StringBuffer str = new StringBuffer("test");
		str.insert(2, 123);
		System.out.println(str);
	}
}

反向()

该方法反转一个 StringBuffer 对象中的字符。

public class Demo {
	public static void main(String[] args) {
		StringBuffer str = new StringBuffer("Hello");
		str.reverse();
		System.out.println(str);
	}
}

奥利

替换()

此方法将字符串从指定的开始索引替换为结束索引。

public class Demo {
	public static void main(String[] args) {
		StringBuffer str = new StringBuffer("Hello World");
		str.replace( 6, 11, "java");
		System.out.println(str);
	}
}

你好 java

容量()

该方法返回 StringBuffer 对象的当前容量。

public class Demo {
	public static void main(String[] args) {
		StringBuffer str = new StringBuffer();
		System.out.println( str.capacity() );
	}
}

Sixteen

注意:空构造器保留 16 个字符的空间。因此输出为 16。

保证能力()

该方法用于保证 StringBuffer 对象的最小容量。

如果 ensureCapacity()方法的参数小于现有容量，则现有容量不会发生变化。

如果 ensureCapacity()方法的参数大于现有容量，则使用以下规则会改变当前容量:新容量=(旧容量*2) + 2 。

public class Demo {
	public static void main(String[] args) {
		StringBuffer str = new StringBuffer();
		System.out.println( str.capacity()); //output: 16 (since empty constructor reserves space for 16 characters)
		str.ensureCapacity(30); //greater than the existing capacity
		System.out.println( str.capacity()); //output: 34 (by following the rule - (oldcapacity*2) + 2.) i.e (16*2)+2 = 34.
	}
}

16 34

Java `StringBuilder`类

原文：https://www.studytonight.com/java/stringbuilder-class.php

StringBuilder 与 StringBuffer 相同，除了一个重要的区别，即它不是同步的，这意味着它不是线程安全的。

StringBuilder 也用于创建可变和不同步的字符串对象。StringBuilder 类不能保证同步。StringBuffer 和 StringBuilder 都是可变的，但是如果不需要同步，那么建议使用 StringBuilder 类。

该类位于java.lang包中，该类的签名如下:

public final class StringBuilder
extends Object
implements Serializable, CharSequence

StringBuilder 构造器

StringBuilder ():创建一个空的 StringBuilder，并为 16 个字符保留空间。
StringBuilder (int size):创建一个空字符串，取一个整数参数来设置缓冲区的容量。
StringBuilder (String str):创建一个 StringBuilder 对象，用 String str 初始化。
StringBuilder(CharSequence seq):它使用 CharSequence 对象创建 StringBuilder 对象。

创建字符串生成器类

让我们使用 StringBuilder 类来创建字符串对象并检查它的可变性。

public class Demo {
  public static void main(String[] args) {
    StringBuilder sb = new StringBuilder("study");
    System.out.println(sb);
    // modifying object
    sb.append("tonight.com");
    System.out.println(sb);
  }
}

研究 studytonight.com

StringBuffer 和 StringBuilder 类之间的区别

StringBuffer 类的示例

  public class BufferDemo{
    public static void main(String[] args){  
StringBufferobj=new StringBuffer("Welcome to ");  
obj.append("studytonight.com");  
System.out.println(obj);  
    }  
}

欢迎来到 studytonight.com

字符串生成器类的示例

    public class BuilderDemo{
    public static void main(String[] args){  
StringBuilderobj=new StringBuilder("Welcome to ");  
obj.append("studytonight.com");  
System.out.println(obj);  
    }  
}

欢迎来到 studytonight.com

字符串生成器方法

StringBuilder 类有各种方法来处理字符串对象，如追加、插入、替换、反转等。让我们通过例子来看看它们的用法。

字符串生成器追加字符串示例

在本例中，我们使用 appen()方法将一个新字符串追加到现有的字符串对象中。

public class Demo {

  public static void main(String[] args) {

    StringBuilder sb = new StringBuilder("study");
    System.out.println(sb);
    // appending object
    sb.append("tonight.com");
    System.out.println(sb);

  }
}

研究 studytonight.com

字符串生成器替换方法

它用于替换字符串对象中的子字符串。这个方法有三个参数，第一个是开始索引，第二个是最后一个索引，第三个是要替换的子串。

 public class Demo {
  public static void main(String[] args) {
    StringBuilder sb = new StringBuilder("Java is a programming language");
    System.out.println(sb);
    // replacing object
    sb.replace( 10, 21, "computer");
    System.out.println(sb);
  }
}

Java 是一种编程语言 Java 是一种计算机语言

字符串生成器反向方法

它用于反转字符串对象。它完全颠倒了字符串从开始到结束的字符。见下面的例子。

public class Demo {
  public static void main(String[] args) {
    StringBuilder sb = new StringBuilder("Java stringbuilder");
    System.out.println(sb);
    // reverse object
    sb.reverse();
    System.out.println(sb);
  }
}

Java string builder rediubgnirs avaj

Java `StringTokenizer`

原文：https://www.studytonight.com/java/string-tokenizer.php

在 Java 中，StringTokenizer 用于根据提供的分隔符将字符串拆分为标记。分隔符可以在对象创建时指定，也可以基于每个标记指定。

它的对象在内部维护要标记化的字符串中的当前位置。它位于java.util包中。

在字符串中，标记器对象在内部维护，并从给定的字符串中返回子字符串的标记。

注意:StringTokenizer 是一个不推荐使用的类，仅出于兼容性原因才可用。

我们可以从下图中了解到，标记器是如何将字符串分成标记的。

string-tokenizer

以下是字符串标记器中的构造器

1. StringTokenizer(字符串 str)

2. StringTokenizer(字符串 str，字符串 delim)

3. StringTokenizer(String str、String delim、booleanreturnvalue)

以下是字符串标记器中的方法

1.booleanhasMoreTokens()

2. 字符串下一个令牌（）

3. 字符串下一个令牌（字符串解密）

4.booleanhasMoreElements()

5.对象 nextElement()

6.intcountTokens()

示例:

在这个例子中，我们使用 Stringtokenizer 根据空间将字符串分解成标记。

	 import java.util.StringTokenizer;  
public class TokenDemo1
{  
	public static void main(String args[])
	{  
		StringTokenizerobj = new StringTokenizer("Welcome to studytonight"," ");  
		while (obj.hasMoreTokens()) 
		{  
			System.out.println(obj.nextToken());  
		}  
	}  
}

欢迎今晚来学习

例子

让我们再举一个例子来理解标记器，这里我们基于冒号(:)分隔符将字符串分成标记。

	 import java.util.*;
public class TokenDemo2{
	public static void main(String args[])
	{
		String a= " : ";
		String b= "Welcome : to : studytonight : . : How : are : You : ?";
		StringTokenizer c = new StringTokenizer(b, a);
		int count1 = c.countTokens();
		for (inti = 0; i<count1; i++)
			System.out.println("token [" + i + "] : "
					+ c.nextToken());
		StringTokenizer d= null;
		while (c.hasMoreTokens())
			System.out.println(d.nextToken());
	}
}

string-tokenizer images

Java 异常处理

原文：https://www.studytonight.com/java/exception-handling.php

异常处理是一种在运行时处理异常的机制。异常是指程序执行过程中出现的导致程序异常终止的情况。可能有几个原因会导致异常，包括程序员错误、硬件故障、需要打开的文件找不到、资源耗尽等。

假设我们运行一个程序从一个文件中读取数据，如果该文件不可用，那么该程序将停止执行，并通过报告异常消息来终止程序。

异常的问题是，它终止程序并跳过剩余的执行，这意味着如果程序有 100 行代码，并且在第 10 行发生异常，那么程序将通过跳过剩余的 90 行代码的执行而立即终止。

为了处理这个问题，我们使用异常处理来避免程序终止，并通过跳过异常代码来继续执行。

Java 异常处理为用户提供了一个关于这个问题的有意义的消息，而不是一个系统生成的消息，用户可能无法理解这个消息。

未捕获的异常

让我们用一个例子来理解异常。当我们不处理异常时，它会导致意外的程序终止。在这个程序中，由于被零除，将抛出一个算术异常。

class UncaughtException
{
 public static void main(String args[])
 {
  int a = 0;
  int b = 7/a;     // Divide by zero, will lead to exception
 }
}

这将在运行时导致异常，因此 Java 运行时系统将构造一个异常，然后抛出它。由于我们在上面的程序中没有任何处理异常的机制，因此默认处理程序(JVM)将处理异常，并将在终端上打印异常的详细信息。

Uncaught Exception in java

Java 异常

Java 异常是描述程序中发生的异常的对象。当 java 中发生异常事件时，就称之为抛出异常。负责处理异常的代码称为异常处理程序

如何处理异常

Java 提供控件来处理程序中的异常。下面列出了这些控件。

尝试:用于封闭可疑代码。
Catch:它充当异常处理程序。
最后:用于执行必要的代码。
抛出:它显式抛出异常。
抛出:它通知可能的异常。

我们将在接下来的教程中讨论所有这些。

例外的类型

在 Java 中，根据异常的性质，异常大致可以分为检查异常、未检查异常和错误。

已检查异常

JVM 在编译时可以预测的异常为例:找不到需要打开的文件，SQLException 等。这些类型的异常必须在编译时检查。

未检查异常

未检查的异常是扩展 RuntimeException 类的类。未检查的异常在编译时被忽略，在运行时被检查。对于示例:算术异常、空指针异常、数组索引超出界限异常。运行时检查未检查的异常。

错误

错误在代码中通常被忽略，因为您很少能对错误做任何事情。对于示例，如果发生栈溢出，将会出现错误。这种类型的错误不能在代码中处理。

Java 异常类层次结构

所有异常类型都是类的子类，它位于异常类层次结构的顶部。

exception handling in java

异常类用于程序应该捕获的异常情况。此类被扩展以创建用户特定的异常类。
RuntimeException 是 Exception 的一个子类。该类下的异常是为程序自动定义的。
异常类型错误类型被 Java 运行时系统用来指示与运行时环境本身有关的错误。栈溢出就是这种错误的一个例子。

Java `try-catch`

原文：https://www.studytonight.com/java/try-and-catch-block.php

试试和抓都是 Java 关键字用于异常处理。try 块用于封装疑似代码。可疑代码是在程序执行过程中可能引发异常的代码。

例如，如果一个代码由于被零除而引发算术异常，那么我们可以将该代码包装到 try 块中。

  try{
  int a = 10;
  int b = 0
  int c = a/b; // exception
}

catch 块也称为处理程序用于处理异常。它处理由包含在 try 块中的代码引发的异常。Try 块必须提供 catch 处理程序或 finally 块。我们将在下一个教程中讨论 finally block。

catch 块只能在 try 块之后使用。我们也可以使用多个 catch 块和一个 try 块。

  try{
  int a = 10;
  int b = 0
  int c = a/b; // exception
}catch(ArithmeticException e){
  System.out.println(e);
}

尝试捕获语法

为了声明 try catch 块，下面给出了一个通用语法。

  try{
  // suspected code
}catch(ExceptionClass ec){}

异常处理是通过在异常发生时将程序的执行转移到适当的异常处理程序(catch 块)来完成的。

示例:处理异常

现在让我们通过一个简单的例子来理解这个尝试和捕捉，在这个例子中，我们将一个数除以零。代码包含在 try 块中，并提供了一个 catch 处理程序来处理异常。

class Excp
{
  public static void main(String args[])
  {
    int a,b,c;
    try
    {
      a = 0;
      b = 10;
      c = b/a;
      System.out.println("This line will not be executed");
    }
    catch(ArithmeticException e)
    {
      System.out.println("Divided by zero");
    }
    System.out.println("After exception is handled");
  }
}

处理异常后除以零

说明

这个程序将抛出一个异常，因为我们试图在尝试块内用零除一个数。程序控制转移到外，尝试块。因此“这一行不会被执行”不会被编译器解析。抛出的异常在 catch 块中处理。一旦异常被处理，程序控制继续程序中的下一行，即 catch 块之后。从而打印出处理异常后的行“”。

多个捕捉块

一个 try 块后面可以跟多个 catch 块。这意味着在一次试块之后，我们可以有任意数量的捕捉块。如果在受保护的代码(try 块)中出现异常，该异常将被传递到列表中的第一个 catch 块。如果异常类型与第一个 catch 块匹配，它将被捕获，否则异常将被传递到下一个 catch 块。这种情况一直持续到异常被捕获或通过所有捕获。

多重捕获语法

要声明多重捕获处理程序，我们可以使用以下语法。

  try  
  {  
   // suspected code
  }  
  catch(Exception1 e)  
  {  
    // handler code
  }   
catch(Exception2 e)  
{  
  // handler code
}

现在让我们看一个实现用于捕获可能的异常的多个 catch 块的例子。

当我们不确定程序执行期间异常的类型时，多个 catch 块非常有用。

多个捕捉块的示例

在这个例子中，我们试图获取一个整数对象的整数值。但是由于输入错误，抛出了数字格式异常。

  class Demo{
  public static void main(String[] args) {
    try
    { 
      Integer in = new Integer("abc");
      in.intValue();

    } 
    catch (ArithmeticException e) 
    { 
      System.out.println("Arithmetic " + e); 
    } 
    catch (NumberFormatException e) 
    { 
      System.out.println("Number Format Exception " + e); 
    } 
  }
}

数字格式异常:对于输入字符串:“abc”

在上面的例子中，我们使用了多个 catch 块，并根据异常的类型执行第二个 catch 块。

示例:多重异常

让我们通过另一个例子来理解多个 catch 处理程序的使用，这里我们在 catch 异常中使用了三个 catch 处理程序。

public class CatchDemo2
{  
  public static void main(String[] args) 
  {  
    try
    {    
      int a[]=new int[10];    
      System.out.println(a[20]);  
    }    
    catch(ArithmeticException e)  
    {  
      System.out.println("Arithmetic Exception --> "+e);  
    }    
    catch(ArrayIndexOutOfBoundsException e)  
    {  
      System.out.println("ArrayIndexOutOfBounds Exception --> "+e);  
    }    
    catch(Exception e)  
    {  
      System.out.println(e);  
    }                 
  }  
}

try-catch-example

一次只处理一个异常，并且只执行一个相应的 catch 块。

不可达捕获块的示例

在使用多个 catch 语句时，重要的是要记住 catch 中类 Exception 的子类必须在它们的任何超级类之前，否则会导致编译时错误。这是因为在 Java 中，如果有任何代码不可访问，那么就会产生编译时错误。

class Excep
{
  public static void main(String[] args)
  {
    try
    {
      int arr[]={1,2};
      arr[2]=3/0;
    }
    catch(Exception e)    //This block handles all Exception
    {
      System.out.println("Generic exception");
    }
    catch(ArrayIndexOutOfBoundsException e)    //This block is unreachable
    {
      System.out.println("array index out of bound exception");
    }
  }
}

一般例外

嵌套 try 语句

试试语句可以将嵌套在的另一个区块里面。当块的一部分可能导致一个错误，而整个块可能导致另一个错误时，使用嵌套的 try 块。如果内部 try 块没有针对特定异常的捕捉处理程序，则检查外部 try 捕捉块是否匹配。

class Excep
{
  public static void main(String[] args)
  {
    try
    {
      int arr[]={5,0,1,2};
      try
      {
        int x = arr[3]/arr[1];
      }
      catch(ArithmeticException ae)
      {
        System.out.println("divide by zero");
      }
      arr[4]=3;
    }
    catch(ArrayIndexOutOfBoundsException e)
    {
      System.out.println("array index out of bound exception");
    }
  }
}

除以零数组索引超出界限异常

需要记住的要点

如果您没有在程序中显式使用 try catch 块，java 将提供一个默认的异常处理程序，每当异常发生时，它将在终端上打印异常详细信息。
超级类可投掷覆盖 toString() 功能，以字符串形式显示错误信息。
在使用多个 catch 块时，始终确保异常类的子类在它们的任何超级类之前。否则你会得到编译时错误。
在嵌套 try catch 中，如果需要，内部 try 块使用自己的 catch 块以及外部 try 的 catch 块。
只能抛出可抛出类或其子类的对象。

Java 资源试用

原文：https://www.studytonight.com/java/try-with-resource-statement.php

Try with resource 是 Java 的一个新特性，在 Java 7 中引入，在 Java 9 中进一步改进。这个特性为资源管理的异常处理增加了另一种方式。也称自动资源管理。它使用自动关闭接口自动关闭资源..

资源可以是任何类似的:文件、连接等，我们不需要显式关闭它们，JVM 会自动关闭它们。

假设，我们运行一个 JDBC 程序来连接数据库，然后我们必须创建一个连接，并在任务结束时关闭它。但是在尝试使用资源的情况下，我们不需要关闭连接，JVM 将使用自动关闭接口自动关闭连接。

尝试资源语法

try(resource-specification(there can be more than one resource))
{
    //use the resource
}
catch()
{
    // handler code
}

这个 try 语句包含一个括号，其中声明了一个或多个资源。任何实现java.lang.AutoCloseable或java.io.Closeable的对象，都可以作为参数传递给 try 语句。资源是程序中使用的对象，在程序完成后必须关闭。 try-with-resources 语句确保每个资源在 try 块的语句结束时关闭。我们不必显式关闭资源。

资源语句不使用`try`的例子

让我们看看这样的场景:我们没有使用 try-with-resource 块，而我们使用的是普通的 try 块，这就是为什么我们需要显式关闭文件引用。

import java.io.*;
class Demo
{
	public static void main(String[] args)
	{
		try {
			String str;
			//opening file in read mode using BufferedReader stream
			BufferedReader br = new BufferedReader(new FileReader("d:\\myfile.txt"));
			while((str=br.readLine())!=null)
			{
				System.out.println(str);
			}
			br.close();     //closing BufferedReader stream
		}
		catch(IOException ie)
		{  
			System.out.println("I/O Exception "+ie);  
		}
	}
}

I/O 异常 Java . io . file notfoundexception:d:\ my file . txt(没有这样的文件或目录)

带有资源语句的示例`try`

在这里，我们使用 try-with-resource 来打开文件，并看到我们没有使用 close 方法来关闭文件连接。

import java.io.*;
class Demo
{
	public static void main(String[] args)
	{
		try(BufferedReader br = new BufferedReader(new FileReader("d:\\myfile.txt")))
		{
			String str;
			while((str = br.readLine()) != null)
			{
				System.out.println(str);
			}
		}
		catch(IOException ie)
		{  
			System.out.println("I/O Exception "+ie);  
		}
	}
}

注意:在上面的例子中，我们不需要显式调用close()方法来关闭 BufferedReader 流。

尝试使用资源–Java 9

在 Java 7 中，引入了 try-with-resource，其中资源是在 try 块中创建的。Java 7 的限制是，在外部创建的连接对象不能在尝试资源内部引用。

在 Java 9 中，这个限制被消除了，所以现在我们可以在 try-with-resource 之外创建对象，然后在里面引用而不会出错。

例子

import java.io.*;
class Demo
{
	public static void main(String[] args) throws FileNotFoundException
	{
		BufferedReader br = new BufferedReader(new FileReader("d:\\myfile.txt"));
		try(br)  // resource is declared outside the try
		{
			String str;
			while((str = br.readLine()) != null)
			{
				System.out.println(str);
			}
		}
		catch(IOException ie)
		{  
			System.out.println("I/O Exception "+ie);  
		}
	}
}

需要记住的要点

资源是程序中的一个对象，它必须在程序完成后关闭。
任何实现java.lang.AutoCloseable或java.io.Closeable的对象都可以作为参数传递给 try 语句。
try-with-resources 语句中声明的所有资源将在 try 块退出时自动关闭。没有必要显式关闭它。
我们可以在 try 语句中编写多个资源。
在 try-with-resources 语句中，任何 catch 或 finally 块都是在已声明的资源关闭后运行的。

Java `throw`、`throws`和`finally`

原文：https://www.studytonight.com/java/throw-throws-and-finally-keyword.php

throw、throws和finally是 Java 中用于异常处理的关键字。throw 关键字用于引发异常，throw 用于用方法签名声明可能的异常列表。而 finally block 用于执行基本代码，特别是释放被占用的资源。

现在让我们用例子详细讨论每一个。

Java Throw

throw 关键字用于显式引发异常。只能抛出可抛出类或其子类的对象。程序执行在遇到抛出语句时停止，检查最接近的 catch 语句是否匹配异常类型。

语法:

**throw** *ThrowableInstance*

创建可抛出类的实例

我们允许使用新的操作符来创建类 Throwable 的实例，

**new** NullPointerException("test");

这用名称测试构造了一个 NullPointerException 的实例。

示例抛出异常

在本例中，我们使用抛出关键字显式抛出算术异常，该关键字将由 catch 块处理。

class Test
{
  static void avg()
  {
    try
    {
      throw new ArithmeticException("demo");
    }
    catch(ArithmeticException e)
    {
      System.out.println("Exception caught");
    }
 }

 public static void main(String args[])
 {
    avg();
 }
}

在上面的例子中，avg()方法抛出了一个 ArithmeticException 的实例，使用 catch 语句成功地处理了这个实例，因此，程序输出了“捕获的异常”。

Java `throws`关键字

throws 关键字用于声明一个方法在程序执行期间可能抛出的异常列表。任何能够导致异常的方法都必须列出其执行过程中可能出现的所有异常，这样任何调用该方法的人都可以事先知道要处理哪些异常。一个方法可以通过使用抛出关键字来实现。

语法:

type method_name(parameter_list) throws exception_list
{
  // definition of method
}

示例抛出关键字

这里，我们有一个可以抛出算术异常的方法，所以我们在方法声明中提到了它，并在主方法中使用 catch 处理程序来捕获它。

class Test
{
  static void check() throws ArithmeticException
  {  
    System.out.println("Inside check function");
    throw new ArithmeticException("demo");
  }

  public static void main(String args[])
  {
    try
    {
      check();
    }
    catch(ArithmeticException e)
    {
      System.out.println("caught" + e);
    }
  }
}

内部检查函数 caughtjava . lang . arithmeticexception:演示

投掷和投掷的区别

`finally`条款

finally 关键字用于创建跟随 try 块的代码块。无论异常是否发生，最终代码块总是被执行。使用 finally 块，它允许您运行任何想要执行的清理类型语句，无论受保护的代码中发生了什么。最后一个块出现在 catch 块的末尾。

finally clause in exception handling in java

示例最终阻止

在这个例子中，我们使用了 finally 块和 try 块。这个程序抛出一个异常，由于异常，程序终止它的执行，但是看到写在最终执行的块里面的代码。正是由于 finally 块的性质，保证了代码的执行。

Class ExceptionTest
{
  public static void main(String[] args)
  {
    int a[] = new int[2];
    System.out.println("out of try");
    try
    {
      System.out.println("Access invalid element"+ a[3]);
      /* the above statement will throw ArrayIndexOutOfBoundException */
    }
    finally
    {
      System.out.println("finally is always executed.");
    }
  }
}

不尝试最后总是被执行。线程主 java 中的异常。郎。异常数组索引超出界限异常。

你可以在上面的例子中看到，即使程序抛出了异常，而异常不是由 catch 块处理的，但是最终块还是会被执行。

示例:最终阻止

最后，无论是否捕获到异常，block 都会在所有场景中执行。在前面的例子中，我们在异常没有被捕获的地方使用了 finally，但是在这里异常被捕获并最终与 handler 一起使用。

class Demo
{
  public static void main(String[] args)
  {
    int a[] = new int[2];
    try
    {
      System.out.println("Access invalid element"+ a[3]);
      /* the above statement will throw ArrayIndexOutOfBoundException */
    }
    catch(ArrayIndexOutOfBoundsException e) {
      System.out.println("Exception caught");
    }
    finally
    {
      System.out.println("finally is always executed.");
    }
  }
}

最后捕获的异常总是被执行。

Java 中用户定义的异常子类

原文：https://www.studytonight.com/java/create-your-own-exception.php

Java 提供了一组丰富的内置异常类，如:ArithmeticException、IOException、NullPointerException 等。所有这些都可以在 java.lang 包中获得，并用于异常处理。这些异常已经被设置为在预定义的条件下触发，例如当您将一个数除以零时，它会触发算术异常。

除了这些类，Java 允许我们创建自己的异常类来提供自己的异常实现。这些类型的异常称为用户定义的异常或自定义的异常。

您可以简单地通过扩展 java 异常类来创建自己的异常。您可以为您的异常定义一个构造器(非强制的)，并且您可以覆盖toString()函数以在捕获时显示您定制的消息。让我们看一个例子。

示例:自定义例外

在这个例子中，我们创建了一个异常类 MyException，它扩展了 Java 异常类

class MyException extends Exception
{
  private int ex;
  MyException(int a)
  {
    ex = a;
  }
  public String toString()
  {
    return "MyException[" + ex +"] is less than zero";
  }
}

class Demo
{
  static void sum(int a,int b) throws MyException
  {
    if(a<0)
    {
      throw new MyException(a); //calling constructor of user-defined exception class
    }
    else
    {
      System.out.println(a+b);
    }
  }

  public static void main(String[] args)
  {
    try
    {
      sum(-10, 10);
    }
    catch(MyException me)
    {
      System.out.println(me); //it calls the toString() method of user-defined Exception
    }
  }
}

MyException[-10]小于零

示例:自定义例外

让我们再举一个例子来理解自定义异常。这里我们创建了一个 ItemNotFound 类，它扩展了 Exception 类并帮助生成我们自己的异常实现。

 class ItemNotFound extends Exception
{
  public ItemNotFound(String s) {
    super(s);
  }

}

class Demo
{
  static void find(int arr[], int item) throws ItemNotFound
  {
    boolean flag = false;
    for (int i = 0; i < arr.length; i++) {
      if(item == arr[i])
        flag = true;
    }
    if(!flag)
    {
      throw new ItemNotFound("Item Not Found"); //calling constructor of user-defined exception class
    }
    else
    {
      System.out.println("Item Found");
    }
  }

  public static void main(String[] args)
  {
    try
    {
      find(new int[]{12,25,45}, 10);
    }
    catch(ItemNotFound i)
    {
      System.out.println(i);
    }
  }
}

未找到项目:未找到项目

需要记住的要点

扩展异常类以创建您自己的异常类。
您不必在其中实现任何东西，也不需要任何方法。
如果需要，可以有一个构造器。
您可以覆盖 toString()函数，以显示自定义消息。

Java 带有异常处理的方法覆盖

原文：https://www.studytonight.com/java/methodoverriding-with-exception-handling.php

用异常处理覆盖方法时，需要记住的事情很少，因为超类的方法可能声明了异常。在这种情况下，可能有两种情况:超级类的任何一种方法都可以声明异常或不声明异常。

如果超类方法声明了异常，那么子类的方法可以声明相同的异常类、子异常类或无异常，但不能是异常类的父类。

例如，如果超类的方法声明了算术异常，那么子类的方法可以声明算术异常，它的子类或者没有异常，但是不能声明它的超/父类，比如:异常类。

在其他情况下，如果超类方法没有声明任何异常，那么子类 overriden 方法不能声明选中的异常，但是它可以声明未选中的异常。让我们看一个例子。

具有选中异常的子类中的方法覆盖

Checked exception 是预期或已知在编译时发生的异常，因此它们必须在编译时处理。

import java.io.*;

class Super
{
  void show() { 
    System.out.println("parent class"); 
  }
}

public class Sub extends Super
{
  void show() throws IOException                //Compile time error
  { 
    System.out.println("parent class"); 
  }

  public static void main(String[] args)
  {
    Super s=new Sub();
    s.show();
  }
}

在上例中，方法show()在 Super 类中声明/定义时不会抛出任何异常，因此其在类 Sub 中的覆盖版本也不会抛出任何选中的异常。

如果我们尝试这样做，我们将会得到一个编译时错误。

使用未检查的异常在子类中覆盖方法

未检查的异常是扩展类RuntimeExeption的异常，并且由于某些运行时错误而引发。

import java.io.*;

class Super
{
  void show() { 
    System.out.println("parent class"); 
  }
}

class Sub extends Super
{
  void show() throws ArrayIndexOutOfBoundsException
  { 
    System.out.println("child class"); 
  }

  public static void main(String[] args)
  {
    Super s = new Sub();
    s.show();
  }
}

儿童班

因为ArrayindexOutofBoundSexception是一个未检查的异常，因此，覆盖的show()方法可以抛出它。

关于覆盖方法和异常的更多信息

如果超类方法抛出异常，那么 Subclass overriden 方法可以抛出相同的异常或者不抛出异常，但是不能抛出超类方法抛出的异常的父异常。

也就是说，如果 Super 类方法抛出 NullPointerException 类的对象，那么 Subclass 方法要么可以抛出相同的异常，要么可以不抛出异常，但是它永远不能抛出异常类的对象(NullPointerException 类的父类)。

具有相同异常的子类覆盖方法的示例

子类的方法可以声明与超类中声明的相同的异常。见下面的例子。

import java.io.*;
class Super
{
 void show() throws Exception
  {  System.out.println("parent class");  }
}

public class Sub extends Super {
 void show() throws Exception           //Correct
   { System.out.println("child class"); }

 public static void main(String[] args)
 {
  try {
   Super s=new Sub();
   s.show();
   }
  catch(Exception e){}
 }
}

儿童班

无异常的子类覆盖方法示例

在覆盖期间，在子类中声明异常是可选的。如果超类的方法声明了一个异常，那么该由子类来声明异常与否。见下面的例子。

import java.io.*;
class Super
{
 void show() throws Exception
  {  System.out.println("parent class");  }
}

public class Sub extends Super {
 void show()                            //Correct
   { System.out.println("child class"); }

 public static void main(String[] args)
 {
  try {
   Super s=new Sub();
   s.show();
   }
  catch(Exception e){}
 }
}

儿童班

具有父异常的子类覆盖方法的示例

不允许在子类方法中声明父类异常，如果我们试图编译那个程序，我们会得到编译时错误。见下面的例子。

import java.io.*;
class Super
{
 void show() throws ArithmeticException
  {  System.out.println("parent class");  }
}

public class Sub extends Super {
 void show() throws Exception                   //Compile time Error
   { System.out.println("child class"); }

 public static void main(String[] args)
 {
  try {
   Super s=new Sub();
   s.show();
   }
  catch(Exception e){}
 }
}

编译时错误

Java 中的链式异常

原文：https://www.studytonight.com/java/chained-exception-in-java.php

在 JDK 1.4 中，链式异常被添加到 Java 中。此功能允许您将一个异常与另一个异常相关联，即一个异常描述另一个异常的原因。例如，考虑一种情况，其中一个方法由于试图除以零而抛出一个算术异常，但是异常的实际原因是一个导致除数为零的输入/输出错误。该方法只会向调用方抛出算术异常。所以打电话的人不会知道异常的真正原因。链式异常用于这种情况。

两个新的构造器和两个新的方法被添加到 Throwable 类中，以支持链式异常。

可投掷(可投掷原因)
可投掷(弦弦，可投掷原因)

在第一个构造器中，参数原因指定了异常的实际原因。在第二种形式中，它允许我们以字符串形式添加异常描述，并说明异常的实际原因。

getCause() 和 initCause() 是添加到可投掷类的两个方法。

getCause() 方法返回与当前异常相关联的实际原因。
initCause() 通过调用异常来设置底层原因(异常)。

是时候举个例子了！

让我们借助一个例子来理解链式异常，这里，程序抛出了一个算术异常，但是导致异常的真正原因是 IOException。我们使用 initCause()方法设置异常的原因。

import java.io.IOException;

public class ChainedException
{
    public static void divide(int a, int b)
    {
      if(b == 0)
      {
        ArithmeticException ae = new ArithmeticException("top layer");
        ae.initCause(new IOException("cause"));
        throw ae;
      }
      else
      {
        System.out.println(a/b);
      }
    }

    public static void main(String[] args)
    {
      try 
      {
        divide(5, 0);
      }
      catch(ArithmeticException ae) {
        System.out.println( "caught : " +ae);
        System.out.println("actual cause: "+ae.getCause());
      }
    }
}

捕获:java.lang.ArithmeticException:顶层实际原因:java.io.IOException:原因

例子

让我们再看一个例子来理解链异常，这里抛出了 NumberFormatException，但是异常的实际原因是一个空指针异常。

  public class ChainedDemo1
{ 
  public static void main(String[] args) 
  { 
    try
    { 

      NumberFormatException a = new NumberFormatException("====> Exception"); 

      a.initCause(new NullPointerException("====> Actual cause of the exception")); 

      throw a; 
    } 

    catch(NumberFormatException a) 
    { 

      System.out.println(a); 
      System.out.println(a.getCause()); 
    } 
  } 
}

chained-example

异常传播

在 Java 中，异常是从栈顶抛出的，如果异常没有被捕获，它就被放在栈底，这个过程一直持续到到达栈底并被捕获。这就是所谓的异常传播。默认情况下，未检查的异常会在被调用的链中转发。

例子

在本例中，方法 a2 调用的方法 a1 出现异常，方法 a3 调用的方法 a2 出现异常。方法 a3()包含在 try 块中，以提供安全保护。我们知道方法 a1 将引发异常，但在方法 a3()中处理。这称为异常传播。

 class ExpDemo1{ 
  void a1() 
  { 
    int data = 30 / 0; 
  } 
  void a2() 
  { 
    a1();  
  } 
  void a3() 
  { 
    try { 
      a2();
    } 
    catch (Exception e) 
    { 
      System.out.println(e); 
    } 
  } 

  public static void main(String args[]) 
  { 
    ExpDemo1 obj1 = new ExpDemo1(); 
    obj1.a3(); 
  } 
}

Java . lang . arithmeticexception:/by zero

例子

让我们再举一个例子，这里程序从方法 m1()抛出一个 IOException，它在 n1()内部被调用。方法 m1()引发的异常由方法 n1()处理。

 import java.io.IOException; 
class Demo{ 
  void m1() throws IOException
  { 
    throw new IOException("device error"); 
  } 
  void n1() throws IOException
  { 
    m1(); 
  } 
  void p1() 
  { 
    try { 
      n1(); 
    } 
    catch (Exception e) 
    { 
      System.out.println("Exception handled"); 
    } 
  } 
  public static void main(String args[]) 
  { 
    Demo obj = new Demo(); 
    obj.p1(); 
  } 
}

Java 多线程

Java 多线程简介

原文：https://www.studytonight.com/java/multithreading-in-java.php

多线程是同时运行多个线程的概念。线程是在多线程环境中执行的进程的轻量级单元。

一个程序可以分成许多小的进程。每个小进程都可以作为一个单独的线程(一个轻量级进程)来处理。您可以将轻量级进程视为执行代码或系统调用的虚拟 CPU。您通常不需要关心用线程编程的轻量级进程。多线程程序包含两个或多个可以并发运行的线程，每个线程定义一个单独的执行路径。这意味着一个程序可以同时执行两个或多个任务。例如，一个线程正在文件上写入内容，同时另一个线程正在执行拼写检查。

在 Java 中， thread 这个词有两种不同的意思。

线程类的一个实例。
或者，执行线程。

像 java 中的任何其他对象一样， Thread 类的实例只是一个对象。但是一个执行线程意味着一个单独的“轻量级”进程，它有自己的调用栈。在 java 中，每个线程都有自己的调用栈。

thread call stack

多线程的优势

多线程减少了中央处理器的空闲时间，从而提高了系统的整体性能。由于线程是轻量级进程，因此它占用更少的内存并执行上下文切换，这有助于共享内存并减少线程之间的切换时间。

多任务处理

多任务是同时执行多个任务的过程。我们可以通过执行多个任务的计算机系统来理解它，例如:将数据写入文件、播放音乐、同时从远程服务器下载文件。

多任务可以通过使用多处理或多线程来实现。使用多处理进行多任务处理涉及多个进程同时执行多个任务，而多线程涉及多个线程执行多个任务。

为什么是多线程？

线程在执行多任务处理方面比进程有很多优势。进程重量大，占用内存多，占用 CPU 时间长，可能导致系统性能问题。为了克服这些问题，流程被分解成独立子流程的小单元。这些子进程称为线程，可以高效地执行独立的任务。所以现在的计算机系统更喜欢使用线程而不是进程，并且使用多线程来执行多任务处理。

如何创建线程？

为了创建一个线程，Java 提供了一个类 Thread 和一个接口 Runnable ，两者都位于 java.lang 包中。

我们可以通过扩展Thread类或者实现 Runnable 接口来创建线程。两者都包括一个运行方法，必须覆盖该方法才能提供线程实现。

如果您只想创建一个线程，但也可以使用Thread类来实现其他线程功能，建议使用 Runnable 接口。

我们将在下一个主题中详细讨论它。

`main`螺纹

当我们运行任何 java 程序时，程序从主方法开始执行它的代码。因此，JVM 创建一个线程来开始执行主方法中的代码。这条线叫做主线线。虽然主线程是自动创建的，但是您可以通过调用 currentThread() 方法获取对它的引用来控制它。

关于主线需要了解的两件重要事情是:

它是产生其他线程的线程。
它必须总是最后一个完成执行的线程。

class MainThread
{
 	public static void main(String[] args)
 	{
  		Thread t = Thread.currentThread();
  		t.setName("MainThread");
  		System.out.println("Name of thread is "+t);
 	}
}

线程的名称是线程[主线程，5，主]

线程的生命周期

和进程一样，线程的生命周期包括不同的阶段，比如:新建、运行、终止等。我们用下图描述了它。

thread life cycle

New : 线程在新状态下开始其生命周期。它一直保持这种状态，直到对它调用 start()方法。
Runnable : 在新线程上调用 start()方法后，该线程变得可运行。
运行:如果线程调度器选择了线程，则该线程处于运行状态。
等待:一个线程如果等待另一个线程执行任务，则处于等待状态。在这个阶段，线程仍然活着。
终止:线程完成任务后进入终止状态。

守护线程

守护线程是一个低优先级线程，为用户线程提供支持。这些线程可以是用户定义的，也可以是系统定义的。垃圾收集线程是系统生成的后台运行的守护线程之一。这些线程在后台运行，执行垃圾收集等任务。守护线程不允许 JVM 存在，直到所有线程完成它们的执行。当一个 JVM 发现守护线程时，它会终止线程，然后关闭自己，它不关心守护线程是否在运行。

线程池

在 Java 中，用于重用先前为执行当前任务而创建的线程。如果在线程周期或资源抖动中出现任何问题，它也提供了解决方案。在 Java 线程池中，创建一组线程，选择一个线程并分配给作业，作业完成后，它被发送回组中。

线程优先级

在 Java 中，当我们创建一个线程时，总是会给它分配一个优先级。在多线程环境中，处理器为线程调度器分配优先级。优先级由 JVM 或程序员自己明确给出。优先级的范围在 1 到 10 之间，Thread类中有三个静态变量来定义优先级。

注意:线程优先级不能保证优先级较高的线程总是比优先级较低的线程先执行。执行线程的选择取决于依赖于平台的线程调度器。

Java `Thread`类

原文：https://www.studytonight.com/java/thread-class-and-functions.php

Thread类是 Java 多线程系统所基于的主要类。Thread类及其伴随接口 Runnable 将用于创建和运行线程，以利用 Java 的多线程特性。

它提供了支持多线程的构造器和方法。它扩展了对象类并实现了 Runnable 接口。

`Thread`类的签名

public class Thread extends Object implements Runnable

`Thread`类优先级常数

`Thread`类的构造器

螺纹()
螺纹(弦线)
螺纹(可运行)
螺纹(可运行 r，弦线)
螺纹 ( 螺纹组组，可运行目标)
线程 ( 线程组组，可运行目标，字符串名称)
线程 ( 线程组组，可运行目标，字符串名称，长栈大小)
螺纹 ( 螺纹组组，螺纹名称)

`Thread`类方法

Thread类还定义了许多管理线程的方法。其中一些是，

方法	描述
setName()	给线程命名
getName（）	返回线程的名称
getPriority()	返回线程的优先级
isalive()	检查线程是否仍在运行
加入()	等待线程结束
运行()	线程的入口点
睡眠()	将线程挂起指定的时间
开始()	通过调用 run()方法启动线程
活动计数()	返回当前线程的线程组及其子组中活动线程数量的估计值。
checkAccess()	确定当前运行的线程是否有权修改此线程。
currentThread()	返回对当前正在执行的线程对象的引用。
dumpStack()	将当前线程的栈跟踪打印到标准错误流。
getId()	返回此线程的标识符。
getState（）	返回此线程的状态。
getThreadGroup()	返回该线程所属的线程组。
中断()	中断这个线程。
中断()	测试当前线程是否已被中断。
isalive()	测试这个线程是否是活动的。
isDaemon()	测试该线程是否是守护线程。
isInterrupted()	测试此线程是否已被中断。
setDaemon(boolean on)	将此线程标记为守护程序线程或用户线程。
设置优先级(整数新优先级)	更改此线程的优先级。
产量()	给调度程序的提示，表明当前线程愿意让出它当前对处理器的使用。

需要记住的几个要点

当我们扩展 Thread 类时，我们不能覆盖 setName() 和 getName() 函数，因为它们在 Thread 类中被声明为 final。

使用 sleep() 时，始终处理它抛出的异常。

*static* void sleep(long *milliseconds*) throws InterruptedException

可运行接口

它也用于创建线程，如果您只打算覆盖run()方法而没有其他线程方法，则应该使用它。

签名

 @FunctionalInterface
public interface Runnable

可运行接口方法

它只提供一个必须由类实现的方法。

| 方法 | 描述 |
| 运行() | 它运行实现的线程。 |

关机钩

在 Java 中，shut hook 用于清理所有资源，它意味着关闭所有文件，发送警报等。我们还可以保存 JVM 关闭时的状态。关闭挂钩主要用于在任何 JVM 关闭之前执行任何代码的情况。以下是 JVM 关闭的一些原因:

在命令提示符下按 ctrl+c
调用 System.exit(int)方法时。
当用户注销或关机等

添加关闭钩(线程钩)

addShutdownHook(线程挂钩)方法用于向虚拟机注册线程。此方法属于运行时类。

示例:

	 class Demo6 extends Thread
{  
    public void run()
	{  
	System.out.println("Shutdown hook task is Now completed...");  
	}  
}  

public class ShutdownDemo1
{  
	public static void main(String[] args)throws Exception 
	{  

		Runtime obj=Runtime.getRuntime();  
		obj.addShutdownHook(new Demo6());  
		System.out.println("Now main method is sleeping... For Exit press ctrl+c");  
		try
		{
			Thread.sleep(4000);
		}
		catch (Exception e) {}  
	}  
}

shutdown_hook

内存不足异常

在 Java 中，我们知道所有的对象都存储在堆中。这些对象是使用 new 关键字创建的。出现以下 OutOfMemoryError 错误:

out-of-memory-exception

当 Java 虚拟机无法分配对象时，会出现此错误，因为对象内存不足，垃圾收集器没有可用的内存。

OutOfMemoryError 的意思是程序中有问题。当第三方库缓存字符串时，问题可能会失控。

可能出现内存不足错误的基本程序

示例:

	 import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class OutOfMemoryDemo1 {
	public static void main(String[] args) {
		List<integer>obj = new ArrayList<>();
		Random obj1= new Random();
		while (true)
			obj.add(obj1.nextInt());
	}
}</integer>

out-of-memory-exception-example

Java 程序：由于内存不足而可能出现内存不足错误

示例:

	 public class OutOfMemoryErrorDemo2
{
	public static void main(String[] args) 
	{
		Integer[] a = new Integer[100000*10000*1000];
		System.out.println("Done");
	}
}

Java 程序：当垃圾收集器超过限制时，可能出现内存不足错误

示例:

	 import java.util.*; 

public class OutOfMemoryErrorDemo2{ 
public static void main(String args[]) throws Exception 
    { 
        Map a = new HashMap(); 
        a = System.getProperties(); 
        Random b = new Random(); 
        while (true) { 
a.put(b.nextInt(), "randomValue"); 
        }   } 
}

out-of-memory-exception-example

在 Java 中创建一个线程

原文：https://www.studytonight.com/java/creating-a-thread.php

为了实现多线程，Java 定义了两种创建线程的方法。

通过实现可运行接口。
通过扩展线程类。

实现可运行接口

创建线程最简单的方法是创建一个实现可运行接口的类。实现可运行接口后，类需要实现run()方法。

运行方法语法:

public void run()

它在你的程序中引入了一个并发线程。当run()方法终止时，该线程将结束。
您必须指定您的线程将在run()方法中执行的代码。
run()方法可以调用其他方法，可以像其他普通方法一样使用其他类和声明变量。

class MyThread implements Runnable
{
    public void run()
    {
        System.out.println("concurrent thread started running..");
    }
}

class MyThreadDemo
{
    public static void main(String args[])
    {
        MyThread mt = new MyThread();
        Thread t = new Thread(mt);
        t.start();
    }
}

并发线程开始运行..

调用run()方法，使用start()方法。在调用 start()时，会向线程提供一个新栈，并调用 run()方法将新线程引入程序。

注意:如果在类中实现 Runnable 接口，那么需要显式创建 Thread 类对象，并且需要将 Runnable 接口实现的类对象作为参数传递到其构造器中。

扩展`Thread`类

这是通过扩展 Thread 类的新类创建线程并创建该类实例的另一种方法。扩展类必须覆盖run()方法，这是新线程的入口点。

class MyThread extends Thread
{
 	public void run()
 	{
  		System.out.println("concurrent thread started running..");
 	}
}

classMyThreadDemo
{
 	public static void main(String args[])
 	{
  		MyThread mt = new  MyThread();
  		mt.start();
 	}
}

并发线程开始运行..

同样在这种情况下，我们必须覆盖run()，然后使用start()方法运行线程。此外，当你创建一个神话类对象时，Thread类构造器也会被调用，因为它是超级类，因此神话类对象充当Thread类对象。

不使用`start()`方法直接调用`run()`方法会怎么样？

在上面的程序中如果我们直接调用run()方法，不使用start()方法，

public static void main(String args[])
{
 	MyThread mt = new MyThread();
	mt.run();
}

这样做，不会给线程分配新的调用栈，它会在当前的调用栈中开始运行，也就是主线程的调用栈。因此多线程不会出现。

calling run without start method

我们可以开始一个线程两次吗？

不，线程不能启动两次。如果尝试这样做，将抛出illegalthreadstatexception。

public static void main(String args[])
{
 	MyThread mt = new MyThread();
 	mt.start();
 	mt.start();		//Exception thrown
}

当一个线程处于运行状态，并且您试图再次启动它，或者任何方法试图使用 start() 方法再次调用该线程时，将引发异常。

线程池

thread-pool

线程池有三种方法。它们如下:

1. 新固定线程池（int）

2.newCachedThreadPool()

3.newSingleThreadExecutor()

以下是创建线程池程序的步骤

1.创建一个可运行的对象来执行。

2.使用执行器创建执行器池

3.现在将对象传递给执行器池

4.最后关闭执行器池。

示例:

	 import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class WorkerThread implements Runnable 
	{
		private String message;
		public WorkerThread(String a)
		{
			this.message=a;
		}
    public void run() 
	{
        System.out.println(Thread.currentThread().getName()+" (Start) message = "+message);
        processmessage();
        System.out.println(Thread.currentThread().getName()+" (End)");
    }
    private void processmessage() 
	{
        try 
		{  
			Thread.sleep(5000);  
		} 
		catch (InterruptedException e) 
		{
			System.out.println(e);
		}
    }
}
public class ThreadPoolDemo1 
{ 
    public static void main(String[] args) 
	{
        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) 
		{
            Runnable obj = new WorkerThread("" + i);
            executor.execute(obj);
         }
        executor.shutdown();
        while (!executor.isTerminated()) 
		{
        }
        System.out.println("********All threads are Finished********");
    }
}

thread-pool-example

在 Java 中连接线程

原文：https://www.studytonight.com/java/joining-a-thread.php

有时一个线程需要知道另一个线程何时终止。在 java 中， isAlive() 和 join() 是两种不同的方法，用于检查线程是否已经完成执行。

如果调用的线程仍在运行，则 isAlive() 方法返回真，否则返回假。

*final* boolean **isAlive()**

但是， join() 方法比 isAlive() 更常用。此方法等待，直到调用它的线程终止。

*final* void **join()** throws **InterruptedException**

使用 join() 方法，我们告诉我们的线程等待，直到指定的线程完成它的执行。 join() 方法有重载版本，允许我们指定等待指定线程终止的时间。

*final* void **join**(long *milliseconds*) throws **InterruptedException**

正如我们在多线程介绍中看到的，主线程必须始终是最后一个完成其执行的线程。因此，我们可以使用 Thread join()方法来确保程序创建的所有线程在主线程执行之前已经被终止。

Java `isAlive`方法

让我们举个例子，看看isAlive()方法是如何工作的。如果线程状态为活动，则返回 true，否则返回 false。

public class MyThread extends Thread
{
	public void run()
	{
		System.out.println("r1 ");
		try {
        		Thread.sleep(500);
    		}
    	catch(InterruptedException ie) 
    	{ 
    		// do something
    	}
       	System.out.println("r2 ");
  	}
	public static void main(String[] args)
	{
		MyThread t1=new MyThread();
		MyThread t2=new MyThread();
		t1.start();
		t2.start();
		System.out.println(t1.isAlive());
		System.out.println(t2.isAlive());
	}
}

r1 真 r1 真 r2 真 r2

没有`join()`方法的螺纹示例

如果我们在不使用 join()方法的情况下运行一个线程，那么线程的执行是无法预测的。线程调度器调度线程的执行。

public class **MyThread** extends **Thread**
{
	public void run()
   	{
       		System.out.println("r1 ");
       		try {
        		Thread.sleep(500);
    		}
    		catch(InterruptedException ie){ }
       		System.out.println("r2 ");
  	}
	public static void main(String[] args)
	{
		MyThread t1=new MyThread();
		MyThread t2=new MyThread();
		t1.start();
		t2.start();
	}
}

r1 r1 r2 r2

在上面的程序中，创建了两个线程 t1 和 t2。t1 首先开始，在控制台上打印“r1”之后，线程 t1 进入睡眠状态 500 ms。同时，线程 t2 将开始其进程，并在控制台上打印“r1”，然后进入睡眠状态 500 ms。线程 t1 将从睡眠中醒来，并在控制台上打印“r2”类似地，线程 t2 将从睡眠中醒来，并在控制台上打印“r2”。所以你会得到类似r1 r1 r2 r2的输出

使用`join()`方法的螺纹示例

在这个例子中，我们使用 join()方法来确保线程在启动其他线程之前完成了它的执行。当我们想根据自己的需求执行多个线程时，这很有帮助。

public class **MyThread** extends **Thread**
{
	public void run()
   	{
       		System.out.println("r1 ");
       		try {
        		Thread.sleep(500);
    		}catch(InterruptedException ie){ }
       		System.out.println("r2 ");
  	}
	public static void main(String[] args)
	{
		MyThread t1=new MyThread();
		MyThread t2=new MyThread();
		**t1.start();**

		try{
  			**t1.join();**	*//Waiting for t1 to finish*
		}catch(InterruptedException ie){}

		**t2.start();**
	}
}

r1 r2 r1 r2

在上面的程序中，线程 t1 上的 join()方法确保 t1 在线程 t2 启动之前完成它的处理。

使用联接指定时间()

如果在上面的程序中，我们在使用 join() 和 t1 的同时指定时间，那么 t1 将在该时间执行，然后 t2 将加入其中。

 public class MyThread extends Thread
{ 
	    MyThread(String str){
	    	super(str);
	    }

        public void run()
        {
                System.out.println(Thread.currentThread().getName());
        }
        public static void main(String[] args)
        {
                MyThread t1=new MyThread("first thread");
                MyThread t2=new MyThread("second thread");
                t1.start();

                try{
                        t1.join(1500);      //Waiting for t1 to finish
                }catch(InterruptedException ie){
                	System.out.println(ie);
                }

                t2.start();

                try{
                    t2.join(1500);      //Waiting for t2 to finish
                }catch(InterruptedException ie){
                	System.out.println(ie);
                }
        }
}

Doing so, initially t1 will execute for 1.5 seconds, after which t2 will join it.

Java 线程休眠

原文：https://www.studytonight.com/java/sleeping-thread-in-java.php

为了让一个线程休眠指定的时间，Java 提供了在 thread 类中定义的休眠方法。sleep 方法是一个重载方法，如下所示。它抛出中断的异常，因此请确保提供正确的处理程序。

它总是暂停当前线程的执行。任何其他线程都可以在睡眠中中断当前线程，在这种情况下，将引发中断异常。

句法

sleep(long millis)throws InterruptedException
sleep(long millis, int nanos)throws InterruptedException

示例:睡眠线程

在这个例子中，我们使用 sleep 方法来睡眠线程。每个线程将休眠 1500 毫秒，然后继续执行。见下面的例子。

    public class MyThread extends Thread
{ 
        MyThread(String str){
            super(str);
        }

        public void run()
        {
                System.out.println(Thread.currentThread().getName()+" Started");
                try{
                    MyThread.sleep(1500); 
                    }catch(InterruptedException ie){
                        System.out.println(ie);
                }
                System.out.println(Thread.currentThread().getName()+" Finished");
        }
        public static void main(String[] args)
        {
                MyThread t1=new MyThread("first thread");
                MyThread t2=new MyThread("second thread");
                t1.start();
                t2.start();
        }
}

第一个线程已启动第二个线程已启动第一个线程已完成第二个线程已完成

例子

    public class MyThread extends Thread
{ 
        MyThread(String str){
            super(str);
        }

        public void run()
        {
                System.out.println(Thread.currentThread().getName()+" Started");
                try{
                    MyThread.sleep(1500);
                    System.out.println(Thread.currentThread().getName()+" Sleeping..");
                    }catch(InterruptedException ie){
                        System.out.println(ie);
                }
                System.out.println(Thread.currentThread().getName()+" Finished");
        }
        public static void main(String[] args)
        {
                MyThread t1=new MyThread("first thread");
                MyThread t2=new MyThread("second thread");
                System.out.println(t1.getName()+" state: "+t1.getState());
                t1.start();
                System.out.println(t1.getName()+" state: "+t1.getState());
                System.out.println(t2.getName()+" state: "+t2.getState());
                t2.start();
                System.out.println(t2.getName()+" state: "+t2.getState());
        }
}

第一线程状态:新的第一线程状态:可运行的第二线程状态:新的第一线程已启动的第二线程状态:可运行的第二线程已启动的第一线程正在睡眠..第二线程正在睡眠..第二个线程已完成第一个线程已完成

Thread.sleep()与线程调度器交互，将当前线程置于等待状态一段指定的时间。等待时间结束后，线程状态变为可运行状态，等待 CPU 进一步执行。所以当前线程休眠的实际时间取决于作为操作系统一部分的线程调度器。

Java 命名线程

原文：https://www.studytonight.com/java/naming-thread-in-java.php

Java 中的每个线程都有自己的名称，默认情况下由 JVM 设置。虽然有许多其他属性与线程相关联，如:id、优先级等。

我们可以通过调用 thread 类的getName()方法得到一个线程的名字。如果我们希望设置线程的新名称，那么可以使用设置名称()方法。这两种方法都属于 Thread 类，甚至我们可以在创建对象时通过传入构造器来设置线程的名称。让我们通过例子来理解。

下面给出了两种方法的语法。

setName(String name)
getName()

示例:获取线程名称

让我们首先获取 JVM 设置的线程名。这是默认名称，所以最初我们无法预测它。

    public class MyThread extends Thread
{ 

    public void run()
    {
       System.out.println("thread running...");
    }
    public static void main(String[] args)
    {
        MyThread t1=new MyThread();

        t1.start();
        System.out.println("thread name: "+t1.getName());
    }
}

线程运行...线程名称:线程-0

我们也可以使用 Thread 类的静态 currentThread()方法。它返回线程名称、优先级等。它是静态方法，因此不需要对象调用它。见下面的例子。

示例:Thread.currentThread()

在这个例子中，我们使用Thread类的 currentThread 方法来获取线程的名称。

    public class MyThread extends Thread
{ 

    public void run()
    {
       System.out.println("thread running...");
       System.out.println("Thread name: "+Thread.currentThread());
    }
    public static void main(String[] args)
    {
        MyThread t1=new MyThread();

        t1.start();
    }
}

线程运行...线程名称:线程[线程-0，5，主]

示例:设置名称

在这个例子中，我们使用 setName()方法来设置线程的名称，使用 getName()方法来获取线程的名称。

    public class MyThread extends Thread
{ 

    public void run()
    {
       System.out.println("thread running...");
    }
    public static void main(String[] args)
    {
        MyThread t1=new MyThread();
        t1.start();
        t1.setName("mythread");
        System.out.println("Thread Name: "+t1.getName());
    }
}

线程运行...线程名称:神话

示例:使用构造器设置名称

我们可以通过传递构造器来设置线程的名称。允许String类型参数的Thread类构造器可用于设置名称。见下面的例子。

    public class MyThread extends Thread
{ 
    MyThread(String name){
        super(name);
    }

    public void run()
    {
       System.out.println("thread running...");
    }
    public static void main(String[] args)
    {
        MyThread t1=new MyThread("mythread");
        t1.start();
        System.out.println("Thread Name: "+t1.getName());
    }
}

线程运行...线程名称:神话

因为我们扩展了Thread类，所以我们通过超级调用调用它的构造器，并将线程名传递给 MyThread 类。

示例:设置名称

我们可以通过创建Thread类对象直接将线程名传递给构造器。

    public class MyThread implements Runnable
{ 

        public void run()
        {
               System.out.println("thread running...");
        }
        public static void main(String[] args)
        {
                MyThread t1=new MyThread();
                Thread t = new Thread(t1, "mythread");
                t.start();
                System.out.println("Thread Name: "+t.getName());
        }
}

线程运行...线程名称:神话

在本主题中，我们学习了使用getName()和currentThread()方法获取线程名称，以及使用 setName()方法设置名称并将名称传递给构造器。

Java 线程优先级

原文：https://www.studytonight.com/java/thread-priorities-in-java.php

一个线程的优先级描述了它多早得到执行并被线程调度器选择。在 Java 中，当我们创建一个线程时，总是会给它分配一个优先级。在多线程环境中，处理器为线程调度器分配优先级。优先级由 JVM 或程序员自己明确给出。优先级的范围在 1 到 10 之间，有三个常量变量是静态的，用于获取线程的优先级。它们如下:

1.公共静态 int MIN_PRIORITY

它持有可以给予线程的最低优先级。该值为 1。

2.公共静态 int NORM_PRIORITY

如果没有定义，它是给线程的默认优先级。该值为 0。

3.公共静态 int MAX_PRIORITY

这是可以赋予线程的最大优先级。这个的值是 10。

获取和设置线程优先级中的方法

1。公共最终 intgetPriority()

在 Java 中，getPriority()方法在 java.lang.Thread 包中。它用于获取线程的优先级。

2。公共最终无效设置优先级(intnewPriority)

在 Java 中，setPriority(intnewPriority)方法在 java.lang.Thread 包中。它用于设置线程的优先级。如果新优先级的值高于最小和最大限制，则 setPriority()方法将引发 IllegalArgumentException。

示例:获取线程优先级

如果我们不设置线程的线程优先级，那么默认情况下它是由 JVM 设置的。在这个例子中，我们使用getPriority()方法获得线程的默认优先级。

    class MyThread extends Thread 
{ 
	public void run() 
	{ 
		System.out.println("Thread Running..."); 
	} 

	public static void main(String[]args) 
	{ 
		MyThread p1 = new MyThread(); 
		MyThread p2 = new MyThread(); 
		MyThread p3 = new MyThread(); 
		p1.start();
		System.out.println("P1 thread priority : " + p1.getPriority()); 
		System.out.println("P2 thread priority : " + p2.getPriority());  
		System.out.println("P3 thread priority : " + p3.getPriority()); 

	} 
}

P1 线程优先级:5 线程运行...P2 线程优先级:5 P3 线程优先级:5

示例:线程常数

我们可以通过使用 thread 类提供的一些预定义常数来获取线程的优先级。这些常量返回线程的最大、最小和正常优先级。

	 class MyThread extends Thread 
{ 
	public void run() 
	{ 
		System.out.println("Thread Running..."); 
	} 

	public static void main(String[]args) 
	{ 
		MyThread p1 = new MyThread(); 
		p1.start();
		System.out.println("max thread priority : " + p1.MAX_PRIORITY); 
		System.out.println("min thread priority : " + p1.MIN_PRIORITY);  
		System.out.println("normal thread priority : " + p1.NORM_PRIORITY); 

	} 
}

线程运行...最大线程优先级:10 分钟线程优先级:1 正常线程优先级:5

示例:设置优先级

要设置线程的优先级，使用Thread类的setPriority()方法。它采用一个必须介于 1 和 10 之间的整数参数。请参见下面的示例。

	 class MyThread extends Thread 
{ 
	public void run() 
	{ 
		System.out.println("Thread Running..."); 
	} 

	public static void main(String[]args) 
	{ 
		MyThread p1 = new MyThread();
		// Starting thread
		p1.start();
		// Setting priority
		p1.setPriority(2);
		// Getting priority
		int p = p1.getPriority();

		System.out.println("thread priority : " + p);  

	} 
}

线程优先级:2 线程运行...

示例:

在这个例子中，我们设置了两个线程的优先级，并运行它们来查看线程优先级的效果。设置更高优先级的线程会先得到 CPU 吗？见下面的例子。

	 class MyThread extends Thread 
{ 
	public void run() 
	{ 
		System.out.println("Thread Running... "+Thread.currentThread().getName()); 
	} 

	public static void main(String[]args) 
	{ 
		MyThread p1 = new MyThread();
		MyThread p2 = new MyThread();
		// Starting thread
		p1.start();
		p2.start();
		// Setting priority
		p1.setPriority(2);
		// Getting -priority
		p2.setPriority(1);
		int p = p1.getPriority();
		int p22 = p2.getPriority();

		System.out.println("first thread priority : " + p);  
		System.out.println("second thread priority : " + p22);

	} 
}

线程运行...线程 0 第一线程优先级:5 第二线程优先级:1 线程正在运行...线程 1

注意:线程优先级不能保证优先级较高的线程总是比优先级较低的线程先执行。执行线程的选择取决于依赖于平台的线程调度器。

Java 守护线程

原文：https://www.studytonight.com/java/daemon-thread-in-java.php

daemon-thread

以下是守护线程中的方法

1 . void set daemon(boolean status)

在 Java 中，此方法用于将当前线程创建为守护线程或用户线程。如果有一个用户线程作为 obj1，那么 obj1.setDaemon(true)将使它成为 Daemon 线程，如果有一个 Daemon 线程 obj2，那么调用 obj2.setDaemon(false)将使它成为用户线程。

语法:

public final void setDaemon(boolean on)

2 .boolean isDaemon()

在 Java 中，这个方法用来检查当前线程是否是守护进程。如果线程是守护进程，则返回真，否则返回假。

语法:

public final booleanisDaemon()

示例:

让我们创建一个创建守护进程和用户线程的示例。要创建守护线程，请使用 setdaemon()方法。它接受真或假的布尔值。

	 public class DaemonDemo1 extends Thread 
{ 
    public DaemonDemo1(String name1)
    { 
        super(name1); 
    } 
    public void run() 
    {  
        if(Thread.currentThread().isDaemon()) 
        {  
            System.out.println(getName() + " is Daemon thread");  
        }  
        else
        {  
            System.out.println(getName() + " is User thread");  
        }  
    }  
    public static void main(String[] args) 
    {  
        DaemonDemo1 D1 = new DaemonDemo1("D1"); 
        DaemonDemo1 D2 = new DaemonDemo1("D2"); 
        DaemonDemo1 D3 = new DaemonDemo1("D3"); 

        D1.setDaemon(true);      
        D1.start();  
        D2.start(); 
        D3.setDaemon(true);  
        D3.start();         
    }  
}

deamon-thread-example

示例:守护线程优先级

因为守护线程是低级线程，所以让我们检查这些线程的优先级。我们得到的优先级是由 JVM 设置的。

    public class DaemonDemo1 extends Thread 
{ 
    public DaemonDemo1(String name1)
    { 
        super(name1); 
    } 
    public void run() 
    {  
        if(Thread.currentThread().isDaemon()) 
        {  
            System.out.println(getName() + " is Daemon thread");

        }  
        else
        {  
            System.out.println(getName() + " is User thread");  
        }
        System.out.println(getName()+" priority "+Thread.currentThread().getPriority());
    }  
    public static void main(String[] args) 
    {  
        DaemonDemo1 D1 = new DaemonDemo1("D1"); 
        DaemonDemo1 D2 = new DaemonDemo1("D2"); 
        DaemonDemo1 D3 = new DaemonDemo1("D3"); 

        D1.setDaemon(true);   
        D1.start();  
        D2.start(); 
        D3.setDaemon(true);  
        D3.start();         
    }  
}

D1 是守护线程 D1 优先级 5 D2 是用户线程 D3 是守护线程 D2 优先级 5 D3 优先级 5

例子

创建守护线程时，确保在线程启动前调用 setDaemon()。在线程启动后调用它将引发异常并终止程序执行。

```java`
public class DaemonDemo1 extends Thread
{
public DaemonDemo1(String name1)
{
super(name1);
}
public void run()
{
if(Thread.currentThread().isDaemon())
{
System.out.println(getName() + " is Daemon thread");

    }  
    else
    {  
        System.out.println(getName() + " is User thread");  
    }
    System.out.println(getName()+" priority "+Thread.currentThread().getPriority());
}  
public static void main(String[] args) 
{  
    DaemonDemo1 D1 = new DaemonDemo1("D1"); 
    DaemonDemo1 D2 = new DaemonDemo1("D2"); 
    DaemonDemo1 D3 = new DaemonDemo1("D3"); 

    D1.setDaemon(true);   
    D1.start();  
    D2.start();
    D3.start();
    D3.setDaemon(true);  

}

}


D1 是线程“main”中的 Daemon threadException D1 优先级 5 D3 是用户线程 D2 是用户线程 D2 优先级 5 Java . lang . illegalthreadstatexception D3 优先级 5 在 Java . base/Java . lang . thread . setdaemon(thread . Java:1410)在 myjavaproject。daemondemo 1 . main(daemondemo 1 . Java:32)

* * *`

# Java 同步

> 原文：<https://www.studytonight.com/java/synchronization.php>

同步是通过多线程请求处理资源可访问性的过程。同步的主要目的是避免线程干扰。当多个线程试图访问共享资源时，我们需要确保一次只有一个线程使用资源。实现这一点的过程称为同步。java 中的 synchronization 关键字创建了一个称为临界区的代码块。

**一般语法:**

```java
synchronized (object)
{
  //statement to be synchronized
}

每个具有关键代码段的 Java 对象都会获得一个与该对象相关联的锁。要进入临界区，线程需要获得相应对象的锁。

为什么我们需要同步？

如果我们不使用同步，让两个或多个线程同时访问一个共享资源，会导致结果失真。

举个例子，假设我们有两个不同的线程 T1 和 T2 ，T1 开始执行，并将某些值保存在一个文件临时. txt 中，当 T1 返回时，该文件将用于计算一些结果。同时，T2 开始，在 T1 返回之前，T2 更改 T1 保存在文件临时. txt 中的值(临时. txt 是共享资源)。现在显然 T1 会返回错误的结果。

为了防止此类问题，引入了同步。有了上述情况下的同步，一旦 T1 开始使用临时. txt 文件，该文件将被锁定(锁定模式)，在 T1 返回之前，其他线程无法访问或修改。

使用同步方法

使用同步方法是实现同步的一种方式。但是让我们先看看当我们在程序中不使用同步时会发生什么。

没有同步的示例

在这个例子中，我们没有使用同步并创建多个线程来访问显示方法并产生随机输出。

class First
{
  public void display(String msg)
  {
    System.out.print ("["+msg);
    try
    {
      Thread.sleep(1000);
    }
    catch(InterruptedException e)
    {
      e.printStackTrace();
    }
    System.out.println ("]");
  }
}

class Second extends Thread
{
  String msg;
  First fobj;
  Second (First fp,String str)
  {
    fobj = fp;
    msg = str;
    start();
  }
  public void run()
  {
    fobj.display(msg);
  }
}

public class Syncro
{
  public static void main (String[] args)
  {
    First fnew = new First();
    Second ss = new Second(fnew, "welcome");
    Second ss1= new Second(fnew,"new");
    Second ss2 = new Second(fnew, "programmer");
  }
}

[欢迎[新[程序员] ] ]

在上面的程序中，类 First 的对象 fnew 被所有三个运行线程(ss、ss1 和 ss2)共享，以调用共享方法(void 显示)。因此结果是不同步的，这种情况被称为比赛状态..

同步关键字

要同步上述程序，我们必须同步对共享的 display() 方法的访问，使其一次只对一个线程可用。这是通过使用关键字将与 display()方法同步来完成的。

synchronized void display (String msg)

示例:同步方法的实现

class First
{
  synchronized public void display(String msg)
  {
    System.out.print ("["+msg);
    try
    {
      Thread.sleep(1000);
    }
    catch(InterruptedException e)
    {
      e.printStackTrace();
    }
    System.out.println ("]");
  }
}

class Second extends Thread
{
  String msg;
  First fobj;
  Second (First fp,String str)
  {
    fobj = fp;
    msg = str;
    start();
  }
  public void run()
  {
    fobj.display(msg);
  }
}

public class MyThread
{
  public static void main (String[] args)
  {
    First fnew = new First();
    Second ss = new Second(fnew, "welcome");
    Second ss1= new Second(fnew,"new");
    Second ss2 = new Second(fnew, "programmer");
  }
}

[欢迎][程序员][新]

使用同步块

如果想要同步对一个类的对象的访问或者只同步一个方法的一部分，那么我们可以使用同步块。它能够使对象和方法的任何部分同步。

例子

在这个例子中，我们使用了同步块，这将使显示方法一次可用于单线程。

  class First
{
  public void display(String msg)
  {
    System.out.print ("["+msg);
    try
    {
      Thread.sleep(1000);
    }
    catch(InterruptedException e)
    {
      e.printStackTrace();
    }
    System.out.println ("]");
  }
}

class Second extends Thread
{
  String msg;
  First fobj;
  Second (First fp,String str)
  {
    fobj = fp;
    msg = str;
    start();
  }
  public void run()
  {
    synchronized(fobj)      //Synchronized block
    {
      fobj.display(msg);
    }
  }
}

public class MyThread
{
  public static void main (String[] args)
  {
    First fnew = new First();
    Second ss = new Second(fnew, "welcome");
    Second ss1= new Second (fnew,"new");
    Second ss2 = new Second(fnew, "programmer");
  }
}

[欢迎][新][程序员]

由于同步块，这个程序给出了预期的输出。

同步关键字和同步块之间的区别

当我们对一个方法使用 synchronized 关键字时，它会为整个方法获取对象中的锁。这意味着在调用了同步方法的当前线程完成执行之前，没有其他线程可以使用任何同步方法。

synchronized 块仅在 synchronized 关键字后的括号之间获取对象中的锁。这意味着在同步块退出之前，没有其他线程可以获取锁定对象的锁。但是其他线程可以访问该方法的其余代码。

同步方法和同步块哪个更好？

在 Java 中，synchronized 关键字会导致性能损失。Java 中的同步方法非常慢，会降低性能。因此，我们必须在必要时使用 java 中的同步关键字，否则，我们应该使用仅用于同步关键部分的 Java synchronized block。

Java 线程间通信

原文：https://www.studytonight.com/java/interthread-communication.php

Java 提供了避免使用线程间通信的线程池的好处。对象类的wait()、notify()和notifyAll()方法用于此目的。这些方法在对象中作为最终方法实现，因此所有类都有它们。所有这三个方法只能从一个同步的上下文中调用

wait()告诉调用线程放弃监视器并进入睡眠，直到其他线程进入同一个监视器并调用 notify。
notify()唤醒同一对象上调用 wait()的线程。
notifyAll()唤醒同一对象上所有调用 wait()的线程。

`wait()`和`sleep()`的区别

线程池

池化通常通过循环实现，即重复检查某些条件。一旦条件成立，就采取适当的措施。这浪费了 CPU 时间。

Java 中的线程死锁

Deadlock condition in Multithreading

死锁是一种完全锁定的情况，此时没有线程可以因为缺乏资源而完成其执行。上图中，线程 1 持有资源 R1，需要另一个资源 R2 来完成执行，但是 R2 被线程 2 锁定，线程 2 需要 R3，R3 又被线程 3 锁定。因此，他们中没有一个人能完成任务，陷入僵局。

例子

在本例中，多个线程正在访问导致死锁情况的同一方法。当一个线程持有该资源并且不释放它时，其他线程将会等待，并且在死锁条件下，等待时间永远不会结束。

class Pen{}
class Paper{}

public class Write {

  public static void main(String[] args)
  {
     final Pen pn =new Pen();
     final Paper pr =new Paper();

     Thread t1 = new Thread() {
        public void run()
        {
            synchronized(pn)
            {
                System.out.println("Thread1 is holding Pen");
                try{
                    Thread.sleep(1000);
                }
                catch(InterruptedException e){
                  // do something
                }
                synchronized(pr)
                {  
                  System.out.println("Requesting for Paper"); 
                }
            }
        }
      };
      Thread t2 = new Thread() {
          public void run()
          {
              synchronized(pr)
              {
                  System.out.println("Thread2 is holding Paper");
                  try {
                      Thread.sleep(1000);
                  }
                  catch(InterruptedException e){
                      // do something
                  }
                  synchronized(pn)
                  {  
                      System.out.println("requesting for Pen"); 
                  }
              }
          }
      };

      t1.start();
      t2.start();
  }
}

线 1 拿着笔线 2 拿着纸

Java 线程组

原文：https://www.studytonight.com/java/java-thread-group.php

线程组是一个用于创建线程组的类。这组线程是树结构的形式，其中初始线程是父线程。一个线程可以拥有组中其他线程的所有信息，但是可以拥有其他组的线程的信息。这在我们想要暂停和恢复大量线程的情况下非常有用。这个线程组是由 java.lang.ThreadGroup 类实现的。

线程组中有两种类型的构造器，如下所示:

1.公共线程组(字符串名称)

2.公共线程组(线程组父级，字符串名称)

以下是线程组中的方法

1。checkAccess()

在 Java 中，checkAccess()方法属于 ThreadGroup 类。用于检查线程组中运行的线程是否有修改权限。

语法

	 public final void checkAccess()

示例:

	 class ThreadDemo1_1 extends Thread   
{  
    ThreadDemo1_1(String a, ThreadGroup b)  
    {  
        super(b, a);  
    }  
    public void run()  
    {  
        for (int i = 0; i< 10; i++)   
        {  
            try  
            {  
                Thread.sleep(10);  
            }  
            catch (InterruptedException ex)   
            {  
                System.out.println(Thread.currentThread().getName());  
            }  
        }  
        System.out.println(Thread.currentThread().getName());  
    }  
}   
public class ThreadDemo1
{  
    public static void main(String arg[]) throws InterruptedException, SecurityException
    {  

        ThreadGroup obj1 = new ThreadGroup("Parent thread =====> ");  
        ThreadGroup obj2 = new ThreadGroup(obj1, "child thread =====> ");  
        ThreadDemo1_1 t1 = new ThreadDemo1_1("*******Thread-1*******", obj1);  
        t1.start();   
        ThreadDemo1_1 t2 = new ThreadDemo1_1("*******Thread-2*******", obj1);  
        t2.start();   
        obj1.checkAccess();  
        System.out.println(obj1.getName() + " has access");  
        obj2.checkAccess();  
        System.out.println(obj2.getName() + " has access");  
    }  
}

thread-group-example

2 .activeCount()

在 Java 中，activeCount()方法属于 ThreadGroup 类。它用于统计组中当前正在运行的活动线程。

	 public static int activeCount()

示例:

	 class Demo2 extends Thread   
{  
    Demo2 (String a, ThreadGroup b)  
    {  
        super(b, a);  
    }  
    public void run()  
    {  
        for (inti = 0; i< 10; i++)   
        {  
            try  
            {  
                Thread.sleep(10);  
            }  
            catch (InterruptedException ex)   
            {  
                Syste  m.out.println(Thread.currentThread().getName());  
            }  
        }  
            System.out.println(Thread.currentThread().getName());  
    }  
}   
public class ThreadDemo2
{  
    public static void main(String arg[])  
    {  
        ThreadGroup o1 = new ThreadGroup("parent thread group");   
        Demo2 obj1 = new Demo2 ("Thread 1 =====> ", o1);  
        Demo2 obj2 = new Demo2 ("Thread 2 =====> ", o1);  
        Demo2 obj3 = new Demo2 ("Thread 3 =====> ", o1);  
    	Demo2 obj4 = new Demo2 ("Thread 4 =====> ", o1);  
        Demo2 obj5 = new Demo2 ("Thread 5 =====> ", o1);  
        Demo2 obj6 = new Demo2 ("Thread 6 =====> ", o1); 
        obj1.start();  
        obj2.start();  
        obj3.start(); 
    	obj4.start();
    	obj5.start();
    	obj6.start();
        System.out.println("Total number of active thread =====> "+ o1.activeCount());  
    }  
}

thread-group-example-2

3 .activeGroupCount()

在 Java 中，activeGroupCount()方法属于 ThreadGroup 类。它用于计算当前正在运行的活动线程组。

语法公共 int activeGroupCount()。

	 public int activeGroupCount().

示例:

	 class Demo2 extends Thread   
{  
    Demo2 (String a, ThreadGroup b)  
    {  
        super(b, a);  
    }  
    public void run()  
    {  
        for (inti = 0; i< 10; i++)   
        {  
            try  
            {  
                Thread.sleep(10);  
            }  
            catch (InterruptedException ex)   
            {  
                System.out.println(Thread.currentThread().getName());  
            }  
        }  
        System.out.println(Thread.currentThread().getName()+" =====> completed executing");  
    }  
}   
public class ThreadDemo2
{  
    public static void main(String arg[])  
    {  
        ThreadGroup o1 = new ThreadGroup("parent thread group");   
        ThreadGroup o2 = new ThreadGroup(o1,"Child thread group");   
        ThreadGroup o3 = new ThreadGroup(o1,"parent thread group");   

        Demo2 obj1 = new Demo2("*****Thread 1*****",o1);
        System.out.println(obj1.getName() + " =====> starts");  

        obj1.start(); 

        System.out.println("Total number of active thread =====> "+ o1.activeGroupCount());  
    }  
}

thread-group-example

4。销毁()

在 Java 中，destroy()方法是 ThreadGroup 的。它用来摧毁一个线程组。要销毁任何线程组，必须停止该组中的所有线程。

语法

	 public void destroy()

示例:

	 class Demo2 extends Thread   
{  
    Demo2 (String a, ThreadGroup b)  
    {  
        super(b, a);  
    }  
    public void run()  
    {  
        for (inti = 0; i< 10; i++)   
        {  
            try  
            {  
                Thread.sleep(10);  
            }  
            catch (InterruptedException ex)   
            {  
                System.out.println(Thread.currentThread().getName());  
            }  
        }  
        System.out.println(Thread.currentThread().getName()+" =====> completed executing");  
    }  
}   
public class ThreadDemo2
{  
    public static void main(String arg[])  throws InterruptedException, SecurityException
    {  
        ThreadGroup o1 = new ThreadGroup("*****parent thread group*****");   
        ThreadGroup o2 = new ThreadGroup(o1,"*****Child thread group*****");   

        Demo2 obj1 = new Demo2("*****Thread 1*****",o1);  
        obj1.start(); 
        Demo2 obj2 = new Demo2("*****Thread 2*****",o1);  
        obj2.start(); 

        obj1.join();
        obj2.join();

        o2.destroy();
        System.out.println(o2.getName()+" ====> Destroyed");
        o1.destroy();
        System.out.println(o1.getName()+" ====> Destroyed");
    }  
}

thread-group-example

5。枚举(线程[]列表)

在 Java 中，enumerate()方法属于 ThreadGroup 类。它用于将活动线程复制到指定的数组中。

	 public int enumerate(Thread[] array)

示例:

	 class Demo2 extends Thread   
{  
    Demo2 (String a, ThreadGroup b)  
    {  
super(b, a);  
    }  
    public void run()  
    {  
        for (inti = 0; i< 10; i++)   
        {  
            try  
            {  
Thread.sleep(10);  
            }  
            catch (InterruptedException ex)   
            {  
System.out.println(Thread.currentThread().getName());  
            }  
        }  
System.out.println(Thread.currentThread().getName()+" =====> completed executing");  
    }  
}   
public class ThreadDemo2
{  
    public static void main(String arg[])  
    {  
ThreadGroup o1 = new ThreadGroup("*****parent thread group*****");   
ThreadGroup o2 = new ThreadGroup(o1,"*****Child thread group*****");   

	Demo2 obj1 = new Demo2("*****Thread 1*****",o1); 
	System.out.println("Thread 1 Starts"); 
        obj1.start(); 
	Demo2 obj2 = new Demo2("*****Thread 2*****",o1);  
	System.out.println("Thread 2 Starts"); 
        obj2.start(); 

	Thread[] tarray = new Thread[o1.activeCount()];  
int count1 = o1.enumerate(tarray);  

        for (inti = 0; i< count1; i++)   
System.out.println(tarray[i].getName() + " =====> Found");          

	}  
}

thread-group-example

6。get axpriority()

在 Java 中，getMaxPriority()方法属于 ThreadGroup 类。它用于检查线程组的最大优先级。

语法

	 public final int getMaxPriority()

示例:

	 class Demo2 extends Thread   
{  
    Demo2 (String a, ThreadGroup b)  
    {  
        super(b, a);  
    }  
    public void run()  
    {  
        for (inti = 0; i< 10; i++)   
        {  
            try  
            {  
                Thread.sleep(10);  
            }  
            catch (InterruptedException ex)   
            {  
                System.out.println(Thread.currentThread().getName());  
            }  
        }  
        System.out.println(Thread.currentThread().getName()+" =====> completed executing");  
    }  
}   
public class ThreadDemo2
{  
    public static void main(String arg[])  
    {  
        ThreadGroup o1 = new ThreadGroup("*****parent thread group*****");
        System.out.println("Maximum priority of Parent Thread: " + o1.getMaxPriority());   
        ThreadGroup o2 = new ThreadGroup(o1,"*****Child thread group*****"); 
        System.out.println("Maximum priority of Child Thread: " + o2.getMaxPriority());
        Demo2 obj1 = new Demo2("*****Thread 1*****",o1); 
        System.out.println("Thread 1 Starts"); 
        obj1.start(); 
        Demo2 obj2 = new Demo2("*****Thread 2*****",o1);  
        System.out.println("Thread 2 Starts"); 
        obj2.start();           

    }  
}

thread-group-example

7.getName（）

在 Java 中，getName()方法属于 ThreadGroup 类。它用于获取当前线程组的名称。

	 public final String getName()

示例:

	 class Demo3 extends Thread   
{  
    Demo3(String a, ThreadGroup b)  
    {  
        super(b, a);  
        start();  
    }  
    public void run()  
    {  
        System.out.println(Thread.currentThread().getName());  
    }  
}   
public class ThreadDemo3
{  
    public static void main(String arg[]) throws InterruptedException,  
    SecurityException, Exception  
    {  
        ThreadGroup o1 = new ThreadGroup("*****Parent thread*****");  
        ThreadGroup o2 = new ThreadGroup(o1, "*****Child thread*****");  

        Demo3 obj1 = new Demo3("Thread-1", o1);  
        System.out.println("Name of First threadGroup : " +obj1.getThreadGroup().getName());  

        Demo3 obj2 = new Demo3("Thread-2", o2);  
        System.out.println("Name of Second threadGroup: " +obj2.getThreadGroup().getName());  
    }  
}

thread-group-example

8 .get arent()

在 Java 中，getParent()方法属于 ThreadGroup 类。它用于从线程组中获取父线程。

	 public final ThreadGroup getParent()

示例:

	 class Demo3 extends Thread   
{  
    Demo3(String a, ThreadGroup b)  
    {  
        super(b, a);  
        start();  
    }  
    public void run()  
    {  
        System.out.println(Thread.currentThread().getName());  
    }  
}   
public class ThreadDemo3
{  
    public static void main(String arg[]) throws InterruptedException,  SecurityException, Exception  
    {  
        ThreadGroup o1 = new ThreadGroup("*****Parent thread*****");  
        ThreadGroup o2 = new ThreadGroup(o1, "*****Child thread*****");  

        Demo3 obj1 = new Demo3("Thread-1", o1);  
        System.out.println("Thread one starting");  
        obj1.start();

        Demo3 obj2 = new Demo3("Thread-2", o2);  
        System.out.println("Thread second starting");
        obj2.start();

        System.out.println("Parent Thread Group for " + o1.getName() + " is " + o1.getParent().getName());  

        System.out.println("Parent Thread Group for " + o2.getName() + " is " + o2.getParent().getName());               
    }    
}

thread-group-example

9。中断()

在 Java 中，interrupt()方法属于 ThreadGroup 类。它用于中断线程组的所有线程。

语法

	 public final void interrupt()

示例:

	 class Demo2 extends Thread   
{  
    Demo2 (String a, ThreadGroup b)  
    {  
        super(b, a);  
    }  
    public void run()  
    {  
        for (inti = 0; i< 10; i++)   
        {  
            try  
            {  
                Thread.sleep(10);  
            }  
            catch (InterruptedException ex)   
            {  
                System.out.println(Thread.currentThread().getName()+ " =====> interrupted");  
            }  
        }  
        System.out.println(Thread.currentThread().getName()+" =====> completed executing");  
    }  
}   
public class ThreadDemo2
{  
    public static void main(String arg[]) throws InterruptedException, SecurityException
    {  
        ThreadGroup o1 = new ThreadGroup("*****parent thread group*****");
        ThreadGroup o2 = new ThreadGroup(o1,"*****Child thread group*****");  

        Demo2 obj1 = new Demo2("*****Thread 1*****",o1); 
        System.out.println(obj1.getName()+"Thread 1 Starts"); 
        obj1.start();
        o1.interrupt();  

        Demo2 obj2 = new Demo2("*****Thread 2*****",o1);  
        System.out.println(obj2.getName()+"Thread 2 Starts"); 
        obj2.start();           

    }  
}

thread-group-example

10。isDaemon()

在 Java 中，isDaemon()方法属于 ThreadGroup 类。它用于检查一个线程是否是 Daemon 线程。

语法

	 public final boolean isDaemon()

示例:

	 class Demo4 extends Thread   
{  
    Demo4(String a, ThreadGroup b)  
    {  
        super(b, a);  
    }  
    public void run()  
    {  
        for(inti = 0;i < 10;i++)   
            {  
                i++;  
            }  
        System.out.println(Thread.currentThread().getName() + " ====> Execution Finished");  
    }  
}  
public class ThreadDemo4
{  
    public static void main(String arg[]) throws InterruptedException, SecurityException, Exception  
    { 
        ThreadGroup o1 = new ThreadGroup("*****Parent thread*****");  
        Demo4 obj1 = new Demo4 ("*****Thread-1*****", o1);  
        obj1.start();   
        System.out.println("Is " + o1.getName() + " a daemon threadGroup? " + o1.isDaemon());  
    }  
}

thread-group-example

11。setDaemon(Boolean daemon)

在 Java 中，setDaemon()方法属于 ThreadGroup 类。它用于使一个线程成为守护线程。

语法:

	 public final void setDaemon(boolean daemon)

示例:

	 class Demo4 extends Thread   
{  
    Demo4(String a, ThreadGroup b)  
    {  
        super(b, a);  
    }  
    public void run()  
    {  
        for(int i = 0;i < 10;i++)   
        {  
            i++;  
        }  
        System.out.println(Thread.currentThread().getName() + " ====> Execution Finished");  
    }  
}  
public class ThreadDemo4
{  
    public static void main(String arg[]) throws InterruptedException, SecurityException, Exception  
    {  

        ThreadGroup o1 = new ThreadGroup("*****Parent thread*****");  
        o1.setDaemon(true);
        ThreadGroup o2 = new ThreadGroup("*****Child thread*****");  
        o2.setDaemon(true);

        Demo4 obj1 = new Demo4 ("*****Thread-1*****", o1);  
        obj1.start();   
        Demo4 obj2 = new Demo4 ("*****Thread-2*****", o2);  
        obj2.start();   
        System.out.println("Is " + o1.getName() + " a daemon threadGroup? " + o1.isDaemon());  
        System.out.println("Is " + o2.getName() + " a daemon threadGroup? " + o2.isDaemon());         

    }  
}

12。isdstoryed()

在 Java 中，isDestroyed()方法属于 ThreadGroup 类。用于检查线程组是否被破坏。

语法

	 public boolean isDestroyed()

示例:

	 class Demo4 extends Thread   
{  
    Demo4(String a, ThreadGroup b)  
    {  
        super(b, a);  
    }  
    public void run()  
    {  
        for(int i = 0;i < 10;i++)   
        {  
            i++;  
        }  
        System.out.println(Thread.currentThread().getName() + " ====> Execution Finished");  
    }  
}  
public class ThreadDemo4
{  
    public static void main(String arg[]) throws InterruptedException, SecurityException, Exception  
    {  

        ThreadGroup o1 = new ThreadGroup("*****Parent thread*****");  
        ThreadGroup o2 = new ThreadGroup("*****Child thread*****");  

        Demo4 obj1 = new Demo4 ("*****Thread-1*****", o1); 
        System.out.println("Starting Thread 1"); 
        obj1.start();   
        Demo4 obj2 = new Demo4 ("*****Thread-2*****", o2); 
        System.out.println("Starting Thread 2");  
        obj2.start();   
        if(o1.isDestroyed()==true)
            System.out.println("The Group is destroyed");
        else
            System.out.println("The Group is not destroyed");
    }  
}

thread-group-example

13。list()

在 Java 中，list()方法属于 ThreadGroup 类。它用于获取关于线程组的所有信息。它在调试时非常有用。

语法

	 public void list()

示例:

	 class Demo4 extends Thread   
{  
    Demo4(String a, ThreadGroup b)  
    {  
        super(b, a);  
    }  
    public void run()  
    {  
        for(int i = 0;i < 10;i++)   
        {  
            i++;  
        }  
        System.out.println(Thread.currentThread().getName() + " ====> Execution Finished");  
    }  
}  
public class ThreadDemo4
{  
    public static void main(String arg[]) throws InterruptedException, SecurityException, Exception  
    {  

        ThreadGroup o1 = new ThreadGroup("*****Parent thread*****");  
        ThreadGroup o2 = new ThreadGroup("*****Child thread*****");  

        Demo4 obj1 = new Demo4("*****Thread-1*****", o1); 
        System.out.println(obj1.getName()+"Starting Thread 1"); 
        obj1.start();  

        Demo4 obj2 = new Demo4 ("*****Thread-2*****", o2); 
        System.out.println(obj2.getName()+"Starting Thread 2"); 
        obj2.start(); 

        System.out.println("List of parent Thread Group: " + o1.getName() + ":");  
        o1.list();
    }  
}

thread-group-example

14。ParentOf(ThreadGroup g)

在 Java 中，ParentOf()方法属于 ThreadGroup 类。它用于检查当前运行的线程是否是哪个线程组的父线程。

语法

	 public final boolean parentOf(ThreadGroup g)

示例:

	 class Demo4 extends Thread   
{  
    Demo4(String a, ThreadGroup b)  
    {  
        super(b, a);  
    }  
    public void run()  
    {  
        for(int i = 0;i < 10;i++)   
        {  
            i++;  
        }  
        System.out.println(Thread.currentThread().getName() + " ====> Execution Finished");  
    }  
}  
public class ThreadDemo4
{  
    public static void main(String arg[]) throws InterruptedException, SecurityException, Exception  
    {  

        ThreadGroup o1 = new ThreadGroup("*****Parent thread*****");  
        ThreadGroup o2 = new ThreadGroup("*****Child thread*****");  

        Demo4 obj1 = new Demo4("*****Thread-1*****", o1); 
        System.out.println(obj1.getName()+"Starting Thread 1"); 
        obj1.start();  

        Demo4 obj2 = new Demo4 ("*****Thread-2*****", o2); 
        System.out.println(obj2.getName()+"Starting Thread 2"); 
        obj2.start(); 

        boolean isParent = o2.parentOf(o1);  
        System.out.println(o2.getName() + " is the parent of " + o1.getName() +": "+ isParent);  

        isParent = o1.parentOf(o2);  
        System.out.println(o1.getName() + " is the parent of " + o2.getName() +": "+ isParent);  
    }  
}

thread-group-example

15。suspend()

在 Java 中，suspend()方法属于 ThreadGroup 类。它用于挂起线程组的所有线程。

语法

	 public final void suspend()

示例:

	 class Demo4 extends Thread   
{  
    Demo4(String a, ThreadGroup b)  
    {  
        super(b, a);  
    }  
    public void run()  
    {  
        for(int i = 0;i < 10;i++)   
        {  
            i++;  
        }  
        System.out.println(Thread.currentThread().getName() + " ====> Execution Finished");  
    }  
}  
public class ThreadDemo4
{  
    public static void main(String arg[]) throws InterruptedException, SecurityException, Exception  
    {  

        ThreadGroup o1 = new ThreadGroup("*****Parent thread*****");  
        ThreadGroup o2 = new ThreadGroup("*****Child thread*****");  

        Demo4 obj1 = new Demo4("*****Thread-1*****", o1); 
        System.out.println(obj1.getName()+"Starting Thread 1"); 
        obj1.start();  

        Demo4 obj2 = new Demo4 ("*****Thread-2*****", o2); 
        System.out.println(obj2.getName()+"Starting Thread 2"); 
        obj2.start(); 

        o1.suspend();   
    }  
}

thread-group-example

16。简历()

在 Java 中，resume()方法属于 ThreadGroup 类。它用于恢复线程组中所有挂起的线程。

语法

	 public final void resume()

示例:

	 class Demo4 extends Thread   
{  
    Demo4(String a, ThreadGroup b)  
    {  
        super(b, a);  
    }  
    public void run()  
    {  
        for(int i = 0;i < 10;i++)   
        {  
            i++;  
        }  
        System.out.println(Thread.currentThread().getName() + " ====> Execution Finished");  
    }  
}  
public class ThreadDemo4
{  
    public static void main(String arg[]) throws InterruptedException, SecurityException, Exception  
    {  

        ThreadGroup o1 = new ThreadGroup("*****Parent thread*****");  
        ThreadGroup o2 = new ThreadGroup("*****Child thread*****");  

        Demo4 obj1 = new Demo4("*****Thread-1*****", o1); 
        System.out.println(obj1.getName()+"Starting Thread 1"); 
        obj1.start();
        o1.suspend();  

        Demo4 obj2 = new Demo4 ("*****Thread-2*****", o2); 
        System.out.println(obj2.getName()+"Starting Thread 2"); 
        obj2.start(); 
        o1.resume();
    }  
}

17。setmaxpriority(inti)

在 Java 中，setMaxPriority()方法属于 ThreadGroup 类。它用于设置线程组的最大优先级。

语法

	 public final void setMaxPriority(int pri)

示例:

	 class Demo5 extends Thread   
{  
    Demo5(String a, ThreadGroup b)  
    {  
        super(b, a);  
    }  
    public void run()  
    {  
        for (int i = 0; i< 10; i++)   
        {  
            try  
            {  
                Thread.sleep(10);  
            }  
            catch (InterruptedException ex) {  
                System.out.println("Thread " + Thread.currentThread().getName() + " =====> Interrupted"); }  
        }  
        System.out.println(Thread.currentThread().getName() + " [Priority = " +   
                Thread.currentThread().getPriority() + "]");  
        System.out.println(Thread.currentThread().getName()+" =====> Execution finish");  
    }  
}   
public class ThreadDemo5
{  
    public static void main(String arg[]) throws InterruptedException,  
    SecurityException, Exception  
    {  
        ThreadGroup o1 = new ThreadGroup("*****Parent threadGroup*****");  
        ThreadGroup o2 = new ThreadGroup(o1, "*****Child threadGroup*****");  
        o1.setMaxPriority(Thread.MAX_PRIORITY-3);  
        o2.setMaxPriority(Thread.MIN_PRIORITY);  

        Demo5 obj1 = new Demo5("*****Thread-1*****", o1);  
        obj1.setPriority(Thread.MAX_PRIORITY);  
        System.out.println(obj1.getName() + " ====> starts");  
        obj1.start();  

        Demo5 obj2 = new Demo5("*****Thread-2*****", o2);  
        obj2.setPriority(Thread.MAX_PRIORITY);  
        System.out.println(obj2.getName() + " ====> starts");  
        obj2.start();  
    }  
}

thread-group-example

18。stop()

在 Java 中，stop()方法属于 ThreadGroup 类。它用于停止线程组的线程。

语法

	 public final void stop()

示例:

	 class Demo5 extends Thread   
{  
    Demo5(String a, ThreadGroup b)  
    {  
        super(b, a);  
    }  
    public void run()  
    {  
        for (int i = 0; i< 10; i++)   
        {  
            try  
            {  
                Thread.sleep(10);  
            }  
            catch (InterruptedException ex) {  
                System.out.println("Thread " + Thread.currentThread().getName() + " =====> Interrupted"); }  
        }  
        System.out.println(Thread.currentThread().getName() + " [Priority = " +   
                Thread.currentThread().getPriority() + "]");  
        System.out.println(Thread.currentThread().getName()+" =====> Execution finish");  
    }  
}   
public class ThreadDemo5
{  
    public static void main(String arg[]) throws InterruptedException,  
    SecurityException, Exception  
    {  
        ThreadGroup o1 = new ThreadGroup("*****Parent threadGroup*****");  
        ThreadGroup o2 = new ThreadGroup(o1, "*****Child threadGroup*****");  
        o1.setMaxPriority(Thread.MAX_PRIORITY-3);  
        o2.setMaxPriority(Thread.MIN_PRIORITY);  

        Demo5 obj1 = new Demo5("*****Thread-1*****", o1);    
        System.out.println("Thread one starting");  
        obj1.start();  

        Demo5 obj2 = new Demo5("*****Thread-2*****", o2);  
        System.out.println("Thread second starting");  
        obj2.start(); 

        o1.stop(); 
    }  
}

thread-group-example

19。toString()

在 Java 中，toString()方法属于 ThreadGroup 类。它用于获取线程组的字符串表示形式。

语法

	 public String toString()

示例:

	 class Demo5 extends Thread   
{  
    Demo5(String a, ThreadGroup b)  
    {  
        super(b, a);  
    }  
    public void run()  
    {  
        for (int i = 0; i< 10; i++)   
        {  
            try  
            {  
                Thread.sleep(10);  
            }  
            catch (InterruptedException ex) {  
                System.out.println("Thread " + Thread.currentThread().getName() + " =====> Interrupted"); }  
        }  
        System.out.println(Thread.currentThread().getName() + " [Priority = " +   
                Thread.currentThread().getPriority() + "]");  
        System.out.println(Thread.currentThread().getName()+" =====> Execution finish");  
    }  
}   
public class ThreadDemo5
{  
    public static void main(String arg[]) throws InterruptedException,  
    SecurityException, Exception  
    {  
        ThreadGroup o1 = new ThreadGroup("*****Parent threadGroup*****");  
        ThreadGroup o2 = new ThreadGroup(o1, "*****Child threadGroup*****");  

        Demo5 obj1 = new Demo5("*****Thread-1*****", o1);    
        System.out.println(obj1.getName() + " ====> starts");  
        obj1.start();  

        Demo5 obj2 = new Demo5("*****Thread-2*****", o2);  
        System.out.println(obj2.getName() + " ====> starts");  
        obj2.start();  
        System.out.println("String equivalent: " + o1.toString()); 

        System.out.println("String equivalent: " + o2.toString()); 
    }  
}

thread-group-example

高级概念

Java 枚举

原文：https://www.studytonight.com/java/enumerations.php

在 JDK5 中，枚举被添加到 Java 语言中。枚举是指命名常量的列表。在 Java 中，枚举定义了一个Class类型。枚举可以有构造器、方法和实例变量。它是使用枚举关键字创建的。每个枚举常量默认为公共、静态和最终。即使枚举定义了一个Class类型并有构造器，您也不能使用 new 实例化一个枚举。枚举变量的使用和声明方式与原始变量非常相似。

如何定义和使用枚举

枚举可以简单地通过创建枚举变量列表来定义。让我们举一个主题变量列表的例子，列表中有不同的主题。
```
//Enumeration defined
enum Subject           
{
	Java, Cpp, C, Dbms
}
```
标识符 Java、Cpp、C 和 Dbms 称为枚举常量。默认情况下，这些是公共的、静态的和最终的。
枚举的变量可以直接定义，不需要任何新的关键字。

枚举示例

让我们创建一个示例来定义枚举，并通过使用枚举引用变量来访问其常量。

enum WeekDays{ 
	SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY 
}

class Demo
{
	public static void main(String args[])
	{
		WeekDays wk; 			//wk is an enumeration variable of type WeekDays
		wk = WeekDays.SUNDAY; 	//wk can be assigned only the constants defined under enum type Weekdays
		System.out.println("Today is "+wk);
	}
}

今天是星期天

使用`switch`语句的枚举示例

枚举可以在 switch case 中用来创建决策应用，这里我们已经创建了一个可以用来挑选用户选择餐厅的餐厅枚举。

enum Restaurants {
dominos, kfc, pizzahut, paninos, burgerking
}
class Test {
public static void main(String args[])
{
Restaurants r;
r = Restaurants.paninos;
switch(r) { //The name of the enumertion constants are used without their enumeration
type name i.e only r, not Restaurants.r
case dominos: //only constants defined under enum Restaurants can be used
System.out.println("I AM " + r.dominos);
break;
case kfc:
System.out.println("I AM " + r.kfc);
break;
case pizzahut:
System.out.println("I AM " + r.pizzahut);
break;
case paninos:
System.out.println("I AM " + r.paninos);
break;
case burgerking:
System.out.println("I AM " + r.burgerking);
break;
}
}
}

我是帕尼诺斯

示例:If-Else 中的枚举

枚举可以在 if 语句中用来将一个值与一些预定义的常数进行比较。这里我们使用了带有 if else 语句的枚举。

	 enum WeekDays{ 
	SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY 
}

class Demo {
	public static void main(String args[])
	{
		WeekDays weekDays = WeekDays.WEDNESDAY;

		if(weekDays == WeekDays.SUNDAY || weekDays == WeekDays.SATURDAY)
			System.out.println("It is Weekend");
		else 
			System.out.println("It is weekday: "+weekDays);

	}
}

今天是工作日:星期三

示例:遍历枚举元素

我们可以通过调用枚举元素的静态方法值()来迭代枚举元素。此方法返回所有枚举常数的数组，这些常数还可以使用 for 循环进行迭代。见下面的例子。

	 enum WeekDays{ 
	SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY 
}

class Demo {
	public static void main(String args[])
	{
		WeekDays[] weekDays = WeekDays.values();

		for(WeekDays weekday : weekDays ){

			System.out.println(weekday);

		}	
	}
}

周日周一周二周三周四周五周六

Values()和 ValueOf()方法

所有枚举预定义方法值()和值()。values()方法返回一个枚举类型的数组，其中包含所有枚举常量。它的一般形式是，

public **static** *enum-type[ ]* **values()**

valueOf()方法用于返回枚举常量，其值等于调用此方法时作为参数传入的字符串。它的一般形式是，

public **static** *enum-type* **valueOf** (String *str*)

使用 values()和 valueOf()方法的枚举示例:

Value 和 valueOf 都是枚举类型的静态方法，可用于访问枚举元素。这里我们使用这两种方法来访问枚举元素。

 enum Restaurants {
	DOMINOS, KFC, PIZZAHUT, PANINOS, BURGERKING
}
class Demo {
	public static void main(String args[])
	{
		Restaurants r;
		System.out.println("All constants of enum type Restaurants are:");
		Restaurants  rArray[] = Restaurants.values(); //returns an array of constants of type Restaurants
		for(Restaurants  a : rArray) //using foreach loop
			System.out.println(a);

		r = Restaurants.valueOf("DOMINOS");
		System.out.println("It is " + r);
	}
}

枚举类型餐厅的所有常量都是:DOMINOS KFC PIZZAHUT PANINOS BURGERKING 它是 DOMINOS

关于枚举需要记住的要点

枚举属于Class类型，具有 Java 类所具有的所有功能。
枚举可以有构造器、实例变量、方法，甚至可以实现接口。
枚举不使用 new 关键字进行实例化。
默认情况下，所有枚举都继承 java.lang.Enum 类。

带有构造器、实例变量和方法的枚举

枚举类似于类，只是它不能实例化。它可以有方法、构造器、变量等。在这个例子中，我们在 enum 中创建构造器和方法，并使用它们访问其常量值。

enum Student
{
	John(11), Bella(10), Sam(13), Viraaj(9);
	private int age;                   //variable defined in enum Student
	int getage() { return age; }  //method defined in enum Student
	private Student(int age)  //constructor defined in enum Student
	{
		this.age= age;
	}
}
class Demo
{
	public static void main( String args[] )
	{
		Student S;
		System.out.println("Age of Viraaj is " +Student.Viraaj.getage()+ " years");
	}
}

维拉杰的年龄是 9 岁

在这个例子中，只要我们声明一个枚举变量(学生 S ，构造器就被调用一次，它用括号中用它们指定的值初始化每个枚举常数的年龄。

Java 中的自动装箱和拆箱

吴奇珍:t0]https://www . studytonight . com/Java/autoboxing-unboxing-Java . PHP

在 Java 1.5 中，Java 增加了自动装箱和拆箱的概念，处理原始类型到对象的转换，反之亦然。

术语自动装箱是指图元类型的自动转换到其对应的对象类型。例如，将整型转换为整型对象，或将Character类型转换为字符对象。这种转换是由 Java 编译器在程序执行过程中隐式完成的。

在同一上下文中，当一个对象转换到其对应的基本类型时，它被称为拆箱。例如，Integer类型到整型或字节到Byte类型的转换等。Java 在程序执行过程中自动执行这种转换。

自动装箱示例

在本例中，我们将 int 类型值赋给 Integer 对象，注意编译器不会报告任何错误，因为它在这里执行自动装箱。

	 class Demo
{
	public static void main(String[] args)
	{
		Integer i = 100; // Auto-boxing of int i.e converting primitive data type int to a Wrapper class Integer
		System.out.println(i);

		Character ch = 'a'; 
		System.out.println(ch);

		Byte b = 12;
		System.out.println(b);

	}
}

100 a 12

解释:

每当我们在表达式中使用包装类的对象时，自动装箱都是由 JVM 完成的。

当我们在表达式或条件等中使用包装类对象时，这种情况总是会发生。

示例:集合中的自动装箱

	 import java.util.ArrayList;

class Demo
{
	public static void main(String[] args)
	{
		ArrayList<Integer> arrayList = new ArrayList<Integer>();
		arrayList.add(100); // autoboxing int to Integer
		arrayList.add(200);
		arrayList.add(300);
		for(Integer i : arrayList) {
			System.out.println(i);
		}
	}
}

100 200 300

以同样的方式，我们可以执行拆箱。让我们看一个例子。

示例:拆箱

在这个例子中，我们使用 arraylist 来存储 int 类型的值。由于ArrayList只存储对象，因此它会自动将整型转换为整型并存储元素。如果我们获取它的元素，它会返回对象类型，如果我们将它存储为原始的 int 类型，那么它会自动将 Integer 转换为 int 类型。见下面的例子。

	 import java.util.ArrayList;

class Demo
{
	public static void main(String[] args)
	{
		ArrayList <integer>arrayList = new ArrayList<integer>();
		arrayList.add(100); // autoboxing int to Integer
		arrayList.add(200);
		arrayList.add(300);
		for(Integer i : arrayList) {
			System.out.println(i);
		}
		// unboxing Integer to int type
		int first = arrayList.get(0);
		System.out.println("int value "+first);
	}
}</integer></integer>

100 200 300 整数值 100

自动装箱/拆箱的好处

自动装箱/拆箱让我们可以互换使用基本类型和包装类对象。
我们不需要执行显式类型转换。
它有助于防止错误，但有时可能会导致意想不到的结果。因此必须小心使用。
自动拆箱还允许您在表达式中混合不同类型的数字对象。当值未装箱时，可以应用标准类型转换。

示例:

 class Demo {
	public static void main(String args[]) {
		Integer i = 35;
		Double d = 33.3;
		d = d + i;
		System.out.println("Value of d is " + d);
	}
}

d 的值是 68.3

注:当陈述d = d+I；被执行，I 被自动拆箱为 int，d 被自动拆箱为 double，然后执行加法，最后 d 的自动装箱为 Double 类型包装类。

类型包装

Java 使用原始数据类型，如 int、double、float 等。为了性能而保存基本数据类型。尽管基本数据类型提供了性能优势，但有时您需要基本数据类型的对象表示。例如，Java 中的许多数据结构对对象进行操作。因此，您不能在这些数据结构中使用原始数据类型。为了处理这种类型的情况，Java 提供了类型包装器，它提供了在对象中封装一个基本类型的类。

Java 提供了对应于每个原始类型的包装类来处理下面列出的对象。

| 原始的 | 包装类 |
| （同 Internationalorganizations）国际组织 | 整数 |
| 字节 | 字节 |
| 短的 | 短的 |
| 漂浮物 | 浮动 |
| 两倍 | 两倍 |
| 茶 | 性格；角色；字母 |
| 长的 | 长的 |
| 布尔 | 布尔代数学体系的 |

上面提到的类属于数值类型包装。这些类封装了字节、短整型、整型、长整型、浮点型、双原始类型。

示例:方法中的自动装箱和拆箱

我们可以看到自动装箱和拆箱是如何在一个方法中发生的。请注意，在方法调用期间，我们传递了 int 类型的基元值，但是方法只接受 Integer 对象，因此在这里 JVM 隐式地执行自动装箱。请注意，这个方法返回一个 int 类型原始类型，这是从 Integer 到 int 类型的另一种转换(拆箱)。

	 class Demo {
	// autoboxing in parameters
	static int add(Integer a, Integer b) {
		// unboxing in return
		return a+b;
	}

	public static void main(String args[]) {

		int sum = add(10,20);

		System.out.println("sum = "+sum);

		}
}

总和= 30

Java 输入输出流

原文：https://www.studytonight.com/java/java-io-stream.php

Java 通过流执行输入输出。java 输入输出系统将一个流链接到一个物理层，用 java 进行输入输出操作。一般来说，流意味着连续的数据流。流是处理输入/输出的干净方式，不需要你的代码的每个部分都理解物理的。

Java 在 java.io 包下封装 Stream。Java 定义了两种类型的流。他们是，

字节流:它提供了一种处理字节输入输出的便捷手段。
字符流:它为处理字符的输入和输出提供了方便的手段。字符流使用 Unicode，因此可以国际化。

Java 字节流类

字节流是通过在层次结构的顶部使用两个抽象类来定义的，它们是 InputStream 和 OutputStream。

byte stream classification

这两个抽象类有几个具体的类来处理各种设备，如磁盘文件、网络连接等。

一些重要的字节流类。

这些类定义了几个关键方法。两个最重要的是

read():读取字节数据。
write():写入字节数据。

Java 字符流类

字符流也是通过在层次结构的顶部使用两个抽象类来定义的，它们是 Reader 和 Writer。

character stream classification

这两个抽象类有几个处理 unicode 字符的具体类。

一些重要的字符流类

读取控制台输入

我们使用 BufferedReader 类的对象从键盘获取输入。

BufferedReader class explanation

阅读字符

read()方法与 BufferedReader 对象一起使用来读取字符。由于这个函数返回的是整型值，我们需要使用类型转换将它转换成字符类型。

*int* **read()** throws **IOException**

下面是一个解释字符输入的简单例子。

class CharRead
{
  public static void main( String args[])
  {
    BufferedReader br = new Bufferedreader(new InputstreamReader(System.in));
    char c = (char)br.read();   //Reading character
  }
}

在 Java 中读取字符串

要读取字符串，我们必须使用readLine()函数和 BufferedReader 类的对象。

String readLine() throws IOException

Program to take String input from Keyboard in Java

import java.io.*;
class MyInput
{
  public static void main(String[] args)
  {
    String text;
    InputStreamReader isr = new InputStreamReader(System.in);
    BufferedReader br = new BufferedReader(isr);
    text = br.readLine();    //Reading String
    System.out.println(text);
  }
}

Java 程序：使用`BufferedReader`类类读取文件

import java. Io *;
class ReadTest
{
  public static void main(String[] args)
  {
    try
    {
      File fl = new File("d:/myfile.txt");
      BufferedReader br = new BufferedReader(new FileReader(fl)) ;
      String str;
      while ((str=br.readLine())!=null)
      {
        System.out.println(str);
      }
      br.close();
      fl.close();
    }
    catch(IOException  e) { 
      e.printStackTrace(); 
    }
  }
}

Java 程序：使用`FileWriter`类写入文件

import java. Io *;
class WriteTest
{
 public static void main(String[] args)
 {
  try
  {
   File fl = new File("d:/myfile.txt");
   String str="Write this string to my file";
   FileWriter fw = new FileWriter(fl) ;
   fw.write(str);
   fw.close();
   fl.close();
  }
  catch (IOException  e)
  { e.printStackTrace(); }
 }
}

Java 序列化和反序列化

原文：https://www.studytonight.com/java/serialization-and-deserialization.php

序列化是将一个对象转换成一个字节序列的过程，该字节序列可以保存到磁盘或数据库中，也可以通过流发送。从字节序列创建对象的相反过程称为反序列化。

一个类必须实现java.io包中存在的可序列化接口，才能成功序列化其对象。 Serializable 是一个标记接口，它为实现它的类增加了可序列化的行为。

Java 提供封装在java.io包下的 Serializable API，用于序列化和反序列化对象，包括:

java.io.serializable
java.io.Externalizable
ObjectInputStream
ObjectOutputStream

Java 标记接口

标记接口是 Java 中的一个特殊接口，没有任何字段和方法。标记接口用于通知编译器实现它的类有一些特殊的行为或意义。标记界面一些例子是，

java.io.serializable
java.lang.Cloneable
java.rmi.Remote
java.util.RandomAccess

所有这些接口都没有任何方法和字段。它们只给实现它们的类添加特殊行为。然而，标记接口从 Java 5 开始就被弃用了，它们被注释所取代。注释被用来代替标记接口，其作用与标记接口之前的作用完全相同。

为了实现序列化和反序列化，Java 提供了两个类 ObjectOutputStream 和 ObjectInputStream。

对象输出流类

它用于将对象状态写入文件。实现 java.io.Serializable 接口的对象可以写入 strams。它提供了各种方法来执行序列化。

ObjectInputStream 类

ObjectInputStream 反序列化使用 ObjectOutputStream 编写的对象和原始数据。

`writeObject()`和`readObject()`方法

ObjectOutputStream类的writeObject()方法序列化一个对象并将其发送到输出流。

public *final* void **writeObject**(*object x*) throws **IOException**

ObjectInputStream类的readObject()方法引用流外的对象并反序列化它。

public final *Object* **readObject()** throws **IOException,ClassNotFoundException**

在序列化时，如果您不想让任何字段成为对象状态的一部分，那么根据您的需要声明它为静态或瞬态,并且在 java 序列化过程中不会包含它。

serialization and deserialization of objects

示例:用 Java 序列化对象

在这个例子中，我们有一个实现 Serializable 接口的类来使它的对象序列化。

import java.io.*;
class Studentinfo implements Serializable
{
    String name;
    int rid;
    static String contact;
    Studentinfo(String n, int r, String c)
    {
    this.name = n;
    this.rid = r;
    this.contact = c;
    }
}

class Demo
{
    public static void main(String[] args)
    {
        try
        {
            Studentinfo si = new Studentinfo("Abhi", 104, "110044");
            FileOutputStream fos = new FileOutputStream("student.txt");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(si);
            oos.flush();
            oos.close();
        }
        catch (Exception e)
        {
            System.out.println(e);
        }
    }
}

Studentinfo 类的对象使用writeObject()方法序列化并写入student.txt文件。

示例:Java 中对象的反序列化

为了反序列化对象，我们使用 ObjectInputStream 类，该类将从指定的文件中读取对象。见下面的例子。

import java.io.*;

class Studentinfo implements Serializable
{
    String name;
    int rid;
    static String contact;
    Studentinfo(String n, int r, String c)
    {
    this.name = n;
    this.rid = r;
    this.contact = c;
    }
}

class Demo
{
    public static void main(String[] args)
    {
        Studentinfo si=null ;
        try
        {
            FileInputStream fis = new FileInputStream("/filepath/student.txt");
            ObjectInputStream ois = new ObjectInputStream(fis);
            si = (Studentinfo)ois.readObject();
        }
        catch (Exception e)
        {
            e.printStackTrace(); }
            System.out.println(si.name);
            System.out. println(si.rid);
            System.out.println(si.contact);
        }
}

Abhi 104 是空的

联系人字段为空，因为它被标记为静态，并且正如我们前面讨论的，静态字段不会被序列化。

注意:静态成员从不序列化，因为它们连接到类而不是类的对象。

`transient`关键字

序列化对象时，如果我们不想序列化对象的某个数据成员，我们可以称之为瞬态。transient 关键字将阻止数据成员被序列化。

class studentinfo implements Serializable 
{
    String name;
    transient int rid;
    static String contact;
}

创建数据成员transient将阻止其序列化。
在本例中rid将不会被序列化，因为它是瞬态，而contact也将保持未序列化，因为它是静态。

Java 中的网络

原文：https://www.studytonight.com/java/networking-in-java.php

Java 是网络编程的主要语言。java.net包封装了大量的类和接口，提供了一种简单易用的方式来访问网络资源。以下是 java.net 包的一些重要类和接口。

Java 网络类

| 班 |
| CacheRequest | CookieHandler |
| CookieManager | 数据报 |
| Inet 地址 | 服务器套接字 |
| 窝 | 关闭 |
| 代理 | 统一资源定位器 |
| 通过 | |

Java 网络接口

互联网地址

Inet 地址封装了数字 IP 地址和该地址的域名。Inet 地址可以处理 IPv4 和 Ipv6 地址。Inet 地址类没有可见的构造器。要创建 inet 地址对象，必须使用工厂方法。

三种常用的 Inet 地址工厂方法是。

静态在线处理T2【getLocalHost()抛出未知异常
静态地址T2(字符串主机名)抛出未知异常
静态InetAddress[]getAllByName(String hostname)抛出未知异常

InetAddress subclasses

使用 InetAddress 类的示例

import java.net.*;
class Demo
{
  public static void main(String[] args) throws UnknownHostException
  {
    InetAddress address = InetAddress.getLocalHost();
    System.out.println(address);
    address = InetAddress.getByName("www.studytonight.com");
    System.out.println(address);
    InetAddress sw[] = InetAddress.getAllByName("www.google.com");
    for(int i=0; i< sw.length; i++)
    {
      System.out.println(sw[i]);
    }
  }
}

www.studytonight.com/208.91.198.55·www.google.com/74.125.236.115·www.google.com/74.125.236.116·www.google.com/74.125.236.112·www.google.com/74.125.236.113·www.google.com/74.125.236.114·www.google.com/2404:6800:4009:802:0:0:0:1014

套接字和服务器套接字类

套接字是现代网络的基础，一个套接字允许单台计算机同时服务于许多不同的客户端。套接字通过使用端口建立连接，端口是特定机器上的编号套接字。套接字通信通过协议进行。套接字使用 TCP 在两台计算机之间提供通信机制。Java 中有两种 TCP 套接字。一个用于服务器，另一个用于客户端。

ServerSocket 是针对服务器的。
Socket 类为客户端。

网址类别

java.net 包中的 Java URL 类，处理唯一标识或定位互联网上资源的 URL(统一资源定位符)。

url defination

网址分类的重要方法

getProtocol() : 返回 URL 的协议
getHost() : 返回 URL 的主机名(域名)
getPort() : 返回 URL 的端口号
getFile() : 返回网址的文件名

Java 程序：使用网址类

import java.net.*;
class Demo
{
  public static void main(String[] arg) throws MalformedURLException
  {
    URL hp = new URL("http://www.studytonight.com/index");
    System.out.println(hp.getProtocol());
    System.out.println(hp.getFile());
  }
}

http/索引

Java 泛型

原文：https://www.studytonight.com/java/generic-in-java.php

泛型最早是在 Java5 中引入的。现在它是 java 编程语言最深刻的特征之一。泛型编程使程序员能够创建类、接口和方法，其中数据类型被指定为参数。它提供了编写独立于任何特定类型数据的算法的工具。泛型还提供类型安全。类型安全意味着在执行操作之前，确保对正确类型的数据执行操作。

使用泛型，可以创建一个单独的类、接口或方法来自动处理所有类型的数据(整数、字符串、浮点等)。它扩展了安全轻松地重用代码的能力。

在引入泛型之前，通用类、接口或方法是使用 Object 类型的引用创建的，因为 Object 是 Java 中所有类的超级类，但是这种编程方式并不能保证类型安全。

创建泛型类型对象的语法

Class_name <data type> reference_name = new Class_name<data type> ();
OR
Class_name <data type> reference_name = new Class_name<>();

这也称为创建泛型对象的菱形符号。

泛型类的示例

 //<> brackets indicates that the class is of generic type
class Gen <T> 
{
  T ob;     //an object of type T is declared<
  Gen(T o)  //constructor
  {
    ob = o;
  }
  public T getOb()
  {
    return ob;
  }
}

class Demo
{
  public static void main (String[] args)
  {
    Gen < Integer> iob = new Gen<>(100);   //instance of Integer type Gen Class
    int  x = iob.getOb();
    System.out.println(x);
    Gen < String> sob = new Gen<>("Hello");  //instance of String type Gen Class
    String str = sob.getOb();
    System.out.println(str);
  }
}

你好

在上面的程序中，我们首先向泛型类传递了一个Integer类型参数。然后，我们将一个String类型参数传递给同一个泛型类。因此，我们为两种不同的数据类型重用了同一个类。因此，泛型很容易帮助代码重用。

泛型仅适用于对象

泛型只适用于对象，即类型参数必须是Class类型。您不能使用诸如 int、char 等基本数据类型。泛型类型。它应该永远是一个对象。我们可以使用所有的包装类对象和String类对象作为泛型类型。

Gen**<int>** iOb = new Gen**<int>**(07);   //Error, can't use primitive type

不同类型参数的泛型类型从不相同

一个泛型类型的引用永远不会与其他泛型类型兼容，除非它们的类型参数相同。在上面的例子中，我们创建了两个类对象 Gen ，一个类型为 Integer ，另一个类型为 String ，因此，

iob = sob;  //Absolutely Wrong

无法创建泛型类型的数组

泛型编程中不允许创建泛型类型数组。我们可以引用一个数组，但是不能实例化它。

例如，在上面的程序中，在 Gen 类、中

t a[]；//这是允许的

T a[] =新的 T[10]；//这是不允许的

具有多个参数的泛型类型

在泛型参数化类型中，我们可以将多个数据类型作为参数传递。它的工作方式与一个参数泛型类型相同。

class Gen <T1,T2>
{
  T1 name;
  T2 value;

  Gen(T1 o1,T2 o2)
  {
    name = o1;
    value = o2;
  }

  public T1 getName()
  {
    return name;
  }

  public T2 getValue()
  {
    return value;
  }

}

class Demo
{
  public static void main (String[] args)
  {
    Gen < String,Integer> obj = new Gen<>("StudyTonight",1);

    String  s = obj.getName();
    System.out.println(s);

    Integer i = obj.getValue();
    System.out.println(i);
  }
}

今晚学习 1

注意:由于泛型类中有两个参数——T1 和 T2，因此，在创建这个泛型类的实例时，我们需要提到两个需要作为参数传递给这个类的数据类型。

通用方法

您还可以创建可以用不同类型的参数调用的泛型方法。根据传递给泛型方法的Parameter类型，编译器处理每个方法。

泛型方法的语法包括尖括号内的类型参数，并且应该出现在方法的返回类型之前。

<type-parameter> return_type method_name (parameters) {...}

通用方法示例

class Demo
{
  static <V, T> void display (V v, T t)
  {
    System.out.println(v.getClass().getName()+" = " +v);
    System.out.println(t.getClass().getName()+" = " +t);
  }
  public static void main(String[] args)
  {
    display(88,"This is string");
  }
}

Java 语。整数= 88 java lang。字符串=这是字符串

Java 中的泛型构造器

即使类不是泛型的，也可以创建泛型构造器。

通用构造器示例

class Gen
{
  private double val;
  <T extends Number> Gen(T ob)
  {
    val = ob.doubleValue();
  }
  void show()
  {
    System.out.println(val);
  }
}

class Demo
{
  public static void main(String[] args)
  {
    Gen g = new Gen(100);
    Gen g1 = new Gen(121.5f);
    g.show();
    g1.show();
  }
}

100.0 121.5

泛型有界类型参数

还可以对允许传递给类型参数的类型设置限制。这是在指定类型参数时借助 extends 关键字完成的。

 < T extends Number >

这里我们取了号类，它可以是任何包装器类名。这规定了 T 只能被号类数据本身或其任何子类代替。

具有有界类型参数的泛型方法

在这个例子中，我们创建了一个只允许数字类型或其子Class类型的显示方法。

class Demo
{
  static < T, V extends Number> void display(T t, V v)
  {
    System.out.println(v.getClass().getName()+" = " +v);
    System.out.println(t.getClass().getName()+" = " +t);
  }
  public static void main(String[] args)
  {
    display ("this is string",99);
  }
}

java.lang.String =这是字符串 java.lang.Double = 99。O

类型五只限于数字类型及其子类。如果display(88,"This is string")没有注释，会给出类型不兼容的错误，因为 String 不是 Number 类的子类。

集合框架

Java 集合框架

原文：https://www.studytonight.com/java/collection-framework.php

Java 集合框架表示用于操作对象组的一组接口和类的层次结构。

Java 1.2 版本增加了集合框架。在 Java 2 之前，Java 提供了字典、向量、栈和属性等特殊类来存储和操作对象组。

Java 集合框架包含在 java.util 包中。它提供了许多重要的类和接口来收集和组织一组对象。

什么是收藏

java 中的集合可以指将多个元素收集到一个单元中的对象。它用于存储、提取和操作数据。例如，列表用于收集元素并由列表对象引用。

集合框架的组成部分

集合框架包括:

集合接口，如集合、列表和映射。这些用于收集不同类型的对象。
集合类，如ArrayList、HashSet等，它们是集合接口的实现。
为高度并发使用而设计的并发实现类。
提供静态方法来对集合执行有用功能的算法，例如对列表进行排序。

收藏框架的优势

它通过提供一组内置的数据结构和算法来减少编程工作。
通过提供数据结构和算法的高性能实现来提高性能。
通过建立一种通用语言来来回传递集合，从而在不相关的 API 之间提供互操作性。
提高生产率
缩短运营时间
多功能性也适用于当前系列

收集 API 的重要接口

| 连接 | 描述 |
| 集合 | 使您能够处理对象组；它位于集合层次结构的顶部 |
| 从开始 | 扩展队列以处理双端队列。 |
| 列表 | 扩展集合以处理对象的序列列表。 |
| 队列 | 扩展集合以处理特殊类型的列表，在该列表中只从头部移除元素。 |
| 设置 | 将集合扩展到句柄集，句柄集必须包含唯一的元素。 |
| 排序集 | 扩展集合以处理排序的集合。 |

Java 集合层次结构

集合框架层次结构用图表表示。您可以了解接口和类是如何相互链接的，以及它们位于什么层次结构中。在框架的顶部，集合框架是可用的，其余的接口是它的子接口。

Collection Heirarchy

收藏层级

所有这些接口都给出了由实现这些接口的集合类定义的几种方法。

集合框架的常用方法

为什么收藏品变得通用？

泛型在 Collection 框架中增加了类型安全。早期的集合存储了对象类引用，这意味着任何集合都可以存储任何类型的对象。因此，有可能在集合中存储不兼容的类型，这可能导致运行时不匹配。因此，引入了泛型，通过它可以显式地声明被存储的对象的类型。

收集和自动装箱

我们已经研究了自动装箱将基元类型转换成包装类对象。由于集合不存储基本数据类型(只存储引用)，因此自动装箱通过将基本数据类型打包到其包装类型中来促进集合中基本数据类型的存储。

集合框架中最常见的抛出异常

使用集合时可能会出现异常。我们已经列出了在程序执行过程中可能发生的一些最常见的异常。

Java 集合框架的接口

原文：https://www.studytonight.com/java/collection-interfaces.php

集合框架有很多接口，设置了各种集合类的基本性质。让我们研究集合框架中最重要的接口。

收集接口

它位于集合层次结构的顶部，必须由定义集合的任何类来实现。它的一般声明是，

interface Collection <E>

收集接口方法

Following are some of the commonly used methods in this interface.

| Method | Description |
| Boolean Add (EOBJ) | is used to add objects to the collection. Returns true if obj is added to the collection. If obj is already a member of the collection, or the collection does not allow duplicates, false is returned. |
| Boolean addition (set C) | Adds all elements of set C to the calling set. Returns true if an element is added. Otherwise, return false. |
| Boolean removal (object object) | Removes an object from a set. Returns true if the element is removed. Otherwise, return false. |
| Boolean remove all (set C) | Remove all elements of set C from the call set. Returns true if the elements of the collection are removed. Otherwise, return false. |
| Boolean inclusion (object object) | Determines whether there is an object in the set. Returns true if obj is an element of the calling collection. Otherwise, return false. |
| Boolean isempty () | Returns true if the set is empty, otherwise returns false. |
| int size () | Returns the number of elements in a set. |
| Empty () | Remove the total number of elements from the set. |
| Object [] ToaArray () | Returns an array of elements of the call collection. |
| Boolean reserved value (set c) | Delete all elements of the calling set except the specified set. |
| Iterator iterator () | Returns the iterator of the calling set. |
| Boolean equals (object object) | If the call set is equal to obj, it returns true. Otherwise, return false. |
| Object [] to array (object array []) | Returns an array that contains only those set elements whose types match the specified array. |

列表界面

它扩展了集合接口，将存储定义为元素序列。以下是它的一般声明，

interface List <E>

根据位置允许随机访问和插入。
它允许复制元素。

列出接口方法

Apart from methods of Collection Interface, Adds following methods of its own. [

| method | describes |
| object acquisition (integer index). | Returns the object |
| object set stored at the specified index (integer index, Electronic object) | Store the object at the specified index in the call set |
| int index of (objectobj) | Returns the index |
| int lastIn the first object in the set. Dex (Objectobj) | Returns the index of the last occurrence of obj in the set |
| List sub-list (int start, int end) | Returns the list containing elements between the start index and the end index in the set |

设置界面

该接口定义了一个集合。它扩展了集合接口，不允许插入重复元素。它的一般声明是，

interface Set <E>

它没有定义任何自己的方法。它有两个子界面，排序集和导航集。
排序设置界面扩展设置界面，按升序排列添加的元素。
导航设置界面扩展了排序设置界面，允许根据与给定值最接近的匹配检索元素。

`Queue`接口

它扩展了集合接口，定义了队列的行为，即先进先出。它的一般声明是，

interface Queue <E>

`Queue`接口方法

There are couple of new and interesting methods added by this interface. Some of them are mentioned in below table.

出列接口

它扩展了队列接口，实现了双端队列的行为。它的一般声明是，

interface Dequeue <E>

因为它实现了 Queue 接口，所以它具有与上面提到的相同的方法。
双端队列可以像标准栈一样作为简单队列运行。

Java 中的集合类

原文：https://www.studytonight.com/java/collection-classes.php

Java 集合框架由用于存储对象的各种类组成。顶部的这些类实现了集合接口。一些类提供了可以直接使用的完整实现。其他的是抽象类，它提供了骨架实现，可以作为创建具体集合的起点。

Java 集合框架类

此表包含实现集合接口的抽象和非抽象类。

标准集合类有:

注意:

要在程序中使用任何 Collection 类，需要导入 java.util 包。
无论何时打印任何集合类，都会在方括号[]内打印它及其元素。

`ArrayList`类

此类提供基于数组的数据结构的实现，该数据结构用于以线性顺序存储元素。这个类实现了列表接口和一个抽象的AbstractList类。它创建了一个基于元素强度增长的动态数组。

简单数组有固定的大小，即它可以存储固定数量的元素，但有时您可能事先不知道要存储在数组中的元素数量。在这种情况下，我们可以使用ArrayList，这是一个大小可以动态增减的数组。

ArrayList 类扩展了AbstractList类，实现了列表接口。
ArrayList 支持动态数组，可以根据需要增长。
它可以包含重复元素，并且还保持插入顺序。
操作很慢，因为如果从ArrayList中删除任何元素，都需要进行大量的移位。
ArrayList不同步。
ArrayList 允许随机访问，因为它基于索引工作。

`ArrayList`构造器

Arraylist 类有三个构造器，可用于从空集合或其他集合的元素创建 ArrayList。

  ArrayList()  // It creates an empty ArrayList
ArrayList( Collection C ) // It creates an ArrayList that is initialized with elements of the Collection C
ArrayList( int capacity ) // It creates an ArrayList that has the specified initial capacity

`ArrayList`示例

让我们创建一个ArrayList来存储字符串元素。看，我们使用列表界面的 add 方法来添加元素。

import java.util.*;
class Demo
{
  public static void main(String[] args)
  {
    ArrayList< String> al = new ArrayList< String>();
    al.add("ab");
    al.add("bc");
    al.add("cd");
    System.out.println(al);
  }
}

[ab，bc，cd]

`LinkedList`类

Java LinkedList 类提供了LinkedList数据结构的实现。它使用双向LinkedList来存储元素。

LinkedList 类扩展了 AbstractSequentialList，实现了 List、dequeue 和 Queue 接口。
它可以用作列表、栈或队列，因为它实现了所有相关的接口。
它本质上是动态的，即在需要时分配内存。因此，可以容易地实现插入和删除操作。
它可以包含重复的元素，并且不同步。
在LinkedList中反向 t 遍历是困难的。
在LinkedList中，操作很快，因为不需要发生移位。

`LinkedList`构造器

LinkedList 类有两个构造器。

  LinkedList() // It creates an empty LinkedList
LinkedList( Collection c) // It creates a LinkedList that is initialized with elements of the Collection c

`LinkedList`类示例

让我们举一个例子来创建一个LinkedList，并使用 add 和其他方法添加元素。见下面的例子。

  import java.util.* ;
class Demo
{
  public static void main(String[] args)
  {
    LinkedList< String> ll = new LinkedList< String>();
    ll.add("a");
    ll.add("b");
    ll.add("c");
    ll.addLast("z");
    ll.addFirst("A");
    System.out.println(ll);
  }
}

[A，A，b，c，z]

`ArrayList`和`LinkedList`的区别

ArrayList和LinkedList是集合类，都实现了 List 接口。ArrayList 类创建一个列表，该列表内部存储在一个动态数组中，随着元素的添加或删除，该数组的大小会增大或缩小。LinkedList还会创建一个列表，该列表内部存储在一个双LinkedList中。这两个类都用于存储列表中的元素，但是这两个类之间的主要区别是ArrayList允许随机访问列表中的元素，因为它是在基于索引的数据结构上运行的。另一方面，LinkedList 不允许随机访问，因为它没有直接访问元素的索引，它必须遍历列表才能从列表中检索或访问元素。

更多不同之处:

ArrayList 扩展了 AbstarctList 类，而 LinkedList 扩展了 AbstractSequentialList。
AbstractList实现列表接口，因此它只能作为一个列表，而LinkedList实现列表、去队列和Queue接口，因此它可以同时作为一个队列和列表。
在列表中，访问ArrayList中的元素更快，因为随机访问也是可能的。对LinkedList元素的访问较慢，因为它只遵循顺序访问。
在列表中，ArrayList中的元素操作速度较慢，而LinkedList中的操作速度较快。

HashSet 类

HashSet 扩展了抽象集类，实现了集接口。
HashSet 有三个构造器。

HashSet()  *//This creates an empty HashSet*

HashSet( Collection C )  *//This creates a HashSet that is initialized with the elements of the Collection C*

HashSet( int capacity )  *//This creates a HashSet that has the specified initial capacity*

它创建一个使用HashMap进行存储的集合。HashMap通过一种叫做哈希的机制来存储信息。
在哈希中，密钥的信息内容用于确定唯一的值，称为其哈希代码。然后，哈希码被用作存储与密钥相关联的数据的索引。
HashSet 不维护元素的任何顺序。
HashSet 只包含唯一的元素。

HashSet 类的示例

在这个例子中，我们创建了一个存储字符串值的 HashSet。由于 HashSet 不存储重复的元素，我们尝试添加一个重复的元素，但是输出只包含唯一的元素。

import java.util.*;
class Demo
{
  public static void main(String args[])
  {
    HashSet<String> hs = new HashSet<String>();
    hs.add("B");
    hs.add("A");
    hs.add("D");
    hs.add("E");
    hs.add("C");
    hs.add("A");
    System.out.println(hs);
  }
}

[甲、乙、丙、丁、戊]

LinkedHashSet Class

LinkedHashSet 类扩展了 HashSet 类
LinkedHashSet 维护集合中条目的LinkedList。
LinkedHashSet 按照元素插入的顺序存储元素，即它保持插入顺序。

LinkedHashSet 类示例

import java.util.*;
class Demo
{
  public static void main(String args[])
  {
    LinkedHashSet<String> hs = new LinkedHashSet<String>();
    hs.add("B");
    hs.add("A");
    hs.add("D");
    hs.add("E");
    hs.add("C");
    hs.add("F");
    System.out.println(hs);
  }
}

[乙、甲、丁、戊、丙、己]

`TreeSet`合类

它扩展了抽象集类，实现了导航集接口。
它以升序存储元素。
它使用树形结构来存储元素。
它只包含像 HashSet 这样的独特元素。
它的存取和检索时间相当快。
它有四个构造器。

TreeSet()  *//It creates an empty tree set that will be sorted in an ascending order according to the
natural order of the tree set*

TreeSet( Collection *C* )  *//It creates a new tree set that contains the elements of the Collection C*

TreeSet( Comparator *comp* )  *//It creates an empty tree set that will be sorted according to given Comparator*

TreeSet( SortedSet *ss* )  *//It creates a TreeSet that contains the elements of given SortedSet*

TreeSet 类的示例

让我们举一个例子来创建一个包含重复元素的TreeSet。但是您可以注意到它打印独特的元素，这意味着它不允许重复的元素。

import java.util.*;
class Demo{
 public static void main(String args[]){
   TreeSet<String> al=new TreeSet<String>();
   al.add("Ravi");
   al.add("Vijay");
   al.add("Ravi");
   al.add("Ajay");

  Iterator itr=al.iterator();
  while(itr.hasNext()){
    System.out.println(itr.next());
  }
 }
}

Ajay Ravi Vijay

优先级队列类

它扩展了抽象队列类。
PriorityQueue 类提供了使用队列的功能。
它不以先进先出的方式对元素进行排序。

优先级队列有六个构造器。在所有情况下，容量都会随着元素的添加而自动增长。

**PriorityQueue**( )  *//This constructor creates an empty queue. By default, its starting capacity is 11*

**PriorityQueue**(int capacity) *//This constructor creates a queue that has the specified initial capacity*

**PriorityQueue**(int capacity, Comparator comp) *//This constructor creates a queue with the specified capacity
and comparator*

*//The last three constructors create queues that are initialized with elements of Collection passed in c*
**PriorityQueue**(*Collection* c)

**PriorityQueue**(*PriorityQueue* c)

**PriorityQueue**(*SortedSet* c)

注意:如果在构建优先级队列时没有指定Comparator，则使用队列中存储的数据类型的默认Comparator。默认Comparator将按升序排列队列。因此，队列的头部将是最小值。但是，通过提供自定义Comparator，您可以指定不同的排序方案。

优先级队列类的示例

让我们举一个例子来创建一个存储和移除元素的优先级队列。

import java.util.*;

class Demo
{
  public static void main(String args[])
  {
    PriorityQueue<String> queue=new PriorityQueue<String>();
    queue.add("WE");
    queue.add("LOVE");
    queue.add("STUDY");
    queue.add("TONIGHT");
    System.out.println("At head of the queue:"+queue.element());
    System.out.println("At head of the queue:"+queue.peek());
    System.out.println("Iterating the queue elements:");
    Iterator itr=queue.iterator();
    while(itr.hasNext()){
      System.out.println(itr.next());
    }
    queue.remove();
    queue.poll();
    System.out.println("After removing two elements:");
    Iterator itr2=queue.iterator();
    while(itr2.hasNext()){
      System.out.println(itr2.next());
    }
  }
}

在队列的最前面:爱在队列的最前面:爱迭代队列元素:爱今晚研究我们在移除两个元素后:今晚我们

使用迭代器访问 Java 集合

原文：https://www.studytonight.com/java/iterator-in-collection.php

要访问集合的元素，如果集合是基于列表的，我们可以使用索引，或者我们需要遍历元素。有三种可能的方式遍历任何集合的元素。

使用迭代器接口
使用列表迭代器接口
使用 for-each 循环

使用迭代器访问元素

迭代器是用于迭代集合元素的接口。它是 java 集合框架的一部分。它提供了一些用于检查和访问集合元素的方法。

迭代器接口用于向前遍历列表，使您能够移除或修改集合的元素。每个集合类都提供iterator()方法来返回一个迭代器。

迭代器接口方法

迭代器示例

在这个例子中，我们使用的是集合接口的 iterator()方法，该方法返回 Iterator 接口的一个实例。之后我们使用 hasNext()方法，返回 true 集合包含一个元素，在循环中，通过调用next()方法获取每个元素。

import java.util.*;
class Demo
{
  public static void main(String[] args)
  {
    ArrayList< String> ar = new ArrayList< String>();
    ar.add("ab");
    ar.add("bc");
    ar.add("cd");
    ar.add("de");
    Iterator it = ar.iterator();    //Declaring Iterator
    while(it.hasNext())
    {  
      System.out.print(it.next()+" ");
    }
  }
}

ab bc cd de

使用`ListIterator`访问元素

ListIterator接口用于在向前和向后两个方向遍历列表。它只适用于那些实现列表界面的集合。

列表迭代器的方法:

列表迭代器示例

让我们创建一个遍历ArrayList元素的例子。列表迭代器仅适用于列表集合。

import java.util.*;
class Demo
{
  public static void main(String[] args)
  {
    ArrayList< String> ar = new ArrayList< String>();
    ar.add("ab");
    ar.add("bc");
    ar.add("cd");
    ar.add("de");
    ListIterator litr = ar.listIterator();
    while(litr.hasNext())   //In forward direction
    {
      System.out.print(litr.next()+" ");
    }
    while(litr.hasPrevious())   //In backward direction
    {
      System.out.print(litr.previous()+" ");
    }
  }
}

ab bc cd de de cd bc ab

loop 每个循环

for-each版本的for循环也可以用于遍历集合的元素。但这只能在我们不想修改收藏的内容，也不想任何反向访问时使用。for-each循环可以循环通过任何实现Iterable接口的对象集合。

Exmaple(前枫树镇)：

import java.util.*;
class Demo
{
  public static void main(String[] args)
  {
    LinkedList< String> ls = new LinkedList< String>();
    ls.add("a");
    ls.add("b");
    ls.add("c");
    ls.add("d");
    for(String str : ls)
    {
      System.out.print(str+" ");
    }
  }
}

a b c d

使用 for 循环遍历

我们可以使用 for 循环遍历集合元素，但只能访问基于索引的集合。例如，list 是基于索引的集合，允许使用索引值访问其元素。

  import java.util.*;
class Demo
{
  public static void main(String[] args)
  {
    LinkedList<String> ls = new LinkedList<String>();
    ls.add("a");
    ls.add("b");
    ls.add("c");
    ls.add("d");
    for(int i = 0; i<ls.size(); i++)
    {
      System.out.print(ls.get(i)+" ");
    }
  }
}

a b c d

Java 集合框架`ArrayList`

原文：https://www.studytonight.com/java/arraylist-in-collection-framework.php

Java `ArrayList`类声明

  public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable

ArrayList 支持动态数组，可以根据需要增长。
它可以包含重复元素，并且还保持插入顺序。
操作很慢，因为如果从ArrayList中删除任何元素，都需要进行大量的移位。
ArrayList不同步。
ArrayList 允许随机访问，因为它基于索引工作。

`ArrayList`构造器

Arraylist 类有三个构造器，可用于从空集合或其他集合的元素创建 ArrayList。

  ArrayList()  // It creates an empty ArrayList
ArrayList( Collection C ) // It creates an ArrayList that is initialized with elements of the Collection C
ArrayList( int capacity ) // It creates an ArrayList that has the specified initial capacity

示例:创建`ArrayList`

让我们创建一个ArrayList来存储字符串元素。这里的列表是空的，因为我们没有添加元素。

import java.util.*;
class Demo
{
  public static void main(String[] args)
  {   
    // Creating an ArrayList
    ArrayList< String> fruits = new ArrayList< String>();

    // Displaying Arraylist
    System.out.println(fruits);
  }
}

[]

`ArrayList`方法

下表包含ArrayList的方法。我们可以用它们来操纵它的元素。

向`ArrayList`添加元素

要将元素添加到ArrayList中，我们使用 add()方法。它按照插入顺序将元素添加到列表中。

  import java.util.*;
class Demo
{
  public static void main(String[] args)
  {   
    // Creating an ArrayList
    ArrayList< String> fruits = new ArrayList< String>();
    // Adding elements to ArrayList
    fruits.add("Mango");
    fruits.add("Apple");
    fruits.add("Berry");
    // Displaying ArrayList
    System.out.println(fruits);
  }
}

[芒果、苹果、浆果]

移除元素

为了从列表中移除元素，我们使用移除指定元素的移除方法。我们还可以传递索引值来移除其中的元素。

  import java.util.*;
class Demo
{
  public static void main(String[] args)
  {   
    // Creating an ArrayList
    ArrayList< String> fruits = new ArrayList< String>();
    // Adding elements to ArrayList
    fruits.add("Mango");
    fruits.add("Apple");
    fruits.add("Berry");
    fruits.add("Orange");
    // Displaying ArrayList
    System.out.println(fruits);
    // Removing Elements
    fruits.remove("Apple");
    System.out.println("After Deleting Elements: \n"+fruits);
    // Removing Second Element
    fruits.remove(1);
    System.out.println("After Deleting Elements: \n"+fruits);

  }
}

【芒果、苹果、浆果、橙子】删除元素后:【芒果、浆果、橙子】删除元素后:【芒果、橙子】

遍历`ArrayList`的元素

因为ArrayList是一个集合，所以我们可以使用循环来迭代它的元素。在这个例子中，我们正在遍历元素。见下面的例子。

  import java.util.*;
class Demo
{
  public static void main(String[] args)
  {   
    // Creating an ArrayList
    ArrayList< String> fruits = new ArrayList< String>();
    // Adding elements to ArrayList
    fruits.add("Mango");
    fruits.add("Apple");
    fruits.add("Berry");
    fruits.add("Orange");
    // Traversing ArrayList
    for(String element : fruits) {
      System.out.println(element);    
    }
  }
}

芒果苹果浆果橙

获取`ArrayList`的大小

有时我们想知道ArrayList包含的元素数量。在这种情况下，我们使用 size()然后返回ArrayList的大小，该大小等于列表中存在的元素数量。

  import java.util.*;
class Demo
{
  public static void main(String[] args)
  {   
    // Creating an ArrayList
    ArrayList< String> fruits = new ArrayList< String>();
    // Adding elements to ArrayList
    fruits.add("Mango");
    fruits.add("Apple");
    fruits.add("Berry");
    fruits.add("Orange");
    // Traversing ArrayList
    for(String element : fruits) {
      System.out.println(element);    
    }
    System.out.println("Total Elements: "+fruits.size());
  }
}

芒果苹果浆果橙子总元素:4

排序`ArrayList`元素

为了对ArrayList的元素进行排序，Java 提供了一个名为 Collections 的类，该类包含一个静态排序方法()。在这个例子中，我们使用排序方法对元素进行排序。

  import java.util.*;
class Demo
{
  public static void main(String[] args)
  {   
    // Creating an ArrayList
    ArrayList< String> fruits = new ArrayList< String>();
    // Adding elements to ArrayList
    fruits.add("Mango");
    fruits.add("Apple");
    fruits.add("Berry");
    fruits.add("Orange");
    // Sorting elements
    Collections.sort(fruits);
    // Traversing ArrayList
    for(String element : fruits) {
      System.out.println(element);    
    }
  }
}

苹果浆果芒果橙

Java 集合框架`LinkedList`

原文：https://www.studytonight.com/java/linkedlist-in-collection-framework.php

Java LinkedList 类提供了LinkedList数据结构的实现。它使用双向LinkedList来存储元素。它实现了 List、dequeue 和 Queue 接口，并扩展了 AbstractSequentialList 类。下面是 LinkedList 类的声明。

`LinkedList`类声明

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, Serializable

LinkedList 类扩展了 AbstractSequentialList，实现了 List、dequeue 和 Queue 接口。
它可以用作列表、栈或队列，因为它实现了所有相关的接口。
它允许空输入。
它本质上是动态的，即在需要时分配内存。因此，可以容易地实现插入和删除操作。
它可以包含重复的元素，并且不同步。
在LinkedList中反向 t 遍历是困难的。
在LinkedList中，操作很快，因为不需要发生移位。

`LinkedList`构造器

LinkedList 类有两个构造器。第一个用于创建空LinkedList，第二个用于从现有集合创建。

  LinkedList() // It creates an empty LinkedList
LinkedList( Collection c) // It creates a LinkedList that is initialized with elements of the Collection c

`LinkedList`类示例

让我们举一个例子来创建一个LinkedList，没有元素被插入，所以它创建了一个空的LinkedList。见下面的例子。

  import java.util.*;
class Demo
{
  public static void main(String[] args)
  {
    // Creating LinkedList
    LinkedList< String> linkedList = new LinkedList< String>();
    // Displaying LinkedLIst
    System.out.println(linkedList);
  }
}

[]

`LinkedList`方法

下表包含LinkedList的方法。我们可以用它们来操纵它的元素。

向`LinkedList`添加元素

要将元素添加到LinkedList中，我们使用add()方法。它按照插入顺序将元素添加到列表中。

  import java.util.*;
class Demo
{
  public static void main(String[] args)
  {
    // Creating LinkedList
    LinkedList< String> linkedList = new LinkedList< String>();
    linkedList.add("Delhi");
    linkedList.add("NewYork");
    linkedList.add("Moscow");
    linkedList.add("Dubai");
    // Displaying LinkedList
    System.out.println(linkedList);
  }
}

[德里、纽约、莫斯科、迪拜]

移除元素

为了从列表中移除元素，我们使用移除指定元素的移除方法。我们还可以传递索引值来移除其中的元素。

  import java.util.*;
class Demo
{
  public static void main(String[] args)
  {
    // Creating LinkedList
    LinkedList< String> linkedList = new LinkedList< String>();
    linkedList.add("Delhi");
    linkedList.add("NewYork");
    linkedList.add("Moscow");
    linkedList.add("Dubai");
    // Displaying LinkedList
    System.out.println(linkedList);
    // Removing Elements
    linkedList.remove("Moscow");
    System.out.println("After Deleting Elements: \n"+linkedList);
    // Removing Second Element
    linkedList.remove(1);
    System.out.println("After Deleting Elements: \n"+linkedList);
  }
}

[德里、纽约、莫斯科、迪拜]删除元素后:[德里、纽约、迪拜]删除元素后:[德里、迪拜]

遍历`LinkedList`的元素

由于 LinkedList 是一个集合，因此我们可以使用循环来迭代它的元素。在这个例子中，我们正在遍历元素。见下面的例子。

  import java.util.*;
class Demo
{
  public static void main(String[] args)
  {
    // Creating LinkedList
    LinkedList< String> linkedList = new LinkedList< String>();
    linkedList.add("Delhi");
    linkedList.add("NewYork");
    linkedList.add("Moscow");
    linkedList.add("Dubai");
    // Traversing ArrayList
    for(String element : linkedList) {
      System.out.println(element);    
    }
  }
}

德里纽约莫斯科迪拜

获取`LinkedList`的大小

有时我们想知道一个LinkedList包含的元素数量。在这种情况下，我们使用size()然后返回LinkedList的大小，它等于列表中存在的元素数量。

  import java.util.*;
class Demo
{
  public static void main(String[] args)
  {
    // Creating LinkedList
    LinkedList< String> linkedList = new LinkedList< String>();
    linkedList.add("Delhi");
    linkedList.add("NewYork");
    linkedList.add("Moscow");
    linkedList.add("Dubai");
    // Traversing ArrayList
    for(String element : linkedList) {
      System.out.println(element);    
    }
System.out.println("Total Elements: "+linkedList.size());
  }
}

德里纽约莫斯科迪拜总要素:4

排序`LinkedList`元素

为了对LinkedList的元素进行排序，Java 提供了一个类 Collections，它包括一个静态排序方法()。在这个例子中，我们使用排序方法对元素进行排序。

  import java.util.*;
class Demo
{
  public static void main(String[] args)
  {
    // Creating LinkedList
    LinkedList< String> linkedList = new LinkedList< String>();
    linkedList.add("Delhi");
    linkedList.add("NewYork");
    linkedList.add("Moscow");
    linkedList.add("Dubai");
    // Sorting elements
    Collections.sort(linkedList);
    // Traversing ArrayList
    for(String element : linkedList) {
      System.out.println(element);    
    }
  }
}

德里迪拜莫斯科纽约

Java 集合框架`HashSet`

原文：https://www.studytonight.com/java/hashset-in-collection-framework.php

Java HashSet 类用于存储唯一的元素。它在内部使用HashMap来存储元素。它实现了集合接口并扩展了抽象集合类。的声明如下。

Java HashSet 类声明

public class HashSet<E>extends AbstractSet<E>implements Set<E>, Cloneable, Serializable

要点:

它创建一个使用HashMap进行存储的集合。HashMap通过使用一种称为哈希的机制来存储信息。
HashSet 不维护元素的任何顺序。
HashSet 只包含唯一的元素。
它允许存储空值。
它是非同步的。
这是搜索操作的最佳方法。
HashSet 的初始默认容量是 16。

HashSet 构造器

HashSet 类有三个构造器，可以用来相应地创建 HashSet。

HashSet()  //This creates an empty HashSet

HashSet( Collection C )  //This creates a HashSet that is initialized with the elements of the Collection C

HashSet( int capacity )  //This creates a HashSet that has the specified initial capacity

HashSet 类的示例

在这个例子中，我们创建了一个初始为空的 HashSet。稍后，我们将向该集合添加项目。

import java.util.*;
class Demo
{
  public static void main(String args[])
  {
    // Creating HashSet
    HashSet<String> hs = new HashSet<String>();
    // Displaying HashSet
    System.out.println(hs);
  }
}

[]

HashSet 方法

向`HashSet`中添加元素

在这个例子中，我们创建了一个存储字符串值的 HashSet。由于 HashSet 不存储重复的元素，我们尝试添加一个重复的元素，但是输出只包含唯一的元素。

  import java.util.*;
class Demo
{
  public static void main(String args[])
  {
    // Creating HashSet
    HashSet<String> hs = new HashSet<String>();
    // Adding elements
    hs.add("Mohan");
    hs.add("Rohan");
    hs.add("Sohan");
    hs.add("Mohan");
    // Displaying HashSet
    System.out.println(hs);
  }
}

[莫罕、索翰、罗翰]

从`HashSet`中移除元素

为了从 hashset 中移除元素，我们使用 remove()方法移除指定的元素。

  import java.util.*;
class Demo
{
  public static void main(String args[])
  {
    // Creating HashSet
    HashSet<String> hs = new HashSet<String>();
    // Adding elements
    hs.add("Mohan");
    hs.add("Rohan");
    hs.add("Sohan");
    hs.add("Mohan");
    // Displaying HashSet
    System.out.println(hs);
    // Removing elements
    hs.remove("Mohan");
    System.out.println("After removing elements: \n"+hs);
  }
}

[莫汉、索汉、罗汉]移除元素后:[索汉、罗汉]

遍历`HashSet`的元素

因为 HashSet 是一个集合，所以我们可以使用循环来迭代它的元素。在这个例子中，我们使用 for 循环遍历元素。见下面的例子。

  import java.util.*;
class Demo
{
  public static void main(String args[])
  {
    // Creating HashSet
    HashSet<String> hs = new HashSet<String>();
    // Adding elements
    hs.add("Mohan");
    hs.add("Rohan");
    hs.add("Sohan");
    hs.add("Mohan");
    // Traversing ArrayList
    for(String element : hs) {
      System.out.println(element);    
    }
  }
}

莫罕·罗翰

获取`HashSet`的大小

有时我们想知道一个 HashSet 包含的元素数量。在这种情况下，我们使用 size()然后返回 HashSet 的大小，它等于列表中存在的元素数量。

  import java.util.*;
class Demo
{
  public static void main(String args[])
  {
    // Creating HashSet
    HashSet<String> hs = new HashSet<String>();
    // Adding elements
    hs.add("Mohan");
    hs.add("Rohan");
    hs.add("Sohan");
    hs.add("Mohan");
    // Traversing ArrayList
    for(String element : hs) {
      System.out.println(element);    
    }
    System.out.println("Total elements : "+hs.size());
  }
}

莫汉索汉罗汉总元素:3

Java 集合框架`LinkedHashSet`

原文：https://www.studytonight.com/java/linkedhashset-in-collection-framework.php

Java LinkedHashSet 类是一个基于LinkedList的 Set 接口实现。它用于存储独特的元素。它在内部使用HashMap来存储元素。它实现了 Set 接口并扩展了 HashSet 类。该类的声明如下。

Java LinkedHashSet 类声明

public class LinkedHashSet<E>extends HashSet<E>implements Set<E>, Cloneable, Serializable

要点:

LinkedHashSet 类扩展了 HashSet 类
它维护集合中条目的LinkedList。
它只包含独特的元素
它允许插入空值。
它按照元素插入的顺序存储元素，即保持插入顺序。
Java LinkedHashSet 类是非同步的。

LinkedHashSet 构造器

LinkedHashSet 类有四个构造器，可以用来相应地创建 LinkedHashSet。

  LinkedHashSet()  // This creates an empty LinkedHashSet
LinkedHashSet( Collection C )  // This creates a LinkedHashSet that is initialized with the elements of the Collection C
LinkedHashSet( int capacity )  // This creates a LinkedHashSet that has the specified initial capacity
LinkedHashSet( int initialCapacity, float loadFactor )

LinkedHashSet 类示例

在这个例子中，我们创建了一个最初为空的 LinkedHashSet。稍后，我们将向该集合添加项目。

import java.util.*;
import java.util.*;
class Demo
{
  public static void main(String args[])
  {
    // Creating LinkedHashSet
    LinkedHashSet<String> hs = new LinkedHashSet<String>();
    // Displaying LinkedHashSet
    System.out.println(hs);
  }
}

[]

LinkedHashSet 方法

它从 HashSet 类继承方法。所以我们可以用 LinkedHashSet 应用所有的 HashSet 操作。给定的表包含 HashSet 的方法。

向链接的`HashSet`中添加元素

在这个例子中，我们创建了一个存储整数值的 LinkedHashSet。由于 LinkedHashSet 不存储重复的元素，我们尝试添加一个重复的元素，但是输出只包含唯一的元素。

  import java.util.*;
class Demo
{
  public static void main(String args[])
  {
    // Creating LinkedHashSet
    LinkedHashSet <integer>hs = new LinkedHashSet<>();
    // Adding elements
    hs.add(100);
    hs.add(200);
    hs.add(300);
    hs.add(100);
    // Displaying LinkedHashSet
    System.out.println(hs);
  }
}</integer>

[100, 200, 300]

从链接的`HashSet`中删除元素

为了从 LinkedHashSet 中移除元素，我们使用了 remove()方法来移除指定的元素。

  import java.util.*;
class Demo
{
  public static void main(String args[])
  {
    // Creating LinkedHashSet
    LinkedHashSet<Integer> hs = new LinkedHashSet<Integer>();
    // Adding elements
    hs.add(100);
    hs.add(200);
    hs.add(300);
    hs.add(100);
    // Displaying LinkedHashSet
    System.out.println(hs);
    // Removing elements
    hs.remove(300);
    System.out.println("After removing elements: \n"+hs);
  }
}

[100，200，300]删除元素后:[100，200]

遍历`LinkedList`的元素

由于 LinkedHashSet 是一个集合，所以我们可以使用循环来迭代它的元素。在这个例子中，我们使用 for 循环遍历元素。见下面的例子。

  import java.util.*;
class Demo
{
  public static void main(String args[])
  {
    // Creating LinkedHashSet
    LinkedHashSet<Integer> hs = new LinkedHashSet<Integer>();
    // Adding elements
    hs.add(100);
    hs.add(200);
    hs.add(300);
    hs.add(100);
    // Traversing ArrayList
    for(Integer element : hs) {
      System.out.println(element);    
    }
  }
}

100 200 300

获取`LinkedHashSet`的大小

有时我们想知道 LinkedHashSet 包含的元素数量。在这种情况下，我们使用 size()然后返回 LinkedHashSet 的大小，它等于列表中存在的元素数量。

  import java.util.*;
class Demo
{
  public static void main(String args[])
  {
    // Creating LinkedHashSet
    LinkedHashSet<Integer> hs = new LinkedHashSet<Integer>();
    // Adding elements
    hs.add(100);
    hs.add(200);
    hs.add(300);
    hs.add(100);
    // Traversing ArrayList
    for(Integer element : hs) {
      System.out.println(element);    
    }
    System.out.println("Total elements : "+hs.size());
  }
}

100 200 300 总要素:3

Java 集合框架`TreeSet`

原文：https://www.studytonight.com/java/treeset-in-collection-framework.php

用于以升序存储唯一元素的 TreeSet 类。它类似于 HashSet ，只是它按照升序对元素进行排序，而 HashSet 不维护任何顺序。

Java TreeSet 类实现 Set 接口，使用基于树的数据结构存储。它扩展了AbstractSet类并实现了导航集接口。该类的声明如下。

`TreeSet`类声明

public class TreeSet<E>extends AbstractSet<E>implements NavigableSet<E>, Cloneable, Serializable

要点

它以升序存储元素。
它使用树形结构来存储元素。
它只包含像 HashSet 这样的独特元素。
它的存取和检索时间相当快。
它不允许空元素。
它是非同步的。

`TreeSet`合构造器

  TreeSet()
TreeSet( Collection C )  
TreeSet( Comparator comp )
TreeSet( SortedSet ss )

示例:创建`TreeSet`

让我们创建一个存储字符串元素的TreeSet。这里的集合是空的，因为我们没有给它添加元素。

  import java.util.*;
class Demo
{
  public static void main(String[] args)
  {   
    // Creating an TreeSet
    TreeSet< String> fruits = new TreeSet< String>();

    // Displaying TreeSet
    System.out.println(fruits);
  }
}

[]

`TreeSet`方法

向`TreeSet`中添加元素

让我们举一个例子来创建一个包含重复元素的TreeSet。但是您可以注意到它打印独特的元素，这意味着它不允许重复的元素。

import java.util.*;
class Demo{
  public static void main(String args[]){
    TreeSet<String> al=new TreeSet<String>();
    al.add("Ravi");
    al.add("Vijay");
    al.add("Ravi");
    al.add("Ajay");

    Iterator itr=al.iterator();
    while(itr.hasNext()){
      System.out.println(itr.next());
    }
  }
}

Ajay Ravi Vijay

从`TreeSet`中移除元素

我们可以用这个类的remove()方法去掉元素。见下面的例子。

  import java.util.*;
class Demo{
  public static void main(String args[]){
    TreeSet<String> al = new TreeSet<String>();
    al.add("Ravi");
    al.add("Vijay");
    al.add("Ravi");
    al.add("Ajay");

    Iterator itr=al.iterator();
    while(itr.hasNext()){
      System.out.println(itr.next());
    }

    al.remove("Ravi");
    System.out.println("After Removing: "+al);
  }
}

移除后的 Ajay Ravi Vijay:[Ajay，Vijay]

在`TreeSet`中搜索元素

TreeSet 提供了contains()方法，如果集合中存在元素，则该方法为真。

  import java.util.*;
class Demo{
  public static void main(String args[]){
    TreeSet<String> al = new TreeSet<String>();
    al.add("Ravi");
    al.add("Vijay");
    al.add("Ravi");
    al.add("Ajay");

    Iterator itr=al.iterator();
    while(itr.hasNext()){
      System.out.println(itr.next());
    }

    boolean iscontain = al.contains("Ravi");
    System.out.println("Is contain Ravi: "+iscontain);
  }
}

阿杰·拉维·维贾伊是遏制拉维:真的

以升序和降序遍历`TreeSet`

我们可以按升序和降序遍历TreeSet合的元素。TreeSet 提供descendingIterator()方法，返回迭代器类型进行降序遍历。见下面的例子。

  import java.util.*;
class Demo{
  public static void main(String args[]){
    TreeSet<String> al = new TreeSet<String>();
    al.add("Ravi");
    al.add("Vijay");
    al.add("Ravi");
    al.add("Ajay");
    System.out.println("Ascending...");
    Iterator itr=al.iterator();
    while(itr.hasNext()){
      System.out.println(itr.next());
    }
    System.out.println("Descending...");
    Iterator itr2=al.descendingIterator();
    while(itr2.hasNext()){
      System.out.println(itr2.next());
    }
  }
}

上升的...Ajay Ravi Vijay 下行...Vijay Ravi Ajay

Java 集合`Map`接口

原文：https://www.studytonight.com/java/map-interface-in-java.php

映射将数据存储在键和值关联中。键和值都是对象。密钥必须唯一，但值可以重复。尽管映射是集合框架的一部分，但由于它们所具有的某些属性，它们实际上不能被称为集合。然而，我们可以获得映射的集合视图。

它提供了各种类: HashMap、TreeMap、LinkedHashMap 用于映射实现。所有这些类都实现了映射接口，以向集合提供映射属性。

映射接口及其子接口

map interface sub interfaces

映射接口方法

这些是映射接口定义的常用方法

布尔包含键(对象 k ):如果映射包含 k 作为键，则返回真。否则为假。
对象获取(对象 k ):返回与键 k 关联的值。
对象放(对象 k ，对象 v ):在映射中存储一个条目。
对象放置所有(映射 m ):将所有来自 m 的条目放置在此映射中。
设置键集():返回包含映射中键的设置。
设置 entrySet ():返回包含映射条目的设置。

HashMap 类

HashMap 类扩展了抽象映射并实现了映射接口。
它使用一个HashMap来存储映射。这使得get()和put()的执行时间保持不变。
HashMap 不维护其元素的顺序。

HashMap 有四个构造器。

HashMap()
HashMap(Map< ? extends k, ? extends V> m)
HashMap(int capacity)
HashMap(int capacity, float fillratio)

`HashMap`示例

让我们举一个例子来创建 hashmap 并将值存储在键和值对中。注意插入元素，我们使用put()方法是因为映射使用 put 来插入元素，而不是我们在列表界面使用的add()方法。

import java.util.*;

class Demo
{
  public static void main(String args[])
  {
    HashMap< String,Integer> hm = new HashMap< String,Integer>();
    hm.put("a",100);
    hm.put("b",200);
    hm.put("c",300);
    hm.put("d",400);

    Set<Map.Entry<String,Integer>> st = hm.entrySet();  //returns Set view
    for(Map.Entry<String,Integer> me:st)
    {
      System.out.print(me.getKey()+":");
      System.out.println(me.getValue());
    }
  }
}

a:100 b:200 c:300 d:400

`TreeMap`类

TreeMap 类扩展了抽象映射，实现了导航映射界面。
它创建映射，存储在树结构中。
一个TreeMap提供了一个有效的方法来有效地存储键/值对。
它以排序顺序提供键/值对，并允许快速检索。

示例:

在这个例子中，我们正在创建TreeMap来存储数据。它使用树来存储数据，并且数据总是按照排序的顺序。见下面的例子。

import java.util.*;

class Demo
{
  public static void main(String args[])
  {
    TreeMap<String,Integer> tm = new TreeMap<String,Integer>();
    tm.put("a",100);
    tm.put("b",200);
    tm.put("c",300);
    tm.put("d",400);

    Set<Map.Entry<String,Integer>> st = tm.entrySet();
    for(Map.Entry<String,Integer> me:st)
    {
      System.out.print(me.getKey()+":");
      System.out.println(me.getValue());
    }
  }
}

a:100 b:200 c:300 d:400

LinkedHashMap 类

链接 HashMap 扩展 HashMap 类。
它按照条目插入的顺序维护映射中条目的LinkedList。

链接HashMap定义以下构造器

LinkedHashMap()

LinkedHashMap(Map< ? extends k, ? extends V> m)

LinkedHashMap(int capacity)

LinkedHashMap(int capacity, float fillratio)

LinkedHashMap(int capacity, float fillratio, boolean order)

它增加了一个新方法removeEldestEntry()。该方法由put()和putAll()调用，默认情况下，该方法不执行任何操作。

示例:

这里我们使用 linkedhashmap 来存储数据。它按照插入顺序存储数据，并在内部使用LinkedList。见下面的例子。

  import java.util.*;

class Demo
{
  public static void main(String args[])
  {
    LinkedHashMap<String,Integer> tm = new LinkedHashMap<String,Integer>();
    tm.put("a",100);
    tm.put("b",200);
    tm.put("c",300);
    tm.put("d",400);

    Set<Map.Entry<String,Integer>> st = tm.entrySet();
    for(Map.Entry<String,Integer> me:st)
    {
      System.out.print(me.getKey()+":");
      System.out.println(me.getValue());
    }
  }
}

a:100 b:200 c:300 d:400

Java 集合框架`Hashmap`

原文：https://www.studytonight.com/java/hashmap-in-collection-framework.php

Java HashMap 类是基于HashMap的 Map 接口的实现。它存储键和值对中的元素，表示为HashMap或HashMap。

扩展了 AbstractMap 类，实现了 Map 接口，可以通过导入 java.util 包进行访问。下面给出了这个类的声明。

`HashMap`声明

public class HashMap<K,V>extends AbstractMap<K,V>implements Map<K,V>,Cloneable, Serializable

要点:

它是 Java 集合框架的成员。
它使用HashMap来存储映射。这使得get()和put()的执行时间保持不变。
HashMap 不维护其元素的顺序。
它包含基于键的值。
它只允许唯一的键。
它是不同步的。
它的初始默认容量是 16。
它允许空值和空键
它是不同步的。

`HashMap`构造器

HashMap 类提供了以下四种构造器。

  HashMap()
HashMap(Map< ? extends k, ? extends V> m)
HashMap(int capacity)
HashMap(int capacity, float loadfactor)

示例:创建`HashMap`

让我们举一个例子来创建一个可以存储整型键和字符串值的 hashmap。最初它是空的，因为我们没有向它添加元素。它的元素用花括号括起来。

  import java.util.*;
class Demo
{
  public static void main(String args[])
  {
  // Creating HashMap
    HashMap<Integer,String> hashMap = new HashMap<Integer,String>();

    // Displaying HashMap
    System.out.println(hashMap);
  }
}

{}

向`HashMap`添加元素

创建HashMap后，现在让我们向其中添加元素。HashMap 提供了put()方法，该方法接受两个参数，第一个是键，第二个是值。见下面的例子。

  import java.util.*;
class Demo
{
  public static void main(String args[])
  {
  // Creating HashMap
    HashMap<Integer,String> hashMap = new HashMap<Integer,String>();
    // Adding elements
    hashMap.put(1, "One");
    hashMap.put(2, "Two");
    hashMap.put(3, "Three");
    hashMap.put(4, "Four");
    // Displaying HashMap
    System.out.println(hashMap);
  }
}

{ 1 =一，2 =二，3 =三，4 =四}

从`HashMap`中移除元素

在这种情况下，我们需要从 hashmap 中移除任何元素。我们可以使用 remove()方法，该方法将 key 作为参数。它有一个重载的 remove()方法，该方法接受两个参数:第一个是键，第二个是值。

  import java.util.*;
class Demo
{
  public static void main(String args[])
  {
  // Creating HashMap
    HashMap<Integer,String> hashMap = new HashMap<Integer,String>();
    // Adding elements
    hashMap.put(1, "One");
    hashMap.put(2, "Two");
    hashMap.put(3, "Three");
    hashMap.put(4, "Four");
    // Displaying HashMap
    System.out.println(hashMap);
    // Remove element by key
    hashMap.remove(2);
    System.out.println("After Removing 2 :\n"+hashMap);
    // Remove by key and value
    hashMap.remove(3, "Three");
    System.out.println("After Removing 3 :\n"+hashMap);

  }
}

{ 1 =一，2 =二，3 =三，4 =四}移除 2 后:{ 1 =一，3 =三，4 =四}移除 3 后:{ 1 =一，4 =四}

遍历元素

为了访问 hashmap 的元素，我们可以使用循环遍历它们。在这个例子中，我们使用 for 循环来迭代元素。

  import java.util.*;
class Demo
{
  public static void main(String args[])
  {
  // Creating HashMap
    HashMap<Integer,String> hashMap = new HashMap<Integer,String>();
    // Adding elements
    hashMap.put(1, "One");
    hashMap.put(2, "Two");
    hashMap.put(3, "Three");
    hashMap.put(4, "Four");
    // Traversing HashMap
    for(Map.Entry<Integer, String> entry : hashMap.entrySet()) {
      System.out.println(entry.getKey()+" : "+entry.getValue());
    }   
  }
}

1:1 2:2 3:3 4:4

替换`HashMap`元素

HashMap 提供了替换元素的内置方法。有两种重载替换方法:第一种方法接受两个参数，一个用于键，第二个用于要替换的值。第二个方法接受三个参数第一个是键，第二个是与键相关联的值，第三个是我们要用键值替换的值。

  import java.util.*;
class Demo
{
  public static void main(String args[])
  {
  // Creating HashMap
    HashMap<Integer,String> hashMap = new HashMap<Integer,String>();
    // Adding Elements
    hashMap.put(1, "One");
    hashMap.put(2, "Two");
    hashMap.put(3, "Three");
    hashMap.put(4, "Four");
    // Traversing HashMap
    for(Map.Entry<Integer, String> entry : hashMap.entrySet()) {
      System.out.println(entry.getKey()+" : "+entry.getValue());
    }
    // Replacing Elements of HashMap
    hashMap.replace(1, "One-1");
    System.out.println(hashMap);
    hashMap.replace(1, "One-1", "First");
    System.out.println(hashMap);
  }
}

1:1 2:2 3:3 4:4 { 1 = 1-1，2 = 2，3 = 3，4 = 4 } { 1 =第一，2 = 2，3 = 3，4 = 4 }

Java 集合框架`TreeMap`

原文：https://www.studytonight.com/java/treemap-in-collection-framework.php

TreeMap 类是基于红黑树的 Map 接口的实现。它提供了一种以排序顺序存储键值对的有效方法。

它类似于 HashMap 类，只是它是按照键的升序排序的。由于其不同步的性质，它不适合线程安全操作。

它实现了导航映射接口并扩展了抽象映射类。下面给出了这个类的声明。

`TreeMap`声明

public class TreeMap<K,V>extends AbstractMap<K,V>implements NavigableMap<K,V>, Cloneable, Serializable

要点:

它只包含独特的元素。
它不能有空键，但可以有多个空值。
它是非同步的。
它保持升序。

`TreeMap`构造器

示例:创建`TreeMap`

让我们举一个例子来理解最初为空的 treeMap 的创建。

  class Demo
{
  public static void main(String args[])
  {
    // Creating TreeMap
    TreeMap<String,Integer> treeMap = new TreeMap<String,Integer>();
    // Displaying TreeMap
    System.out.println(treeMap);
  }
}

{}

`TreeMap`方法

此表包含可用于操作对象的TreeMap方法。

示例:向`TreeMap`添加元素

创建TreeMap后，让我们向其中添加元素。我们使用 put 方法插入元素，该方法需要两个参数:第一个是键，第二个是值。

  class Demo
{
  public static void main(String args[])
  {
    // Creating TreeMap
    TreeMap<String,Integer> treeMap = new TreeMap<String,Integer>();
    // Adding elements
    treeMap.put("a",100);
    treeMap.put("b",200);
    treeMap.put("c",300);
    treeMap.put("d",400);
    // Displaying TreeMap
    System.out.println(treeMap);
  }

{a=100，b=200，c=300，d=400}

获取 LinkedHashMap 中的第一个和最后一个键

我们可以使用 firstEntry()和 lastEntry()方法获取映射的第一个和最后一个元素。它返回一对键和值。

  import java.util.*;

class Demo
{
  public static void main(String args[])
  {
    // Creating TreeMap
    TreeMap<String,Integer> treeMap = new TreeMap<String,Integer>();
    // Adding elements
    treeMap.put("a",100);
    treeMap.put("b",200);
    treeMap.put("c",300);
    treeMap.put("d",400);
    // Displaying TreeMap
    System.out.println(treeMap);
    // First Element
    System.out.println("First Element: "+treeMap.firstEntry());
    // Last Element
    System.out.println("Last Element: "+treeMap.lastEntry());

  }
}

{a=100，b=200，c=300，d=400}第一个元素:a=100 最后一个元素:d=400

示例:查找`TreeMap`的头图和尾图

我们可以使用头映射()和尾映射()方法来获取TreeMap的头元素和尾元素。这些方法返回包含元素的映射。

  import java.util.*;

class Demo
{
  public static void main(String args[])
  {
    // Creating TreeMap
    TreeMap<String,Integer> treeMap = new TreeMap<String,Integer>();
    // Adding elements
    treeMap.put("a",100);
    treeMap.put("b",200);
    treeMap.put("c",300);
    treeMap.put("d",400);
    // Displaying TreeMap
    System.out.println(treeMap);
    // Head Map
    System.out.println("Head Map: "+treeMap.headMap("c"));
    // Tail Map
    System.out.println("Tail Map: "+treeMap.tailMap("c"));

  }
}

{a=100，b=200，c=300，d=400}头部图:{a=100，b=200}尾部图:{c=300，d=400}

示例:迭代`TreeMap`

在这个例子中，我们正在创建TreeMap来存储数据。它使用树来存储数据，数据总是按照排序的顺序，并使用循环来迭代映射。见下面的例子。

  import java.util.*;

class Demo
{
  public static void main(String args[])
  {
    TreeMap<String,Integer> tm = new TreeMap<String,Integer>();
    tm.put("a",100);
    tm.put("b",200);
    tm.put("c",300);
    tm.put("d",400);

    Set<Map.Entry<String,Integer>> st = tm.entrySet();
    for(Map.Entry<String,Integer> me:st)
    {
      System.out.print(me.getKey()+":");
      System.out.println(me.getValue());
    }
  }
}

a:100 b:200 c:300 d:400

Java 集合框架`Hashtable`

原文：https://www.studytonight.com/java/hashtable-in-collection-framework.php

Java Hashtable是Hashtable的一种实现，它以键值对的形式存储元素。它不允许空键和空值。它是 HashMap 的同步版本。

它扩展了字典类并实现了映射接口。下面给出了这个类的声明。

`Hashtable`声明

public class Hashtable<K,V>extends Dictionary<K,V>implements Map<K,V>, Cloneable, Serializable

要点

它包含基于键的值。
它包含独特的元素。
它不允许空键或空值。
它是同步的。
Hashtable的初始默认容量是 11。

在本教程中，我们将学习创建一个Hashtable，向其中添加新元素，遍历其元素等。

`Hashtable`构造器

示例:创建`Hashtable`

让我们举一个例子来创建Hashtable，该Hashtable包含字符串和Integer类型对的元素。最初它是空的，所以如果我们打印它，它会显示空括号。我们将在下一个例子中学习添加元素。

  import java.util.*;

class Demo
{
  public static void main(String args[])
  {
    // Creating Hashtable
    Hashtable<String,Integer> hashtable = new Hashtable<String,Integer>();

    // Displaying Hashtable
    System.out.println(hashtable);

  }
}

{}

`Hashtable`方法

向`Hashtable`添加元素

为了在Hashtable中插入元素，我们使用了put()方法来添加新元素。它需要两个参数:第一个是关键，第二个是价值。

  import java.util.*;

class Demo
{
  public static void main(String args[])
  {
    // Creating Hashtable
    Hashtable<String,Integer> hashtable = new Hashtable<String,Integer>();
    // Adding elements
    hashtable.put("a",100);
    hashtable.put("b",200);
    hashtable.put("c",300);
    hashtable.put("d",400);
    // Displaying Hashtable
    System.out.println(hashtable);

  }
}

{b=200，a=100，d=400，c=300}

示例:不允许空值

由于Hashtable不允许空键或空值，因此强制插入空值会引发错误。见下面的例子。

  import java.util.*;

class Demo
{
  public static void main(String args[])
  {
    // Creating Hashtable
    Hashtable<String,Integer> hashtable = new Hashtable<String,Integer>();
    // Adding elements
    hashtable.put("a",100);
    hashtable.put("b",200);
    hashtable.put("c",300);
    hashtable.put("d",400);
    hashtable.put(null, 0); // error: no null allowed
    // Displaying Hashtable
    System.out.println(hashtable);

  }
}

线程“main”Java . lang . nullpointerexception 中出现异常

示例:搜索关键字或值

Hashtable提供了各种方法，如contains()、containsKey()等来搜索Hashtable中的元素。包含()方法搜索指定值，而containsKey()方法搜索指定键。

  import java.util.*;

class Demo
{
  public static void main(String args[])
  {
    // Creating Hashtable
    Hashtable<String,Integer> hashtable = new Hashtable<String,Integer>();
    // Adding elements
    hashtable.put("a",100);
    hashtable.put("b",200);
    hashtable.put("c",300);
    hashtable.put("d",400);
    // Displaying Hashtable
    System.out.println(hashtable);
    // Search for a value
    boolean val = hashtable.contains(400);
    System.out.println("is 400 present: "+val);
    // Search for a key
    val = hashtable.containsKey("d");
    System.out.println("is d present: "+val);   
  }
}

{b=200，a=100，d=400，c=300}存在 400:真存在 d 存在:真

示例:遍历`Hashtable`

我们可以使用循环遍历Hashtable元素来访问它的元素，并获得所有可用元素的列表。

  import java.util.*;

class Demo
{
  public static void main(String args[])
  {
    // Creating Hashtable
    Hashtable<String,Integer> hashtable = new Hashtable<String,Integer>();
    // Adding elements
    hashtable.put("a",100);
    hashtable.put("b",200);
    hashtable.put("c",300);
    hashtable.put("d",400);
    // Traversing Hashtable
    for(Map.Entry<String, Integer> m : hashtable.entrySet()) {
      System.out.println(m.getKey()+" "+m.getValue());
    }   
  }
}

b 200 a 100 d 400 c 300

Java `Collections`类

原文：https://www.studytonight.com/java/collections-in-collection-framework.php

Java Collections 类是集合框架的一部分。这个类被设计为提供搜索、排序、复制等方法。它只包含对集合进行操作或返回集合的内置静态方法。它包含对集合进行操作的多态算法。

该类位于 java.util 包中。这个类的声明如下。

集合类声明

public class Collections extends Object

它继承了 Object 类，如果对象为空，这个类的所有方法都会抛出一个 NullPointerException 。

收集方法

此表包含集合类的常用方法。

示例:排序列表

在这个例子中，我们使用的是 Collections 类的sort()方法，用于对集合的元素进行排序。这里我们使用存储Integer类型对象和排序的ArrayList类。

  import java.util.*;  
public class Demo {  
    public static void main(String a[]){
      // Creating ArrayList
        ArrayList<Integer> list = new ArrayList<>();
        // Adding elements
        list.add(100);  
        list.add(2);  
        list.add(66); 
        list.add(22);
        list.add(10);
        // Displaying list
        System.out.println(list);
        // Sorting list
        Collections.sort(list);
        // Displaying sort data
        System.out.println(list);
    }  
}

[100, 2, 66, 22, 10] [2, 10, 22, 66, 100]

示例:查找最小和最大元素

collections 类提供了两种方法max()和min()，可用于从集合中获取最大值和最小值。见下面的例子。

  import java.util.*;  
public class Demo {  
    public static void main(String a[]){
      // Creating ArrayList
        ArrayList<Integer> list = new ArrayList<>();
        // Adding elements
        list.add(100);  
        list.add(2);  
        list.add(66); 
        list.add(22);
        list.add(10);
        // Displaying list
        System.out.println(list);
        // Find min element
        int min = Collections.min(list);
        // Find max element
        int max = Collections.max(list);
        // Displaying data
        System.out.println("Minimum element : "+ min);
        System.out.println("Maximum element : "+ max);
    }  
}

[100，2，66，22，10]最小元素:2 最大元素:100

示例:交换元素

为了交换元素，我们不需要编写逻辑代码。Collections 类提供了内置的交换方法，可用于将元素从集合中的一个位置交换到另一个位置。swap()方法取三个参数:第一个是对象的引用，第二个是第一个元素的索引，第三个是要交换的第二个元素的索引。见下面的例子。

  import java.util.*;  
public class Demo {  
    public static void main(String a[]){
      // Creating ArrayList
        ArrayList<Integer> list = new ArrayList<>();
        // Adding elements
        list.add(100);  
        list.add(2);  
        list.add(66); 
        list.add(22);
        list.add(10);
        // Displaying list
        System.out.println(list);
        // Swapping elements
        Collections.swap(list, 0, 4); // 100 is swapped by 10
        System.out.println("List after swapping : "+ list);
    }  
}

[100，2，66，22，10]交换后的列表:[10，2，66，22，100]

示例:反转列表

Collections 类提供了一个静态方法reverse()，用于以相反的顺序获取一个集合。在下面的例子中，我们使用reverse()方法以相反的顺序获得列表。

  import java.util.*;  
public class Demo {  
    public static void main(String a[]){
      // Creating ArrayList
        ArrayList<Integer> list = new ArrayList<>();
        // Adding elements
        list.add(100);  
        list.add(2);  
        list.add(66); 
        list.add(22);
        list.add(10);
        // Displaying list
        System.out.println(list);
        // Reverse the list
        Collections.reverse(list);
        // Displaying data
        System.out.println("List in reverse order "+list);
    }  
}

[100，2，66，22，10]按相反顺序列出[10，22，66，2，100]

Java `Comparable`接口

原文：https://www.studytonight.com/java/comparable-in-collection-framework.php

Java Comparable 接口是集合框架的一个成员，用于比较对象，并按照自然顺序进行排序。

自然排序是指compareTo()方法的行为，定义在Comparable接口中。它的排序技术取决于接口使用的对象类型。如果对象类型是字符串，则按字典顺序对其进行排序。

如果对象类型是包装类对象，如:整数或列表，那么它会根据它们的值进行排序。

如果对象类型是自定义对象，如:用户定义的对象，则根据定义的compareTo()方法进行排序。

实现这个接口的类可以通过调用Collections.sort()方法自动排序。实现此接口的对象可以用作排序映射中的键或排序集合中的元素，而无需指定 comaprator。这个接口的声明如下。

申报

public interface Comparable<T>

可比方法

它包含下面给出的单一方法compareTo()。

int compareTo(T o) : 它将对象与指定的对象进行比较，以便排序。

compareTo()功能将当前对象与提供的对象进行比较。这个函数已经为默认包装类和基本数据类型实现了，但是这个函数也需要为用户定义的类实现。

如果当前对象大于提供的对象，则返回正整数。

如果当前对象小于提供的对象，则返回负整数。

如果当前对象等于提供的对象，则它返回零。

例外

如果指定的对象为空，则该方法返回 NullPointerException，如果指定对象的类型阻止将其与该对象进行比较，则返回ClassCastException。

示例:排序列表

让我们举一个例子来对存储整数值的ArrayList进行排序。我们使用集合类的sort()方法对实现比较接口的对象进行排序。因为整数包装类实现了可比较，所以我们能够得到排序的对象。见下面的例子。

  import java.util.*;  
public class Demo {  
    public static void main(String a[]){
      // Creating List
        ArrayList<Integer> list = new ArrayList<>();
        // Adding elements
        list.add(100);  
        list.add(2);  
        list.add(66); 
        list.add(22);
        list.add(10);
        // Displaying list
        System.out.println(list);
        // Sorting list
        Collections.sort(list);
        // Displaying sorted list
        System.out.println("Sorted List : "+list);
    }  
}

[100，2，66，22，10]排序列表:[2，10，22，66，100]

示例:排序字符串对象

对字符串对象进行排序时，可比较的基于字典顺序对其进行排序。意思是像排序顺序这样的字典。见下面的例子。

  import java.util.*;  
public class Demo {  
    public static void main(String a[]){
      // Creating List
        ArrayList<String> list = new ArrayList<>();
        // Adding elements
        list.add("D");  
        list.add("L");  
        list.add("A"); 
        list.add("Z");
        list.add("C");
        // Displaying list
        System.out.println(list);
        // Sorting list
        Collections.sort(list);
        // Displaying sorted list
        System.out.println("Sorted List : "+list);
    }

[D，L，A，Z，C]排序列表:[A，C，D，L，Z]

示例:排序用户定义的对象

如果我们有自定义对象，那么我们必须实现 Comparable 接口并覆盖其 compareTo()方法。现在它将基于我们在compareTo()方法中定义的逻辑进行比较。见下面的例子。

  import java.util.*;  

class Employee implements Comparable <Employee>
{
    int empId;
    String name;
    public Employee (int empId, String name)
    {
        this.empId=empId;
        this.name=name;
    }
    public String toString()
    {
        return this.empId + " " + this.name;
    }

     // Sorting by empId
    public int compareTo(Employee std){    

        return this.empId - std.empId; 
    } 
}

public class Demo {  
    public static void main(String a[]){
      ArrayList <Employee> list = new ArrayList <Employee> ( ); 
        list.add(new Employee(2, "Boman")); 
        list.add(new Employee(1, "Abram")); 
        list.add(new Employee(3, "Dinesh")); 

        // Displaying
        for (int i=0; i<list.size(); i++) 
            System.out.println(list.get(i)); 

        // Sorting 
        Collections.sort(list); 

        // Displaying after sorting
        System.out.println("\nAfter Sorting :\n");
        for (int i=0; i<list.size(); i++) 
            System.out.println(list.get(i)); 
    }  
}

2 博曼 1 亚伯兰 3 迪内什排序后:1 亚伯兰 2 博曼 3 迪内什

Java 集合`Comparator`接口

原文：https://www.studytonight.com/java/comparators-interface-in-java.php

在 Java 中，Comparator 接口用于以自己的方式对集合中的对象进行排序。它使您能够决定如何在集合和映射中对元素进行排序和存储。

Comparator接口定义compare()方法。这个方法有两个参数。此方法比较参数中传递的两个对象。如果两个对象相等，则返回 0。如果 object1 大于 object2，则返回正值。否则返回负值。如果对象类型不兼容，该方法可以抛出 ClassCastException 进行比较。

使用`Comparator`接口的规则

使用Comparator接口的规则:

如果要对集合的元素进行排序，需要实现 Comparator 接口。
如果您没有在Comparator接口中指定对象的类型，那么默认情况下，它假设您将对对象类型的对象进行排序。因此，当您覆盖 compare()方法时，您需要将参数的类型指定为“仅对象”。
如果要对用户定义的类型元素进行排序，那么在实现Comparator接口时，需要一般地指定用户定义的类型。如果在实现接口时没有指定用户定义的类型，则默认情况下，它采用对象类型，并且您将无法比较集合中的用户定义类型元素

例如:

如果您想根据学生类中定义的滚动数对元素进行排序，那么在实现Comparator接口时，您需要将其概括如下:

class MyComparator implements Comparator<Student>{}

如果你只写，

class MyComparator implements Comparator {}

然后，默认情况下，它假设 compare()方法参数的数据类型为 Object，因此您将无法比较 Student 类型(用户定义类型)对象。

是时候举个例子了！

学生班级:

class Student
int roll;
  String name;
  Student(int r,String n)
  {
      roll = r;
      name = n;
  }
  public String toString()
  {
      return roll+" "+name;
  }

MyComparator 类:

该类根据学生的成绩定义学生类的比较逻辑。学生对象将按卷的升序排序。

class MyComparator implements Comparator<Student>
{
  public int compare(Student s1,Student s2)
    {
        if(s1.roll == s2.roll) return 0;
        else if(s1.roll > s2.roll) return 1;
        else return -1;
    }
}

现在我们用main()函数创建一个 Test 类，

public class Test
{

   public static void main(String[] args)
   {
       TreeSet< Student> ts = new TreeSet< Student>(**new MyComparator()**);
       ts.add(new Student(45, "Rahul"));
       ts.add(new Student(11, "Adam"));
       ts.add(new Student(19, "Alex"));
       System.out.println(ts);
   }

}

[ 11 亚当，19 亚历克斯，45 拉胡尔]

如您在输出中所见，学生对象按照其滚动的升序存储。

注:

当我们使用Comparator接口对集合中的元素进行排序时，我们需要传递实现Comparator接口的类对象。
要对 TreeSet 集合进行排序，需要在 TreeSet 的构造器中传递该对象。
如果使用了任何其他集合，比如 ArrayList，那么我们需要调用 Collections 类的 sort 方法，并将集合的名称和这个对象作为参数传递。
例如，如果上述程序使用ArrayList集合，公共类测试如下:

public class Test
{
   public static void main(String[] args)
   {
       ArrayList< Student> ts = new ArrayList< Student>();
       ts.add(new Student(45, "Rahul"));
       ts.add(new Student(11, "Adam"));
       ts.add(new Student(19, "Alex"));
       Collections.sort(ts,new MyComparator()); /*passing the name of the ArrayList and the
object of the class that implements Comparator in a predefined sort() method in Collections
class*/
       System.out.println(ts);
   }
}

Java 集合遗留类

原文：https://www.studytonight.com/java/legacy-classes-and-interface.php

早期版本的 java 不包括 Collections 框架。它只定义了几个提供存储对象方法的类和接口。当集合框架被添加到 J2SE 1.2 中时，原始的类被重新设计以支持集合接口。这些类也被称为遗留类。JDK 5 重新设计了所有遗留类和接口，以支持泛型。一般来说，遗留类是受支持的，因为仍然有一些代码使用它们。

以下是由 java.util 包定义的遗留类

词典
Hashtable
性能
堆
矢量

只有一个遗留接口叫做枚举

注意:所有的遗留类都是同步的

枚举接口

枚举接口定义通过对象集合进行枚举(一次获取一个)的方法。
该接口被迭代器接口取代。
但是有些遗留类如向量、属性定义了几种使用枚举接口的方法。
它规定了以下两种方法

boolean hasMoreElements() *//It returns true while there are still more elements to extract,
and returns false when all the elements have been enumerated.*

Object nextElement() *//It returns the next object in the enumeration i.e. each call to nextElement() method
obtains the next object in the enumeration. It throws NoSuchElementException when the
enumeration is complete.*

向量类

Vector 类似于ArrayList，代表一个动态数组。
向量和ArrayList有两个区别。首先，Vector 是同步的，而 ArrayList 不是，其次，它包含许多不属于 Collections Framework 的遗留方法。
随着 JDK 5 的发布，Vector 也实现了 Iterable。这意味着 Vector 与集合完全兼容，并且 Vector 可以通过 for-each 循环迭代其内容。

向量类有以下四个构造器

Vector() *//This creates a default vector, which has an initial size of 10.*

Vector(int size) *//This creates a vector whose initial capacity is specified by size.*

Vector(int size, int incr) *//This creates a vector whose initial capacity is specified by size and whose
increment is specified by incr. The increment specifies the number of elements to allocate each time
when a vector is resized for addition of objects.*

Vector(Collection c) *//This creates a vector that contains the elements of collection c.*

Vector 定义了几种遗留方法。让我们看看由 Vector 类定义的一些重要的遗留方法。

向量的例子

import java.util.*;
public class Test
{
  public static void main(String[] args)
   {
      Vector<Integer> ve = new Vector<Integer>();
       ve.add(10);
       ve.add(20);
       ve.add(30);
       ve.add(40);
       ve.add(50);
       ve.add(60);

       Enumeration<Integer> en = ve.elements();

       while(en.hasMoreElements())
       {
           System.out.println(en.nextElement());
       }
   }

}

10 20 30 40 50 60

`Hashtable`类

像 HashMap 一样，Hashtable 也存储键/值对。然而键和值都不能为空。
HashMap 和 Hashtable 还有一个区别就是 Hashtable 是同步的，而 HashMap 不是。

Hashtable有以下四个构造器

Hashtable() *//This is the default constructor. The default size is 11.*

Hashtable(int size) *//This creates a hash table that has an initial size specified by size.*

Hashtable(int size, float fillratio) *//This creates a hash table that has an initial size specified by size
and a fill ratio specified by fillRatio. This ratio must be between 0.0 and 1.0, and it determines how full
the hash table can be before it is resized upward. Specifically, when the number of elements is greater
than the capacity of the hash table multiplied by its fill ratio, the hash table is expanded.
If you do not specify a fill ratio, then 0.75 is used.*

Hashtable(Map< ? extends K, ? extends V> m) *//This creates a hash table that is initialized with the
elements in m. The capacity of the hash table is set to twice the number of elements in m.
The default load factor of 0.75 is used.*

`Hashtable`示例

import java.util.*;
class HashTableDemo
{
  public static void main(String args[])
  {
    Hashtable<String,Integer> ht = new Hashtable<String,Integer>();
    ht.put("a",new Integer(100));
    ht.put("b",new Integer(200));
    ht.put("c",new Integer(300));
    ht.put("d",new Integer(400));

    Set st = ht.entrySet();
    Iterator itr=st.iterator();
    while(itr.hasNext())
    {
      Map.Entry m=(Map.Entry)itr.next();
      System.out.println(itr.getKey()+" "+itr.getValue());
    }
  }
}

a 100 b 200 c 300 d 400

`Hashtable`和`HashMap`的区别

属性类

属性类扩展了Hashtable类。
用于维护键和值均为字符串的值列表

属性类定义两个构造器

Properties() *//This creates a Properties object that has no default values*

Properties(Properties propdefault) *//This creates an object that uses propdefault for its default values.*

属性相对于Hashtable的一个优点是，我们可以指定一个默认属性，当没有值与某个键相关联时，该属性会很有用。

注意:在这两种情况下，属性列表都为空

在属性类中，您可以指定一个默认属性，如果没有值与某个键相关联，将返回该属性。

属性类示例

import java.util.*;

public class Test
{

   public static void main(String[] args)
   {
     Properties pr = new Properties();
     pr.put("Java", "James Ghosling");
     pr.put("C++", "Bjarne Stroustrup");
     pr.put("C", "Dennis Ritchie");
     pr.put("C#", "Microsoft Inc.");
     Set< ?> creator = pr.keySet();

     for(Object ob: creator)
     {
         System.out.println(ob+" was created by "+ pr.getProperty((String)ob) );
     }

   }

}

Java 是詹姆斯·戈林创造的 C++是比雅尼·斯特劳斯特鲁普创造的 C 是丹尼斯·里奇创造的 C#是微软公司创造的

栈类

栈类扩展了向量。
对于栈元素，它遵循后进先出原则。
它只定义了一个默认构造器
```
Stack() //This creates an empty stack
```
如果要将对象放在栈顶部，请调用 push()方法。如果要移除并返回顶部元素，请调用 pop()方法。如果在调用栈为空时调用 pop()方法，将引发 EmptyStackException。

您可以使用 peek()方法返回，但不能移除顶部对象。如果栈上没有任何内容，则 empty()方法返回 true。search()方法确定一个对象是否存在于栈中，并返回将它带到栈顶部所需的弹出次数。

栈示例

import java.util.*;

class StackDemo {
public static void main(String args[]) {
Stack st = new Stack();
st.push(11);
st.push(22);
st.push(33);
st.push(44);
st.push(55);
Enumeration e1 = st.elements();

while(e1.hasMoreElements())
System.out.print(e1.nextElement()+" ");

st.pop();
st.pop();

System.out.println("\nAfter popping out two elements");

Enumeration e2 = st.elements();

while(e2.hasMoreElements())
System.out.print(e2.nextElement()+" ");

}
}

11 22 33 44 55 弹出两个元素后 11 22 33

词典类

字典是抽象类。
它代表一个键/值对，操作非常像 Map。
虽然字典目前没有被弃用，但它被归类为过时的，因为它完全被映射类取代了。

GUI

Java 中的 Applet

原文：https://www.studytonight.com/java/java-applet.php

Applet 是一种特殊的 Java 程序，在支持 Java 的浏览器中运行。这是第一个可以使用浏览器在网络上运行的 Java 程序。Applet 通常嵌入在网页中，并在浏览器中运行。

换句话说，我们可以说 Applet 是小型的 Java 应用，可以在互联网服务器上访问，通过互联网传输，并且可以作为网络文档的一部分自动安装和运行。

在用户接收到 Applet 之后，Applet 可以产生图形用户界面。它对资源的访问有限，因此它可以运行复杂的计算，而不会引入病毒或破坏数据完整性的风险。

要创建 Applet，类必须扩展 java.applet.Applet 类。

Applet 类没有任何 main()方法。使用 JVM 查看。JVM 可以使用网络浏览器的插件或者单独的运行时环境来运行 Applet 应用。

JVM 创建一个 applet 类的实例，并调用init()方法来初始化 Applet。

注意: Java Applet 从 Java 9 开始就被弃用了。这意味着 Applet API 不再被认为是重要的。

Java Applet 的生命周期

以下是 Applet 中的各个阶段

Applet 已初始化。
Applet 已启动
Applet 已绘制。
Applet 已停止。
Applet 被销毁。

life-cycle-applet

简单的 Applet

import java.awt.*;
import java.applet.*;
public class Simple extends Applet
{
  public void **paint**(Graphics g)
    {
      g.drawString("A simple Applet", 20, 20);
    }
}

creating simple applet

每个 Applet 应用必须导入两个包- java.awt和java.applet。

java.awt.*导入抽象窗口工具包(AWT)类。Applet 通过 AWT 与用户交互(直接或间接)。AWT 支持基于窗口的图形用户界面。java.applet.*导入 applet 包，其中包含 Applet 类。您创建的每个 applet 都必须是 Applet 类的子类。

程序中的类必须声明为公共的，因为它将被程序外的代码访问。每个 Applet 应用都必须声明一个paint()方法。这个方法是由 AWT 类定义的，必须被 applet 覆盖。每当 Applet 需要重新显示其输出时，都会调用 paint()方法。关于 applet 应用需要注意的另一件重要的事情是，applet 的执行并不是从main()方法开始的。事实上，Applet 应用没有任何main()方法。

Applet 的优势

因为它在客户端工作，所以需要非常少的响应时间。
它可以在任何运行 JVM 的浏览器上运行。

Applet 类

Applet 类为 applet 的执行提供了所有必要的支持，比如 applet 的初始化和销毁。它还提供了加载和显示图像的方法以及加载和播放音频剪辑的方法。

Applet 框架

大多数 Applet 会覆盖这四种方法。这四种方法形成了 Applet 生命周期。

init() : init()是第一个被调用的方法。这是变量初始化地方。这个方法在 applet 运行时只被调用一次。
start():init()之后调用 start()方法。调用此方法是为了在 Applet 停止后重新启动它。
stop() : 调用 stop()方法，在 applet 不可见时挂起不需要运行的线程。
destroy() : 当你的 Applet 需要从内存中完全移除时，会调用 destroy()方法。

注意:stop()方法总是在 destroy()方法之前调用。

Applet 框架示例

import java.awt.*;
import java.applet.*;
public class AppletTest extends Applet
{
 public void **init()**
 {
  //initialization
 }
 public void **start** ()
 {
  //start or resume execution
 }
 public void **stop()**
 {
  //suspend execution
 {
 public void **destroy()**
 {
  //perform shutdown activity
 }
 public void **paint** (Graphics g)
 {
  //display the content of window
 }
}

Applet 示例

import java.applet.*;
import java.awt.*;
public class MyApplet extends Applet
{
 int height, width;
 public void init()
 {
  height = getSize().height;
  width = getSize().width;
  setName("MyApplet");
 }
 public void paint(Graphics g)
 {
  g.drawRoundRect(10, 30, 120, 120, 2, 3);
 }
}

applet example

Applet 中的参数

可以在 Applet 中使用<【PARAM…>标签应用用户定义的参数。每个<PARAM……>标签都有一个名称和值属性。

示例:

  name = color
Value = red

语法:

<PARAM name = ……… Value = “………” >

在 applet 代码中，applet 可以通过名称引用参数，然后找到它的值。

处理和设置参数最重要的两件事是 HTML 文档中的标记和解析该参数的 Applet 代码。

init()方法用于获取标签中定义的参数。getParameter()方法用于获取参数。

在 Applet 中，参数在加载时传递给 Applet。

示例:

java 停止

  import java.applet.*;
import java.awt.*;
public class param extends Applet
{
  String str;
  public void init()
  {
    str=getParameter("pname");  
    if (str == null)
    str = "Welcome to studytonight.com";
    str = "Hello " + str; 
  }   
    public void paint(Graphics g)
    {
      g.drawString(str, 200, 200);
    }
}

我的钱. html

  <html>
<applet code=param.class height=300 width=300> 
<param Name="pname" value="Welcome to studytonight.com">
</applet>
</html>

applet-viewer-parameter

applet-start

如何运行 Applet 程序

Applet 程序的编译方式与您编译控制台程序的方式相同。然而，有两种方法可以运行 Applet。

在兼容 Java 的网络浏览器中执行 Applet。
使用 Applet 查看器，如标准工具 Applet 查看器。Applet 查看器在窗口中执行您的 Applet

要在网络浏览器中执行 Applet，请在同一目录中创建简短的 HTML 文件。在文件的正文标签内，包含以下代码。(Applet标签加载 Applet 类)

< applet code = "MyApplet" width=400 height=400 >
< /applet >

运行 HTML 文件

running applet inside browser

使用 Applet 查看器运行 Applet

要使用 Applet 查看器执行 Applet，请编写如上所述的短 HTML 文件。如果你将其命名为run.htm，那么下面的命令将运行你的 Applet 程序。

f:/>appletviewer run.htm

running applet using applet viewer

Applet 中的图形

在 Applet 中，java.awt.Graphicsclass 提供了使用图形的方法。

下面是图形类的方法。

示例:

graphicsdemo 1 . java

  import java.applet.Applet;  
import java.awt.*;  
public class GraphicsDemo1 extends Applet
{    
  public void paint(Graphics g)
  {  
    g.setColor(Color.black);  
    g.drawString("Welcome to studytonight",50, 50); 
    g.setColor(Color.blue);  
    g.fillOval(170,200,30,30);  
    g.drawArc(90,150,30,30,30,270);  
    g.fillArc(270,150,30,30,0,180);  
    g.drawLine(21,31,20,300);  
    g.drawRect(70,100,30,30);  
    g.fillRect(170,100,30,30);  
    g.drawOval(70,200,30,30);  
  }  
}

GraphicsDemo1.html

  <html>
<body>
<applet code="GraphicsDemo1.class" width="300" height="300">
</applet>
</body>
</html>

graphics-demo-applet

在 Applet 中使用图像

在 Applet 程序中，也可以使用图像

java.awt.Image 类用于表示图像。

java.applet、java.awt 和 java.awt.image 是用于事件处理的包。

加载图像

在 Applet 中，使用 getImage() 方法加载图像。当调用 Applet 的构造器时，此方法有效。总是建议在 init() 方法中调用构造器。

这里有一些例子:

image1 = getImage(getCodeBase()、“image 1 . gif”)；
image 2 = getimage(getdocumentbase()，" image 1 . JPEG ")；【image 3 = getimage(新 URL(" http://Java . sun . com/graphics/image . gif ")；

显示图像

在 Applet 中，使用 drawImage()方法显示图像。此方法由 Graphics 对象提供，该对象被传递给 paint()方法。

示例:

aiming . Java

  import java.awt.*;
import java.applet.*;
public class Aimage extends Applet
{
  Image img1;
  public void init()
  {
    img1=getImage(getDocumentBase(),"icon.png");
  }
  public void paint(Graphics g)
  {
    g.drawImage(img1,100,100,this);
  }   
}

aiming . html

  <html>
<applet code=Aimage height=300 width=300>
</applet>
</html>

images-with-applet

studytonight-icon-applet

Applet 中的事件处理

在 Applet 中，我们还可以执行事件处理。

下面是一个事件处理的例子，点击按钮时会打印一条消息。

示例:

EventAppletDemo.java

  import java.applet.*;  
import java.awt.*;  
import java.awt.event.*;  
public class EventAppletDemo extends Applet implements ActionListener
{  
  Button b1;  
  TextField tf1;  
  public void init()
  {  
    tf1=new TextField();  
    tf1.setBounds(30,40,200,20);  
    b1=new Button("Click");  
    b1.setBounds(80,150,60,50);    
    add(b1);
    add(tf1);  
    b1.addActionListener(this);  
    setLayout(null);  
  }  
  public void actionPerformed(ActionEvent e)
  {  
    tf1.setText("Welcome to studytonight");  
  }   
}

Myapplet.html

  <html>
<body>
<applet code="EventAppletDemo.class" width="300" height="300">
</applet>
</body>
</html>

event-handling-in-applet

applet-with-event-handling

Applet 中的动画

在 Applet 中，我们还可以使用 gif 图像在程序中创建动画。下面是一个使用 drawImage()方法的示例，该方法属于 Graphics 类，用于显示图像。

注意:下载下面例子的 gif 文件

示例:

动画演示. java

  import java.awt.*;  
import java.applet.*;  
public class AnimationDemo extends Applet 
{  
  Image p;  
  public void init() 
  {  
    p = getImage(getDocumentBase(),"ball.gif");  
  }  
  public void paint(Graphics g) 
  {  
    for(inti=0;i<500;i++)
    {  
      g.drawImage(p, i,50, this);  
      try
      {
        Thread.sleep(100);
      }
      catch(Exception e)
      {}  
    }  
  }  
}

动画演示. html

  <html>
<body>
<applet code="AnimationDemo.class" width="300" height="300">
</applet>
</body>
</html>

animation-applet

日本管道等级

在 Java 中，JApplet 是 swing 的公共类。japlet 在 java.applet.Applet 中扩展了这个类。japlet 在 JVM 或 Applet 查看器的帮助下生成一个字节码。JApplet 可以用任何编程语言编写，然后可以编译成 Java 字节码。

示例:

JAppletDemo.java

  import java.applet.*;  
import javax.swing.*;  
import java.awt.event.*;  
public class JAppletDemo extends JApplet implements ActionListener
{  
  JButton b;  
  JTextField t;  
  public void init()
  {  
    t=new JTextField();  
    t.setBounds(30,40,220,20);  
    b=new JButton("Click");  
    b.setBounds(80,150,70,40);  
    add(b);
    add(t);  
    b.addActionListener(this);  
    setLayout(null);  
  }  
  public void actionPerformed(ActionEvent e)
  {  
    t.setText("Welcome to studytonight.com");  
  }  
}

JAppletDemo.html

  <html>
<body>
<applet code="JAppletDemo.class" width="300" height="300">
</applet>
</body>
</html>

jclass-applet

在 Applet 中绘画

下面是一个在 Applet 中使用 MouseMotionListener 的 mouseDragged()方法进行绘画的例子。

示例:

PaintingDemo.java

  import java.awt.*;  
import java.awt.event.*;  
import java.applet.*;  
public class PaintingDemo extends Applet implements MouseMotionListener
{    
  public void init()
  {  
    addMouseMotionListener(this);  
    setBackground(Color.white);  
  }  
  public void mouseDragged(MouseEvent me)
  {  
    Graphics g=getGraphics();  
    g.setColor(Color.black);  
    g.fillOval(me.getX(),me.getY(),5,5);  
  }  
  public void mouseMoved(MouseEvent me)
  {}  
}

PaintingDemo.html

  <html>
<body>
<applet code="PaintingDemo.class" width="300" height="300">
</applet>
</body>
</html>

applet-painting

Applet 中的模拟时钟

在 java 中，Applet 可以用来创建一个模拟时钟。为模拟时钟创建程序，需要导入 java.apple、java.awt、java.util 和 java.text 包。还使用了日期和时间功能。数学函数在创建模拟时钟中起着重要作用。下面是一个创建模拟时钟的程序。

示例:

模拟演示 1.java

  import java.applet.*;  
import java.awt.*;  
import java.util.*;  
import java.text.*;  

public class AnalogDemo1 extends Applet implements Runnable 
{  
int width, height;  
    Thread t = null;  
    booleanthreadSuspended;  
    int hours=0, minutes=0, seconds=0;  
    String timeString = ""; 
    public void init() 
      {   
        width = getSize().width;  
        height = getSize().height;  
        setBackground( Color.black );  
      }  
public void start() 
  {  
    if ( t == null ) 
      {  
        t = new Thread( this );  
        t.setPriority( Thread.MIN_PRIORITY );  
        threadSuspended = false;  
        t.start();  
      }  
    else 
      {  
        if ( threadSuspended ) 
          {  
            threadSuspended = false;  
            synchronized( this ) 
            {  
              notify();  
            }  
          }  
      }  
   }  

public void stop() 
{  
  threadSuspended = true;  
}  

public void run() {  
  try {  
     while (true) {  

        Calendar cal = Calendar.getInstance();  
        hours = cal.get( Calendar.HOUR_OF_DAY );  
        if ( hours> 12 ) hours -= 12;  
        minutes = cal.get( Calendar.MINUTE );  
        seconds = cal.get( Calendar.SECOND );  
        SimpleDateFormat formatter = new SimpleDateFormat( "hh:mm:ss", Locale.getDefault() );  
        Date date = cal.getTime();  
        timeString = formatter.format( date );  
        if ( threadSuspended ) {  
            synchronized( this ) {  
              while ( threadSuspended ) {  
                wait();  
              }  
           }  
        }  
        repaint(); 
        t.sleep( 1000 ); 
     }  
  }  
  catch (Exception e) { }
}  

void drawHand( double angle, int radius, Graphics g ) {  
  angle -= 0.5 * Math.PI;  
  int x = (int)( radius*Math.cos(angle) );  
  int y = (int)( radius*Math.sin(angle) );  
  g.drawLine( width/2, height/2, width/2 + x, height/2 + y );  
}  

void drawWedge( double angle, int radius, Graphics g ) {  
  angle -= 0.5 * Math.PI;  
  int x = (int)( radius*Math.cos(angle) );  
  int y = (int)( radius*Math.sin(angle) );  
  angle += 2*Math.PI/3;  
  int x2 = (int)( 5*Math.cos(angle) );  
  int y2 = (int)( 5*Math.sin(angle) );  
  angle += 2*Math.PI/3;  
  int x3 = (int)( 5*Math.cos(angle) );  
  int y3 = (int)( 5*Math.sin(angle) );  
  g.drawLine( width/2+x2, height/2+y2, width/2 + x, height/2 + y );  
  g.drawLine( width/2+x3, height/2+y3, width/2 + x, height/2 + y );  
  g.drawLine( width/2+x2, height/2+y2, width/2 + x3, height/2 + y3 );  
}  

public void paint( Graphics g ) {  
  g.setColor( Color.pink );  
  drawWedge( 2*Math.PI * hours / 12, width/5, g );  
  drawWedge( 2*Math.PI * minutes / 60, width/3, g );  
  drawHand( 2*Math.PI * seconds / 60, width/2, g );  
  g.setColor( Color.white );  
  g.drawString( timeString, 10, height-10 );  
}  
}

AnalogueDemo1.html

  <html>
<body>
<applet code="AnalogDemo1.class" width="300" height="300">
</applet>
</body>
</html>

analog-clock

Applet 中的数字时钟

在 java 中，Applet 可以用来创建数字时钟。为了给数字钟创建一个程序，需要导入 java.apple、java.awt、java.util 和 java.text 包。还使用了日期和时间功能。下面是一个创建数字时钟的程序。

示例:

DigitalClockDemo1.java

  import java.applet.*;  
import java.awt.*;  
import java.util.*;  
import java.text.*;  
public class DigitalClockDemo1 extends Applet implements Runnable 
{  
  Thread t = null;  
  int h=0, m=0, s=0;  
  String timeString = "";  
public void init() 
{  
  setBackground( Color.black);  
}  
public void start() 
{  
  t = new Thread( this );  
  t.start();  
}  
public void run() 
{  
  try 
    {  
      while (true) 
        {  
          Calendar cal = Calendar.getInstance();  
          h = cal.get( Calendar.HOUR_OF_DAY );  
          if ( h> 12 ) h -= 12;  
          m = cal.get( Calendar.MINUTE );  
          s = cal.get( Calendar.SECOND );  
          SimpleDateFormat f = new SimpleDateFormat("hh:mm:ss");  
          Date date = cal.getTime();  
          timeString = f.format( date );  
          repaint();  
          t.sleep( 1000 );  
       }  
    }  
  catch (Exception e) { }
}  
public void paint( Graphics g ) 
  {  
    g.setColor( Color.white );  
    g.drawString( timeString, 50, 50 );  
  }  
}

DigitalClockDemo1.html

  <html>
<body>
<applet code="DigitalClockDemo1.class" width="300" height="300">
</applet>
</body>
</html>

digital-clock-applet

Java GUI 事件处理

原文：https://www.studytonight.com/java/event-handling-in-java.php

任何使用图形用户界面(GUI)的程序，比如为 windows 编写的 Java 应用，都是事件驱动的。事件描述任何对象的状态变化。例如:按下按钮、在文本框中输入字符、点击或拖动鼠标等。

事件处理的组件

事件处理有三个主要组件，

事件:事件是物体状态的变化。
事件源:事件源是生成事件的对象。
监听器:监听器是监听事件的对象。当事件发生时，监听器会收到通知。

事件是如何处理的？

一个源生成一个事件，并将其发送给一个或多个在该源中注册的侦听器。一旦侦听器接收到事件，它们就会处理该事件，然后返回。许多 Java 包都支持事件，如 java.util 、 java.awt 和 java.awt.event 。

重要事件类和接口

处理事件的步骤:

在类中实现适当的接口。
向侦听器注册组件。

事件处理示例

import java.awt.*;
import java.awt.event.*;
import java.applet.*;
import java.applet.*;
import java.awt.event.*;
import java.awt.*;

public class Test extends Applet implements KeyListener
{
	String msg="";
	public void init()
	{
		addKeyListener(this);
	}
	public void keyPressed(KeyEvent k)
	{
		showStatus("KeyPressed");
	}
	public void keyReleased(KeyEvent k)
	{
		showStatus("KeyRealesed");
	}
	public void keyTyped(KeyEvent k)
	{
		msg = msg+k.getKeyChar();
		repaint();
	}
	public void paint(Graphics g)
	{
		g.drawString(msg, 20, 40);
	}
}

HTML 代码:

<applet code="Test" width=300, height=100>
</applet>

event handling example

Java AWT

原文：https://www.studytonight.com/java/java-awt.php

Java AWT 是一个包含大量类和方法的 API，用于创建和管理图形用户界面(GUI)应用。AWT 旨在为图形用户界面设计提供一套通用的工具，可以在各种平台上工作。AWT 提供的工具是使用每个平台的本映射形用户界面工具包实现的，因此保留了每个平台的外观和感觉。这是使用 AWT 的一个优势。但是这种方法的缺点是，在一个平台上设计的图形用户界面在另一个平台上显示时可能看起来不同，这意味着 AWT 组件依赖于平台。

AWT 是 Swing 的基础，即 Swing 是一个改进的图形用户界面 API，扩展了 AWT。但是现在使用 AWT 仅仅是因为大多数图形用户界面 Java 程序是使用 Swing 实现的，因为它丰富的图形用户界面控件实现和轻量级的特性。

Java AWT 层次结构

下面给出了 Java AWT 类的层次结构，所有的类都在 java.awt 包中提供。

heirarchy of component class

组件类

组件类位于 AWT 层次结构的顶部。它是一个抽象类，封装了可视组件的所有属性。组件对象负责记住当前的前景和背景颜色以及当前选定的文本字体。

容器

容器是 AWT 中的一个组件，它包含另一个组件，如按钮、文本字段、表格等。容器是组件类的子类。容器类跟踪添加到另一个组件的组件。

面板

面板类是容器的具体子类。面板不包含标题栏、菜单栏或边框。它是一个用来装组件的容器。

窗口类

窗口类创建顶层窗口。窗口没有边框和菜单栏。

基本框架

框架是窗口的子类，有调整大小画布。它是一个容器，包含几个不同的组件，如按钮、标题栏、文本字段、标签等。在 Java 中，大多数 AWT 应用都是使用框架窗口创建的。Frame 类有两种不同的构造器，

Frame() throws HeadlessException
Frame(String title) throws HeadlessException

创建框架

有两种方法可以创建框架。他们是，

通过实例化框架类
通过扩展框架类

通过实例化框架类创建框架窗口

import java.awt.*;
public class Testawt
{
  Testawt()
  {
    Frame fm=new Frame();    //Creating a frame
    Label lb = new Label("welcome to java graphics");   //Creating a label
    fm.add(lb);                  //adding label to the frame
    fm.setSize(300, 300);   //setting frame size.
    fm.setVisible(true);     //set frame visibilty true
  }
  public static void main(String args[])
  {
    Testawt ta = new Testawt();
  }
}

creating Frame Window

通过扩展框架类创建框架窗口

package testawt;

import java.awt.*;
import java.awt.event.*;

public class Testawt extends Frame
{
    public Testawt()
    {
        Button btn=new Button("Hello World");
        add(btn); 		//adding a new Button.
        setSize(400, 500);        //setting size.
        setTitle("StudyTonight");  //setting title.
        setLayout(new FlowLayout());	 //set default layout for frame.
        setVisible(true);           //set frame visibilty true.
    }

    public static void main (String[] args)
    {
        Testawt ta = new Testawt();   //creating a frame.
    }
}

awt example

需要记住的要点:

创建框架时(通过实例化或扩展框架类)，框架的可见性必须具备以下两个属性:
- setSize(int width，int height)；
- set visible(true)；
当您创建其他组件时，如按钮、文本字段等。然后需要使用 add(组件的对象)的方法将其添加到框架中；
您也可以添加以下方法来调整框架的大小- 设置大小可调整(真)；

AWT 按钮

在 Java 中，AWT 包含一个按钮类。它用于创建一个可以执行动作的标签按钮。

自动测试按钮类别声明:

公共类 Button 扩展了组件实现 Accessible

示例:

让我们举一个例子来创建一个按钮，并通过提供坐标将其添加到框架中。

  import java.awt.*;  
public class ButtonDemo1
{  
public static void main(String[] args) 
{  
    Frame f1=new Frame("studytonight ==> Button Demo");  
    Button b1=new Button("Press Here");  
    b1.setBounds(80,200,80,50);  
    f1.add(b1);  
    f1.setSize(500,500);  
    f1.setLayout(null);  
    f1.setVisible(true);   
}  
}

awt-button

AWT 标签

在 Java 中，AWT 包含一个标签类。它用于将文本放置在容器中。只允许单行文本，不能直接更改文本。

标签声明:

公共类标签扩展了组件实现可访问

示例:

在本例中，我们创建了两个标签来向框架显示文本。

  import java.awt.*;  
class LabelDemo1
{  
  public static void main(String args[])
  {     
    Frame l_Frame= new Frame("studytonight ==> Label Demo");  
    Label lab1,lab2;  
    lab1=new Label("Welcome to studytonight.com");  
    lab1.setBounds(50,50,200,30);  
    lab2=new Label("This Tutorial is of Java");  
    lab2.setBounds(50,100,200,30);  
l_Frame.add(lab1); 
l_Frame.add(lab2);  
l_Frame.setSize(500,500);  
l_Frame.setLayout(null);  
l_Frame.setVisible(true);  
}  
}

awt-label

AWT TextField 物件

在 Java 中，AWT 包含一个 TextField 类。它用于显示单行文本。

文本字段声明:

公共类 TextField 扩展了 TextComponent

示例:

我们正在创建两个文本字段来显示单行文本字符串。该文本本质上是可编辑的，参见下面的示例。

  import java.awt.*;  
class TextFieldDemo1{  
public static void main(String args[]){  
    Frame TextF_f= new Frame("studytonight ==>TextField");  
TextField text1,text2;  
    text1=new TextField("Welcome to studytonight");  
    text1.setBounds(60,100, 230,40);  
    text2=new TextField("This tutorial is of Java");  
    text2.setBounds(60,150, 230,40);  
TextF_f.add(text1); 
TextF_f.add(text2);  
TextF_f.setSize(500,500);  
TextF_f.setLayout(null);  
TextF_f.setVisible(true);  
}  
}

awt-textbox

AWT TextArea(阿拉伯文)

在 Java 中，AWT 包含一个文本区域类。它用于显示多行文本。

文本区域声明:

公共类 TextArea 扩展了 TextComponent

示例:

在本例中，我们创建了一个文本区域，用于显示多行文本字符串并允许文本编辑。

  import java.awt.*;  
public class TextAreaDemo1 
{  
  TextAreaDemo1()
  {  
    Frame textArea_f= new Frame();  
    TextArea area=new TextArea("Welcome to studytonight.com");  
    area.setBounds(30,40, 200,200);  
    textArea_f.add(area);  
    textArea_f.setSize(300,300);  
    textArea_f.setLayout(null);  
    textArea_f.setVisible(true);  
  }  
  public static void main(String args[])  
  {  
    new TextAreaDemo1();  
  }  
}

awt-textarea

AWT 复选框

在 Java 中，AWT 包含一个复选框类。当我们只想选择一个选项，即“真”或“假”时，就会用到它。勾选复选框后，其状态为“开”(真)，否则为“关”(假)。

复选框语法

公共类 Checkbox 扩展组件实现项目可选择，可访问

示例:

在这个例子中，我们正在创建用于获取用户输入的复选框。如果复选框被选中，它返回真，否则返回假。

  import java.awt.*;  
public class CheckboxDemo1  
{  
  CheckboxDemo1(){
    Frame checkB_f= new Frame("studytonight ==>Checkbox Example");  
    Checkbox ckbox1 = new Checkbox("Yes", true);  
    ckbox1.setBounds(100,100, 60,60);  
    Checkbox ckbox2 = new Checkbox("No");  
    ckbox2.setBounds(100,150, 60,60);  
    checkB_f.add(ckbox1);  
    checkB_f.add(ckbox2);  
    checkB_f.setSize(400,400);  
    checkB_f.setLayout(null);  
    checkB_f.setVisible(true);  
  }  
  public static void main(String args[])  
  {  
    new CheckboxDemo1();  
  }  
}

awt-checkbox

AWT 复选框组

在 Java 中，AWT 包含了 aCheckboxGroup 类。它用于对一组复选框进行分组。将复选框分组后，一次只能选中一个复选框。

复选框组声明:

公共类 CheckboxGroup 扩展了实现 Serializable 的对象

示例:

本示例创建一个 checkboxgroup，用于将多个复选框分组到一个单元中。当我们必须在多个选项中选择一个选项时，这很有帮助。

  import java.awt.*;    
public class CheckboxGroupDemo
{    
  CheckboxGroupDemo(){    
    Frame ck_groupf= new Frame("studytonight ==>CheckboxGroup");    
    CheckboxGroupobj = new CheckboxGroup();  
    Checkbox ckBox1 = new Checkbox("Yes", obj, true);    
    ckBox1.setBounds(100,100, 50,50);    
    Checkbox ckBox2 = new Checkbox("No", obj, false);    
    ckBox2.setBounds(100,150, 50,50);    
    ck_groupf.add(ckBox1);    
    ck_groupf.add(ckBox2);    
    ck_groupf.setSize(400,400);    
    ck_groupf.setLayout(null);    
    ck_groupf.setVisible(true);    
  }    
  public static void main(String args[])    
  {    
    new CheckboxGroupDemo();    
  }    
}

awt-checkbox-group

AWT 选择

在 Java 中，AWT 包含一个选择类。它用于创建选项的下拉菜单。当用户从下拉列表中选择特定项目时，它会显示在菜单的顶部。

选择声明:

公共类选择扩展组件实现项目可选择，可访问

示例:

在本例中，我们正在创建下拉菜单，用于从多个选项中获得用户选择。

  import java.awt.*;  
public class ChoiceDemo
{  
  ChoiceDemo()
  {  
    Frame choice_f= new Frame();  
    Choice obj=new Choice();  
    obj.setBounds(80,80, 100,100);  
    obj.add("Red");  
    obj.add("Blue");  
    obj.add("Black");  
    obj.add("Pink");  
    obj.add("White");  
    obj.add("Green");
    choice_f.add(obj);  
    choice_f.setSize(400,400);  
    choice_f.setLayout(null);  
    choice_f.setVisible(true);  
  }  
  public static void main(String args[])  
  {  
    new ChoiceDemo();  
  }  
}

awt-choice

自动气象测试列表

在 Java 中，AWT 包含一个列表类。它用于一起表示项目列表。可以从列表中选择一个或多个项目。

列表声明:

公共类列表扩展组件实现项目可选择，可访问

示例:

在本例中，我们创建了一个用于列出项目的列表。

  import java.awt.*;  
public class ListDemo
{  
  ListDemo()
  {  
    Frame list_f= new Frame();  
    List obj=new List(6);  
    obj.setBounds(80,80, 100,100);  
    obj.add("Red");  
    obj.add("Blue");  
    obj.add("Black");  
    obj.add("Pink");  
    obj.add("White");  
    obj.add("Green");
    list_f.add(obj);  
    list_f.setSize(400,400);  
    list_f.setLayout(null);  
    list_f.setVisible(true);  
  }  
  public static void main(String args[])  
  {  
    new ListDemo();  
  }  
}

awt-list

AWT 画布

在 Java 中，AWT 包含一个画布类。提供空白矩形区域。当用户想要在屏幕上绘图时使用它。

声明:

公共类 Canvas 扩展了组件实现可访问

示例:

画布用于提供使用鼠标指针进行绘制的位置。我们可以用它来获取用户架构用户输入。

  import java.awt.*;  
public class CanvasDemo1  
{  
  public CanvasDemo1()  
  {  
    Frame canvas_f= new Frame("studytonight ==> Canvas");  
    canvas_f.add(new CanvasDemo());  
    canvas_f.setLayout(null);  
    canvas_f.setSize(500, 500);  
    canvas_f.setVisible(true);  
  }  
  public static void main(String args[])  
  {  
    new CanvasDemo1();  
  }  
}  
class CanvasDemo extends Canvas  
{  
  public CanvasDemo() {  
    setBackground (Color.WHITE);  
    setSize(300, 200);  
  }  
  public void paint(Graphics g)  
  {  
    g.setColor(Color.green);  
    g.fillOval(80, 80, 150, 75);  
  }  
}

awt-canvas

Java 抽象窗口工具包（AWT）

原文：https://www.studytonight.com/java/java-awt-1.php

在我们之前的主题中，我们讨论了 AWT API 的一些组件，现在这里我们将讨论其余的组件和事件侦听器。

菜单和菜单

在 Java 中，AWT 包含一个菜单项和菜单类。菜单项用于在菜单中添加标签。菜单用于创建菜单组件的下拉列表

MenuItem 声明

公共类 MenuItem 扩展了 MenuComponent 实现的可访问性

菜单声明

公共类 Menu 扩展 MenuItem 实现 MenuContainer，可访问

示例:

在这个例子中，我们正在创建一个包含子菜单的菜单项。我们使用菜单项和菜单类来创建菜单。

  import java.awt.*;  
class MenuDemo1  
{  
  MenuDemo1()
  {  
    Frame menu_f= new Frame("studytonight ==> Menu and MenuItem Demo");  
    MenuBarmenu_bar=new MenuBar();  
    Menu menu11=new Menu("Menu");  
    Menu sub_menu1=new Menu("Sub Menu =>");  
    MenuItem a1=new MenuItem("Red");  
    MenuItem a2=new MenuItem("Light Red");  
    MenuItem a3=new MenuItem("Drak Red");  
    MenuItem b1=new MenuItem("Green");  
    MenuItem b2=new MenuItem("Light Green");  
    MenuItem b3=new MenuItem("Dark Green");
    menu11.add(a1); 
    sub_menu1.add(a2);
    sub_menu1.add(a3); 
    menu11.add(b1);    
    sub_menu1.add(b2);  
    sub_menu1.add(b3);  
    menu11.add(sub_menu1);  
    menu_bar.add(menu11);  
    menu_f.setMenuBar(menu_bar);  
    menu_f.setSize(400,400);  
    menu_f.setLayout(null);  
    menu_f.setVisible(true);  
  }  
  public static void main(String args[])  
  {  
    new MenuDemo1();  
  }  
}

awt-menu

AWT 弹出菜单

在 Java 中，AWT 包含一个弹出菜单。这是一个动态的弹出窗口。

人口数量声明

公共类弹出菜单扩展菜单实现菜单容器，可访问

示例:

  import java.awt.*;  
import java.awt.event.*;  
class PopupMenuDemo1  
{  
  PopupMenuDemo1()
  {  
    final Frame pop_menuf= new Frame("studytonight ==>PopupMenu Demo");  
    final PopupMenupop_menu = new PopupMenu("*Edit*");   
    MenuItempop_cut = new MenuItem("Cut");  
    pop_cut.setActionCommand("Cut");  
    MenuItempop_copy = new MenuItem("Copy");  
    pop_copy.setActionCommand("Copy");  
    MenuItempop_paste = new MenuItem("Paste");  
    pop_paste.setActionCommand("Paste");      
    pop_menu.add(pop_cut);  
    pop_menu.add(pop_copy);  
    pop_menu.add(pop_paste);        
    pop_menuf.addMouseListener(new MouseAdapter() 
    {  
      public void mouseClicked(MouseEvent a) 
      {              
        pop_menu.show(pop_menuf , a.getX(), a.getY());  
      }                 
    });  
    pop_menuf.add(pop_menu);   
    pop_menuf.setSize(400,400);  
    pop_menuf.setLayout(null);  
    pop_menuf.setVisible(true);  
  }  
  public static void main(String args[])  
  {  
    new PopupMenuDemo1();  
  }  
}

awt-popup

AWT 面板

在 Java 中，AWT 包含一个面板。面板提供了一个可以放置组件的自由空间。

小组声明

公共类 Panel 扩展了容器实现可访问

示例:

让我们创建一个面板来添加组件，如:按钮，文本框等。面板提供了添加 awt 组件的位置。

  import java.awt.*;  
public class PanelDemo1{  
  PanelDemo1()  
  {  
    Frame panel_f= new Frame("studytonight ==> Panel Demo");    
    Panel panel11=new Panel();  
    panel11.setBounds(40,80,200,200);    
    panel11.setBackground(Color.red);  
    Button box1=new Button("On");     
    box1.setBounds(50,100,80,30);    
    box1.setBackground(Color.gray);   
    Button box2=new Button("Off");   
    box2.setBounds(100,100,80,30);    
    box2.setBackground(Color.gray);   
    panel11.add(box1); 
    panel11.add(box2);  
    panel_f.add(panel11);  
    panel_f.setSize(400,400);    
    panel_f.setLayout(null);    
    panel_f.setVisible(true);    
  }  
  public static void main(String args[])  
  {  
    new PanelDemo1();  
  }  
}

awt-panel

怎么用

在 Java 中，AWT 包含一个对话框。这是一种有边框和标题的窗口。但是它没有任何最大化和最小化按钮。

申报

公共类对话框扩展窗口

示例:

在这个例子中，我们正在创建一个对话框。对话框用于向用户提供信息。

  import java.awt.*;  
import java.awt.event.*;  
public class DialogDemo1
{  
  private static Dialog dialog_d;  
  DialogDemo1() 
  {  
    Frame dialog_f= new Frame();  
    dialog_d = new Dialog(dialog_f , "studytonight ==> Dialog Demo", true);  
    dialog_d.setLayout( new FlowLayout() );  
    Button dialog_b = new Button ("OK");  
    dialog_b.addActionListener ( new ActionListener()  
    {  
      public void actionPerformed( ActionEvent e )  
      {  
        DialogDemo1.dialog_d.setVisible(false);  
      }  
    });  
    dialog_d.add( new Label ("Welcome to studytonight. Click on button to continue."));  
    dialog_d.add(dialog_b);   
    dialog_d.setSize(300,300);    
    dialog_d.setVisible(true);  
  }  
  public static void main(String args[])  
  {  
    new DialogDemo1();  
  }  
}

awt-dialog

AWT 工具包

在 Java 中，AWT 包含一个工具包。它是抽象窗口工具包的超类，可以在任何地方实现。

申报

公共抽象类工具包扩展了对象

示例:

  import java.awt.*;  
import java.awt.event.*;  
public class ToolkitDemo1 
{  
  public static void main(String[] args) 
  {  
    Frame toolkit_f=new Frame("studytonight ==> Toolkit Demo");  
    Button toolkit_b=new Button("beep");  
    toolkit_b.setBounds(50,100,60,30);  
    toolkit_f.add(toolkit_b);     
    toolkit_f.setSize(300,300);  
    toolkit_f.setLayout(null);  
    toolkit_f.setVisible(true);  
    toolkit_b.addActionListener(new ActionListener()
    {  
      public void actionPerformed(ActionEvent a)
      {  
        Toolkit.getDefaultToolkit().beep();  
      }  
    });       
  }  
}

awt-toolkit

动作监听器接口

在 java 中，ActionListener 接口位于 java.awt 下。事件包。当您想要通知按钮或菜单项上的点击操作时，使用此界面。它有actionPeformed()法。

句法

public abstract void actionPerformed(ActionEvent e)

以下是添加操作侦听器接口的三个步骤

步骤 1: 在类中实现 ActionListener 接口。

语法:

public class ActionListenerDemo Implements ActionListener

步骤 2: 现在向监听器注册所有组件。

语法:

component.addActionListener(instanceOfListenerclass);

步骤 3: 最后覆盖 actionPerformed()方法。

语法:

 public void actionPerformed(ActionEvent e)
{  
           //statements
}

示例:

我们可以使用动作监听器在 awt 组件中实现事件。事件可以是任何像:鼠标时钟，鼠标拖动等。在这个例子中，我们实现了 actionlistener。

  import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTextArea;

public class ActionListenerDemo1 implements ActionListener {

  JButton aL_button;
  JFrame aL_frame;
  JTextArea aL_textArea;

  public ActionListenerDemo1() {
    aL_button = new JButton("Click Me");
    aL_frame = new JFrame("studytonight ==>ActionListener Demo");
    aL_textArea = new JTextArea(50, 50);

    aL_button.addActionListener(this);
    aL_textArea.setLineWrap(true);
    aL_frame.setLayout(new BorderLayout());
    aL_frame.add(aL_textArea, BorderLayout.NORTH);
    aL_frame.add(aL_button, BorderLayout.SOUTH);
    aL_frame.pack();

    aL_frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    aL_frame.setVisible(true);
  }

  @Override
  public void actionPerformed(ActionEvent e) {
    aL_textArea.setText(aL_textArea.getText().concat("Welocme to studytonight.com\n"));
  }

  public static void main(String args[]) {
    ActionListenerDemo1 obj= new ActionListenerDemo1();
  }
}

awt-actionlistener

鼠标监听器接口

在 Java 中，MouseListener 接口在 java.awt.event 包下。当鼠标状态改变时，使用这个接口。它有以下 5 种方法:

1.公共抽象 void MouseClicked(MouseEvent e)；

2.公共抽象 void MouseEnTER(MouseEvent e)；

3.公共抽象 void MouseExIt(MouseEvent e)；

4.公共抽象 void MousePressed(MouseEvent e)；

5.公共抽象 void MouseReleased(MouseEvent e)；

示例:

  import java.awt.*;  
import java.awt.event.*;  
public class MouseListenerDemo1 extends Frame implements MouseListener{
  Label mL_l;  
  MouseListenerDemo1(){
    addMouseListener(this);  

    mL_l=new Label();  
    mL_l.setBounds(10,20,500,100);  
    add(mL_l);  
    setSize(300,300);  
    setLayout(null);  
    setVisible(true);  
  }  
  public void mouseClicked(MouseEvent e) {  
    mL_l.setText("studytonight ==> Mouse Clicked");  
  }  
  public void mouseEntered(MouseEvent e) {  
    mL_l.setText("studytonight ==> Mouse Entered");  
  }  
  public void mouseExited(MouseEvent e) {  
    mL_l.setText("studytonight ==> Mouse Exited");  
  }  
  public void mousePressed(MouseEvent e) {  
    mL_l.setText("studytonight ==> Mouse Pressed");  
  }  
  public void mouseReleased(MouseEvent e) {  
    mL_l.setText("studytonight ==> Mouse Released");  
  }  
  public static void main(String[] args) {  
    new MouseListenerDemo1();  
  }  
}

awt-mouselistner

mousemotionlistener 接口

在 Java 中，MouseMotionListener 接口在 java.awt.event 包下。每当移动或拖动鼠标时，都会使用此界面。它有以下两种方法:

1.公共抽象 void MouseDrawed(MouseEvent e)；

2.公共抽象 void Mousemoved(MouseEvent e)；

示例:

  import java.awt.*;  
import java.awt.event.*;  
public class MouseMotionListenerDemo1 extends Frame implements MouseMotionListener{
  MouseMotionListenerDemo1(){
    addMouseMotionListener(this);  

    setSize(500,500);  
    setLayout(null);  
    setVisible(true);  
  }  
  public void mouseDragged(MouseEvent a) {  
    Graphics mM_g=getGraphics();  
    mM_g.setColor(Color.ORANGE);  
    mM_g.fillOval(a.getX(),a.getY(),10,10);  
  }  
  public void mouseMoved(MouseEvent e) {}  

  public static void main(String[] args) {  
    new MouseMotionListenerDemo1();  
  }  
}

awt-mousemotion

项目筛选器接口

在 Java 中，ItemListener 接口在 java.awt.event 包下。只要点击复选框，就会使用该界面。它有 itemStateChanged()方法。

语法:

public abstract void itemStateChanged(ItemEvent e)

示例:

此界面用于处理项目侦听器事件，如:项目已选中或复选框已选中。在这个例子中，我们正在处理复选框选中事件。

  import java.awt.*;    
import java.awt.event.*;    
public class ItemListenerDemo1 implements ItemListener{
  Checkbox iT_checkBox1,iT_checkBox2;  
  Label iT_label;  
  ItemListenerDemo1(){
    Frame iT_f= new Frame("studytonight ==>CheckBox Demo");    
    iT_label = new Label();            
    iT_label.setAlignment(Label.CENTER);    
    iT_label.setSize(400,100);    
    iT_checkBox1 = new Checkbox("Core Java");    
    iT_checkBox1.setBounds(100,100, 100,40);    
    iT_checkBox2 = new Checkbox("jsp");    
    iT_checkBox2.setBounds(100,150, 100,40);    
    iT_f.add(iT_checkBox1); 
    iT_f.add(iT_checkBox2); 
    iT_f.add(iT_label);    
    iT_checkBox1.addItemListener(this);    
    iT_checkBox2.addItemListener(this);    
    iT_f.setSize(400,400);    
    iT_f.setLayout(null);    
    iT_f.setVisible(true);    
  }    
  public void itemStateChanged(ItemEventiT) {      
    if(iT.getSource()==iT_checkBox1)  
      iT_label.setText("Core Java Checkbox: "+ (iT.getStateChange()==1?"checked":"unchecked"));   
    if(iT.getSource()==iT_checkBox2)  
      iT_label.setText("jsp Checkbox: "+ (iT.getStateChange()==1?"checked":"unchecked"));    
  }  
  public static void main(String args[])    
  {    
    new ItemListenerDemo1();    
  }    
}

awt-itemlistener

KeyListener 接口

在 Java 中，KeyListener 接口在 java.awt.event 包下。当键的状态改变时，使用这个接口。它有以下三种方法:

1.公共抽象 void KeyPress(KeyEvent e)；

2.公共抽象 void KeyReleased(KeyEvent e)；

3.公共抽象 void KeyType(KeyEvent e)；

示例:

在这个例子中，我们使用 keylistener 接口来处理按键事件，可以是按键释放、键入等。请参见下面的示例。

  import java.awt.*;  
import java.awt.event.*;  
public class KeyListenerDemo1 extends Frame implements KeyListener{
  Label kL_l;  
  TextArea kL_area;  
  KeyListenerDemo1(){

    kL_l=new Label();  
    kL_l.setBounds(20,50,500,20);  
    kL_area=new TextArea();  
    kL_area.setBounds(20,80,300, 300);  
    kL_area.addKeyListener(this);  

    add(kL_l);
    add(kL_area);  
    setSize(400,400);  
    setLayout(null);  
    setVisible(true);  
  }  
  public void keyPressed(KeyEvent e) {  
    kL_l.setText("studytonight ==> Key Pressed");  
  }  
  public void keyReleased(KeyEvent e) {  
    kL_l.setText("studytonight ==> Key Released");  
  }  
  public void keyTyped(KeyEvent e) {  
    kL_l.setText("studytonight ==> Key Typed");  
  }  

  public static void main(String[] args) {  
    new KeyListenerDemo1();  
  }  
}

awt-keylistener

窗口侦听器接口

在 Java 中，WindowListener Interface 位于 java.awt.event 包下。当窗口的状态改变时，使用这个接口。它有以下 7 种方法:

1.公共抽象 void window activated(window event e)；

2.公共抽象 void window closed(window event e)；

3.公共抽象 void window closing(window event e)；

4.公共抽象 void window deactivated(window event e)；

5.公共抽象 void windowDeiconified(WindowEvent e)；

6.公共抽象 void windowIconified(WindowEvent e)；

7.公共抽象 void window open(window event e)；

示例:

在这个例子中，我们正在处理窗口事件，如:窗口打开，关闭等。

  import java.awt.*;  
import java.awt.event.WindowEvent;  
import java.awt.event.WindowListener;  
public class WindowDemo1 extends Frame implements WindowListener
{  
  WindowDemo1()
  {  
    addWindowListener(this);  
    setSize(500,500);  
    setLayout(null);  
    setVisible(true);  
  }  

  public static void main(String[] args) 
  {  
    new WindowDemo1();  
  }  
  public void windowActivated(WindowEvent arg0) 
  {  
    System.out.println("studytonight ==> activated");  
  }  
  public void windowClosed(WindowEvent arg0) 
  {  
    System.out.println("studytonight ==> closed");  
  }  
  public void windowClosing(WindowEvent arg0) 
  {  
    System.out.println("studytonight ==> closing");  
    dispose();  
  }  
  public void windowDeactivated(WindowEvent arg0) 
  {  
    System.out.println("studytonight ==> deactivated");  
  }  
  public void windowDeiconified(WindowEvent arg0) 
  {  
    System.out.println("studytonight ==>deiconified");  
  }  
  public void windowIconified(WindowEvent arg0) 
  {  
    System.out.println("studytonight ==>iconified");  
  }  
  public void windowOpened(WindowEvent arg0) 
  {  
    System.out.println("studytonight ==> opened");  
  }  
}

在控制台中，它会打印如下消息:今晚研究== >已打开研究今晚== >已激活研究今晚== >正在关闭研究今晚== >已停用研究今晚== >已关闭 awt-windowListener

Java Swing

原文：https://www.studytonight.com/java/java-swing.php

Java Swing 是一个 GUI 框架，包含一组类，提供比 AWT 更强大、更灵活的 GUI 组件。Swing 提供了现代 Java GUI 的观感。Swing 库是 Sun 微系统公司发布的一个官方 Java GUI 工具包。它用于用 Java 创建图形用户界面。

Swing 类在 javax.swing 包及其子包中定义。

秋千的特点

独立于平台
可定制的
可扩张的
可配置的
轻量级选手
丰富的控件
可插拔外观

挥杆和 JFC

JFC 是 Java Foundation 类的缩写，它包含一组构建图形用户界面(GUI)的特性，并为 Java 应用添加丰富的图形功能和交互性。Java Swing 是 Java 基础类(JFC)的一部分。

JFC 的特点

摆动图形用户界面组件。
观感支持。
Java 2D。

AWT 和 Swing 层次结构

swing heirarchy

摇摆班介绍

JPanel : JPanel 是 Swing 的 AWT 类 Panel 的版本，使用相同的默认布局，FlowLayout。JPanel 直接从 JComponent 派生而来。

JFrame : JFrame 是 Swing 版本的 Frame，直接从 Frame 级进化而来。添加到框架的组件称为其内容。

JWindow : 这是 Swing 版本的 Window，直接从 Window 类进化而来。像窗口一样，默认情况下使用边框布局。

JLabel : JLabel 是 JComponent 的后代，用于创建文本标签。

按钮:按钮类提供按钮的功能。JButton 允许图标、字符串或两者与按钮相关联。

JTextField:JTextField 允许编辑单行文本。

创建 JFrame

有两种方法可以创建 JFrame 窗口。

通过实例化 JFrame 类。
通过扩展 JFrame 类。

通过实例化 JFrame 类创建 JFrame 窗口

import javax.swing.*;  //importing swing package
import javax.swing.*;  //importing swing package
import java.awt.*;     //importing awt package
public class First
{
	JFrame jf;
	public First() {
		jf = new JFrame("MyWindow");            //Creating a JFrame with name MyWindow
		JButton btn = new JButton("Say Hello");//Creating a Button named Say Hello
		jf.add(btn);                            //adding button to frame
		jf.setLayout(new FlowLayout());        //setting layout using FlowLayout object
		jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);      //setting close  operation.
		jf.setSize(400, 400);                   //setting size
		jf.setVisible(true);                    //setting frame visibility
	}
	public static void main(String[] args)
	{
		new First();
	}
}

creating jframe using composition

通过扩展 JFrame 类创建 JFrame 窗口

import javax.swing.*; //importing swing package
import java.awt.*; //importing awt package
public class Second extends JFrame
{
	public Second()
	{
		setTitle("MyWindow"); //setting title of frame as  MyWindow
		JLabel lb = new JLabel("Welcome to My Second Window");//Creating a label named Welcome to My Second Window
		add(lb);                        //adding label to frame.
		setLayout(new FlowLayout());    //setting layout using FlowLayout object.
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //setting close operation.
		setSize(400, 400);              //setting size
		setVisible(true);               //setting frame visibility
	}

	public static void main(String[] args)
	{
		new Second();
	}
}

creating jframe using inheritance

要记住的要点

导入 javax.swing 和 java.awt 包，使用 swing 的类和方法。
创建框架时(通过实例化或扩展框架类)，框架的可见性必须具备以下两个属性:
```
setSize(int width, int height);
setVisible(true);
```
当您创建其他组件(如按钮、文本字段等)的对象时。然后需要使用 add(组件的对象)的方法将其添加到框架中；
您也可以添加以下方法来调整框架的大小- 设置大小可调整(真)；

Java Swing 组件和容器

原文：https://www.studytonight.com/java/java-swing-components.php

一个组件是一个独立的视觉控件，而 Java Swing 框架包含了一大组这样的组件，它们提供了丰富的功能并允许高级定制。它们都是从 JComponent 类派生的。所有这些组件都是轻量级组件。这个类提供了一些常见的功能，比如可插拔的外观、对可访问性的支持、拖放、布局等。

容器容纳一组组件。它提供了一个可以管理和显示组件的空间。容器有两种类型:

顶层容器

它继承了 AWT 的组件和容器。
它不能包含在其他容器中。
重量级。
示例:JFrame、JDialog、JApplet

Lightweight Containers

它继承了 JComponent 类。
它是一个通用容器。
它可以用来将相关组件组织在一起。
示例:JPanel

摇摆 JButton

JButton 类提供了按钮的功能。它用于创建按钮组件。JButton 类有三个构造器，

JButton 的例子

在这个例子中，我们使用 Jbutton 类创建了两个按钮，并将它们添加到 Jframe 容器中。

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
public class testswing extends JFrame
{

  testswing()
  {
    JButton bt1 = new JButton("Yes");             //Creating a Yes Button.
    JButton bt2 = new JButton("No");              //Creating a No Button.
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)     //setting close operation.
    setLayout(new FlowLayout());          //setting layout using FlowLayout object
    setSize(400, 400);                    //setting size of Jframe
    add(bt1);             //adding Yes button to frame.
    add(bt2);             //adding No button to frame.

    setVisible(true);
  }
  public static void main(String[] args)
  {
    new testswing();
  }
}

swing button example

jtextfield(jtextfield)

JTextField 用于输入单行文本。它是使用最广泛的文本组件。它有三个构造器，

**JTextField**(int *cols*)
**JTextField**(String *str*, int *cols*)
**JTextField**(String *str*)

列代表文本字段中的列数。

使用 JTextField 的示例

在这个例子中，我们使用 JtextField 类创建文本字段，并将其添加到 jframe 容器中。

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
public class MyTextField extends JFrame
{
  public MyTextField()
  {
    JTextField jtf = new JTextField(20);  //creating JTextField.
    add(jtf);                             //adding JTextField to frame.
    setLayout(new FlowLayout());
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setSize(400, 400);
    setVisible(true);
  }
  public static void main(String[] args)
  {
    new MyTextField();
  }
}

jtextfield example

检验盒

JcheckBox 类用于在 swing 框架中创建 checkBox。在这个例子中，我们创建了三个复选框来获得用户响应。

**JCheckBox**(String *str*)

using JCheckBox

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
public class Test extends JFrame
{
  public Test()
  {
    JCheckBox jcb = new JCheckBox("yes");   //creating JCheckBox.
    add(jcb);                               //adding JCheckBox to frame.
    jcb = new JCheckBox("no");              //creating JCheckBox.
    add(jcb);                               //adding JCheckBox to frame.
    jcb = new JCheckBox("maybe");           //creating JCheckBox.
    add(jcb);                               //adding JCheckBox to frame.
    setLayout(new FlowLayout());
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setSize(400, 400);
    setVisible(true);
  }
  public static void main(String[] args)
  {
    new Test();
  }
}

jcheckbox example

按钮

单选按钮是一组相关按钮，其中只能选择一个。类用于在框架中创建一个单选按钮。下面是 JRadioButton 的构造器，

**JRadioButton**(String *str*)

使用 radiobutton 的示例

为了在 swing 中创建单选按钮，我们使用了 jradiobutton 类。它用于一次获得单个用户响应。

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
public class Test **extends** JFrame
{
 public Test()
 {
  **JRadioButton jcb = new JRadioButton("A")**;	//creating JRadioButton.
  add(jcb);					//adding JRadioButton to frame.
  **jcb = new JRadioButton("B")**;			//creating JRadioButton.
  add(jcb);					//adding JRadioButton to frame.
  **jcb = new JRadioButton("C")**;			//creating JRadioButton.
  add(jcb);					//adding JRadioButton to frame.
  **jcb = new JRadioButton("none")**;
  add(jcb);
  setLayout(new FlowLayout());
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  setSize(400, 400);
  setVisible(true);
 }
 public static void main(String[] args)
 {
  new Test();
 }
}

jradiobutton example

jcombo box-jcombo 方块

组合框是文本字段和下拉列表的组合。 JComboBox 组件用于在 Swing 中创建组合框。下面是 JComboBox 的构造器，

**JComboBox**(String *arr[]*)

使用 JComboBox 的示例

让我们创建一个向 jframe 添加 combobox 的示例。组合框用于创建下拉菜单。见下面的例子。

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
public class Test **extends** JFrame
{
 String **name[]** = {"Abhi","Adam","Alex","Ashkay"};  //list of name.
 public Test()
 {
  **JComboBox jc = new JComboBox(name)**;	//initialzing combo box with list of name.
  add(jc);				//adding JComboBox to frame.
  setLayout(new FlowLayout());
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  setSize(400, 400);
  setVisible(true);
 }
 public static void main(String[] args)
 {
  new Test();
 }
}

jcombobox example

Java 程序：改变框架背景颜色(使用动作事件)

import java.awt.*;  //importing awt package
import javax.swing.*;  //importing swing package
import java.awt.event.*;  //importing event package

//For an event to occur upon clicking the button, ActionListener interface should be implemented
class StColor extends JFrame implements ActionListener{

JFrame frame;
JPanel panel;
JButton b1,b2,b3,b4,b5;

StColor(){

   frame = new JFrame("COLORS");
   frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

   panel = new JPanel();  //Creating a panel which is a container and will hold all the buttons
   panel.setSize(100, 50);

   b1 = new JButton("BLUE");  //Creating a button named BLUE
   b1.addActionListener(this);  //Registering the button with the listener

   b2 = new JButton("RED");  //Creating a button named RED
   b2.addActionListener(this);  //Registering the button with the listener

   b3 = new JButton("CYAN");//Creating a button named CYAN
   b3.addActionListener(this);//Registering the button with the listener

   b4 = new JButton("PINK");  //Creating a button named PINK
   b4.addActionListener(this);  //Registering the button with the listener

   b5 = new JButton("MAGENTA");  //Creating a button named MAGENTA
   b5.addActionListener(this);  //Registering the button with the listener

   //Adding buttons to the Panel
   panel.add(b1);
   panel.add(b2);
   panel.add(b3);
   panel.add(b4);
   panel.add(b5);

   frame.getContentPane().add(panel);  //adding panel to the frame
   frame.setSize(500,300);
   frame.setVisible(true);
   frame.setLayout(new FlowLayout());

}
//The below method is called whenever a button is clicked
    @Override
    public void actionPerformed(ActionEvent e) {

        //This method returns an object of the button on which the Event-
        Pressing of button initially occurred
        Object see = e.getSource();

        if(see ==(b1)){  //Checking if the object returned is of button1
        frame.getContentPane().setBackground(java.awt.Color.blue);  //changing the panel color to blue
        }
        if(see == b2){  //Checking if the object returned is of button2
            frame.getContentPane().setBackground(java.awt.Color.red);  //changing the panel color to red
        }
        if(see == b3){  //Checking if the object returned is of button3
        frame.getContentPane().setBackground(java.awt.Color.cyan);//changing the panel color to cyan
        }
        if(see == b4){  //Checking if the object returned is of button4
            frame.getContentPane().setBackground(java.awt.Color.pink);  //changing the panel color to pink
        }
        if(see == b5){  //Checking if the object returned is of button5
        frame.getContentPane().setBackground(java.awt.Color.magenta);  //changing the panel color to magenta
        }
    }
}

class Test {
    public static void main(String[] args) {
        StColor o = new StColor();
    }
}

输出:

Background Color of a frame

JLabel

在 Java 中，Swingtoolkit 包含一个 JLabel 类。它在 package javax.swing.JLabel 类下。它用于在框中放置文本。只允许单行文本，不能直接更改文本。

申报

公共类 JLabel 扩展了 JComponent 实现了 SwingConstants，可访问

JLabel 包含 4 个构造器。它们如下:

1. JLabel（）

2. JLabel（字符串）

3. JLabel（图标 i）

4.字符串，图标，内部水平对齐

示例:

  import javax.swing.*;  
class SLabelDemo1  
{  
public static void main(String args[])  
{  
    JFrame label_f= new JFrame("studytonight ==> Label Demo");  
    JLabel label_l1,label_l2;  
    label_l1=new JLabel("Welcome to studytonight.com");  
    label_l1.setBounds(50,50, 200,30);  
    label_l2=new JLabel("How are You?");  
    label_l2.setBounds(50,100, 200,30);  
    label_f.add(label_l1); 
    label_f.add(label_l2);  
    label_f.setSize(300,300);  
    label_f.setLayout(null);  
    label_f.setVisible(true);  
    }  
}

swing-jlabel-demo

JTextArea(人名)

在 Java 中，Swing 工具包包含一个 JTextArea 类。它在 package javax.swing.JTextArea 类下。它用于显示多行文本。

申报

公共类 JTextArea 扩展了 JTextComponent

JTextArea 包含 4 个构造器。它们如下:

1.JTextArea()

2.字符串区域

3.JTextArea(内部行，内部列)

4.字符串，内部行，内部列

示例:

让我们举个例子来创建文本区域。我们使用 JtextArea 类来创建文本区域并添加到 Jframe 容器中。

  import javax.swing.*;  
public class STextAreaDemo1  
{  
    STextAreaDemo1()
  {  
        JFrame textArea_f= new JFrame();  
        JTextArea textArea_area=new JTextArea("Welcome to studytonight.com ");  
        textArea_area.setBounds(10,30, 200,200);  
        textArea_f.add(textArea_area);  
        textArea_f.setSize(400,400);  
        textArea_f.setLayout(null);  
        textArea_f.setVisible(true);  
        }  
public static void main(String args[])  
    {  
   new STextAreaDemo1();  
}
}

swing-textarea-demo

jpassword field(jpassword 字段)

在 Java 中，Swing 工具包包含一个 JPasswordField 类。它在 package javax . swing . jpasswordfield 类下。它专门用于密码，可以编辑。

申报

公共类 JPasswordField 扩展了 JTextField

JPasswordFieldContains 包含 4 个构造器。它们如下:

1.jpasswordfield()

2.JPasswordField(整数列)

3.字符串字段(字符串文本)

4.字符串文本，整型列

示例:

为了生成密码组件，swing 提供了以加密格式接受用户输入的 Jpasswordfield。

  import javax.swing.*;    
public class SPasswordFieldDemo1 
{  
    public static void main(String[] args) 
  {    
  JFrame passWord_f=new JFrame("studytonight ==> Password Field Demo");    
  JPasswordField passWord_value = new JPasswordField();   
  JLabel passWord_l1=new JLabel("Password ");    
        passWord_l1.setBounds(20,100, 100,30);    
        passWord_value.setBounds(100,100,100,30);    
        passWord_f.add(passWord_value);  
  passWord_f.add(passWord_l1);  
        passWord_f.setSize(300,300);    
        passWord_f.setLayout(null);    
        passWord_f.setVisible(true);     
  }  
}

swing-password

组建

在 Java 中，Swing 工具包包含一个 JTable 类。它在 package javax.swing.JTable 类下。它用于绘制表格来显示数据。

jtable 包含两个构造器。它们如下:

1.JTable()

2.JTable(对象[]行，对象[]列)

示例:

我们正在创建一个示例，使用 Jtable 类创建一个表，然后将其添加到 Jframe 容器中。

  import javax.swing.*;    
public class STableDemo1 
{    
    JFrame table_f;    
    STableDemo1(){    
    table_f=new JFrame();    
    String table_data[][]={ {"1001","Cherry"}, {"1002","Candy"}, {"1003","Coco"}};    
    String table_column[]={"SID","SNAME"};         
    JTable table_jt=new JTable(table_data,table_column);    
    table_jt.setBounds(30,40,200,300);          
    JScrollPane table_sp=new JScrollPane(table_jt);    
    table_f.add(table_sp);          
    table_f.setSize(300,400);    
    table_f.setVisible(true);    
}     
public static void main(String[] args) 
{    
    new STableDemo1();    
}    
}

swing-table

列表框

在 Java 中，Swing 工具包包含一个 JList 类。它在 package javax.swing.JList 类下。它用于一起表示项目列表。可以从列表中选择一个或多个项目。

申报

公共类 JList 扩展了 JComponent，实现了可滚动、可访问

jlist 包含 3 个构造器。它们如下:

1.JList()

2. JList（和[] listData）

3.JList(列表模型数据模型)

示例:

在这个例子中，我们使用 Jlist 类创建了一个项目列表。该列表用于以列表格式显示项目，并从项目列表中获取用户输入。见下面的例子。

  import javax.swing.*;  
public class SListDemo  
{  
     SListDemo()
  {  
        JFrame list_f= new JFrame();  
        DefaultListModel<String> list_l1 = new DefaultListModel<>();  
        list_l1.addElement("Red");  
        list_l1.addElement("Pink");  
        list_l1.addElement("Blue");  
        list_l1.addElement("Black");  
        JList<String> list1 = new JList<>(list_l1);  
        list1.setBounds(100,100, 75,75);  
        list_f.add(list1);  
        list_f.setSize(400,400);  
        list_f.setLayout(null);  
        list_f.setVisible(true);  
     }  
public static void main(String args[])  
    {  
  new SListDemo();  
    }
}

swing-list

Java Swing 组件和容器

原文：https://www.studytonight.com/java/java-swing-components-1.php

在上一个主题中，我们讨论了 swing 及其一些组件。现在，我们将介绍 swing 框架的其余组件。让我们从 JoptionPane 开始。

jooption pane

在 Java 中，Swing 工具包包含一个 JOptionPane 类。它在 package javax . swing . JoOptionpane 类下。它用于创建显示消息、确认框或输入对话框的对话框。

申报

公共类 JOptionPane 扩展了 JComponent 实现可访问

JOptionPaneContains 包含 3 个构造器。它们如下:

1.JOptionPane()

2. JOptionPane（对象消息）

3.JOptionPane(对象消息，intmessageType)

示例:

让我们举一个例子来创建 JoptionPane 来显示对话框。见下面的例子。

  import javax.swing.*;  
public class SOptionPaneDemo
{  
  JFrameoptionPane_f;  
  SOptionPaneDemo()
  {  
    optionPane_f=new JFrame();  
    JOptionPane.showMessageDialog(optionPane_f,"Hello, Welcome to studytonight.com");  
  }  
  public static void main(String[] args) 
  {  
    new SOptionPaneDemo();  
  }  
}

swing-paneout

示例:

让我们再举一个例子来理解 JoptionPane 的用法。这里我们创建了一个对话来向用户显示更新消息。

  import javax.swing.*;  
public class SOptionPaneDemo
{  
  JFrame optionPane_f;  
  SOptionPaneDemo()
  {  
    optionPane_f=new JFrame();  
    JOptionPane.showMessageDialog(optionPane_f,"Successfully Updated.","studytonight",JOptionPane.WARNING_MESSAGE);     
  }  
  public static void main(String[] args) 
  {  
    new SOptionPaneDemo();  
  }  
}

swing-pane

示例:

我们可以使用 JoptionPane 创建用于获取用户输入的提示框。在这个例子中，我们创建了一个对话框来获取用户名。

  import javax.swing.*;  
public class SOptionPaneDemo
{  
  JFrame optionPane_f;  
  SOptionPaneDemo()
  {  
    optionPane_f=new JFrame();  
    JOptionPane.showInputDialog(optionPane_f,"Enter your Name");     
  }  
  public static void main(String[] args) 
  {  
    new SOptionPaneDemo();  
  }  
}

swing-optionpane

JScrollBar

在 Java 中，Swing 工具包包含一个 JScrollBar 类。它在 package javax.swing.JScrollBar 类下。它用于添加水平和垂直滚动条。

申报

公共类 JScrollBar 扩展了 JComponent 实现可调整、可访问

JScrollBarContains 包含 3 个构造器。它们如下:

1. JScrollBar（）

2.内部定向(JScrollBar)

3.JScrollBar(int 方向，int 值，int 范围，int min_，intmax_)

示例:

我们可以使用 swing JscrollBar 类来创建水平和垂直滚动条。在这个例子中，我们创建了水平和垂直滚动条。

  import javax.swing.*;  
class SScrollBarDemo
{  
  SScrollBarDemo()
  {  
    JFrame scrollBar_f= new JFrame("studytonight ==> Scrollbar Demo");  
    JScrollBar scrollBar_s=new JScrollBar();  
    scrollBar_s.setBounds(100,100, 80,100);  
    scrollBar_f.add(scrollBar_s);  
    scrollBar_f.setSize(500,500);  
    scrollBar_f.setLayout(null);  
    scrollBar_f.setVisible(true);  
  }  
  public static void main(String args[])  
  {  
    new SScrollBarDemo();  
  }
}

swing-scroller

名字，名字，名字

在 Java 中，Swing 工具包包含一个 JMenuBar、JMenu 和 JMenuItem 类。它在 package javax.swing.JMenuBar、javax.swing.JMenu 和 javax.swing.JMenuItem 类下。JMenuBar 类用于在框架上显示菜单栏。JMenu 对象用于下拉菜单栏的组件。对象用于添加带标签的菜单项。

姓名、名称和名称声明

公共类 JMenuBar 扩展了 JComponent 实现的 MenuElement，可访问

公共类 JMenu 扩展 JMenuItem 实现 MenuElement，可访问

公共类 JMenuItem 扩展了 AbstractButton 实现了 Accessible，MenuElement

示例:

让我们举一个例子，在 swing jframe 容器中创建菜单和子菜单。见下面的例子。

  import javax.swing.*;  
class SMenuDemo1  
{  
  JMenu m_menu, m_submenu;  
  JMenuItem menu_i1, menu_i2, menu_i3, menu_i4, menu_i5;  
  SMenuDemo1()
  {  
    JFrame menu_f= new JFrame("Menu and MenuItem Example");  
    JMenuBar menu_mb=new JMenuBar();  
    m_menu=new JMenu("Menu");  
    m_submenu=new JMenu("Sub Menu");  
    menu_i1=new JMenuItem("Red");  
    menu_i2=new JMenuItem("Pink");  
    menu_i3=new JMenuItem("Black");  
    menu_i4=new JMenuItem("Green");  
    menu_i5=new JMenuItem("White");  
    m_menu.add(menu_i1); 
    m_menu.add(menu_i2); 
    m_menu.add(menu_i3);  
    m_submenu.add(menu_i4); 
    m_submenu.add(menu_i5);  
    m_menu.add(m_submenu);  
    menu_mb.add(m_menu);  
    menu_f.setJMenuBar(menu_mb);  
    menu_f.setSize(500,500);  
    menu_f.setLayout(null);  
    menu_f.setVisible(true);  
  }  
  public static void main(String args[])  
  {  
    new SMenuDemo1();  
  }
}

swing-menu

JPopupMenu

在 Java 中，Swing 工具包包含一个 JPopupMenu 类。它在 package javax.swing.JPopupMenu 类下。它用于在指定位置动态创建弹出窗口。

申报

公共类 JPopupMenu 扩展了 JComponent 实现了 Accessible，MenuElement

JPopupMenuContains 包含 2 个构造器。它们如下:

1. JPopupMenu（）

2. JPopupMenu（字符串标签）

示例:

  import javax.swing.*;  
import java.awt.event.*;  
class PopupMenuDemo
{  
  PopupMenuDemo(){  
    final JFrame pop_upf= new JFrame("studytonight ==>PopupMenu Demo");  
    final JPopupMenu popupmenu1 = new JPopupMenu("Edit");   
    JMenuItem pop_upcut = new JMenuItem("Cut");  
    JMenuItem pop_upcopy = new JMenuItem("Copy");  
    JMenuItem pop_uppaste = new JMenuItem("Paste");  
    popupmenu1.add(pop_upcut); 
    popupmenu1.add(pop_upcopy); 
    popupmenu1.add(pop_uppaste);        
    pop_upf.addMouseListener(new MouseAdapter() 
    {  
      public void mouseClicked(MouseEvent a) 
      {              
        popupmenu1.show(pop_upf ,a.getX(), a.getY());  
      }                 
    });  
    pop_upf.add(popupmenu1);   
    pop_upf.setSize(300,300);  
    pop_upf.setLayout(null);  
    pop_upf.setVisible(true);  
  }  
  public static void main(String args[])  
  {  
    new PopupMenuDemo();  
  }
}

swing-popup

复选菜单项

在 Java 中，Swing 工具包包含一个 JCheckBoxMenuItem 类。它在 package javax . swing . jcheckbox menuitem 类下。它用于在菜单上创建复选框。

JCheckBoxMenuItemContains 包含 2 个构造器。它们如下:

1.JCheckBoxMenuItem()

2.jcheckboxmenuitem(动作 a)

3.jcheckboxmenuitem(图标)

4.jcheckboxmenuitem(字符串文本)

5.jcheckboxmenuitem(字符串文本，布尔型 b)

6.jcheckboxmenuitem(字符串文本图标)

7.jcheckboxmenuitem(字符串文本、图标、布尔 b)

示例:

  import java.awt.event.ActionEvent;  
import java.awt.event.ActionListener;  
import java.awt.event.KeyEvent;  
import javax.swing.AbstractButton;  
import javax.swing.Icon;  
import javax.swing.JCheckBoxMenuItem;  
import javax.swing.JFrame;  
import javax.swing.JMenu;  
import javax.swing.JMenuBar;  
import javax.swing.JMenuItem;  

public class SCheckBoxDemo
{  
  public static void main(final String args[]) 
  {  
    JFrame checkbox_frame = new JFrame("studytonight ==>Jmenu Example");  
    checkbox_frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
    JMenuBar checkbox_menuBar = new JMenuBar();  
    JMenu checkbox_fileMenu = new JMenu("File");  
    checkbox_fileMenu.setMnemonic(KeyEvent.VK_F);  
    checkbox_menuBar.add(checkbox_fileMenu);  
    JMenuItem checkbox_menuItem1 = new JMenuItem("Open", KeyEvent.VK_N);  
    checkbox_fileMenu.add(checkbox_menuItem1);  

    JCheckBoxMenuItem checkbox_caseMenuItem = new JCheckBoxMenuItem("Option_1");  
    checkbox_caseMenuItem.setMnemonic(KeyEvent.VK_C);  
    checkbox_fileMenu.add(checkbox_caseMenuItem);  

    ActionListener checkbox_aListener = new ActionListener() 
    {  
      public void actionPerformed(ActionEvent event) 
      {  
        AbstractButton checkbox_aButton = (AbstractButton) event.getSource();  
        boolean checkbox_selected = checkbox_aButton.getModel().isSelected();  
        String checkbox_newLabel;  
        Icon checkbox_newIcon;  
        if (checkbox_selected) {  
          checkbox_newLabel = "Value-1";  
        } else {  
          checkbox_newLabel = "Value-2";  
        }  
        checkbox_aButton.setText(checkbox_newLabel);  
      }  
    };  

    checkbox_caseMenuItem.addActionListener(checkbox_aListener);  
    checkbox_frame.setJMenuBar(checkbox_menuBar);  
    checkbox_frame.setSize(350, 250);  
    checkbox_frame.setVisible(true);  
  }  
}

swing-checkbox

JSeparator

在 Java 中，Swing 工具包包含一个 JSeparator 类。它在 package javax.swing.JSeparator 类下。它用于在两个组件之间创建分隔线。

申报

公共类 JSeparator 扩展 JComponent 实现 SwingConstants，可访问

JSeparatorContains 包含 2 个构造器。它们如下:

1. JSeparator（）

2.JSeparator(面向内部)

示例:

  import javax.swing.*;    
class SeparatorDemo
{    
  JMenu sep_menu, sep_submenu;    
  JMenuItem sep_i1, sep_i2, sep_i3, sep_i4, sep_i5;    
  SeparatorDemo()  
  {    
    JFrame sep_f= new JFrame("Separator Example");    
    JMenuBar sep_mb=new JMenuBar();    
    sep_menu = new JMenu("Menu");    
    sep_i1=new JMenuItem("Black");    
    sep_i2=new JMenuItem("White");       
    sep_menu.add(sep_i1);  
    sep_menu.addSeparator();  
    sep_menu.add(sep_i2);  
    sep_mb.add(sep_menu);    
    sep_f.setJMenuBar(sep_mb);    
    sep_f.setSize(500,500);    
    sep_f.setLayout(null);    
    sep_f.setVisible(true);    
  }    
  public static void main(String args[])    
  {    
    new SeparatorDemo();    
  }
}

swing-seprator

进程条

在 Java 中，Swing 工具包包含一个 JProgressBar 类。它位于 package javax . swing . jprogressbarclass 下，用于创建任务的进度条。

申报

公共类 JProgressBar 扩展了 JComponent 实现 SwingConstants，可访问

JProgressBarContains 包含 4 个构造器。它们如下:

1.JProgressBar()

2 . jprogressbar(内部最小值、内部最大值)

3 . jprogressbar(内部东方)

4.jpprogress(int orient、int min、int max)

示例:

  import javax.swing.*;    
public class ProgressBarDemo extends JFrame
{    
  JProgressBar progBar_jb;    
  int progBar_i=0, progBar_num=0;     
  ProgressBarDemo()
  {    
    progBar_jb=new JProgressBar(0,2000);    
    progBar_jb.setBounds(40,40,180,30);         
    progBar_jb.setValue(0);    
    progBar_jb.setStringPainted(true);    
    add(progBar_jb);    
    setSize(250,150);    
    setLayout(null);    
  }    
  public void iterate()
  {    
    while(progBar_i<=2000)
    {    
      progBar_jb.setValue(progBar_i);    
      progBar_i = progBar_i + 10;    
      try
      {
        Thread.sleep(150);
      }
      catch(Exception e){}    
    }    
  }    
  public static void main(String[] args) {    
    ProgressBarDemo obj=new ProgressBarDemo();    
    obj.setVisible(true);    
    obj.iterate();    
  }    
}

swing-progressbar

树形结构

在 Java 中，Swing 工具包包含一个 JTree 类。它位于包 javax.swing.JTreeclass 下，用于创建树结构的数据。这是一个非常复杂的组件。

申报

公共类 JTree 扩展了 JComponent，实现了可滚动、可访问

jtree 包含 3 个构造器。它们如下:

1.JTree()

2.对象[]值

3. J 树（树节点根）

示例:

在这个例子中，我们创建了一个显示目录的树形菜单结构。我们使用 Jtree 类来创建树结构。见下面的例子。

  import javax.swing.*;  
import javax.swing.tree.DefaultMutableTreeNode;  
public class TreeDemo
{  
  JFrame tree_f;  
  TreeDemo()
  {  
    tree_f=new JFrame();   
    DefaultMutableTreeNode tree_style=new DefaultMutableTreeNode("Style");  
    DefaultMutableTreeNode tree_color=new DefaultMutableTreeNode("color");  
    DefaultMutableTreeNode tree_font=new DefaultMutableTreeNode("font");  
    tree_style.add(tree_color);  
    tree_style.add(tree_font);  
    DefaultMutableTreeNode tree_red=new DefaultMutableTreeNode("red");  
    DefaultMutableTreeNode tree_blue=new DefaultMutableTreeNode("blue");  
    DefaultMutableTreeNode tree_black=new DefaultMutableTreeNode("black");  
    DefaultMutableTreeNode tree_green=new DefaultMutableTreeNode("green");  
    tree_color.add(tree_red); 
    tree_color.add(tree_blue); 
    tree_color.add(tree_black); 
    tree_color.add(tree_green);      
    JTree tree_jt=new JTree(tree_style);  
    tree_f.add(tree_jt);  
    tree_f.setSize(200,200);  
    tree_f.setVisible(true);  
  }  
  public static void main(String[] args) {  
    new TreeDemo();  
  }
}

swing-tree

Java 包装类

原文：https://www.studytonight.com/java/wrapper-class.php

在 Java 中，包装类用于将原始类型数据类型转换为对象，并将对象转换为原始类型数据类型。对于每个原始数据类型，都有一个预定义的类，称为包装类。从 J2SE 5.0 版本开始，自动装箱和拆箱功能用于将原始数据类型自动转换为对象，并将对象自动转换为原始数据类型。

为什么要使用包装类？

我们知道，在 Java 中，当用户给出输入时，它是以字符串的形式。为了将字符串转换成不同的数据类型，使用了包装类。

当我们想要将原始类型转换为对象或者相反时，每次都可以使用包装类。

以下是原始数据类型及其包装类名和用于对话的方法。

| 原始数据类型 | 类包装 Name | 转换方法 |
| 字节 | 字节 | 公共静态字节解析字节(字符串) |
| 短的 | 短的 | 公共静态短解析短(字符串) |
| （同 Internationalorganizations）国际组织 | 整数 | 公共静态整数解析整数(字符串) |
| 长的 | 长的 | 公共静态长解析长(字符串) |
| 漂浮物 | 浮动 | 公共静态浮点解析浮点(字符串) |
| 两倍 | 两倍 | 公共静态双解析双(字符串) |
| 茶 | 性格；角色；字母 | |
| 布尔 | 布尔代数学体系的 | 公共静态布尔解析布尔(字符串) |

在 Java 中，所有的原始包装类都是不可变的。创建新对象时，旧对象不会被修改。下面是一个例子来证明这个概念。

示例:

	 class WrapperPrimitiveDemo1 
{ 
    public static void main(String[] args) 
    { 
        Integer a = new Integer(12); 
        System.out.println("Old value = "+a); 
        xyz(a); 
        System.out.println("New Value = "+a); 
    } 
    private static void xyz(Integer a) 
    { 
        a = a + 10; 
    } 
}

wrapper-class

数字类

Java Number 类是所有数值包装类中的超级类。有 6 个子类，你可以通过跟随图片得到想法。

Number 类包含一些为所有子类提供通用操作的方法。

下面是 Number 类的方法和例子

1.值()方法

此方法用于将数值对象转换为基本数据类型。例如，我们可以将一个整型对象转换为整型，或者将一个双精度对象转换为浮点型。value()方法适用于每种基元类型，语法如下。

语法:

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

示例:

这里我们使用了几种方法，如:byteValue(), intValue(), floatValue()等，将对象类型转换为基本类型。double 类型对象用于获取不同类型的基元值。

	 public class NumberDemo1
{ 
    public static void main(String[] args)  
    { 
        Double d1 = new Double("4.2365"); 
        byte b = d1.byteValue();  
        short s = d1.shortValue();  
        int i = d1.intValue();  
        long l = d1.longValue();  
        float f = d1.floatValue();  
        double d = d1.doubleValue();  

        System.out.println("converting Double to byte : " + b); 
        System.out.println("converting Double to short : " + s); 
        System.out.println("converting Double to int : " + i); 
        System.out.println("converting Double to long : " + l); 
        System.out.println("converting Double to float : " + f); 
        System.out.println("converting Double to double : " + d1); 
    } 
}

number-class-example.

Java `Integer`类

Java Integer 类用于处理整数对象。它提供了可用于将基元转换为对象的方法，反之亦然。

它将一个基元类型的值包装在一个对象中。这个类提供了几种将 int 转换为 String 和将 String 转换为 int 的方法，以及在使用 int 时有帮助的其他常量和方法。

它位于 java.lang pakage 和 java.base 模块中。下面给出了这个类的声明。

申报

public final class Integer extends Number implements Comparable<Integer>

下面讨论Integer类的方法和例子。

1.toString()方法

此方法返回一个 String 对象，表示该整数的值。该值被转换为带符号的十进制表示形式，并作为字符串返回。它覆盖了对象类的toString()方法。

它不接受任何参数，但返回以 10 为基数的该对象值的字符串表示形式。下面给出了该方法的语法。

	 public String toString(int b)

示例:

在这个例子中，我们使用 toString 方法来获取 Integer 对象的字符串表示。

	 public class IntegerClassDemo1  
{ 
    public static void main(String args[])  
    { 
		int a = 95;
        Integer x = new Integer(a); 
		System.out.println("toString(a) = " + Integer.toString(a));           
    } 
}

integer-class

2. 十六进制字符串（）

toHexString()方法用于获取整数参数的字符串表示形式，以 16 为基数表示无符号整数。

此方法接受 int 类型的参数，并返回一个十六进制字符串。下面给出了该方法的语法。

语法:

	 public String toHexString(int b)

示例:

我们正在使用 toHexString()方法获取 int 值的十六进制字符串值。在这个例子中，我们传递了 95 作为参数，得到了 5f 作为十六进制字符串。见下面的例子。

	 public class IntegerClassDemo1  
{ 
    public static void main(String args[])  
    { 
		int a = 95;
        Integer x = new Integer(a); 
		System.out.println("toHexString(a) = " + Integer.toHexString(a));           
    } 
}

integer-class-example

3.toOctalString()

当我们想要获取 int 类型值的八进制字符串表示时，此方法很有帮助。

它可用于获取整数参数的字符串表示形式，即以 8 为基数的无符号整数。

它接受 int 类型的参数，并返回该参数的无符号字符串表示形式。下面给出了该方法的语法。

语法:

	 public String toOctalString(int b)

示例:

让我们举一个例子来获取一个 int 值的八进制值。这里我们将 95 传递给toOctalString()方法，并得到它的八进制值 135。

	 public class IntegerClassDemo1  
{ 
    public static void main(String args[])  
    { 
		int a = 95;
        Integer x = new Integer(a); 
		System.out.println("toOctalString(a) = " + Integer.toOctalString(a));           
    } 
}

integer-class-example

4.toBinaryString()

toBinaryString()方法用于获取整数参数的字符串表示形式，作为基数为 2 的无符号整数。

它采用整数参数，并返回无符号整数值的字符串表示形式。下面给出了该方法的语法。

语法:

	 public String toBinaryString(int b)

示例:

在这个例子中，我们使用 toBinaryString()方法来获取一个 int 值的二进制。这是获取整数值二进制的有效方法。

	 public class IntegerClassDemo1  
{ 
    public static void main(String args[])  
    { 
		int a = 95;
        Integer x = new Integer(a); 
		System.out.println("toBinaryString(a) = " + Integer.toBinaryString(a));           
    } 
}

integer-class-example

5.valueOf()

valueOf()方法用于获取表示指定 int 值的 Integer 对象。它接受一个 int 类型的参数，并返回一个 Integer 实例。下面给出了该方法的语法。

语法:

	 public static Integer valueOf(int b)

Exmaple(前枫树镇)：

	 public class IntegerClassDemo1  
{ 
    public static void main(String args[])  
    { 
		int a = 95;
        Integer x = Integer.valueOf(a); 
		System.out.println("valueOf(a) = " + x);           
    } 
}

integer-class-example

6.parseInt()

parseInt()方法用于将指定的字符串参数解析为带符号的十进制整数。字符串中的字符必须都是十进制数字。

它接受String类型的单个参数，并返回一个 int 值。

语法:

	 public static intparseInt(String val, int radix) throws NumberFormatException

示例:

在下面的例子中，我们将一个包含数字的字符串传递给parseInt()方法。方法返回与字符串对应的 int 值。

	 public class IntegerClassDemo1  
{ 
    public static void main(String args[])  
    { 
        String a = "95";
        Integer x = Integer.parseInt(a); 
		System.out.println("parseInt(a) = " + x);           
    } 
}

integer-class-example

7 .整数()

语法:

	 public static Integer getInteger(String prop)

示例:

	 public class IntegerClassDemo1  
{ 
    public static void main(String args[])  
    { 
		int a = Integer.getInteger("sun.arch.data.model");
		System.out.println("getInteger(sun.arch.data.model) = " + a);           
    } 
}

integer-class-example

8.解码()

decode()方法用于将字符串解码为整数。它接受可以是十进制、十六进制和八进制数的String类型参数，并返回Integer类的实例。下面给出了该方法的语法。

语法:

	 public static Integer decode(String s)
             throws NumberFormatException

示例:

在本例中，我们使用不同类型的数值对其进行解码并获得整数实例。

	 public class IntegerClassDemo1  
{ 
    public static void main(String args[])  
    { 
        String a = "55";
		String b = "004";
		String c = "0x0f";

		Integer a1 = Integer.decode(a); 
		System.out.println("decode(55) = " + a1); 
		a1 = Integer.decode(b); 
		System.out.println("decode(004) = " + a1); 
		a1 = Integer.decode(c); 
		System.out.println("decode(0x0f) = " + a1);           
    } 
}

integer-class-example

9.旋转垂直()和旋转垂直()

这两种方法用于将指定 int 值的二进制补码表示向左或向右旋转指定的位数。

语法:

	 public static introtateLeft(intval, intdist)
public static introtateRight(intval, intdist)

示例:

	 public class IntegerClassDemo1  
{ 
    public static void main(String args[])  
    { 
        int a = 5;
        System.out.println("rotateLeft = "+ Integer.rotateLeft(a, 5));
        System.out.println("rotateRight = "+ Integer.rotateRight(a, 4));            
    } 
}

integer-class-example

Java `Long`类

long 类是一个包装类，用于包装对象中的基元类型 Long 的值。long 类型的对象包含类型为 Long 的单个字段。

此外，这个类提供了几种将 long 转换为 String 的方法，反之亦然。该类的声明如下。

申报

public final class Long extends Number implements Comparable<Long>

该类位于 java.lang 包和 java.base 模块中。下面我们就用龙课堂的例子来讨论一下他们的方法。

1.toString()

此方法返回一个 String 对象，表示这个 Long 的值。该值被转换为带符号的十进制表示形式，并作为字符串返回。它覆盖了对象类的toString()方法。

它不接受任何参数，但返回以 10 为基数的该对象值的字符串表示形式。下面给出了该方法的语法。

语法:

	 public String toString(long b)

示例:

	 public class LongDemo1
{
	public static void main(String as[])
	{
		long a = 25;
		System.out.println("toString(a) = " + Long.toString(a));
	}
}

long-class

2. 十六进制字符串（）

toHexString()方法用于获取长参数的字符串表示。

此方法接受一个Long类型的参数，并返回一个十六进制字符串。下面给出了该方法的语法。

语法:

	 public String toHexString(long b)

3.toOctalString()

当我们想要获得Long类型值的八进制字符串表示时，这个方法很有帮助。

它可以用来获取长参数的字符串表示形式。

它接受一个Long类型参数，并返回该参数的无符号字符串表示形式。下面给出了该方法的语法。

语法:

	 public String toOctalString(long b)

4.toBinaryString()

toBinaryString()方法用于获取长参数的字符串表示形式，以 2 为基数的无符号整数表示。

它接受一个长参数，并返回无符号长值的字符串表示形式。下面给出了该方法的语法。

语法:

	 public String toBinaryString(long b)

示例:

我们正在使用toHexString()方法获取一个长值的十六进制字符串值。在这个例子中，我们传递了 25 作为参数，并得到了它的二进制、十六进制和八进制字符串。见下面的例子。

	 public class LongDemo1
{
	public static void main(String as[])
	{
		long a = 25;
		System.out.println("toHexString(a) =" + Long.toHexString(a)); 
		System.out.println("toOctalString(a) =" + Long.toOctalString(a)); 
		System.out.println("toBinaryString(a) =" + Long.toBinaryString(a)); 
	}
}

long-class-example

5.valueOf()

valueOf()方法用于获取表示指定长值的长对象。它接受一个Long类型参数并返回一个长实例。下面给出了该方法的语法。

语法:

	 public static Long valueOf(long b)

示例:

	 public class LongDemo1
{
	public static void main(String as[])
	{
		long a = 25;
		String b = "45";
		Long x = Long.valueOf(a); 
		System.out.println("valueOf(a) = " + x); 
		x = Long.valueOf(b); 
		System.out.println("ValueOf(b) = " + x); 
		x = Long.valueOf(b, 6); 
		System.out.println("ValueOf(b,6) = " + x); 		
	}
}

long-class-example

6. 解析龙（）

parseLong()方法用于将指定的字符串参数解析为带符号的十进制长整型。字符串中的字符必须都是十进制数字。

它接受String类型的单个参数，并返回一个 Long 值。

语法:

	 public static long parseInt(String val, int radix) throws NumberFormatException

示例:

在下面的例子中，我们将一个包含数字的字符串传递给parseLong()方法。方法返回对应于字符串的长值。

	 public class LongDemo1
{
	public static void main(String as[])
	{
		long a = 25;
		String b = "45";
		Long x = Long.parseLong(b); 
		System.out.println("parseLong(b) = " + x); 
		x = Long.parseLong(b, 6); 
		System.out.println("parseLong(b,6) = " + x); 		
	}
}

long-class-example

7 .格龙()

getLong()方法用于确定指定名称的系统属性的长值。它采用指定属性名称的字符串参数，并返回一个 Long 值。下面给出了该方法的语法。

语法:

	 public static Long getLong(String prop)

示例:

	 public class LongDemo1
{
	public static void main(String as[])
	{
		long a = Long.getLong("sun.arch.data.model"); 
		System.out.println("getLong(sun.arch.data.model) = " + a); 
		System.out.println("getLong(abcd) =" + Long.getLong("abcd"));
	}
}

long-class-example

8 .解码()

decode()方法用于将字符串解码为长字符串。它接受可以是十进制、十六进制和八进制数的String类型参数，并返回 Long 类的实例。下面给出了该方法的语法。

语法:

	 public static Long decode(String s) throws NumberFormatException

示例:

在这个例子中，我们使用不同类型的数值来解码和获取长实例。

	 public class LongDemo1
{
	public static void main(String as[])
	{
	String a = "25"; 
        String b = "007"; 
        String c = "0x0f"; 

        Long x = Long.decode(a); 
		System.out.println("decode(25) = " + x); 
		x = Long.decode(b); 
		System.out.println("decode(007) = " + x); 
		x = Long.decode(c); 
		System.out.println("decode(0x0f) = " + x); 	
	}
}

long-class-example

9.旋转垂直()和旋转垂直()

这两种方法用于将指定长值的二进制补码表示向左或向右旋转指定的位数。

语法:

	 public static long rotateLeft(long val, int dist)       
public static long rotateRight(long val, int dist)

示例:

	 public class LongDemo1
{
    public static void main(String as[])
    {
	    long a = 3;
	    System.out.println("rotateLeft(0000 0000 0000 0011 , 3) =" + Long.rotateLeft(a, 3));    
	    System.out.println("rotateRight(0000 0000 0000 0011 , 3) =" + Long.rotateRight(a, 3));          
    }
}

long-class-example

Java `Byte`类

原文：https://www.studytonight.com/java/byte-class.php

Byte类是一个包装类，用于包装对象中基元类型字节的值。Byte类型的对象包含类型为字节的单个字段。

这个类位于 java.lang 包中，并提供了几种将一个字节转换为字符串的方法，反之亦然。这个类的声明如下。

声明:

public final class Byte extends Number implements Comparable<Byte>

现在让我们通过例子来看看它的方法和用法。

1.toString()

语法:

	 public String toString(byte b)

示例:

让我们举个例子来获取Byte类型的字符串对象。我们使用了toString()方法，它是静态的，所以我们可以用类名来调用它。

	 public class ByteDemo1 
{ 
	public static void main(String[] args)  
	{ 
		byte a = 65; 
		System.out.println("toString(a) = " + Byte.toString(a));
	}
}

byte-class

2.valueOf()

此方法返回一个表示指定字节值的字节实例。此方法通常应优先于构造器 Byte(字节)使用。

语法:

	 public static Byte valueOf(byte b)

示例:

在这个例子中，我们使用valueOf()方法返回代表指定Byte类型的Byte类实例。

	 public class ByteDemo1 
{ 
    public static void main(String[] args)  
        { 
        byte a = 65; 
        String b = "25";
        Byte x = Byte.valueOf(a); 
        System.out.println("ValueOf(a) = " + x);
        x = Byte.valueOf(b, 6); 
        System.out.println("ValueOf(a,6) = " + x);
     }
}

byte-class-example

3.parseByte()

此方法返回指定字符串值的字节值。我们可以用它从String类型值中获取字节值。

	 public static byte parseByte(String val, int radix) throws NumberFormatException

示例:

让我们举一个例子，其中我们有一个String类型变量，并使用 parseByte()方法获取它的字节值。

	 public class ByteDemo1 
{ 
	public static void main(String[] args)  
	{ 
		byte a = 65; 
		String b = "25";
		byte x = Byte.parseByte(b); 
		System.out.println("parseByte(b) = " + x); 
		x = Byte.parseByte(b, 6); 
		System.out.println("parseByte(b,6) = " + x); 
	}
}

byte-class-example

4.解码()

此方法用于将字符串解码为字节。它接受十进制、十六进制和八进制数字。

语法:

	 public static Byte decode(String s) throws NumberFormatException

示例:

我们可以使用 decode 方法将String类型解码为字节对象。见下面的例子。

	 public class ByteDemo1 
{ 
	public static void main(String[] args)  
	{ 
		String a = "25"; 
		String b = "006"; 
		String c = "0x0f"; 
		Byte x = Byte.decode(a); 
		System.out.println("decode(25) = " + x); 
		x = Byte.decode(b); 
		System.out.println("decode(006) = " + x); 
		x= Byte.decode(c); 
		System.out.println("decode(0x0f) = " + x); 
	}
}

byte-class-example

5. 字节值（）

此方法用于从 byte 对象获取基元类型字节值。在转换为类型字节后，它返回由该对象表示的数值。

句法

	 public byte byteValue()

6. 短值（）

此方法在扩展基元转换后以短整型返回此字节的值。

句法

	 public short shortValue()

7. intValue（）

intValue()方法在扩展基元转换后，将该字节的值作为基元 int 类型返回。

句法

	 public int intValue()

8. 长值（）

longValue()方法在扩展原始类型转换后，将该Byte类型的值作为Long类型返回。

句法

	 public long longValue()

9.doubleValue()

在扩展原始类型转换后，它将该Byte类型的值作为双精度类型返回。

句法

	 public double doubleValue()

10. 浮点值（）

此方法用于在扩展基元转换后将此Byte类型的值作为Float类型获取。

语法:

	 public float floatValue()

示例:

让我们举一个例子，将Byte类型转换为 int、long 和 float 类型的值。在这个例子中，我们使用intValue(), floatValue(), doubleValue()方法。

	 public class ByteDemo1 
{ 
	public static void main(String[] args)  
	{ 
		Byte a = 45;
		Byte obj = new Byte(a);

		System.out.println("bytevalue(obj) = " + obj.byteValue()); 
		System.out.println("shortvalue(obj) = " + obj.shortValue()); 
		System.out.println("intvalue(obj) = " + obj.intValue()); 
		System.out.println("longvalue(obj) = " + obj.longValue()); 
		System.out.println("doublevalue(obj) = " + obj.doubleValue()); 
		System.out.println("floatvalue(obj) = " + obj.floatValue());
	}
}

byte-class-example

11. hashCode()

此方法用于获取字节值的哈希代码。它返回一个字节对象的 int 值。

语法:

	 public inthashCode()

示例:

	 public class ByteDemo1 
{ 
    public static void main(String[] args)  
	{ 
        Byte a = 45;
		Byte obj = new Byte(a);

		int x =obj.hashCode(); 
		System.out.println("hashcode(obj) = " + x); 
	}
}

byte-class-example

12.等于()

equals()方法将一个对象与指定的对象进行比较。如果对象相同，则返回 true 否则为假。

语法:

	 public boolean equals(Object obj)

示例:

我们使用 equals 方法比较两个字节对象，如果两个对象都为真，则该方法返回 true。

	 public class ByteDemo1 
{ 
    public static void main(String[] args)  
	{ 
        Byte a = 45;
		String b ="25";
		Byte obj = new Byte(a);
		Byte obj1 = new Byte(b);

		boolean z = obj.equals(obj1); 
		System.out.println("obj.equals(obj1) = " + z); 
	}
}

byte-class-example

13.compareTo()

此方法用于对两个字节对象进行数字比较。如果两个字节对象相等，则返回 0。如果一个字节对象小于参数对象，则返回小于 0 的值。如果一个字节对象的数值大于参数字节对象，则返回大于 0 的值。

语法:

公共内部比较

示例:

在本例中，我们使用compareTo()方法比较两个字节对象，该方法对两个字节对象进行数值比较并返回一个数值。

	 public class ByteDemo1 
{ 
    public static void main(String[] args)  
	{ 
        Byte a = 45;
		String b ="25";
		Byte obj = new Byte(a);
		Byte obj1 = new Byte(b);

		int z = obj.compareTo(obj1); 
		System.out.println("obj.compareTo(obj1) = " + z); 
	}
}

byte-class-example

14.比较()

它用于在数字上比较两个字节值。返回的值与。

语法:

	 public static intcompare(byte x,byte y)

示例:

我们可以使用比较方法来比较两个字节的值。如果两者相等，则返回 0，否则返回负值或正值。

	 public class ByteDemo1 
{ 
    public static void main(String[] args)  
	{ 
        Byte a = 45;
		String b ="25";
		Byte obj = new Byte(a);
		Byte obj1 = new Byte(b);

		int z = Byte.compare(obj, obj1); 
		System.out.println("compare(obj, obj1) = " + z); 
	}
}

byte-class-example

Java `Short`类

原文：https://www.studytonight.com/java/short-class.php

Short 类是一个包装类，用于包装对象类型中基本 short 类型值。

类型为“短”的对象包含类型为“短”的单个字段。

此类提供了几种将短字符串转换为字符串和将字符串转换为短字符串的方法，以及在使用Short类型时有帮助的其他常量和方法。简Short类型的声明如下。

声明:

public final class Short extends Number implements Comparable<Short>

下面是短训班的方法和他们的例子。

1.toString()

此方法用于获取字节对象的字符串表示形式。它返回一个新的 String 对象，表示指定的短字符串。它采用String类型单参数。

语法:

	 public String toString(short b)

示例:

在这个例子中，我们使用toString()方法来获得Short类型对象的字符串表示。

	 public class ShortDemo1 
{ 
    public static void main(String[] args)  
	{ 
        short a = 45;
		String b ="25";
		Short obj = new Short(a);
		Short obj1 = new Short(b);
		System.out.println("toString(a) = " + Short.toString(a));
	}
}

short-class

2.valueOf()

此方法返回表示指定短值的短实例。该方法通常应优先于构造器 Short(short)使用。它接受一个Short类型的参数。

语法:

	 public static Short valueOf(short b)

示例:

在这个例子中，我们使用valueOf()方法返回代表指定Short类型的Short类实例。

	 public class ShortDemo1 
{ 
    public static void main(String[] args)  
	{ 
        short a = 45;
		String b ="25";
		Short obj = new Short(a);
		Short obj1 = new Short(b);
		Short x = Short.valueOf(a); 
		System.out.println("valueOf(a) = " + x); 
        x = Short.valueOf(b); 
		System.out.println("ValueOf(b) = " + x); 
        x = Short.valueOf(b, 6); 
		System.out.println("ValueOf(b,6) = " + x); 
	}
}

short-class-example

3.parseShort()

此方法返回指定字符串值的短值。我们可以用它从String类型值中获取一个短值。它需要两个参数:一个是 String 类型，第二个是 int 类型。

语法:

	 public static short parseShort(String val, int radix) throws NumberFormatException

示例:

让我们举一个例子，其中我们有一个String类型的变量，并使用parseShort()方法获得它的短值。

	 public class ShortDemo1 
{ 
    public static void main(String[] args)  
	{ 
        short a = 45;
		String b ="25";
		Short obj = new Short(a);
		Short obj1 = new Short(b);
		Short x = Short.parseShort(b); 
		System.out.println("parseShort(b) = " + x);  
        x = Short.valueOf(b, 6); 
		System.out.println("parseShort(b,6) = " + x); 
	}
}

short-class-example

4.解码()

此方法用于将字符串解码为短字符串。它接受十进制、十六进制和八进制数字。它接受一个String类型的参数。

	 public static Short decode(String s) throws NumberFormatException

示例:

我们可以使用 decode 方法将String类型解码为一个短对象。见下面的例子。

	 public class ShortDemo1 
{ 
    public static void main(String[] args)  
	{ 
        String a = "25"; 
        String b = "007"; 
        String c = "0x0f"; 
        Short x = Short.decode(a); 
		System.out.println("decod(45) = " + x); 
        x = Short.decode(b); 
		System.out.println("decode(005) = " + x); 
        x = Short.decode(c); 
		System.out.println("decode(0x0f) = " + x); 
	}
}

short-class-example

5. 字节值（）

此方法用于从 Short 对象中获取基元类型字节值。在转换为类型字节后，它返回由该对象表示的数值。

语法:

	 public byte byteValue()

6. 短值（）

此方法将此 Short 的值作为扩展基元转换后的短值返回。

语法:

	 public short shortValue()

7. intValue（）

intValue()方法在扩展原始类型转换后，将此 Short 的值作为原始类型 int 类型返回。

语法:

	 Syntax : public int intValue()

8. 长值（）

longValue()方法在扩展原始类型转换后，将此Short类型的值作为Long类型返回。

语法:

	 public long longValue()

9.doubleValue()

它在扩展基元转换后将此Short类型的值作为双精度类型返回。

语法:

	 public double doubleValue()

10. 浮点值（）

此方法用于在扩展基元转换后将此Short类型的值作为Float类型获取。

语法:

	 public float floatValue()

示例:

让我们举一个例子，将Short类型转换为 int、long 和 float 类型的值。在这个例子中，我们使用intValue(), floatValue(), doubleValue()方法。

	 public class ShortDemo1 
{ 
    public static void main(String[] args)  
	{ 
		short a = 75; 
        Short obj = new Short(a);
		System.out.println("bytevalue(obj) = " + obj.byteValue()); 
		System.out.println("shortvalue(obj) = " + obj.shortValue()); 
		System.out.println("intvalue(obj) = " + obj.intValue()); 
		System.out.println("longvalue(obj) = " + obj.longValue()); 
		System.out.println("doublevalue(obj) = " + obj.doubleValue()); 
		System.out.println("floatvalue(obj) = " + obj.floatValue()); 
	}
}

short-class-example

11. hashCode()

此方法用于获取短值的哈希代码。它返回一个短对象的 int 值。

语法:

	 public inthashCode()

示例:

	 public class ShortDemo1 
{ 
   public static void main(String[] args)  
	{ 
        short a = 45;
		Short obj = new Short(a);
		int x =obj.hashCode(); 
		System.out.println("hashcode(obj) = " + x); 
	}
}

short-class-example

12.等于()

equals()方法将一个对象与指定的对象进行比较。如果对象相同，则返回 true 否则为假

语法:

	 public boolean equals(Object obj)

示例:

我们使用 equals 方法比较两个字节对象，如果两个对象都为真，则该方法返回 true。

	 public class ShortDemo1 
{ 
   public static void main(String[] args)  
	{ 
        short a = 45;
		String b ="25";
		Short obj = new Short(a);
		Short obj1 = new Short(b);
		boolean z = obj.equals(obj1); 
		System.out.println("obj.equals(obj1) = " + z); 
	}
}

short-class-example

13.compareTo()

这种方法用于对两个短物体进行数值比较。如果两个短对象相等，则返回 0。如果一个短对象小于参数对象，则返回小于 0 的值。如果一个短对象的数值大于参数短对象，则返回大于 0 的值。

语法:

	 public intcompareTo(Short b)

示例:

在本例中，我们使用 compareTo 方法比较两个短对象，该方法对两个短对象进行数值比较并返回一个数值。

	 public class ShortDemo1 
{ 
   public static void main(String[] args)  
	{ 
        short a = 45;
		String b ="25";
		Short obj = new Short(a);
		Short obj1 = new Short(b);
		int z = obj.compareTo(obj1); 
		System.out.println("obj.compareTo(obj1) = " + z); 
	}
}

short-class-example

14.比较()

它用于在数字上比较两个字节值。返回的值与。

语法:

	 public static int compare(short x,short y)

示例:

我们可以使用比较方法来比较两个短值。如果两者相等，则返回 0，否则返回负值或正值。

	 public class ShortDemo1 
{ 
   public static void main(String[] args)  
	{ 
        short a = 45;
		String b ="25";
		Short obj = new Short(a);
		Short obj1 = new Short(b);
		int z = Short.compare(obj, obj1); 
		System.out.println("compare(obj, obj1) = " + z); 
	}
}

short-class-example

15.反转字节数()

此方法用于获取通过反转指定短值的二进制补码表示中的字节顺序而获得的值。

语法:

	 public static short reverseBytes(short val)

示例:

在反转字节后，我们得到一个短的值。返回值不同于参数值。

	 public class ShortDemo1 
{ 
   public static void main(String[] args)  
	{ 
        short a = 25;
		System.out.println("Short.reverseBytes(a) = " + Short.reverseBytes(a)); 
	}
}

short-class-example

posted @ 2024-10-24 18:15 绝不原创的飞龙阅读(27) 评论(0) 编辑收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

StudyTonight-Java-中文教程-一-

StudyTonight Java 中文教程（一）

Java 核心

Java 基础

Java 简介

Java 的创建

Java 的历史

Java 版本历史

Java 的演变

Java 的应用

Java 应用的类型

1.独立应用

2.网络应用

3.企业应用

4.移动应用

下载 JDK

Java 特性

1)简单

2)面向对象

3)稳健

4)平台独立

5)安全

6)多线程

7)建筑中性

8)便携式

9)高性能

10)分布式

JAVA 8 的新特性

JAVA 11 的新特性

Java 版本

1.Java 标准版

2.Java 微版

3.Java 企业版

4.应用

设置 Java 环境和类路径

设置窗口路径 ( 2000/XP/vista/Window 7，8 )

为 95/98/ME 窗口设置路径

为 Linux、Unix、Solaris、免费 BSD 设置路径

Java JVM、JDK 和 JRE

JVM 架构

JDK 和 JRE 的区别

Java HelloWorld 程序

编译和运行第一个 Java 程序的步骤

编写 Java 程序的方法

使用 Eclipse 的 Hello World 程序

运行 Eclipse 并创建项目

创建 Java 类

写你好世界

运行程序

现在让我们看看运行时会发生什么

Java 中的变量

什么是变量？

Java 中的实例变量

Java 中的静态变量

静态变量的附加点:

Java 中的局部变量

Java 中的变量范围

示例:

Java 中的数据类型

1)原始数据类型

整数

浮点数

特性

Character类型示例

布尔代数学体系的

Boolean类型示例

2)非原始(引用)数据类型

Java 中的标识符

Java 中的静态块

静态块的示例

多个静态块的示例

Java 中的初始化器块

使用静态和初始值设定项块的示例

Java 中的类型转换

加宽或自动类型转换

收缩或显式类型转换

显式转换的示例

int 和 double 转换为字节的示例

`Character`类型示例

`Boolean`类型示例

Java `If Else`语句

Java `switch`语句

Java `break`和`continue`语句

`instanceOf`运算符

Java `System.exit()`方法